capitests/tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 static void print_error (guestfs_h *g, void *data, const char *msg)
  35 {
  36   if (!suppress_error)
  37     fprintf (stderr, "%s\n", msg);
  38 }
  39
  40 static void print_strings (char * const * const argv)
  41 {
  42   int argc;
  43
  44   for (argc = 0; argv[argc] != NULL; ++argc)
  45     printf ("\t%s\n", argv[argc]);
  46 }
  47
  48 /*
  49 static void print_table (char * const * const argv)
  50 {
  51   int i;
  52
  53   for (i = 0; argv[i] != NULL; i += 2)
  54     printf ("%s: %s\n", argv[i], argv[i+1]);
  55 }
  56 */
  57
  58 static void no_test_warnings (void)
  59 {
  60   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  61   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  62   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  63   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  64   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  65   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_set_memsize\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_get_memsize\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 156   fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
 157   fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
 158   fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
 159   fprintf (stderr, "warning: \"guestfs_umask\" has no tests\n");
 160 }
 161
 162 static int test_mknod_c_0_skip (void)
 163 {
 164   const char *str;
 165
 166   str = getenv ("TEST_ONLY");
 167   if (str)
 168     return strstr (str, "mknod_c") == NULL;
 169   str = getenv ("SKIP_TEST_MKNOD_C_0");
 170   if (str && strcmp (str, "1") == 0) return 1;
 171   str = getenv ("SKIP_TEST_MKNOD_C");
 172   if (str && strcmp (str, "1") == 0) return 1;
 173   return 0;
 174 }
 175
 176 static int test_mknod_c_0 (void)
 177 {
 178   if (test_mknod_c_0_skip ()) {
 179     printf ("        %s skipped (reason: environment variable set)\n", "test_mknod_c_0");
 180     return 0;
 181   }
 182
 183   /* InitBasicFS for test_mknod_c_0: create ext2 on /dev/sda1 */
 184   {
 185     char device[] = "/dev/sda";
 186     int r;
 187     suppress_error = 0;
 188     r = guestfs_blockdev_setrw (g, device);
 189     if (r == -1)
 190       return -1;
 191   }
 192   {
 193     int r;
 194     suppress_error = 0;
 195     r = guestfs_umount_all (g);
 196     if (r == -1)
 197       return -1;
 198   }
 199   {
 200     int r;
 201     suppress_error = 0;
 202     r = guestfs_lvm_remove_all (g);
 203     if (r == -1)
 204       return -1;
 205   }
 206   {
 207     char device[] = "/dev/sda";
 208     char lines_0[] = ",";
 209     char *lines[] = {
 210       lines_0,
 211       NULL
 212     };
 213     int r;
 214     suppress_error = 0;
 215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 216     if (r == -1)
 217       return -1;
 218   }
 219   {
 220     char fstype[] = "ext2";
 221     char device[] = "/dev/sda1";
 222     int r;
 223     suppress_error = 0;
 224     r = guestfs_mkfs (g, fstype, device);
 225     if (r == -1)
 226       return -1;
 227   }
 228   {
 229     char device[] = "/dev/sda1";
 230     char mountpoint[] = "/";
 231     int r;
 232     suppress_error = 0;
 233     r = guestfs_mount (g, device, mountpoint);
 234     if (r == -1)
 235       return -1;
 236   }
 237   /* TestOutputStruct for mknod_c (0) */
 238   {
 239     char path[] = "/node";
 240     int r;
 241     suppress_error = 0;
 242     r = guestfs_mknod_c (g, 511, 99, 66, path);
 243     if (r == -1)
 244       return -1;
 245   }
 246   {
 247     char path[] = "/node";
 248     struct guestfs_stat *r;
 249     suppress_error = 0;
 250     r = guestfs_stat (g, path);
 251     if (r == NULL)
 252       return -1;
 253     if (r->mode != 8685) {
 254       fprintf (stderr, "test_mknod_c_0: mode was %d, expected 8685\n",
 255                (int) r->mode);
 256       return -1;
 257     }
 258     free (r);
 259   }
 260   return 0;
 261 }
 262
 263 static int test_mknod_b_0_skip (void)
 264 {
 265   const char *str;
 266
 267   str = getenv ("TEST_ONLY");
 268   if (str)
 269     return strstr (str, "mknod_b") == NULL;
 270   str = getenv ("SKIP_TEST_MKNOD_B_0");
 271   if (str && strcmp (str, "1") == 0) return 1;
 272   str = getenv ("SKIP_TEST_MKNOD_B");
 273   if (str && strcmp (str, "1") == 0) return 1;
 274   return 0;
 275 }
 276
 277 static int test_mknod_b_0 (void)
 278 {
 279   if (test_mknod_b_0_skip ()) {
 280     printf ("        %s skipped (reason: environment variable set)\n", "test_mknod_b_0");
 281     return 0;
 282   }
 283
 284   /* InitBasicFS for test_mknod_b_0: create ext2 on /dev/sda1 */
 285   {
 286     char device[] = "/dev/sda";
 287     int r;
 288     suppress_error = 0;
 289     r = guestfs_blockdev_setrw (g, device);
 290     if (r == -1)
 291       return -1;
 292   }
 293   {
 294     int r;
 295     suppress_error = 0;
 296     r = guestfs_umount_all (g);
 297     if (r == -1)
 298       return -1;
 299   }
 300   {
 301     int r;
 302     suppress_error = 0;
 303     r = guestfs_lvm_remove_all (g);
 304     if (r == -1)
 305       return -1;
 306   }
 307   {
 308     char device[] = "/dev/sda";
 309     char lines_0[] = ",";
 310     char *lines[] = {
 311       lines_0,
 312       NULL
 313     };
 314     int r;
 315     suppress_error = 0;
 316     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 317     if (r == -1)
 318       return -1;
 319   }
 320   {
 321     char fstype[] = "ext2";
 322     char device[] = "/dev/sda1";
 323     int r;
 324     suppress_error = 0;
 325     r = guestfs_mkfs (g, fstype, device);
 326     if (r == -1)
 327       return -1;
 328   }
 329   {
 330     char device[] = "/dev/sda1";
 331     char mountpoint[] = "/";
 332     int r;
 333     suppress_error = 0;
 334     r = guestfs_mount (g, device, mountpoint);
 335     if (r == -1)
 336       return -1;
 337   }
 338   /* TestOutputStruct for mknod_b (0) */
 339   {
 340     char path[] = "/node";
 341     int r;
 342     suppress_error = 0;
 343     r = guestfs_mknod_b (g, 511, 99, 66, path);
 344     if (r == -1)
 345       return -1;
 346   }
 347   {
 348     char path[] = "/node";
 349     struct guestfs_stat *r;
 350     suppress_error = 0;
 351     r = guestfs_stat (g, path);
 352     if (r == NULL)
 353       return -1;
 354     if (r->mode != 25069) {
 355       fprintf (stderr, "test_mknod_b_0: mode was %d, expected 25069\n",
 356                (int) r->mode);
 357       return -1;
 358     }
 359     free (r);
 360   }
 361   return 0;
 362 }
 363
 364 static int test_mkfifo_0_skip (void)
 365 {
 366   const char *str;
 367
 368   str = getenv ("TEST_ONLY");
 369   if (str)
 370     return strstr (str, "mkfifo") == NULL;
 371   str = getenv ("SKIP_TEST_MKFIFO_0");
 372   if (str && strcmp (str, "1") == 0) return 1;
 373   str = getenv ("SKIP_TEST_MKFIFO");
 374   if (str && strcmp (str, "1") == 0) return 1;
 375   return 0;
 376 }
 377
 378 static int test_mkfifo_0 (void)
 379 {
 380   if (test_mkfifo_0_skip ()) {
 381     printf ("        %s skipped (reason: environment variable set)\n", "test_mkfifo_0");
 382     return 0;
 383   }
 384
 385   /* InitBasicFS for test_mkfifo_0: create ext2 on /dev/sda1 */
 386   {
 387     char device[] = "/dev/sda";
 388     int r;
 389     suppress_error = 0;
 390     r = guestfs_blockdev_setrw (g, device);
 391     if (r == -1)
 392       return -1;
 393   }
 394   {
 395     int r;
 396     suppress_error = 0;
 397     r = guestfs_umount_all (g);
 398     if (r == -1)
 399       return -1;
 400   }
 401   {
 402     int r;
 403     suppress_error = 0;
 404     r = guestfs_lvm_remove_all (g);
 405     if (r == -1)
 406       return -1;
 407   }
 408   {
 409     char device[] = "/dev/sda";
 410     char lines_0[] = ",";
 411     char *lines[] = {
 412       lines_0,
 413       NULL
 414     };
 415     int r;
 416     suppress_error = 0;
 417     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 418     if (r == -1)
 419       return -1;
 420   }
 421   {
 422     char fstype[] = "ext2";
 423     char device[] = "/dev/sda1";
 424     int r;
 425     suppress_error = 0;
 426     r = guestfs_mkfs (g, fstype, device);
 427     if (r == -1)
 428       return -1;
 429   }
 430   {
 431     char device[] = "/dev/sda1";
 432     char mountpoint[] = "/";
 433     int r;
 434     suppress_error = 0;
 435     r = guestfs_mount (g, device, mountpoint);
 436     if (r == -1)
 437       return -1;
 438   }
 439   /* TestOutputStruct for mkfifo (0) */
 440   {
 441     char path[] = "/node";
 442     int r;
 443     suppress_error = 0;
 444     r = guestfs_mkfifo (g, 511, path);
 445     if (r == -1)
 446       return -1;
 447   }
 448   {
 449     char path[] = "/node";
 450     struct guestfs_stat *r;
 451     suppress_error = 0;
 452     r = guestfs_stat (g, path);
 453     if (r == NULL)
 454       return -1;
 455     if (r->mode != 4589) {
 456       fprintf (stderr, "test_mkfifo_0: mode was %d, expected 4589\n",
 457                (int) r->mode);
 458       return -1;
 459     }
 460     free (r);
 461   }
 462   return 0;
 463 }
 464
 465 static int test_mknod_0_skip (void)
 466 {
 467   const char *str;
 468
 469   str = getenv ("TEST_ONLY");
 470   if (str)
 471     return strstr (str, "mknod") == NULL;
 472   str = getenv ("SKIP_TEST_MKNOD_0");
 473   if (str && strcmp (str, "1") == 0) return 1;
 474   str = getenv ("SKIP_TEST_MKNOD");
 475   if (str && strcmp (str, "1") == 0) return 1;
 476   return 0;
 477 }
 478
 479 static int test_mknod_0 (void)
 480 {
 481   if (test_mknod_0_skip ()) {
 482     printf ("        %s skipped (reason: environment variable set)\n", "test_mknod_0");
 483     return 0;
 484   }
 485
 486   /* InitBasicFS for test_mknod_0: create ext2 on /dev/sda1 */
 487   {
 488     char device[] = "/dev/sda";
 489     int r;
 490     suppress_error = 0;
 491     r = guestfs_blockdev_setrw (g, device);
 492     if (r == -1)
 493       return -1;
 494   }
 495   {
 496     int r;
 497     suppress_error = 0;
 498     r = guestfs_umount_all (g);
 499     if (r == -1)
 500       return -1;
 501   }
 502   {
 503     int r;
 504     suppress_error = 0;
 505     r = guestfs_lvm_remove_all (g);
 506     if (r == -1)
 507       return -1;
 508   }
 509   {
 510     char device[] = "/dev/sda";
 511     char lines_0[] = ",";
 512     char *lines[] = {
 513       lines_0,
 514       NULL
 515     };
 516     int r;
 517     suppress_error = 0;
 518     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 519     if (r == -1)
 520       return -1;
 521   }
 522   {
 523     char fstype[] = "ext2";
 524     char device[] = "/dev/sda1";
 525     int r;
 526     suppress_error = 0;
 527     r = guestfs_mkfs (g, fstype, device);
 528     if (r == -1)
 529       return -1;
 530   }
 531   {
 532     char device[] = "/dev/sda1";
 533     char mountpoint[] = "/";
 534     int r;
 535     suppress_error = 0;
 536     r = guestfs_mount (g, device, mountpoint);
 537     if (r == -1)
 538       return -1;
 539   }
 540   /* TestOutputStruct for mknod (0) */
 541   {
 542     char path[] = "/node";
 543     int r;
 544     suppress_error = 0;
 545     r = guestfs_mknod (g, 4607, 0, 0, path);
 546     if (r == -1)
 547       return -1;
 548   }
 549   {
 550     char path[] = "/node";
 551     struct guestfs_stat *r;
 552     suppress_error = 0;
 553     r = guestfs_stat (g, path);
 554     if (r == NULL)
 555       return -1;
 556     if (r->mode != 4589) {
 557       fprintf (stderr, "test_mknod_0: mode was %d, expected 4589\n",
 558                (int) r->mode);
 559       return -1;
 560     }
 561     free (r);
 562   }
 563   return 0;
 564 }
 565
 566 static int test_mknod_1_skip (void)
 567 {
 568   const char *str;
 569
 570   str = getenv ("TEST_ONLY");
 571   if (str)
 572     return strstr (str, "mknod") == NULL;
 573   str = getenv ("SKIP_TEST_MKNOD_1");
 574   if (str && strcmp (str, "1") == 0) return 1;
 575   str = getenv ("SKIP_TEST_MKNOD");
 576   if (str && strcmp (str, "1") == 0) return 1;
 577   return 0;
 578 }
 579
 580 static int test_mknod_1 (void)
 581 {
 582   if (test_mknod_1_skip ()) {
 583     printf ("        %s skipped (reason: environment variable set)\n", "test_mknod_1");
 584     return 0;
 585   }
 586
 587   /* InitBasicFS for test_mknod_1: create ext2 on /dev/sda1 */
 588   {
 589     char device[] = "/dev/sda";
 590     int r;
 591     suppress_error = 0;
 592     r = guestfs_blockdev_setrw (g, device);
 593     if (r == -1)
 594       return -1;
 595   }
 596   {
 597     int r;
 598     suppress_error = 0;
 599     r = guestfs_umount_all (g);
 600     if (r == -1)
 601       return -1;
 602   }
 603   {
 604     int r;
 605     suppress_error = 0;
 606     r = guestfs_lvm_remove_all (g);
 607     if (r == -1)
 608       return -1;
 609   }
 610   {
 611     char device[] = "/dev/sda";
 612     char lines_0[] = ",";
 613     char *lines[] = {
 614       lines_0,
 615       NULL
 616     };
 617     int r;
 618     suppress_error = 0;
 619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 620     if (r == -1)
 621       return -1;
 622   }
 623   {
 624     char fstype[] = "ext2";
 625     char device[] = "/dev/sda1";
 626     int r;
 627     suppress_error = 0;
 628     r = guestfs_mkfs (g, fstype, device);
 629     if (r == -1)
 630       return -1;
 631   }
 632   {
 633     char device[] = "/dev/sda1";
 634     char mountpoint[] = "/";
 635     int r;
 636     suppress_error = 0;
 637     r = guestfs_mount (g, device, mountpoint);
 638     if (r == -1)
 639       return -1;
 640   }
 641   /* TestOutputStruct for mknod (1) */
 642   {
 643     char path[] = "/node";
 644     int r;
 645     suppress_error = 0;
 646     r = guestfs_mknod (g, 25087, 66, 99, path);
 647     if (r == -1)
 648       return -1;
 649   }
 650   {
 651     char path[] = "/node";
 652     struct guestfs_stat *r;
 653     suppress_error = 0;
 654     r = guestfs_stat (g, path);
 655     if (r == NULL)
 656       return -1;
 657     if (r->mode != 25069) {
 658       fprintf (stderr, "test_mknod_1: mode was %d, expected 25069\n",
 659                (int) r->mode);
 660       return -1;
 661     }
 662     free (r);
 663   }
 664   return 0;
 665 }
 666
 667 static int test_mkswap_U_0_skip (void)
 668 {
 669   const char *str;
 670
 671   str = getenv ("TEST_ONLY");
 672   if (str)
 673     return strstr (str, "mkswap_U") == NULL;
 674   str = getenv ("SKIP_TEST_MKSWAP_U_0");
 675   if (str && strcmp (str, "1") == 0) return 1;
 676   str = getenv ("SKIP_TEST_MKSWAP_U");
 677   if (str && strcmp (str, "1") == 0) return 1;
 678   return 0;
 679 }
 680
 681 static int test_mkswap_U_0 (void)
 682 {
 683   if (test_mkswap_U_0_skip ()) {
 684     printf ("        %s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
 685     return 0;
 686   }
 687
 688   /* InitNone|InitEmpty for test_mkswap_U_0 */
 689   {
 690     char device[] = "/dev/sda";
 691     int r;
 692     suppress_error = 0;
 693     r = guestfs_blockdev_setrw (g, device);
 694     if (r == -1)
 695       return -1;
 696   }
 697   {
 698     int r;
 699     suppress_error = 0;
 700     r = guestfs_umount_all (g);
 701     if (r == -1)
 702       return -1;
 703   }
 704   {
 705     int r;
 706     suppress_error = 0;
 707     r = guestfs_lvm_remove_all (g);
 708     if (r == -1)
 709       return -1;
 710   }
 711   /* TestRun for mkswap_U (0) */
 712   {
 713     char device[] = "/dev/sda";
 714     char lines_0[] = ",";
 715     char *lines[] = {
 716       lines_0,
 717       NULL
 718     };
 719     int r;
 720     suppress_error = 0;
 721     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 722     if (r == -1)
 723       return -1;
 724   }
 725   {
 726     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
 727     char device[] = "/dev/sda1";
 728     int r;
 729     suppress_error = 0;
 730     r = guestfs_mkswap_U (g, uuid, device);
 731     if (r == -1)
 732       return -1;
 733   }
 734   return 0;
 735 }
 736
 737 static int test_mkswap_L_0_skip (void)
 738 {
 739   const char *str;
 740
 741   str = getenv ("TEST_ONLY");
 742   if (str)
 743     return strstr (str, "mkswap_L") == NULL;
 744   str = getenv ("SKIP_TEST_MKSWAP_L_0");
 745   if (str && strcmp (str, "1") == 0) return 1;
 746   str = getenv ("SKIP_TEST_MKSWAP_L");
 747   if (str && strcmp (str, "1") == 0) return 1;
 748   return 0;
 749 }
 750
 751 static int test_mkswap_L_0 (void)
 752 {
 753   if (test_mkswap_L_0_skip ()) {
 754     printf ("        %s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
 755     return 0;
 756   }
 757
 758   /* InitNone|InitEmpty for test_mkswap_L_0 */
 759   {
 760     char device[] = "/dev/sda";
 761     int r;
 762     suppress_error = 0;
 763     r = guestfs_blockdev_setrw (g, device);
 764     if (r == -1)
 765       return -1;
 766   }
 767   {
 768     int r;
 769     suppress_error = 0;
 770     r = guestfs_umount_all (g);
 771     if (r == -1)
 772       return -1;
 773   }
 774   {
 775     int r;
 776     suppress_error = 0;
 777     r = guestfs_lvm_remove_all (g);
 778     if (r == -1)
 779       return -1;
 780   }
 781   /* TestRun for mkswap_L (0) */
 782   {
 783     char device[] = "/dev/sda";
 784     char lines_0[] = ",";
 785     char *lines[] = {
 786       lines_0,
 787       NULL
 788     };
 789     int r;
 790     suppress_error = 0;
 791     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 792     if (r == -1)
 793       return -1;
 794   }
 795   {
 796     char label[] = "hello";
 797     char device[] = "/dev/sda1";
 798     int r;
 799     suppress_error = 0;
 800     r = guestfs_mkswap_L (g, label, device);
 801     if (r == -1)
 802       return -1;
 803   }
 804   return 0;
 805 }
 806
 807 static int test_mkswap_0_skip (void)
 808 {
 809   const char *str;
 810
 811   str = getenv ("TEST_ONLY");
 812   if (str)
 813     return strstr (str, "mkswap") == NULL;
 814   str = getenv ("SKIP_TEST_MKSWAP_0");
 815   if (str && strcmp (str, "1") == 0) return 1;
 816   str = getenv ("SKIP_TEST_MKSWAP");
 817   if (str && strcmp (str, "1") == 0) return 1;
 818   return 0;
 819 }
 820
 821 static int test_mkswap_0 (void)
 822 {
 823   if (test_mkswap_0_skip ()) {
 824     printf ("        %s skipped (reason: environment variable set)\n", "test_mkswap_0");
 825     return 0;
 826   }
 827
 828   /* InitNone|InitEmpty for test_mkswap_0 */
 829   {
 830     char device[] = "/dev/sda";
 831     int r;
 832     suppress_error = 0;
 833     r = guestfs_blockdev_setrw (g, device);
 834     if (r == -1)
 835       return -1;
 836   }
 837   {
 838     int r;
 839     suppress_error = 0;
 840     r = guestfs_umount_all (g);
 841     if (r == -1)
 842       return -1;
 843   }
 844   {
 845     int r;
 846     suppress_error = 0;
 847     r = guestfs_lvm_remove_all (g);
 848     if (r == -1)
 849       return -1;
 850   }
 851   /* TestRun for mkswap (0) */
 852   {
 853     char device[] = "/dev/sda";
 854     char lines_0[] = ",";
 855     char *lines[] = {
 856       lines_0,
 857       NULL
 858     };
 859     int r;
 860     suppress_error = 0;
 861     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 862     if (r == -1)
 863       return -1;
 864   }
 865   {
 866     char device[] = "/dev/sda1";
 867     int r;
 868     suppress_error = 0;
 869     r = guestfs_mkswap (g, device);
 870     if (r == -1)
 871       return -1;
 872   }
 873   return 0;
 874 }
 875
 876 static int test_initrd_list_0_skip (void)
 877 {
 878   const char *str;
 879
 880   str = getenv ("TEST_ONLY");
 881   if (str)
 882     return strstr (str, "initrd_list") == NULL;
 883   str = getenv ("SKIP_TEST_INITRD_LIST_0");
 884   if (str && strcmp (str, "1") == 0) return 1;
 885   str = getenv ("SKIP_TEST_INITRD_LIST");
 886   if (str && strcmp (str, "1") == 0) return 1;
 887   return 0;
 888 }
 889
 890 static int test_initrd_list_0 (void)
 891 {
 892   if (test_initrd_list_0_skip ()) {
 893     printf ("        %s skipped (reason: environment variable set)\n", "test_initrd_list_0");
 894     return 0;
 895   }
 896
 897   /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
 898   {
 899     char device[] = "/dev/sda";
 900     int r;
 901     suppress_error = 0;
 902     r = guestfs_blockdev_setrw (g, device);
 903     if (r == -1)
 904       return -1;
 905   }
 906   {
 907     int r;
 908     suppress_error = 0;
 909     r = guestfs_umount_all (g);
 910     if (r == -1)
 911       return -1;
 912   }
 913   {
 914     int r;
 915     suppress_error = 0;
 916     r = guestfs_lvm_remove_all (g);
 917     if (r == -1)
 918       return -1;
 919   }
 920   {
 921     char device[] = "/dev/sda";
 922     char lines_0[] = ",";
 923     char *lines[] = {
 924       lines_0,
 925       NULL
 926     };
 927     int r;
 928     suppress_error = 0;
 929     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 930     if (r == -1)
 931       return -1;
 932   }
 933   {
 934     char fstype[] = "ext2";
 935     char device[] = "/dev/sda1";
 936     int r;
 937     suppress_error = 0;
 938     r = guestfs_mkfs (g, fstype, device);
 939     if (r == -1)
 940       return -1;
 941   }
 942   {
 943     char device[] = "/dev/sda1";
 944     char mountpoint[] = "/";
 945     int r;
 946     suppress_error = 0;
 947     r = guestfs_mount (g, device, mountpoint);
 948     if (r == -1)
 949       return -1;
 950   }
 951   /* TestOutputList for initrd_list (0) */
 952   {
 953     char options[] = "ro";
 954     char vfstype[] = "squashfs";
 955     char device[] = "/dev/sdd";
 956     char mountpoint[] = "/";
 957     int r;
 958     suppress_error = 0;
 959     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 960     if (r == -1)
 961       return -1;
 962   }
 963   {
 964     char path[] = "/initrd";
 965     char **r;
 966     int i;
 967     suppress_error = 0;
 968     r = guestfs_initrd_list (g, path);
 969     if (r == NULL)
 970       return -1;
 971     if (!r[0]) {
 972       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 973       print_strings (r);
 974       return -1;
 975     }
 976     {
 977       char expected[] = "empty";
 978       if (strcmp (r[0], expected) != 0) {
 979         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 980         return -1;
 981       }
 982     }
 983     if (!r[1]) {
 984       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 985       print_strings (r);
 986       return -1;
 987     }
 988     {
 989       char expected[] = "known-1";
 990       if (strcmp (r[1], expected) != 0) {
 991         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 992         return -1;
 993       }
 994     }
 995     if (!r[2]) {
 996       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 997       print_strings (r);
 998       return -1;
 999     }
1000     {
1001       char expected[] = "known-2";
1002       if (strcmp (r[2], expected) != 0) {
1003         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1004         return -1;
1005       }
1006     }
1007     if (!r[3]) {
1008       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
1009       print_strings (r);
1010       return -1;
1011     }
1012     {
1013       char expected[] = "known-3";
1014       if (strcmp (r[3], expected) != 0) {
1015         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1016         return -1;
1017       }
1018     }
1019     if (r[4] != NULL) {
1020       fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
1021       print_strings (r);
1022       return -1;
1023     }
1024     for (i = 0; r[i] != NULL; ++i)
1025       free (r[i]);
1026     free (r);
1027   }
1028   return 0;
1029 }
1030
1031 static int test_du_0_skip (void)
1032 {
1033   const char *str;
1034
1035   str = getenv ("TEST_ONLY");
1036   if (str)
1037     return strstr (str, "du") == NULL;
1038   str = getenv ("SKIP_TEST_DU_0");
1039   if (str && strcmp (str, "1") == 0) return 1;
1040   str = getenv ("SKIP_TEST_DU");
1041   if (str && strcmp (str, "1") == 0) return 1;
1042   return 0;
1043 }
1044
1045 static int test_du_0 (void)
1046 {
1047   if (test_du_0_skip ()) {
1048     printf ("        %s skipped (reason: environment variable set)\n", "test_du_0");
1049     return 0;
1050   }
1051
1052   /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
1053   {
1054     char device[] = "/dev/sda";
1055     int r;
1056     suppress_error = 0;
1057     r = guestfs_blockdev_setrw (g, device);
1058     if (r == -1)
1059       return -1;
1060   }
1061   {
1062     int r;
1063     suppress_error = 0;
1064     r = guestfs_umount_all (g);
1065     if (r == -1)
1066       return -1;
1067   }
1068   {
1069     int r;
1070     suppress_error = 0;
1071     r = guestfs_lvm_remove_all (g);
1072     if (r == -1)
1073       return -1;
1074   }
1075   {
1076     char device[] = "/dev/sda";
1077     char lines_0[] = ",";
1078     char *lines[] = {
1079       lines_0,
1080       NULL
1081     };
1082     int r;
1083     suppress_error = 0;
1084     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1085     if (r == -1)
1086       return -1;
1087   }
1088   {
1089     char fstype[] = "ext2";
1090     char device[] = "/dev/sda1";
1091     int r;
1092     suppress_error = 0;
1093     r = guestfs_mkfs (g, fstype, device);
1094     if (r == -1)
1095       return -1;
1096   }
1097   {
1098     char device[] = "/dev/sda1";
1099     char mountpoint[] = "/";
1100     int r;
1101     suppress_error = 0;
1102     r = guestfs_mount (g, device, mountpoint);
1103     if (r == -1)
1104       return -1;
1105   }
1106   /* TestOutputInt for du (0) */
1107   {
1108     char path[] = "/p";
1109     int r;
1110     suppress_error = 0;
1111     r = guestfs_mkdir (g, path);
1112     if (r == -1)
1113       return -1;
1114   }
1115   {
1116     char path[] = "/p";
1117     int64_t r;
1118     suppress_error = 0;
1119     r = guestfs_du (g, path);
1120     if (r == -1)
1121       return -1;
1122     if (r != 1) {
1123       fprintf (stderr, "test_du_0: expected 1 but got %d\n",               (int) r);
1124       return -1;
1125     }
1126   }
1127   return 0;
1128 }
1129
1130 static int test_tail_n_0_skip (void)
1131 {
1132   const char *str;
1133
1134   str = getenv ("TEST_ONLY");
1135   if (str)
1136     return strstr (str, "tail_n") == NULL;
1137   str = getenv ("SKIP_TEST_TAIL_N_0");
1138   if (str && strcmp (str, "1") == 0) return 1;
1139   str = getenv ("SKIP_TEST_TAIL_N");
1140   if (str && strcmp (str, "1") == 0) return 1;
1141   return 0;
1142 }
1143
1144 static int test_tail_n_0 (void)
1145 {
1146   if (test_tail_n_0_skip ()) {
1147     printf ("        %s skipped (reason: environment variable set)\n", "test_tail_n_0");
1148     return 0;
1149   }
1150
1151   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
1152   {
1153     char device[] = "/dev/sda";
1154     int r;
1155     suppress_error = 0;
1156     r = guestfs_blockdev_setrw (g, device);
1157     if (r == -1)
1158       return -1;
1159   }
1160   {
1161     int r;
1162     suppress_error = 0;
1163     r = guestfs_umount_all (g);
1164     if (r == -1)
1165       return -1;
1166   }
1167   {
1168     int r;
1169     suppress_error = 0;
1170     r = guestfs_lvm_remove_all (g);
1171     if (r == -1)
1172       return -1;
1173   }
1174   {
1175     char device[] = "/dev/sda";
1176     char lines_0[] = ",";
1177     char *lines[] = {
1178       lines_0,
1179       NULL
1180     };
1181     int r;
1182     suppress_error = 0;
1183     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1184     if (r == -1)
1185       return -1;
1186   }
1187   {
1188     char fstype[] = "ext2";
1189     char device[] = "/dev/sda1";
1190     int r;
1191     suppress_error = 0;
1192     r = guestfs_mkfs (g, fstype, device);
1193     if (r == -1)
1194       return -1;
1195   }
1196   {
1197     char device[] = "/dev/sda1";
1198     char mountpoint[] = "/";
1199     int r;
1200     suppress_error = 0;
1201     r = guestfs_mount (g, device, mountpoint);
1202     if (r == -1)
1203       return -1;
1204   }
1205   /* TestOutputList for tail_n (0) */
1206   {
1207     char options[] = "ro";
1208     char vfstype[] = "squashfs";
1209     char device[] = "/dev/sdd";
1210     char mountpoint[] = "/";
1211     int r;
1212     suppress_error = 0;
1213     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1214     if (r == -1)
1215       return -1;
1216   }
1217   {
1218     char path[] = "/10klines";
1219     char **r;
1220     int i;
1221     suppress_error = 0;
1222     r = guestfs_tail_n (g, 3, path);
1223     if (r == NULL)
1224       return -1;
1225     if (!r[0]) {
1226       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1227       print_strings (r);
1228       return -1;
1229     }
1230     {
1231       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1232       if (strcmp (r[0], expected) != 0) {
1233         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1234         return -1;
1235       }
1236     }
1237     if (!r[1]) {
1238       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1239       print_strings (r);
1240       return -1;
1241     }
1242     {
1243       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1244       if (strcmp (r[1], expected) != 0) {
1245         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1246         return -1;
1247       }
1248     }
1249     if (!r[2]) {
1250       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1251       print_strings (r);
1252       return -1;
1253     }
1254     {
1255       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1256       if (strcmp (r[2], expected) != 0) {
1257         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1258         return -1;
1259       }
1260     }
1261     if (r[3] != NULL) {
1262       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
1263       print_strings (r);
1264       return -1;
1265     }
1266     for (i = 0; r[i] != NULL; ++i)
1267       free (r[i]);
1268     free (r);
1269   }
1270   return 0;
1271 }
1272
1273 static int test_tail_n_1_skip (void)
1274 {
1275   const char *str;
1276
1277   str = getenv ("TEST_ONLY");
1278   if (str)
1279     return strstr (str, "tail_n") == NULL;
1280   str = getenv ("SKIP_TEST_TAIL_N_1");
1281   if (str && strcmp (str, "1") == 0) return 1;
1282   str = getenv ("SKIP_TEST_TAIL_N");
1283   if (str && strcmp (str, "1") == 0) return 1;
1284   return 0;
1285 }
1286
1287 static int test_tail_n_1 (void)
1288 {
1289   if (test_tail_n_1_skip ()) {
1290     printf ("        %s skipped (reason: environment variable set)\n", "test_tail_n_1");
1291     return 0;
1292   }
1293
1294   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
1295   {
1296     char device[] = "/dev/sda";
1297     int r;
1298     suppress_error = 0;
1299     r = guestfs_blockdev_setrw (g, device);
1300     if (r == -1)
1301       return -1;
1302   }
1303   {
1304     int r;
1305     suppress_error = 0;
1306     r = guestfs_umount_all (g);
1307     if (r == -1)
1308       return -1;
1309   }
1310   {
1311     int r;
1312     suppress_error = 0;
1313     r = guestfs_lvm_remove_all (g);
1314     if (r == -1)
1315       return -1;
1316   }
1317   {
1318     char device[] = "/dev/sda";
1319     char lines_0[] = ",";
1320     char *lines[] = {
1321       lines_0,
1322       NULL
1323     };
1324     int r;
1325     suppress_error = 0;
1326     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1327     if (r == -1)
1328       return -1;
1329   }
1330   {
1331     char fstype[] = "ext2";
1332     char device[] = "/dev/sda1";
1333     int r;
1334     suppress_error = 0;
1335     r = guestfs_mkfs (g, fstype, device);
1336     if (r == -1)
1337       return -1;
1338   }
1339   {
1340     char device[] = "/dev/sda1";
1341     char mountpoint[] = "/";
1342     int r;
1343     suppress_error = 0;
1344     r = guestfs_mount (g, device, mountpoint);
1345     if (r == -1)
1346       return -1;
1347   }
1348   /* TestOutputList for tail_n (1) */
1349   {
1350     char options[] = "ro";
1351     char vfstype[] = "squashfs";
1352     char device[] = "/dev/sdd";
1353     char mountpoint[] = "/";
1354     int r;
1355     suppress_error = 0;
1356     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1357     if (r == -1)
1358       return -1;
1359   }
1360   {
1361     char path[] = "/10klines";
1362     char **r;
1363     int i;
1364     suppress_error = 0;
1365     r = guestfs_tail_n (g, -9998, path);
1366     if (r == NULL)
1367       return -1;
1368     if (!r[0]) {
1369       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1370       print_strings (r);
1371       return -1;
1372     }
1373     {
1374       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1375       if (strcmp (r[0], expected) != 0) {
1376         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1377         return -1;
1378       }
1379     }
1380     if (!r[1]) {
1381       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1382       print_strings (r);
1383       return -1;
1384     }
1385     {
1386       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1387       if (strcmp (r[1], expected) != 0) {
1388         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1389         return -1;
1390       }
1391     }
1392     if (!r[2]) {
1393       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1394       print_strings (r);
1395       return -1;
1396     }
1397     {
1398       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1399       if (strcmp (r[2], expected) != 0) {
1400         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1401         return -1;
1402       }
1403     }
1404     if (r[3] != NULL) {
1405       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
1406       print_strings (r);
1407       return -1;
1408     }
1409     for (i = 0; r[i] != NULL; ++i)
1410       free (r[i]);
1411     free (r);
1412   }
1413   return 0;
1414 }
1415
1416 static int test_tail_n_2_skip (void)
1417 {
1418   const char *str;
1419
1420   str = getenv ("TEST_ONLY");
1421   if (str)
1422     return strstr (str, "tail_n") == NULL;
1423   str = getenv ("SKIP_TEST_TAIL_N_2");
1424   if (str && strcmp (str, "1") == 0) return 1;
1425   str = getenv ("SKIP_TEST_TAIL_N");
1426   if (str && strcmp (str, "1") == 0) return 1;
1427   return 0;
1428 }
1429
1430 static int test_tail_n_2 (void)
1431 {
1432   if (test_tail_n_2_skip ()) {
1433     printf ("        %s skipped (reason: environment variable set)\n", "test_tail_n_2");
1434     return 0;
1435   }
1436
1437   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
1438   {
1439     char device[] = "/dev/sda";
1440     int r;
1441     suppress_error = 0;
1442     r = guestfs_blockdev_setrw (g, device);
1443     if (r == -1)
1444       return -1;
1445   }
1446   {
1447     int r;
1448     suppress_error = 0;
1449     r = guestfs_umount_all (g);
1450     if (r == -1)
1451       return -1;
1452   }
1453   {
1454     int r;
1455     suppress_error = 0;
1456     r = guestfs_lvm_remove_all (g);
1457     if (r == -1)
1458       return -1;
1459   }
1460   {
1461     char device[] = "/dev/sda";
1462     char lines_0[] = ",";
1463     char *lines[] = {
1464       lines_0,
1465       NULL
1466     };
1467     int r;
1468     suppress_error = 0;
1469     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1470     if (r == -1)
1471       return -1;
1472   }
1473   {
1474     char fstype[] = "ext2";
1475     char device[] = "/dev/sda1";
1476     int r;
1477     suppress_error = 0;
1478     r = guestfs_mkfs (g, fstype, device);
1479     if (r == -1)
1480       return -1;
1481   }
1482   {
1483     char device[] = "/dev/sda1";
1484     char mountpoint[] = "/";
1485     int r;
1486     suppress_error = 0;
1487     r = guestfs_mount (g, device, mountpoint);
1488     if (r == -1)
1489       return -1;
1490   }
1491   /* TestOutputList for tail_n (2) */
1492   {
1493     char options[] = "ro";
1494     char vfstype[] = "squashfs";
1495     char device[] = "/dev/sdd";
1496     char mountpoint[] = "/";
1497     int r;
1498     suppress_error = 0;
1499     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1500     if (r == -1)
1501       return -1;
1502   }
1503   {
1504     char path[] = "/10klines";
1505     char **r;
1506     int i;
1507     suppress_error = 0;
1508     r = guestfs_tail_n (g, 0, path);
1509     if (r == NULL)
1510       return -1;
1511     if (r[0] != NULL) {
1512       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1513       print_strings (r);
1514       return -1;
1515     }
1516     for (i = 0; r[i] != NULL; ++i)
1517       free (r[i]);
1518     free (r);
1519   }
1520   return 0;
1521 }
1522
1523 static int test_tail_0_skip (void)
1524 {
1525   const char *str;
1526
1527   str = getenv ("TEST_ONLY");
1528   if (str)
1529     return strstr (str, "tail") == NULL;
1530   str = getenv ("SKIP_TEST_TAIL_0");
1531   if (str && strcmp (str, "1") == 0) return 1;
1532   str = getenv ("SKIP_TEST_TAIL");
1533   if (str && strcmp (str, "1") == 0) return 1;
1534   return 0;
1535 }
1536
1537 static int test_tail_0 (void)
1538 {
1539   if (test_tail_0_skip ()) {
1540     printf ("        %s skipped (reason: environment variable set)\n", "test_tail_0");
1541     return 0;
1542   }
1543
1544   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1545   {
1546     char device[] = "/dev/sda";
1547     int r;
1548     suppress_error = 0;
1549     r = guestfs_blockdev_setrw (g, device);
1550     if (r == -1)
1551       return -1;
1552   }
1553   {
1554     int r;
1555     suppress_error = 0;
1556     r = guestfs_umount_all (g);
1557     if (r == -1)
1558       return -1;
1559   }
1560   {
1561     int r;
1562     suppress_error = 0;
1563     r = guestfs_lvm_remove_all (g);
1564     if (r == -1)
1565       return -1;
1566   }
1567   {
1568     char device[] = "/dev/sda";
1569     char lines_0[] = ",";
1570     char *lines[] = {
1571       lines_0,
1572       NULL
1573     };
1574     int r;
1575     suppress_error = 0;
1576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1577     if (r == -1)
1578       return -1;
1579   }
1580   {
1581     char fstype[] = "ext2";
1582     char device[] = "/dev/sda1";
1583     int r;
1584     suppress_error = 0;
1585     r = guestfs_mkfs (g, fstype, device);
1586     if (r == -1)
1587       return -1;
1588   }
1589   {
1590     char device[] = "/dev/sda1";
1591     char mountpoint[] = "/";
1592     int r;
1593     suppress_error = 0;
1594     r = guestfs_mount (g, device, mountpoint);
1595     if (r == -1)
1596       return -1;
1597   }
1598   /* TestOutputList for tail (0) */
1599   {
1600     char options[] = "ro";
1601     char vfstype[] = "squashfs";
1602     char device[] = "/dev/sdd";
1603     char mountpoint[] = "/";
1604     int r;
1605     suppress_error = 0;
1606     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1607     if (r == -1)
1608       return -1;
1609   }
1610   {
1611     char path[] = "/10klines";
1612     char **r;
1613     int i;
1614     suppress_error = 0;
1615     r = guestfs_tail (g, path);
1616     if (r == NULL)
1617       return -1;
1618     if (!r[0]) {
1619       fprintf (stderr, "test_tail_0: short list returned from command\n");
1620       print_strings (r);
1621       return -1;
1622     }
1623     {
1624       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1625       if (strcmp (r[0], expected) != 0) {
1626         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1627         return -1;
1628       }
1629     }
1630     if (!r[1]) {
1631       fprintf (stderr, "test_tail_0: short list returned from command\n");
1632       print_strings (r);
1633       return -1;
1634     }
1635     {
1636       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1637       if (strcmp (r[1], expected) != 0) {
1638         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1639         return -1;
1640       }
1641     }
1642     if (!r[2]) {
1643       fprintf (stderr, "test_tail_0: short list returned from command\n");
1644       print_strings (r);
1645       return -1;
1646     }
1647     {
1648       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1649       if (strcmp (r[2], expected) != 0) {
1650         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1651         return -1;
1652       }
1653     }
1654     if (!r[3]) {
1655       fprintf (stderr, "test_tail_0: short list returned from command\n");
1656       print_strings (r);
1657       return -1;
1658     }
1659     {
1660       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1661       if (strcmp (r[3], expected) != 0) {
1662         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1663         return -1;
1664       }
1665     }
1666     if (!r[4]) {
1667       fprintf (stderr, "test_tail_0: short list returned from command\n");
1668       print_strings (r);
1669       return -1;
1670     }
1671     {
1672       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1673       if (strcmp (r[4], expected) != 0) {
1674         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1675         return -1;
1676       }
1677     }
1678     if (!r[5]) {
1679       fprintf (stderr, "test_tail_0: short list returned from command\n");
1680       print_strings (r);
1681       return -1;
1682     }
1683     {
1684       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1685       if (strcmp (r[5], expected) != 0) {
1686         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1687         return -1;
1688       }
1689     }
1690     if (!r[6]) {
1691       fprintf (stderr, "test_tail_0: short list returned from command\n");
1692       print_strings (r);
1693       return -1;
1694     }
1695     {
1696       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1697       if (strcmp (r[6], expected) != 0) {
1698         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1699         return -1;
1700       }
1701     }
1702     if (!r[7]) {
1703       fprintf (stderr, "test_tail_0: short list returned from command\n");
1704       print_strings (r);
1705       return -1;
1706     }
1707     {
1708       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1709       if (strcmp (r[7], expected) != 0) {
1710         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1711         return -1;
1712       }
1713     }
1714     if (!r[8]) {
1715       fprintf (stderr, "test_tail_0: short list returned from command\n");
1716       print_strings (r);
1717       return -1;
1718     }
1719     {
1720       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1721       if (strcmp (r[8], expected) != 0) {
1722         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1723         return -1;
1724       }
1725     }
1726     if (!r[9]) {
1727       fprintf (stderr, "test_tail_0: short list returned from command\n");
1728       print_strings (r);
1729       return -1;
1730     }
1731     {
1732       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1733       if (strcmp (r[9], expected) != 0) {
1734         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1735         return -1;
1736       }
1737     }
1738     if (r[10] != NULL) {
1739       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1740       print_strings (r);
1741       return -1;
1742     }
1743     for (i = 0; r[i] != NULL; ++i)
1744       free (r[i]);
1745     free (r);
1746   }
1747   return 0;
1748 }
1749
1750 static int test_head_n_0_skip (void)
1751 {
1752   const char *str;
1753
1754   str = getenv ("TEST_ONLY");
1755   if (str)
1756     return strstr (str, "head_n") == NULL;
1757   str = getenv ("SKIP_TEST_HEAD_N_0");
1758   if (str && strcmp (str, "1") == 0) return 1;
1759   str = getenv ("SKIP_TEST_HEAD_N");
1760   if (str && strcmp (str, "1") == 0) return 1;
1761   return 0;
1762 }
1763
1764 static int test_head_n_0 (void)
1765 {
1766   if (test_head_n_0_skip ()) {
1767     printf ("        %s skipped (reason: environment variable set)\n", "test_head_n_0");
1768     return 0;
1769   }
1770
1771   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1772   {
1773     char device[] = "/dev/sda";
1774     int r;
1775     suppress_error = 0;
1776     r = guestfs_blockdev_setrw (g, device);
1777     if (r == -1)
1778       return -1;
1779   }
1780   {
1781     int r;
1782     suppress_error = 0;
1783     r = guestfs_umount_all (g);
1784     if (r == -1)
1785       return -1;
1786   }
1787   {
1788     int r;
1789     suppress_error = 0;
1790     r = guestfs_lvm_remove_all (g);
1791     if (r == -1)
1792       return -1;
1793   }
1794   {
1795     char device[] = "/dev/sda";
1796     char lines_0[] = ",";
1797     char *lines[] = {
1798       lines_0,
1799       NULL
1800     };
1801     int r;
1802     suppress_error = 0;
1803     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1804     if (r == -1)
1805       return -1;
1806   }
1807   {
1808     char fstype[] = "ext2";
1809     char device[] = "/dev/sda1";
1810     int r;
1811     suppress_error = 0;
1812     r = guestfs_mkfs (g, fstype, device);
1813     if (r == -1)
1814       return -1;
1815   }
1816   {
1817     char device[] = "/dev/sda1";
1818     char mountpoint[] = "/";
1819     int r;
1820     suppress_error = 0;
1821     r = guestfs_mount (g, device, mountpoint);
1822     if (r == -1)
1823       return -1;
1824   }
1825   /* TestOutputList for head_n (0) */
1826   {
1827     char options[] = "ro";
1828     char vfstype[] = "squashfs";
1829     char device[] = "/dev/sdd";
1830     char mountpoint[] = "/";
1831     int r;
1832     suppress_error = 0;
1833     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1834     if (r == -1)
1835       return -1;
1836   }
1837   {
1838     char path[] = "/10klines";
1839     char **r;
1840     int i;
1841     suppress_error = 0;
1842     r = guestfs_head_n (g, 3, path);
1843     if (r == NULL)
1844       return -1;
1845     if (!r[0]) {
1846       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1847       print_strings (r);
1848       return -1;
1849     }
1850     {
1851       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1852       if (strcmp (r[0], expected) != 0) {
1853         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1854         return -1;
1855       }
1856     }
1857     if (!r[1]) {
1858       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1859       print_strings (r);
1860       return -1;
1861     }
1862     {
1863       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1864       if (strcmp (r[1], expected) != 0) {
1865         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1866         return -1;
1867       }
1868     }
1869     if (!r[2]) {
1870       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1871       print_strings (r);
1872       return -1;
1873     }
1874     {
1875       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1876       if (strcmp (r[2], expected) != 0) {
1877         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1878         return -1;
1879       }
1880     }
1881     if (r[3] != NULL) {
1882       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1883       print_strings (r);
1884       return -1;
1885     }
1886     for (i = 0; r[i] != NULL; ++i)
1887       free (r[i]);
1888     free (r);
1889   }
1890   return 0;
1891 }
1892
1893 static int test_head_n_1_skip (void)
1894 {
1895   const char *str;
1896
1897   str = getenv ("TEST_ONLY");
1898   if (str)
1899     return strstr (str, "head_n") == NULL;
1900   str = getenv ("SKIP_TEST_HEAD_N_1");
1901   if (str && strcmp (str, "1") == 0) return 1;
1902   str = getenv ("SKIP_TEST_HEAD_N");
1903   if (str && strcmp (str, "1") == 0) return 1;
1904   return 0;
1905 }
1906
1907 static int test_head_n_1 (void)
1908 {
1909   if (test_head_n_1_skip ()) {
1910     printf ("        %s skipped (reason: environment variable set)\n", "test_head_n_1");
1911     return 0;
1912   }
1913
1914   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1915   {
1916     char device[] = "/dev/sda";
1917     int r;
1918     suppress_error = 0;
1919     r = guestfs_blockdev_setrw (g, device);
1920     if (r == -1)
1921       return -1;
1922   }
1923   {
1924     int r;
1925     suppress_error = 0;
1926     r = guestfs_umount_all (g);
1927     if (r == -1)
1928       return -1;
1929   }
1930   {
1931     int r;
1932     suppress_error = 0;
1933     r = guestfs_lvm_remove_all (g);
1934     if (r == -1)
1935       return -1;
1936   }
1937   {
1938     char device[] = "/dev/sda";
1939     char lines_0[] = ",";
1940     char *lines[] = {
1941       lines_0,
1942       NULL
1943     };
1944     int r;
1945     suppress_error = 0;
1946     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1947     if (r == -1)
1948       return -1;
1949   }
1950   {
1951     char fstype[] = "ext2";
1952     char device[] = "/dev/sda1";
1953     int r;
1954     suppress_error = 0;
1955     r = guestfs_mkfs (g, fstype, device);
1956     if (r == -1)
1957       return -1;
1958   }
1959   {
1960     char device[] = "/dev/sda1";
1961     char mountpoint[] = "/";
1962     int r;
1963     suppress_error = 0;
1964     r = guestfs_mount (g, device, mountpoint);
1965     if (r == -1)
1966       return -1;
1967   }
1968   /* TestOutputList for head_n (1) */
1969   {
1970     char options[] = "ro";
1971     char vfstype[] = "squashfs";
1972     char device[] = "/dev/sdd";
1973     char mountpoint[] = "/";
1974     int r;
1975     suppress_error = 0;
1976     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1977     if (r == -1)
1978       return -1;
1979   }
1980   {
1981     char path[] = "/10klines";
1982     char **r;
1983     int i;
1984     suppress_error = 0;
1985     r = guestfs_head_n (g, -9997, path);
1986     if (r == NULL)
1987       return -1;
1988     if (!r[0]) {
1989       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1990       print_strings (r);
1991       return -1;
1992     }
1993     {
1994       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1995       if (strcmp (r[0], expected) != 0) {
1996         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1997         return -1;
1998       }
1999     }
2000     if (!r[1]) {
2001       fprintf (stderr, "test_head_n_1: short list returned from command\n");
2002       print_strings (r);
2003       return -1;
2004     }
2005     {
2006       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2007       if (strcmp (r[1], expected) != 0) {
2008         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2009         return -1;
2010       }
2011     }
2012     if (!r[2]) {
2013       fprintf (stderr, "test_head_n_1: short list returned from command\n");
2014       print_strings (r);
2015       return -1;
2016     }
2017     {
2018       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2019       if (strcmp (r[2], expected) != 0) {
2020         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2021         return -1;
2022       }
2023     }
2024     if (r[3] != NULL) {
2025       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
2026       print_strings (r);
2027       return -1;
2028     }
2029     for (i = 0; r[i] != NULL; ++i)
2030       free (r[i]);
2031     free (r);
2032   }
2033   return 0;
2034 }
2035
2036 static int test_head_n_2_skip (void)
2037 {
2038   const char *str;
2039
2040   str = getenv ("TEST_ONLY");
2041   if (str)
2042     return strstr (str, "head_n") == NULL;
2043   str = getenv ("SKIP_TEST_HEAD_N_2");
2044   if (str && strcmp (str, "1") == 0) return 1;
2045   str = getenv ("SKIP_TEST_HEAD_N");
2046   if (str && strcmp (str, "1") == 0) return 1;
2047   return 0;
2048 }
2049
2050 static int test_head_n_2 (void)
2051 {
2052   if (test_head_n_2_skip ()) {
2053     printf ("        %s skipped (reason: environment variable set)\n", "test_head_n_2");
2054     return 0;
2055   }
2056
2057   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
2058   {
2059     char device[] = "/dev/sda";
2060     int r;
2061     suppress_error = 0;
2062     r = guestfs_blockdev_setrw (g, device);
2063     if (r == -1)
2064       return -1;
2065   }
2066   {
2067     int r;
2068     suppress_error = 0;
2069     r = guestfs_umount_all (g);
2070     if (r == -1)
2071       return -1;
2072   }
2073   {
2074     int r;
2075     suppress_error = 0;
2076     r = guestfs_lvm_remove_all (g);
2077     if (r == -1)
2078       return -1;
2079   }
2080   {
2081     char device[] = "/dev/sda";
2082     char lines_0[] = ",";
2083     char *lines[] = {
2084       lines_0,
2085       NULL
2086     };
2087     int r;
2088     suppress_error = 0;
2089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2090     if (r == -1)
2091       return -1;
2092   }
2093   {
2094     char fstype[] = "ext2";
2095     char device[] = "/dev/sda1";
2096     int r;
2097     suppress_error = 0;
2098     r = guestfs_mkfs (g, fstype, device);
2099     if (r == -1)
2100       return -1;
2101   }
2102   {
2103     char device[] = "/dev/sda1";
2104     char mountpoint[] = "/";
2105     int r;
2106     suppress_error = 0;
2107     r = guestfs_mount (g, device, mountpoint);
2108     if (r == -1)
2109       return -1;
2110   }
2111   /* TestOutputList for head_n (2) */
2112   {
2113     char options[] = "ro";
2114     char vfstype[] = "squashfs";
2115     char device[] = "/dev/sdd";
2116     char mountpoint[] = "/";
2117     int r;
2118     suppress_error = 0;
2119     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2120     if (r == -1)
2121       return -1;
2122   }
2123   {
2124     char path[] = "/10klines";
2125     char **r;
2126     int i;
2127     suppress_error = 0;
2128     r = guestfs_head_n (g, 0, path);
2129     if (r == NULL)
2130       return -1;
2131     if (r[0] != NULL) {
2132       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
2133       print_strings (r);
2134       return -1;
2135     }
2136     for (i = 0; r[i] != NULL; ++i)
2137       free (r[i]);
2138     free (r);
2139   }
2140   return 0;
2141 }
2142
2143 static int test_head_0_skip (void)
2144 {
2145   const char *str;
2146
2147   str = getenv ("TEST_ONLY");
2148   if (str)
2149     return strstr (str, "head") == NULL;
2150   str = getenv ("SKIP_TEST_HEAD_0");
2151   if (str && strcmp (str, "1") == 0) return 1;
2152   str = getenv ("SKIP_TEST_HEAD");
2153   if (str && strcmp (str, "1") == 0) return 1;
2154   return 0;
2155 }
2156
2157 static int test_head_0 (void)
2158 {
2159   if (test_head_0_skip ()) {
2160     printf ("        %s skipped (reason: environment variable set)\n", "test_head_0");
2161     return 0;
2162   }
2163
2164   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
2165   {
2166     char device[] = "/dev/sda";
2167     int r;
2168     suppress_error = 0;
2169     r = guestfs_blockdev_setrw (g, device);
2170     if (r == -1)
2171       return -1;
2172   }
2173   {
2174     int r;
2175     suppress_error = 0;
2176     r = guestfs_umount_all (g);
2177     if (r == -1)
2178       return -1;
2179   }
2180   {
2181     int r;
2182     suppress_error = 0;
2183     r = guestfs_lvm_remove_all (g);
2184     if (r == -1)
2185       return -1;
2186   }
2187   {
2188     char device[] = "/dev/sda";
2189     char lines_0[] = ",";
2190     char *lines[] = {
2191       lines_0,
2192       NULL
2193     };
2194     int r;
2195     suppress_error = 0;
2196     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2197     if (r == -1)
2198       return -1;
2199   }
2200   {
2201     char fstype[] = "ext2";
2202     char device[] = "/dev/sda1";
2203     int r;
2204     suppress_error = 0;
2205     r = guestfs_mkfs (g, fstype, device);
2206     if (r == -1)
2207       return -1;
2208   }
2209   {
2210     char device[] = "/dev/sda1";
2211     char mountpoint[] = "/";
2212     int r;
2213     suppress_error = 0;
2214     r = guestfs_mount (g, device, mountpoint);
2215     if (r == -1)
2216       return -1;
2217   }
2218   /* TestOutputList for head (0) */
2219   {
2220     char options[] = "ro";
2221     char vfstype[] = "squashfs";
2222     char device[] = "/dev/sdd";
2223     char mountpoint[] = "/";
2224     int r;
2225     suppress_error = 0;
2226     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2227     if (r == -1)
2228       return -1;
2229   }
2230   {
2231     char path[] = "/10klines";
2232     char **r;
2233     int i;
2234     suppress_error = 0;
2235     r = guestfs_head (g, path);
2236     if (r == NULL)
2237       return -1;
2238     if (!r[0]) {
2239       fprintf (stderr, "test_head_0: short list returned from command\n");
2240       print_strings (r);
2241       return -1;
2242     }
2243     {
2244       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
2245       if (strcmp (r[0], expected) != 0) {
2246         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2247         return -1;
2248       }
2249     }
2250     if (!r[1]) {
2251       fprintf (stderr, "test_head_0: short list returned from command\n");
2252       print_strings (r);
2253       return -1;
2254     }
2255     {
2256       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2257       if (strcmp (r[1], expected) != 0) {
2258         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2259         return -1;
2260       }
2261     }
2262     if (!r[2]) {
2263       fprintf (stderr, "test_head_0: short list returned from command\n");
2264       print_strings (r);
2265       return -1;
2266     }
2267     {
2268       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2269       if (strcmp (r[2], expected) != 0) {
2270         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2271         return -1;
2272       }
2273     }
2274     if (!r[3]) {
2275       fprintf (stderr, "test_head_0: short list returned from command\n");
2276       print_strings (r);
2277       return -1;
2278     }
2279     {
2280       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
2281       if (strcmp (r[3], expected) != 0) {
2282         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2283         return -1;
2284       }
2285     }
2286     if (!r[4]) {
2287       fprintf (stderr, "test_head_0: short list returned from command\n");
2288       print_strings (r);
2289       return -1;
2290     }
2291     {
2292       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
2293       if (strcmp (r[4], expected) != 0) {
2294         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
2295         return -1;
2296       }
2297     }
2298     if (!r[5]) {
2299       fprintf (stderr, "test_head_0: short list returned from command\n");
2300       print_strings (r);
2301       return -1;
2302     }
2303     {
2304       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
2305       if (strcmp (r[5], expected) != 0) {
2306         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
2307         return -1;
2308       }
2309     }
2310     if (!r[6]) {
2311       fprintf (stderr, "test_head_0: short list returned from command\n");
2312       print_strings (r);
2313       return -1;
2314     }
2315     {
2316       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
2317       if (strcmp (r[6], expected) != 0) {
2318         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
2319         return -1;
2320       }
2321     }
2322     if (!r[7]) {
2323       fprintf (stderr, "test_head_0: short list returned from command\n");
2324       print_strings (r);
2325       return -1;
2326     }
2327     {
2328       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
2329       if (strcmp (r[7], expected) != 0) {
2330         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
2331         return -1;
2332       }
2333     }
2334     if (!r[8]) {
2335       fprintf (stderr, "test_head_0: short list returned from command\n");
2336       print_strings (r);
2337       return -1;
2338     }
2339     {
2340       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
2341       if (strcmp (r[8], expected) != 0) {
2342         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
2343         return -1;
2344       }
2345     }
2346     if (!r[9]) {
2347       fprintf (stderr, "test_head_0: short list returned from command\n");
2348       print_strings (r);
2349       return -1;
2350     }
2351     {
2352       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
2353       if (strcmp (r[9], expected) != 0) {
2354         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
2355         return -1;
2356       }
2357     }
2358     if (r[10] != NULL) {
2359       fprintf (stderr, "test_head_0: extra elements returned from command\n");
2360       print_strings (r);
2361       return -1;
2362     }
2363     for (i = 0; r[i] != NULL; ++i)
2364       free (r[i]);
2365     free (r);
2366   }
2367   return 0;
2368 }
2369
2370 static int test_wc_c_0_skip (void)
2371 {
2372   const char *str;
2373
2374   str = getenv ("TEST_ONLY");
2375   if (str)
2376     return strstr (str, "wc_c") == NULL;
2377   str = getenv ("SKIP_TEST_WC_C_0");
2378   if (str && strcmp (str, "1") == 0) return 1;
2379   str = getenv ("SKIP_TEST_WC_C");
2380   if (str && strcmp (str, "1") == 0) return 1;
2381   return 0;
2382 }
2383
2384 static int test_wc_c_0 (void)
2385 {
2386   if (test_wc_c_0_skip ()) {
2387     printf ("        %s skipped (reason: environment variable set)\n", "test_wc_c_0");
2388     return 0;
2389   }
2390
2391   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
2392   {
2393     char device[] = "/dev/sda";
2394     int r;
2395     suppress_error = 0;
2396     r = guestfs_blockdev_setrw (g, device);
2397     if (r == -1)
2398       return -1;
2399   }
2400   {
2401     int r;
2402     suppress_error = 0;
2403     r = guestfs_umount_all (g);
2404     if (r == -1)
2405       return -1;
2406   }
2407   {
2408     int r;
2409     suppress_error = 0;
2410     r = guestfs_lvm_remove_all (g);
2411     if (r == -1)
2412       return -1;
2413   }
2414   {
2415     char device[] = "/dev/sda";
2416     char lines_0[] = ",";
2417     char *lines[] = {
2418       lines_0,
2419       NULL
2420     };
2421     int r;
2422     suppress_error = 0;
2423     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2424     if (r == -1)
2425       return -1;
2426   }
2427   {
2428     char fstype[] = "ext2";
2429     char device[] = "/dev/sda1";
2430     int r;
2431     suppress_error = 0;
2432     r = guestfs_mkfs (g, fstype, device);
2433     if (r == -1)
2434       return -1;
2435   }
2436   {
2437     char device[] = "/dev/sda1";
2438     char mountpoint[] = "/";
2439     int r;
2440     suppress_error = 0;
2441     r = guestfs_mount (g, device, mountpoint);
2442     if (r == -1)
2443       return -1;
2444   }
2445   /* TestOutputInt for wc_c (0) */
2446   {
2447     char options[] = "ro";
2448     char vfstype[] = "squashfs";
2449     char device[] = "/dev/sdd";
2450     char mountpoint[] = "/";
2451     int r;
2452     suppress_error = 0;
2453     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2454     if (r == -1)
2455       return -1;
2456   }
2457   {
2458     char path[] = "/100kallspaces";
2459     int r;
2460     suppress_error = 0;
2461     r = guestfs_wc_c (g, path);
2462     if (r == -1)
2463       return -1;
2464     if (r != 102400) {
2465       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
2466       return -1;
2467     }
2468   }
2469   return 0;
2470 }
2471
2472 static int test_wc_w_0_skip (void)
2473 {
2474   const char *str;
2475
2476   str = getenv ("TEST_ONLY");
2477   if (str)
2478     return strstr (str, "wc_w") == NULL;
2479   str = getenv ("SKIP_TEST_WC_W_0");
2480   if (str && strcmp (str, "1") == 0) return 1;
2481   str = getenv ("SKIP_TEST_WC_W");
2482   if (str && strcmp (str, "1") == 0) return 1;
2483   return 0;
2484 }
2485
2486 static int test_wc_w_0 (void)
2487 {
2488   if (test_wc_w_0_skip ()) {
2489     printf ("        %s skipped (reason: environment variable set)\n", "test_wc_w_0");
2490     return 0;
2491   }
2492
2493   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
2494   {
2495     char device[] = "/dev/sda";
2496     int r;
2497     suppress_error = 0;
2498     r = guestfs_blockdev_setrw (g, device);
2499     if (r == -1)
2500       return -1;
2501   }
2502   {
2503     int r;
2504     suppress_error = 0;
2505     r = guestfs_umount_all (g);
2506     if (r == -1)
2507       return -1;
2508   }
2509   {
2510     int r;
2511     suppress_error = 0;
2512     r = guestfs_lvm_remove_all (g);
2513     if (r == -1)
2514       return -1;
2515   }
2516   {
2517     char device[] = "/dev/sda";
2518     char lines_0[] = ",";
2519     char *lines[] = {
2520       lines_0,
2521       NULL
2522     };
2523     int r;
2524     suppress_error = 0;
2525     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2526     if (r == -1)
2527       return -1;
2528   }
2529   {
2530     char fstype[] = "ext2";
2531     char device[] = "/dev/sda1";
2532     int r;
2533     suppress_error = 0;
2534     r = guestfs_mkfs (g, fstype, device);
2535     if (r == -1)
2536       return -1;
2537   }
2538   {
2539     char device[] = "/dev/sda1";
2540     char mountpoint[] = "/";
2541     int r;
2542     suppress_error = 0;
2543     r = guestfs_mount (g, device, mountpoint);
2544     if (r == -1)
2545       return -1;
2546   }
2547   /* TestOutputInt for wc_w (0) */
2548   {
2549     char options[] = "ro";
2550     char vfstype[] = "squashfs";
2551     char device[] = "/dev/sdd";
2552     char mountpoint[] = "/";
2553     int r;
2554     suppress_error = 0;
2555     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2556     if (r == -1)
2557       return -1;
2558   }
2559   {
2560     char path[] = "/10klines";
2561     int r;
2562     suppress_error = 0;
2563     r = guestfs_wc_w (g, path);
2564     if (r == -1)
2565       return -1;
2566     if (r != 10000) {
2567       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
2568       return -1;
2569     }
2570   }
2571   return 0;
2572 }
2573
2574 static int test_wc_l_0_skip (void)
2575 {
2576   const char *str;
2577
2578   str = getenv ("TEST_ONLY");
2579   if (str)
2580     return strstr (str, "wc_l") == NULL;
2581   str = getenv ("SKIP_TEST_WC_L_0");
2582   if (str && strcmp (str, "1") == 0) return 1;
2583   str = getenv ("SKIP_TEST_WC_L");
2584   if (str && strcmp (str, "1") == 0) return 1;
2585   return 0;
2586 }
2587
2588 static int test_wc_l_0 (void)
2589 {
2590   if (test_wc_l_0_skip ()) {
2591     printf ("        %s skipped (reason: environment variable set)\n", "test_wc_l_0");
2592     return 0;
2593   }
2594
2595   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2596   {
2597     char device[] = "/dev/sda";
2598     int r;
2599     suppress_error = 0;
2600     r = guestfs_blockdev_setrw (g, device);
2601     if (r == -1)
2602       return -1;
2603   }
2604   {
2605     int r;
2606     suppress_error = 0;
2607     r = guestfs_umount_all (g);
2608     if (r == -1)
2609       return -1;
2610   }
2611   {
2612     int r;
2613     suppress_error = 0;
2614     r = guestfs_lvm_remove_all (g);
2615     if (r == -1)
2616       return -1;
2617   }
2618   {
2619     char device[] = "/dev/sda";
2620     char lines_0[] = ",";
2621     char *lines[] = {
2622       lines_0,
2623       NULL
2624     };
2625     int r;
2626     suppress_error = 0;
2627     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2628     if (r == -1)
2629       return -1;
2630   }
2631   {
2632     char fstype[] = "ext2";
2633     char device[] = "/dev/sda1";
2634     int r;
2635     suppress_error = 0;
2636     r = guestfs_mkfs (g, fstype, device);
2637     if (r == -1)
2638       return -1;
2639   }
2640   {
2641     char device[] = "/dev/sda1";
2642     char mountpoint[] = "/";
2643     int r;
2644     suppress_error = 0;
2645     r = guestfs_mount (g, device, mountpoint);
2646     if (r == -1)
2647       return -1;
2648   }
2649   /* TestOutputInt for wc_l (0) */
2650   {
2651     char options[] = "ro";
2652     char vfstype[] = "squashfs";
2653     char device[] = "/dev/sdd";
2654     char mountpoint[] = "/";
2655     int r;
2656     suppress_error = 0;
2657     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2658     if (r == -1)
2659       return -1;
2660   }
2661   {
2662     char path[] = "/10klines";
2663     int r;
2664     suppress_error = 0;
2665     r = guestfs_wc_l (g, path);
2666     if (r == -1)
2667       return -1;
2668     if (r != 10000) {
2669       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
2670       return -1;
2671     }
2672   }
2673   return 0;
2674 }
2675
2676 static int test_mkdtemp_0_skip (void)
2677 {
2678   const char *str;
2679
2680   str = getenv ("TEST_ONLY");
2681   if (str)
2682     return strstr (str, "mkdtemp") == NULL;
2683   str = getenv ("SKIP_TEST_MKDTEMP_0");
2684   if (str && strcmp (str, "1") == 0) return 1;
2685   str = getenv ("SKIP_TEST_MKDTEMP");
2686   if (str && strcmp (str, "1") == 0) return 1;
2687   return 0;
2688 }
2689
2690 static int test_mkdtemp_0 (void)
2691 {
2692   if (test_mkdtemp_0_skip ()) {
2693     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2694     return 0;
2695   }
2696
2697   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2698   {
2699     char device[] = "/dev/sda";
2700     int r;
2701     suppress_error = 0;
2702     r = guestfs_blockdev_setrw (g, device);
2703     if (r == -1)
2704       return -1;
2705   }
2706   {
2707     int r;
2708     suppress_error = 0;
2709     r = guestfs_umount_all (g);
2710     if (r == -1)
2711       return -1;
2712   }
2713   {
2714     int r;
2715     suppress_error = 0;
2716     r = guestfs_lvm_remove_all (g);
2717     if (r == -1)
2718       return -1;
2719   }
2720   {
2721     char device[] = "/dev/sda";
2722     char lines_0[] = ",";
2723     char *lines[] = {
2724       lines_0,
2725       NULL
2726     };
2727     int r;
2728     suppress_error = 0;
2729     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2730     if (r == -1)
2731       return -1;
2732   }
2733   {
2734     char fstype[] = "ext2";
2735     char device[] = "/dev/sda1";
2736     int r;
2737     suppress_error = 0;
2738     r = guestfs_mkfs (g, fstype, device);
2739     if (r == -1)
2740       return -1;
2741   }
2742   {
2743     char device[] = "/dev/sda1";
2744     char mountpoint[] = "/";
2745     int r;
2746     suppress_error = 0;
2747     r = guestfs_mount (g, device, mountpoint);
2748     if (r == -1)
2749       return -1;
2750   }
2751   /* TestRun for mkdtemp (0) */
2752   {
2753     char path[] = "/tmp";
2754     int r;
2755     suppress_error = 0;
2756     r = guestfs_mkdir (g, path);
2757     if (r == -1)
2758       return -1;
2759   }
2760   {
2761     char template[] = "/tmp/tmpXXXXXX";
2762     char *r;
2763     suppress_error = 0;
2764     r = guestfs_mkdtemp (g, template);
2765     if (r == NULL)
2766       return -1;
2767     free (r);
2768   }
2769   return 0;
2770 }
2771
2772 static int test_scrub_file_0_skip (void)
2773 {
2774   const char *str;
2775
2776   str = getenv ("TEST_ONLY");
2777   if (str)
2778     return strstr (str, "scrub_file") == NULL;
2779   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2780   if (str && strcmp (str, "1") == 0) return 1;
2781   str = getenv ("SKIP_TEST_SCRUB_FILE");
2782   if (str && strcmp (str, "1") == 0) return 1;
2783   return 0;
2784 }
2785
2786 static int test_scrub_file_0 (void)
2787 {
2788   if (test_scrub_file_0_skip ()) {
2789     printf ("        %s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2790     return 0;
2791   }
2792
2793   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2794   {
2795     char device[] = "/dev/sda";
2796     int r;
2797     suppress_error = 0;
2798     r = guestfs_blockdev_setrw (g, device);
2799     if (r == -1)
2800       return -1;
2801   }
2802   {
2803     int r;
2804     suppress_error = 0;
2805     r = guestfs_umount_all (g);
2806     if (r == -1)
2807       return -1;
2808   }
2809   {
2810     int r;
2811     suppress_error = 0;
2812     r = guestfs_lvm_remove_all (g);
2813     if (r == -1)
2814       return -1;
2815   }
2816   {
2817     char device[] = "/dev/sda";
2818     char lines_0[] = ",";
2819     char *lines[] = {
2820       lines_0,
2821       NULL
2822     };
2823     int r;
2824     suppress_error = 0;
2825     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2826     if (r == -1)
2827       return -1;
2828   }
2829   {
2830     char fstype[] = "ext2";
2831     char device[] = "/dev/sda1";
2832     int r;
2833     suppress_error = 0;
2834     r = guestfs_mkfs (g, fstype, device);
2835     if (r == -1)
2836       return -1;
2837   }
2838   {
2839     char device[] = "/dev/sda1";
2840     char mountpoint[] = "/";
2841     int r;
2842     suppress_error = 0;
2843     r = guestfs_mount (g, device, mountpoint);
2844     if (r == -1)
2845       return -1;
2846   }
2847   /* TestRun for scrub_file (0) */
2848   {
2849     char path[] = "/file";
2850     char content[] = "content";
2851     int r;
2852     suppress_error = 0;
2853     r = guestfs_write_file (g, path, content, 0);
2854     if (r == -1)
2855       return -1;
2856   }
2857   {
2858     char file[] = "/file";
2859     int r;
2860     suppress_error = 0;
2861     r = guestfs_scrub_file (g, file);
2862     if (r == -1)
2863       return -1;
2864   }
2865   return 0;
2866 }
2867
2868 static int test_scrub_device_0_skip (void)
2869 {
2870   const char *str;
2871
2872   str = getenv ("TEST_ONLY");
2873   if (str)
2874     return strstr (str, "scrub_device") == NULL;
2875   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2876   if (str && strcmp (str, "1") == 0) return 1;
2877   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2878   if (str && strcmp (str, "1") == 0) return 1;
2879   return 0;
2880 }
2881
2882 static int test_scrub_device_0 (void)
2883 {
2884   if (test_scrub_device_0_skip ()) {
2885     printf ("        %s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2886     return 0;
2887   }
2888
2889   /* InitNone|InitEmpty for test_scrub_device_0 */
2890   {
2891     char device[] = "/dev/sda";
2892     int r;
2893     suppress_error = 0;
2894     r = guestfs_blockdev_setrw (g, device);
2895     if (r == -1)
2896       return -1;
2897   }
2898   {
2899     int r;
2900     suppress_error = 0;
2901     r = guestfs_umount_all (g);
2902     if (r == -1)
2903       return -1;
2904   }
2905   {
2906     int r;
2907     suppress_error = 0;
2908     r = guestfs_lvm_remove_all (g);
2909     if (r == -1)
2910       return -1;
2911   }
2912   /* TestRun for scrub_device (0) */
2913   {
2914     char device[] = "/dev/sdc";
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_scrub_device (g, device);
2918     if (r == -1)
2919       return -1;
2920   }
2921   return 0;
2922 }
2923
2924 static int test_glob_expand_0_skip (void)
2925 {
2926   const char *str;
2927
2928   str = getenv ("TEST_ONLY");
2929   if (str)
2930     return strstr (str, "glob_expand") == NULL;
2931   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2932   if (str && strcmp (str, "1") == 0) return 1;
2933   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2934   if (str && strcmp (str, "1") == 0) return 1;
2935   return 0;
2936 }
2937
2938 static int test_glob_expand_0 (void)
2939 {
2940   if (test_glob_expand_0_skip ()) {
2941     printf ("        %s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2942     return 0;
2943   }
2944
2945   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2946   {
2947     char device[] = "/dev/sda";
2948     int r;
2949     suppress_error = 0;
2950     r = guestfs_blockdev_setrw (g, device);
2951     if (r == -1)
2952       return -1;
2953   }
2954   {
2955     int r;
2956     suppress_error = 0;
2957     r = guestfs_umount_all (g);
2958     if (r == -1)
2959       return -1;
2960   }
2961   {
2962     int r;
2963     suppress_error = 0;
2964     r = guestfs_lvm_remove_all (g);
2965     if (r == -1)
2966       return -1;
2967   }
2968   {
2969     char device[] = "/dev/sda";
2970     char lines_0[] = ",";
2971     char *lines[] = {
2972       lines_0,
2973       NULL
2974     };
2975     int r;
2976     suppress_error = 0;
2977     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2978     if (r == -1)
2979       return -1;
2980   }
2981   {
2982     char fstype[] = "ext2";
2983     char device[] = "/dev/sda1";
2984     int r;
2985     suppress_error = 0;
2986     r = guestfs_mkfs (g, fstype, device);
2987     if (r == -1)
2988       return -1;
2989   }
2990   {
2991     char device[] = "/dev/sda1";
2992     char mountpoint[] = "/";
2993     int r;
2994     suppress_error = 0;
2995     r = guestfs_mount (g, device, mountpoint);
2996     if (r == -1)
2997       return -1;
2998   }
2999   /* TestOutputList for glob_expand (0) */
3000   {
3001     char path[] = "/a/b/c";
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_mkdir_p (g, path);
3005     if (r == -1)
3006       return -1;
3007   }
3008   {
3009     char path[] = "/a/b/c/d";
3010     int r;
3011     suppress_error = 0;
3012     r = guestfs_touch (g, path);
3013     if (r == -1)
3014       return -1;
3015   }
3016   {
3017     char path[] = "/a/b/c/e";
3018     int r;
3019     suppress_error = 0;
3020     r = guestfs_touch (g, path);
3021     if (r == -1)
3022       return -1;
3023   }
3024   {
3025     char pattern[] = "/a/b/c/*";
3026     char **r;
3027     int i;
3028     suppress_error = 0;
3029     r = guestfs_glob_expand (g, pattern);
3030     if (r == NULL)
3031       return -1;
3032     if (!r[0]) {
3033       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3034       print_strings (r);
3035       return -1;
3036     }
3037     {
3038       char expected[] = "/a/b/c/d";
3039       if (strcmp (r[0], expected) != 0) {
3040         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3041         return -1;
3042       }
3043     }
3044     if (!r[1]) {
3045       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3046       print_strings (r);
3047       return -1;
3048     }
3049     {
3050       char expected[] = "/a/b/c/e";
3051       if (strcmp (r[1], expected) != 0) {
3052         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3053         return -1;
3054       }
3055     }
3056     if (r[2] != NULL) {
3057       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
3058       print_strings (r);
3059       return -1;
3060     }
3061     for (i = 0; r[i] != NULL; ++i)
3062       free (r[i]);
3063     free (r);
3064   }
3065   return 0;
3066 }
3067
3068 static int test_glob_expand_1_skip (void)
3069 {
3070   const char *str;
3071
3072   str = getenv ("TEST_ONLY");
3073   if (str)
3074     return strstr (str, "glob_expand") == NULL;
3075   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
3076   if (str && strcmp (str, "1") == 0) return 1;
3077   str = getenv ("SKIP_TEST_GLOB_EXPAND");
3078   if (str && strcmp (str, "1") == 0) return 1;
3079   return 0;
3080 }
3081
3082 static int test_glob_expand_1 (void)
3083 {
3084   if (test_glob_expand_1_skip ()) {
3085     printf ("        %s skipped (reason: environment variable set)\n", "test_glob_expand_1");
3086     return 0;
3087   }
3088
3089   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
3090   {
3091     char device[] = "/dev/sda";
3092     int r;
3093     suppress_error = 0;
3094     r = guestfs_blockdev_setrw (g, device);
3095     if (r == -1)
3096       return -1;
3097   }
3098   {
3099     int r;
3100     suppress_error = 0;
3101     r = guestfs_umount_all (g);
3102     if (r == -1)
3103       return -1;
3104   }
3105   {
3106     int r;
3107     suppress_error = 0;
3108     r = guestfs_lvm_remove_all (g);
3109     if (r == -1)
3110       return -1;
3111   }
3112   {
3113     char device[] = "/dev/sda";
3114     char lines_0[] = ",";
3115     char *lines[] = {
3116       lines_0,
3117       NULL
3118     };
3119     int r;
3120     suppress_error = 0;
3121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3122     if (r == -1)
3123       return -1;
3124   }
3125   {
3126     char fstype[] = "ext2";
3127     char device[] = "/dev/sda1";
3128     int r;
3129     suppress_error = 0;
3130     r = guestfs_mkfs (g, fstype, device);
3131     if (r == -1)
3132       return -1;
3133   }
3134   {
3135     char device[] = "/dev/sda1";
3136     char mountpoint[] = "/";
3137     int r;
3138     suppress_error = 0;
3139     r = guestfs_mount (g, device, mountpoint);
3140     if (r == -1)
3141       return -1;
3142   }
3143   /* TestOutputList for glob_expand (1) */
3144   {
3145     char path[] = "/a/b/c";
3146     int r;
3147     suppress_error = 0;
3148     r = guestfs_mkdir_p (g, path);
3149     if (r == -1)
3150       return -1;
3151   }
3152   {
3153     char path[] = "/a/b/c/d";
3154     int r;
3155     suppress_error = 0;
3156     r = guestfs_touch (g, path);
3157     if (r == -1)
3158       return -1;
3159   }
3160   {
3161     char path[] = "/a/b/c/e";
3162     int r;
3163     suppress_error = 0;
3164     r = guestfs_touch (g, path);
3165     if (r == -1)
3166       return -1;
3167   }
3168   {
3169     char pattern[] = "/a/*/c/*";
3170     char **r;
3171     int i;
3172     suppress_error = 0;
3173     r = guestfs_glob_expand (g, pattern);
3174     if (r == NULL)
3175       return -1;
3176     if (!r[0]) {
3177       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3178       print_strings (r);
3179       return -1;
3180     }
3181     {
3182       char expected[] = "/a/b/c/d";
3183       if (strcmp (r[0], expected) != 0) {
3184         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3185         return -1;
3186       }
3187     }
3188     if (!r[1]) {
3189       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3190       print_strings (r);
3191       return -1;
3192     }
3193     {
3194       char expected[] = "/a/b/c/e";
3195       if (strcmp (r[1], expected) != 0) {
3196         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3197         return -1;
3198       }
3199     }
3200     if (r[2] != NULL) {
3201       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
3202       print_strings (r);
3203       return -1;
3204     }
3205     for (i = 0; r[i] != NULL; ++i)
3206       free (r[i]);
3207     free (r);
3208   }
3209   return 0;
3210 }
3211
3212 static int test_glob_expand_2_skip (void)
3213 {
3214   const char *str;
3215
3216   str = getenv ("TEST_ONLY");
3217   if (str)
3218     return strstr (str, "glob_expand") == NULL;
3219   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
3220   if (str && strcmp (str, "1") == 0) return 1;
3221   str = getenv ("SKIP_TEST_GLOB_EXPAND");
3222   if (str && strcmp (str, "1") == 0) return 1;
3223   return 0;
3224 }
3225
3226 static int test_glob_expand_2 (void)
3227 {
3228   if (test_glob_expand_2_skip ()) {
3229     printf ("        %s skipped (reason: environment variable set)\n", "test_glob_expand_2");
3230     return 0;
3231   }
3232
3233   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
3234   {
3235     char device[] = "/dev/sda";
3236     int r;
3237     suppress_error = 0;
3238     r = guestfs_blockdev_setrw (g, device);
3239     if (r == -1)
3240       return -1;
3241   }
3242   {
3243     int r;
3244     suppress_error = 0;
3245     r = guestfs_umount_all (g);
3246     if (r == -1)
3247       return -1;
3248   }
3249   {
3250     int r;
3251     suppress_error = 0;
3252     r = guestfs_lvm_remove_all (g);
3253     if (r == -1)
3254       return -1;
3255   }
3256   {
3257     char device[] = "/dev/sda";
3258     char lines_0[] = ",";
3259     char *lines[] = {
3260       lines_0,
3261       NULL
3262     };
3263     int r;
3264     suppress_error = 0;
3265     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3266     if (r == -1)
3267       return -1;
3268   }
3269   {
3270     char fstype[] = "ext2";
3271     char device[] = "/dev/sda1";
3272     int r;
3273     suppress_error = 0;
3274     r = guestfs_mkfs (g, fstype, device);
3275     if (r == -1)
3276       return -1;
3277   }
3278   {
3279     char device[] = "/dev/sda1";
3280     char mountpoint[] = "/";
3281     int r;
3282     suppress_error = 0;
3283     r = guestfs_mount (g, device, mountpoint);
3284     if (r == -1)
3285       return -1;
3286   }
3287   /* TestOutputList for glob_expand (2) */
3288   {
3289     char path[] = "/a/b/c";
3290     int r;
3291     suppress_error = 0;
3292     r = guestfs_mkdir_p (g, path);
3293     if (r == -1)
3294       return -1;
3295   }
3296   {
3297     char path[] = "/a/b/c/d";
3298     int r;
3299     suppress_error = 0;
3300     r = guestfs_touch (g, path);
3301     if (r == -1)
3302       return -1;
3303   }
3304   {
3305     char path[] = "/a/b/c/e";
3306     int r;
3307     suppress_error = 0;
3308     r = guestfs_touch (g, path);
3309     if (r == -1)
3310       return -1;
3311   }
3312   {
3313     char pattern[] = "/a/*/x/*";
3314     char **r;
3315     int i;
3316     suppress_error = 0;
3317     r = guestfs_glob_expand (g, pattern);
3318     if (r == NULL)
3319       return -1;
3320     if (r[0] != NULL) {
3321       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
3322       print_strings (r);
3323       return -1;
3324     }
3325     for (i = 0; r[i] != NULL; ++i)
3326       free (r[i]);
3327     free (r);
3328   }
3329   return 0;
3330 }
3331
3332 static int test_ntfs_3g_probe_0_skip (void)
3333 {
3334   const char *str;
3335
3336   str = getenv ("TEST_ONLY");
3337   if (str)
3338     return strstr (str, "ntfs_3g_probe") == NULL;
3339   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
3340   if (str && strcmp (str, "1") == 0) return 1;
3341   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3342   if (str && strcmp (str, "1") == 0) return 1;
3343   return 0;
3344 }
3345
3346 static int test_ntfs_3g_probe_0 (void)
3347 {
3348   if (test_ntfs_3g_probe_0_skip ()) {
3349     printf ("        %s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
3350     return 0;
3351   }
3352
3353   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
3354   {
3355     char device[] = "/dev/sda";
3356     int r;
3357     suppress_error = 0;
3358     r = guestfs_blockdev_setrw (g, device);
3359     if (r == -1)
3360       return -1;
3361   }
3362   {
3363     int r;
3364     suppress_error = 0;
3365     r = guestfs_umount_all (g);
3366     if (r == -1)
3367       return -1;
3368   }
3369   {
3370     int r;
3371     suppress_error = 0;
3372     r = guestfs_lvm_remove_all (g);
3373     if (r == -1)
3374       return -1;
3375   }
3376   /* TestOutputInt for ntfs_3g_probe (0) */
3377   {
3378     char device[] = "/dev/sda";
3379     char lines_0[] = ",";
3380     char *lines[] = {
3381       lines_0,
3382       NULL
3383     };
3384     int r;
3385     suppress_error = 0;
3386     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3387     if (r == -1)
3388       return -1;
3389   }
3390   {
3391     char fstype[] = "ntfs";
3392     char device[] = "/dev/sda1";
3393     int r;
3394     suppress_error = 0;
3395     r = guestfs_mkfs (g, fstype, device);
3396     if (r == -1)
3397       return -1;
3398   }
3399   {
3400     char device[] = "/dev/sda1";
3401     int r;
3402     suppress_error = 0;
3403     r = guestfs_ntfs_3g_probe (g, 1, device);
3404     if (r == -1)
3405       return -1;
3406     if (r != 0) {
3407       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
3408       return -1;
3409     }
3410   }
3411   return 0;
3412 }
3413
3414 static int test_ntfs_3g_probe_1_skip (void)
3415 {
3416   const char *str;
3417
3418   str = getenv ("TEST_ONLY");
3419   if (str)
3420     return strstr (str, "ntfs_3g_probe") == NULL;
3421   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
3422   if (str && strcmp (str, "1") == 0) return 1;
3423   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3424   if (str && strcmp (str, "1") == 0) return 1;
3425   return 0;
3426 }
3427
3428 static int test_ntfs_3g_probe_1 (void)
3429 {
3430   if (test_ntfs_3g_probe_1_skip ()) {
3431     printf ("        %s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
3432     return 0;
3433   }
3434
3435   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
3436   {
3437     char device[] = "/dev/sda";
3438     int r;
3439     suppress_error = 0;
3440     r = guestfs_blockdev_setrw (g, device);
3441     if (r == -1)
3442       return -1;
3443   }
3444   {
3445     int r;
3446     suppress_error = 0;
3447     r = guestfs_umount_all (g);
3448     if (r == -1)
3449       return -1;
3450   }
3451   {
3452     int r;
3453     suppress_error = 0;
3454     r = guestfs_lvm_remove_all (g);
3455     if (r == -1)
3456       return -1;
3457   }
3458   /* TestOutputInt for ntfs_3g_probe (1) */
3459   {
3460     char device[] = "/dev/sda";
3461     char lines_0[] = ",";
3462     char *lines[] = {
3463       lines_0,
3464       NULL
3465     };
3466     int r;
3467     suppress_error = 0;
3468     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3469     if (r == -1)
3470       return -1;
3471   }
3472   {
3473     char fstype[] = "ext2";
3474     char device[] = "/dev/sda1";
3475     int r;
3476     suppress_error = 0;
3477     r = guestfs_mkfs (g, fstype, device);
3478     if (r == -1)
3479       return -1;
3480   }
3481   {
3482     char device[] = "/dev/sda1";
3483     int r;
3484     suppress_error = 0;
3485     r = guestfs_ntfs_3g_probe (g, 1, device);
3486     if (r == -1)
3487       return -1;
3488     if (r != 12) {
3489       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
3490       return -1;
3491     }
3492   }
3493   return 0;
3494 }
3495
3496 static int test_sleep_0_skip (void)
3497 {
3498   const char *str;
3499
3500   str = getenv ("TEST_ONLY");
3501   if (str)
3502     return strstr (str, "sleep") == NULL;
3503   str = getenv ("SKIP_TEST_SLEEP_0");
3504   if (str && strcmp (str, "1") == 0) return 1;
3505   str = getenv ("SKIP_TEST_SLEEP");
3506   if (str && strcmp (str, "1") == 0) return 1;
3507   return 0;
3508 }
3509
3510 static int test_sleep_0 (void)
3511 {
3512   if (test_sleep_0_skip ()) {
3513     printf ("        %s skipped (reason: environment variable set)\n", "test_sleep_0");
3514     return 0;
3515   }
3516
3517   /* InitNone|InitEmpty for test_sleep_0 */
3518   {
3519     char device[] = "/dev/sda";
3520     int r;
3521     suppress_error = 0;
3522     r = guestfs_blockdev_setrw (g, device);
3523     if (r == -1)
3524       return -1;
3525   }
3526   {
3527     int r;
3528     suppress_error = 0;
3529     r = guestfs_umount_all (g);
3530     if (r == -1)
3531       return -1;
3532   }
3533   {
3534     int r;
3535     suppress_error = 0;
3536     r = guestfs_lvm_remove_all (g);
3537     if (r == -1)
3538       return -1;
3539   }
3540   /* TestRun for sleep (0) */
3541   {
3542     int r;
3543     suppress_error = 0;
3544     r = guestfs_sleep (g, 1);
3545     if (r == -1)
3546       return -1;
3547   }
3548   return 0;
3549 }
3550
3551 static int test_find_0_skip (void)
3552 {
3553   const char *str;
3554
3555   str = getenv ("TEST_ONLY");
3556   if (str)
3557     return strstr (str, "find") == NULL;
3558   str = getenv ("SKIP_TEST_FIND_0");
3559   if (str && strcmp (str, "1") == 0) return 1;
3560   str = getenv ("SKIP_TEST_FIND");
3561   if (str && strcmp (str, "1") == 0) return 1;
3562   return 0;
3563 }
3564
3565 static int test_find_0 (void)
3566 {
3567   if (test_find_0_skip ()) {
3568     printf ("        %s skipped (reason: environment variable set)\n", "test_find_0");
3569     return 0;
3570   }
3571
3572   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3573   {
3574     char device[] = "/dev/sda";
3575     int r;
3576     suppress_error = 0;
3577     r = guestfs_blockdev_setrw (g, device);
3578     if (r == -1)
3579       return -1;
3580   }
3581   {
3582     int r;
3583     suppress_error = 0;
3584     r = guestfs_umount_all (g);
3585     if (r == -1)
3586       return -1;
3587   }
3588   {
3589     int r;
3590     suppress_error = 0;
3591     r = guestfs_lvm_remove_all (g);
3592     if (r == -1)
3593       return -1;
3594   }
3595   {
3596     char device[] = "/dev/sda";
3597     char lines_0[] = ",";
3598     char *lines[] = {
3599       lines_0,
3600       NULL
3601     };
3602     int r;
3603     suppress_error = 0;
3604     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3605     if (r == -1)
3606       return -1;
3607   }
3608   {
3609     char fstype[] = "ext2";
3610     char device[] = "/dev/sda1";
3611     int r;
3612     suppress_error = 0;
3613     r = guestfs_mkfs (g, fstype, device);
3614     if (r == -1)
3615       return -1;
3616   }
3617   {
3618     char device[] = "/dev/sda1";
3619     char mountpoint[] = "/";
3620     int r;
3621     suppress_error = 0;
3622     r = guestfs_mount (g, device, mountpoint);
3623     if (r == -1)
3624       return -1;
3625   }
3626   /* TestOutputList for find (0) */
3627   {
3628     char directory[] = "/";
3629     char **r;
3630     int i;
3631     suppress_error = 0;
3632     r = guestfs_find (g, directory);
3633     if (r == NULL)
3634       return -1;
3635     if (!r[0]) {
3636       fprintf (stderr, "test_find_0: short list returned from command\n");
3637       print_strings (r);
3638       return -1;
3639     }
3640     {
3641       char expected[] = "lost+found";
3642       if (strcmp (r[0], expected) != 0) {
3643         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3644         return -1;
3645       }
3646     }
3647     if (r[1] != NULL) {
3648       fprintf (stderr, "test_find_0: extra elements returned from command\n");
3649       print_strings (r);
3650       return -1;
3651     }
3652     for (i = 0; r[i] != NULL; ++i)
3653       free (r[i]);
3654     free (r);
3655   }
3656   return 0;
3657 }
3658
3659 static int test_find_1_skip (void)
3660 {
3661   const char *str;
3662
3663   str = getenv ("TEST_ONLY");
3664   if (str)
3665     return strstr (str, "find") == NULL;
3666   str = getenv ("SKIP_TEST_FIND_1");
3667   if (str && strcmp (str, "1") == 0) return 1;
3668   str = getenv ("SKIP_TEST_FIND");
3669   if (str && strcmp (str, "1") == 0) return 1;
3670   return 0;
3671 }
3672
3673 static int test_find_1 (void)
3674 {
3675   if (test_find_1_skip ()) {
3676     printf ("        %s skipped (reason: environment variable set)\n", "test_find_1");
3677     return 0;
3678   }
3679
3680   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3681   {
3682     char device[] = "/dev/sda";
3683     int r;
3684     suppress_error = 0;
3685     r = guestfs_blockdev_setrw (g, device);
3686     if (r == -1)
3687       return -1;
3688   }
3689   {
3690     int r;
3691     suppress_error = 0;
3692     r = guestfs_umount_all (g);
3693     if (r == -1)
3694       return -1;
3695   }
3696   {
3697     int r;
3698     suppress_error = 0;
3699     r = guestfs_lvm_remove_all (g);
3700     if (r == -1)
3701       return -1;
3702   }
3703   {
3704     char device[] = "/dev/sda";
3705     char lines_0[] = ",";
3706     char *lines[] = {
3707       lines_0,
3708       NULL
3709     };
3710     int r;
3711     suppress_error = 0;
3712     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3713     if (r == -1)
3714       return -1;
3715   }
3716   {
3717     char fstype[] = "ext2";
3718     char device[] = "/dev/sda1";
3719     int r;
3720     suppress_error = 0;
3721     r = guestfs_mkfs (g, fstype, device);
3722     if (r == -1)
3723       return -1;
3724   }
3725   {
3726     char device[] = "/dev/sda1";
3727     char mountpoint[] = "/";
3728     int r;
3729     suppress_error = 0;
3730     r = guestfs_mount (g, device, mountpoint);
3731     if (r == -1)
3732       return -1;
3733   }
3734   /* TestOutputList for find (1) */
3735   {
3736     char path[] = "/a";
3737     int r;
3738     suppress_error = 0;
3739     r = guestfs_touch (g, path);
3740     if (r == -1)
3741       return -1;
3742   }
3743   {
3744     char path[] = "/b";
3745     int r;
3746     suppress_error = 0;
3747     r = guestfs_mkdir (g, path);
3748     if (r == -1)
3749       return -1;
3750   }
3751   {
3752     char path[] = "/b/c";
3753     int r;
3754     suppress_error = 0;
3755     r = guestfs_touch (g, path);
3756     if (r == -1)
3757       return -1;
3758   }
3759   {
3760     char directory[] = "/";
3761     char **r;
3762     int i;
3763     suppress_error = 0;
3764     r = guestfs_find (g, directory);
3765     if (r == NULL)
3766       return -1;
3767     if (!r[0]) {
3768       fprintf (stderr, "test_find_1: short list returned from command\n");
3769       print_strings (r);
3770       return -1;
3771     }
3772     {
3773       char expected[] = "a";
3774       if (strcmp (r[0], expected) != 0) {
3775         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3776         return -1;
3777       }
3778     }
3779     if (!r[1]) {
3780       fprintf (stderr, "test_find_1: short list returned from command\n");
3781       print_strings (r);
3782       return -1;
3783     }
3784     {
3785       char expected[] = "b";
3786       if (strcmp (r[1], expected) != 0) {
3787         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3788         return -1;
3789       }
3790     }
3791     if (!r[2]) {
3792       fprintf (stderr, "test_find_1: short list returned from command\n");
3793       print_strings (r);
3794       return -1;
3795     }
3796     {
3797       char expected[] = "b/c";
3798       if (strcmp (r[2], expected) != 0) {
3799         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3800         return -1;
3801       }
3802     }
3803     if (!r[3]) {
3804       fprintf (stderr, "test_find_1: short list returned from command\n");
3805       print_strings (r);
3806       return -1;
3807     }
3808     {
3809       char expected[] = "lost+found";
3810       if (strcmp (r[3], expected) != 0) {
3811         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3812         return -1;
3813       }
3814     }
3815     if (r[4] != NULL) {
3816       fprintf (stderr, "test_find_1: extra elements returned from command\n");
3817       print_strings (r);
3818       return -1;
3819     }
3820     for (i = 0; r[i] != NULL; ++i)
3821       free (r[i]);
3822     free (r);
3823   }
3824   return 0;
3825 }
3826
3827 static int test_find_2_skip (void)
3828 {
3829   const char *str;
3830
3831   str = getenv ("TEST_ONLY");
3832   if (str)
3833     return strstr (str, "find") == NULL;
3834   str = getenv ("SKIP_TEST_FIND_2");
3835   if (str && strcmp (str, "1") == 0) return 1;
3836   str = getenv ("SKIP_TEST_FIND");
3837   if (str && strcmp (str, "1") == 0) return 1;
3838   return 0;
3839 }
3840
3841 static int test_find_2 (void)
3842 {
3843   if (test_find_2_skip ()) {
3844     printf ("        %s skipped (reason: environment variable set)\n", "test_find_2");
3845     return 0;
3846   }
3847
3848   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3849   {
3850     char device[] = "/dev/sda";
3851     int r;
3852     suppress_error = 0;
3853     r = guestfs_blockdev_setrw (g, device);
3854     if (r == -1)
3855       return -1;
3856   }
3857   {
3858     int r;
3859     suppress_error = 0;
3860     r = guestfs_umount_all (g);
3861     if (r == -1)
3862       return -1;
3863   }
3864   {
3865     int r;
3866     suppress_error = 0;
3867     r = guestfs_lvm_remove_all (g);
3868     if (r == -1)
3869       return -1;
3870   }
3871   {
3872     char device[] = "/dev/sda";
3873     char lines_0[] = ",";
3874     char *lines[] = {
3875       lines_0,
3876       NULL
3877     };
3878     int r;
3879     suppress_error = 0;
3880     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3881     if (r == -1)
3882       return -1;
3883   }
3884   {
3885     char fstype[] = "ext2";
3886     char device[] = "/dev/sda1";
3887     int r;
3888     suppress_error = 0;
3889     r = guestfs_mkfs (g, fstype, device);
3890     if (r == -1)
3891       return -1;
3892   }
3893   {
3894     char device[] = "/dev/sda1";
3895     char mountpoint[] = "/";
3896     int r;
3897     suppress_error = 0;
3898     r = guestfs_mount (g, device, mountpoint);
3899     if (r == -1)
3900       return -1;
3901   }
3902   /* TestOutputList for find (2) */
3903   {
3904     char path[] = "/a/b/c";
3905     int r;
3906     suppress_error = 0;
3907     r = guestfs_mkdir_p (g, path);
3908     if (r == -1)
3909       return -1;
3910   }
3911   {
3912     char path[] = "/a/b/c/d";
3913     int r;
3914     suppress_error = 0;
3915     r = guestfs_touch (g, path);
3916     if (r == -1)
3917       return -1;
3918   }
3919   {
3920     char directory[] = "/a/b/";
3921     char **r;
3922     int i;
3923     suppress_error = 0;
3924     r = guestfs_find (g, directory);
3925     if (r == NULL)
3926       return -1;
3927     if (!r[0]) {
3928       fprintf (stderr, "test_find_2: short list returned from command\n");
3929       print_strings (r);
3930       return -1;
3931     }
3932     {
3933       char expected[] = "c";
3934       if (strcmp (r[0], expected) != 0) {
3935         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3936         return -1;
3937       }
3938     }
3939     if (!r[1]) {
3940       fprintf (stderr, "test_find_2: short list returned from command\n");
3941       print_strings (r);
3942       return -1;
3943     }
3944     {
3945       char expected[] = "c/d";
3946       if (strcmp (r[1], expected) != 0) {
3947         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3948         return -1;
3949       }
3950     }
3951     if (r[2] != NULL) {
3952       fprintf (stderr, "test_find_2: extra elements returned from command\n");
3953       print_strings (r);
3954       return -1;
3955     }
3956     for (i = 0; r[i] != NULL; ++i)
3957       free (r[i]);
3958     free (r);
3959   }
3960   return 0;
3961 }
3962
3963 static int test_lvresize_0_skip (void)
3964 {
3965   const char *str;
3966
3967   str = getenv ("TEST_ONLY");
3968   if (str)
3969     return strstr (str, "lvresize") == NULL;
3970   str = getenv ("SKIP_TEST_LVRESIZE_0");
3971   if (str && strcmp (str, "1") == 0) return 1;
3972   str = getenv ("SKIP_TEST_LVRESIZE");
3973   if (str && strcmp (str, "1") == 0) return 1;
3974   return 0;
3975 }
3976
3977 static int test_lvresize_0 (void)
3978 {
3979   if (test_lvresize_0_skip ()) {
3980     printf ("        %s skipped (reason: environment variable set)\n", "test_lvresize_0");
3981     return 0;
3982   }
3983
3984   /* InitNone|InitEmpty for test_lvresize_0 */
3985   {
3986     char device[] = "/dev/sda";
3987     int r;
3988     suppress_error = 0;
3989     r = guestfs_blockdev_setrw (g, device);
3990     if (r == -1)
3991       return -1;
3992   }
3993   {
3994     int r;
3995     suppress_error = 0;
3996     r = guestfs_umount_all (g);
3997     if (r == -1)
3998       return -1;
3999   }
4000   {
4001     int r;
4002     suppress_error = 0;
4003     r = guestfs_lvm_remove_all (g);
4004     if (r == -1)
4005       return -1;
4006   }
4007   /* TestOutput for lvresize (0) */
4008   char expected[] = "test content";
4009   {
4010     char device[] = "/dev/sda";
4011     char lines_0[] = ",";
4012     char *lines[] = {
4013       lines_0,
4014       NULL
4015     };
4016     int r;
4017     suppress_error = 0;
4018     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4019     if (r == -1)
4020       return -1;
4021   }
4022   {
4023     char device[] = "/dev/sda1";
4024     int r;
4025     suppress_error = 0;
4026     r = guestfs_pvcreate (g, device);
4027     if (r == -1)
4028       return -1;
4029   }
4030   {
4031     char volgroup[] = "VG";
4032     char physvols_0[] = "/dev/sda1";
4033     char *physvols[] = {
4034       physvols_0,
4035       NULL
4036     };
4037     int r;
4038     suppress_error = 0;
4039     r = guestfs_vgcreate (g, volgroup, physvols);
4040     if (r == -1)
4041       return -1;
4042   }
4043   {
4044     char logvol[] = "LV";
4045     char volgroup[] = "VG";
4046     int r;
4047     suppress_error = 0;
4048     r = guestfs_lvcreate (g, logvol, volgroup, 10);
4049     if (r == -1)
4050       return -1;
4051   }
4052   {
4053     char fstype[] = "ext2";
4054     char device[] = "/dev/VG/LV";
4055     int r;
4056     suppress_error = 0;
4057     r = guestfs_mkfs (g, fstype, device);
4058     if (r == -1)
4059       return -1;
4060   }
4061   {
4062     char device[] = "/dev/VG/LV";
4063     char mountpoint[] = "/";
4064     int r;
4065     suppress_error = 0;
4066     r = guestfs_mount (g, device, mountpoint);
4067     if (r == -1)
4068       return -1;
4069   }
4070   {
4071     char path[] = "/new";
4072     char content[] = "test content";
4073     int r;
4074     suppress_error = 0;
4075     r = guestfs_write_file (g, path, content, 0);
4076     if (r == -1)
4077       return -1;
4078   }
4079   {
4080     char pathordevice[] = "/";
4081     int r;
4082     suppress_error = 0;
4083     r = guestfs_umount (g, pathordevice);
4084     if (r == -1)
4085       return -1;
4086   }
4087   {
4088     char device[] = "/dev/VG/LV";
4089     int r;
4090     suppress_error = 0;
4091     r = guestfs_lvresize (g, device, 20);
4092     if (r == -1)
4093       return -1;
4094   }
4095   {
4096     char device[] = "/dev/VG/LV";
4097     int r;
4098     suppress_error = 0;
4099     r = guestfs_e2fsck_f (g, device);
4100     if (r == -1)
4101       return -1;
4102   }
4103   {
4104     char device[] = "/dev/VG/LV";
4105     int r;
4106     suppress_error = 0;
4107     r = guestfs_resize2fs (g, device);
4108     if (r == -1)
4109       return -1;
4110   }
4111   {
4112     char device[] = "/dev/VG/LV";
4113     char mountpoint[] = "/";
4114     int r;
4115     suppress_error = 0;
4116     r = guestfs_mount (g, device, mountpoint);
4117     if (r == -1)
4118       return -1;
4119   }
4120   {
4121     char path[] = "/new";
4122     char *r;
4123     suppress_error = 0;
4124     r = guestfs_cat (g, path);
4125     if (r == NULL)
4126       return -1;
4127     if (strcmp (r, expected) != 0) {
4128       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
4129       return -1;
4130     }
4131     free (r);
4132   }
4133   return 0;
4134 }
4135
4136 static int test_zerofree_0_skip (void)
4137 {
4138   const char *str;
4139
4140   str = getenv ("TEST_ONLY");
4141   if (str)
4142     return strstr (str, "zerofree") == NULL;
4143   str = getenv ("SKIP_TEST_ZEROFREE_0");
4144   if (str && strcmp (str, "1") == 0) return 1;
4145   str = getenv ("SKIP_TEST_ZEROFREE");
4146   if (str && strcmp (str, "1") == 0) return 1;
4147   return 0;
4148 }
4149
4150 static int test_zerofree_0 (void)
4151 {
4152   if (test_zerofree_0_skip ()) {
4153     printf ("        %s skipped (reason: environment variable set)\n", "test_zerofree_0");
4154     return 0;
4155   }
4156
4157   /* InitNone|InitEmpty for test_zerofree_0 */
4158   {
4159     char device[] = "/dev/sda";
4160     int r;
4161     suppress_error = 0;
4162     r = guestfs_blockdev_setrw (g, device);
4163     if (r == -1)
4164       return -1;
4165   }
4166   {
4167     int r;
4168     suppress_error = 0;
4169     r = guestfs_umount_all (g);
4170     if (r == -1)
4171       return -1;
4172   }
4173   {
4174     int r;
4175     suppress_error = 0;
4176     r = guestfs_lvm_remove_all (g);
4177     if (r == -1)
4178       return -1;
4179   }
4180   /* TestOutput for zerofree (0) */
4181   char expected[] = "test file";
4182   {
4183     char device[] = "/dev/sda";
4184     char lines_0[] = ",";
4185     char *lines[] = {
4186       lines_0,
4187       NULL
4188     };
4189     int r;
4190     suppress_error = 0;
4191     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4192     if (r == -1)
4193       return -1;
4194   }
4195   {
4196     char fstype[] = "ext3";
4197     char device[] = "/dev/sda1";
4198     int r;
4199     suppress_error = 0;
4200     r = guestfs_mkfs (g, fstype, device);
4201     if (r == -1)
4202       return -1;
4203   }
4204   {
4205     char device[] = "/dev/sda1";
4206     char mountpoint[] = "/";
4207     int r;
4208     suppress_error = 0;
4209     r = guestfs_mount (g, device, mountpoint);
4210     if (r == -1)
4211       return -1;
4212   }
4213   {
4214     char path[] = "/new";
4215     char content[] = "test file";
4216     int r;
4217     suppress_error = 0;
4218     r = guestfs_write_file (g, path, content, 0);
4219     if (r == -1)
4220       return -1;
4221   }
4222   {
4223     char pathordevice[] = "/dev/sda1";
4224     int r;
4225     suppress_error = 0;
4226     r = guestfs_umount (g, pathordevice);
4227     if (r == -1)
4228       return -1;
4229   }
4230   {
4231     char device[] = "/dev/sda1";
4232     int r;
4233     suppress_error = 0;
4234     r = guestfs_zerofree (g, device);
4235     if (r == -1)
4236       return -1;
4237   }
4238   {
4239     char device[] = "/dev/sda1";
4240     char mountpoint[] = "/";
4241     int r;
4242     suppress_error = 0;
4243     r = guestfs_mount (g, device, mountpoint);
4244     if (r == -1)
4245       return -1;
4246   }
4247   {
4248     char path[] = "/new";
4249     char *r;
4250     suppress_error = 0;
4251     r = guestfs_cat (g, path);
4252     if (r == NULL)
4253       return -1;
4254     if (strcmp (r, expected) != 0) {
4255       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
4256       return -1;
4257     }
4258     free (r);
4259   }
4260   return 0;
4261 }
4262
4263 static int test_hexdump_0_skip (void)
4264 {
4265   const char *str;
4266
4267   str = getenv ("TEST_ONLY");
4268   if (str)
4269     return strstr (str, "hexdump") == NULL;
4270   str = getenv ("SKIP_TEST_HEXDUMP_0");
4271   if (str && strcmp (str, "1") == 0) return 1;
4272   str = getenv ("SKIP_TEST_HEXDUMP");
4273   if (str && strcmp (str, "1") == 0) return 1;
4274   return 0;
4275 }
4276
4277 static int test_hexdump_0 (void)
4278 {
4279   if (test_hexdump_0_skip ()) {
4280     printf ("        %s skipped (reason: environment variable set)\n", "test_hexdump_0");
4281     return 0;
4282   }
4283
4284   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
4285   {
4286     char device[] = "/dev/sda";
4287     int r;
4288     suppress_error = 0;
4289     r = guestfs_blockdev_setrw (g, device);
4290     if (r == -1)
4291       return -1;
4292   }
4293   {
4294     int r;
4295     suppress_error = 0;
4296     r = guestfs_umount_all (g);
4297     if (r == -1)
4298       return -1;
4299   }
4300   {
4301     int r;
4302     suppress_error = 0;
4303     r = guestfs_lvm_remove_all (g);
4304     if (r == -1)
4305       return -1;
4306   }
4307   {
4308     char device[] = "/dev/sda";
4309     char lines_0[] = ",";
4310     char *lines[] = {
4311       lines_0,
4312       NULL
4313     };
4314     int r;
4315     suppress_error = 0;
4316     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4317     if (r == -1)
4318       return -1;
4319   }
4320   {
4321     char fstype[] = "ext2";
4322     char device[] = "/dev/sda1";
4323     int r;
4324     suppress_error = 0;
4325     r = guestfs_mkfs (g, fstype, device);
4326     if (r == -1)
4327       return -1;
4328   }
4329   {
4330     char device[] = "/dev/sda1";
4331     char mountpoint[] = "/";
4332     int r;
4333     suppress_error = 0;
4334     r = guestfs_mount (g, device, mountpoint);
4335     if (r == -1)
4336       return -1;
4337   }
4338   /* TestOutput for hexdump (0) */
4339   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
4340   {
4341     char path[] = "/new";
4342     char content[] = "hello\nworld\n";
4343     int r;
4344     suppress_error = 0;
4345     r = guestfs_write_file (g, path, content, 12);
4346     if (r == -1)
4347       return -1;
4348   }
4349   {
4350     char path[] = "/new";
4351     char *r;
4352     suppress_error = 0;
4353     r = guestfs_hexdump (g, path);
4354     if (r == NULL)
4355       return -1;
4356     if (strcmp (r, expected) != 0) {
4357       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
4358       return -1;
4359     }
4360     free (r);
4361   }
4362   return 0;
4363 }
4364
4365 static int test_hexdump_1_skip (void)
4366 {
4367   const char *str;
4368
4369   str = getenv ("TEST_ONLY");
4370   if (str)
4371     return strstr (str, "hexdump") == NULL;
4372   str = getenv ("SKIP_TEST_HEXDUMP_1");
4373   if (str && strcmp (str, "1") == 0) return 1;
4374   str = getenv ("SKIP_TEST_HEXDUMP");
4375   if (str && strcmp (str, "1") == 0) return 1;
4376   return 0;
4377 }
4378
4379 static int test_hexdump_1 (void)
4380 {
4381   if (test_hexdump_1_skip ()) {
4382     printf ("        %s skipped (reason: environment variable set)\n", "test_hexdump_1");
4383     return 0;
4384   }
4385
4386   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
4387   {
4388     char device[] = "/dev/sda";
4389     int r;
4390     suppress_error = 0;
4391     r = guestfs_blockdev_setrw (g, device);
4392     if (r == -1)
4393       return -1;
4394   }
4395   {
4396     int r;
4397     suppress_error = 0;
4398     r = guestfs_umount_all (g);
4399     if (r == -1)
4400       return -1;
4401   }
4402   {
4403     int r;
4404     suppress_error = 0;
4405     r = guestfs_lvm_remove_all (g);
4406     if (r == -1)
4407       return -1;
4408   }
4409   {
4410     char device[] = "/dev/sda";
4411     char lines_0[] = ",";
4412     char *lines[] = {
4413       lines_0,
4414       NULL
4415     };
4416     int r;
4417     suppress_error = 0;
4418     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4419     if (r == -1)
4420       return -1;
4421   }
4422   {
4423     char fstype[] = "ext2";
4424     char device[] = "/dev/sda1";
4425     int r;
4426     suppress_error = 0;
4427     r = guestfs_mkfs (g, fstype, device);
4428     if (r == -1)
4429       return -1;
4430   }
4431   {
4432     char device[] = "/dev/sda1";
4433     char mountpoint[] = "/";
4434     int r;
4435     suppress_error = 0;
4436     r = guestfs_mount (g, device, mountpoint);
4437     if (r == -1)
4438       return -1;
4439   }
4440   /* TestRun for hexdump (1) */
4441   {
4442     char options[] = "ro";
4443     char vfstype[] = "squashfs";
4444     char device[] = "/dev/sdd";
4445     char mountpoint[] = "/";
4446     int r;
4447     suppress_error = 0;
4448     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
4449     if (r == -1)
4450       return -1;
4451   }
4452   {
4453     char path[] = "/100krandom";
4454     char *r;
4455     suppress_error = 0;
4456     r = guestfs_hexdump (g, path);
4457     if (r == NULL)
4458       return -1;
4459     free (r);
4460   }
4461   return 0;
4462 }
4463
4464 static int test_strings_e_0_skip (void)
4465 {
4466   const char *str;
4467
4468   str = getenv ("TEST_ONLY");
4469   if (str)
4470     return strstr (str, "strings_e") == NULL;
4471   str = getenv ("SKIP_TEST_STRINGS_E_0");
4472   if (str && strcmp (str, "1") == 0) return 1;
4473   str = getenv ("SKIP_TEST_STRINGS_E");
4474   if (str && strcmp (str, "1") == 0) return 1;
4475   return 0;
4476 }
4477
4478 static int test_strings_e_0 (void)
4479 {
4480   if (test_strings_e_0_skip ()) {
4481     printf ("        %s skipped (reason: environment variable set)\n", "test_strings_e_0");
4482     return 0;
4483   }
4484
4485   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
4486   {
4487     char device[] = "/dev/sda";
4488     int r;
4489     suppress_error = 0;
4490     r = guestfs_blockdev_setrw (g, device);
4491     if (r == -1)
4492       return -1;
4493   }
4494   {
4495     int r;
4496     suppress_error = 0;
4497     r = guestfs_umount_all (g);
4498     if (r == -1)
4499       return -1;
4500   }
4501   {
4502     int r;
4503     suppress_error = 0;
4504     r = guestfs_lvm_remove_all (g);
4505     if (r == -1)
4506       return -1;
4507   }
4508   {
4509     char device[] = "/dev/sda";
4510     char lines_0[] = ",";
4511     char *lines[] = {
4512       lines_0,
4513       NULL
4514     };
4515     int r;
4516     suppress_error = 0;
4517     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4518     if (r == -1)
4519       return -1;
4520   }
4521   {
4522     char fstype[] = "ext2";
4523     char device[] = "/dev/sda1";
4524     int r;
4525     suppress_error = 0;
4526     r = guestfs_mkfs (g, fstype, device);
4527     if (r == -1)
4528       return -1;
4529   }
4530   {
4531     char device[] = "/dev/sda1";
4532     char mountpoint[] = "/";
4533     int r;
4534     suppress_error = 0;
4535     r = guestfs_mount (g, device, mountpoint);
4536     if (r == -1)
4537       return -1;
4538   }
4539   /* TestOutputList for strings_e (0) */
4540   {
4541     char path[] = "/new";
4542     char content[] = "hello\nworld\n";
4543     int r;
4544     suppress_error = 0;
4545     r = guestfs_write_file (g, path, content, 0);
4546     if (r == -1)
4547       return -1;
4548   }
4549   {
4550     char encoding[] = "b";
4551     char path[] = "/new";
4552     char **r;
4553     int i;
4554     suppress_error = 0;
4555     r = guestfs_strings_e (g, encoding, path);
4556     if (r == NULL)
4557       return -1;
4558     if (r[0] != NULL) {
4559       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
4560       print_strings (r);
4561       return -1;
4562     }
4563     for (i = 0; r[i] != NULL; ++i)
4564       free (r[i]);
4565     free (r);
4566   }
4567   return 0;
4568 }
4569
4570 static int test_strings_e_1_skip (void)
4571 {
4572   const char *str;
4573
4574   str = getenv ("TEST_ONLY");
4575   if (str)
4576     return strstr (str, "strings_e") == NULL;
4577   str = getenv ("SKIP_TEST_STRINGS_E_1");
4578   if (str && strcmp (str, "1") == 0) return 1;
4579   str = getenv ("SKIP_TEST_STRINGS_E");
4580   if (str && strcmp (str, "1") == 0) return 1;
4581   return 0;
4582 }
4583
4584 static int test_strings_e_1 (void)
4585 {
4586   if (test_strings_e_1_skip ()) {
4587     printf ("        %s skipped (reason: environment variable set)\n", "test_strings_e_1");
4588     return 0;
4589   }
4590
4591   printf ("        %s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
4592   return 0;
4593 }
4594
4595 static int test_strings_0_skip (void)
4596 {
4597   const char *str;
4598
4599   str = getenv ("TEST_ONLY");
4600   if (str)
4601     return strstr (str, "strings") == NULL;
4602   str = getenv ("SKIP_TEST_STRINGS_0");
4603   if (str && strcmp (str, "1") == 0) return 1;
4604   str = getenv ("SKIP_TEST_STRINGS");
4605   if (str && strcmp (str, "1") == 0) return 1;
4606   return 0;
4607 }
4608
4609 static int test_strings_0 (void)
4610 {
4611   if (test_strings_0_skip ()) {
4612     printf ("        %s skipped (reason: environment variable set)\n", "test_strings_0");
4613     return 0;
4614   }
4615
4616   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
4617   {
4618     char device[] = "/dev/sda";
4619     int r;
4620     suppress_error = 0;
4621     r = guestfs_blockdev_setrw (g, device);
4622     if (r == -1)
4623       return -1;
4624   }
4625   {
4626     int r;
4627     suppress_error = 0;
4628     r = guestfs_umount_all (g);
4629     if (r == -1)
4630       return -1;
4631   }
4632   {
4633     int r;
4634     suppress_error = 0;
4635     r = guestfs_lvm_remove_all (g);
4636     if (r == -1)
4637       return -1;
4638   }
4639   {
4640     char device[] = "/dev/sda";
4641     char lines_0[] = ",";
4642     char *lines[] = {
4643       lines_0,
4644       NULL
4645     };
4646     int r;
4647     suppress_error = 0;
4648     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4649     if (r == -1)
4650       return -1;
4651   }
4652   {
4653     char fstype[] = "ext2";
4654     char device[] = "/dev/sda1";
4655     int r;
4656     suppress_error = 0;
4657     r = guestfs_mkfs (g, fstype, device);
4658     if (r == -1)
4659       return -1;
4660   }
4661   {
4662     char device[] = "/dev/sda1";
4663     char mountpoint[] = "/";
4664     int r;
4665     suppress_error = 0;
4666     r = guestfs_mount (g, device, mountpoint);
4667     if (r == -1)
4668       return -1;
4669   }
4670   /* TestOutputList for strings (0) */
4671   {
4672     char path[] = "/new";
4673     char content[] = "hello\nworld\n";
4674     int r;
4675     suppress_error = 0;
4676     r = guestfs_write_file (g, path, content, 0);
4677     if (r == -1)
4678       return -1;
4679   }
4680   {
4681     char path[] = "/new";
4682     char **r;
4683     int i;
4684     suppress_error = 0;
4685     r = guestfs_strings (g, path);
4686     if (r == NULL)
4687       return -1;
4688     if (!r[0]) {
4689       fprintf (stderr, "test_strings_0: short list returned from command\n");
4690       print_strings (r);
4691       return -1;
4692     }
4693     {
4694       char expected[] = "hello";
4695       if (strcmp (r[0], expected) != 0) {
4696         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4697         return -1;
4698       }
4699     }
4700     if (!r[1]) {
4701       fprintf (stderr, "test_strings_0: short list returned from command\n");
4702       print_strings (r);
4703       return -1;
4704     }
4705     {
4706       char expected[] = "world";
4707       if (strcmp (r[1], expected) != 0) {
4708         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
4709         return -1;
4710       }
4711     }
4712     if (r[2] != NULL) {
4713       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4714       print_strings (r);
4715       return -1;
4716     }
4717     for (i = 0; r[i] != NULL; ++i)
4718       free (r[i]);
4719     free (r);
4720   }
4721   return 0;
4722 }
4723
4724 static int test_strings_1_skip (void)
4725 {
4726   const char *str;
4727
4728   str = getenv ("TEST_ONLY");
4729   if (str)
4730     return strstr (str, "strings") == NULL;
4731   str = getenv ("SKIP_TEST_STRINGS_1");
4732   if (str && strcmp (str, "1") == 0) return 1;
4733   str = getenv ("SKIP_TEST_STRINGS");
4734   if (str && strcmp (str, "1") == 0) return 1;
4735   return 0;
4736 }
4737
4738 static int test_strings_1 (void)
4739 {
4740   if (test_strings_1_skip ()) {
4741     printf ("        %s skipped (reason: environment variable set)\n", "test_strings_1");
4742     return 0;
4743   }
4744
4745   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4746   {
4747     char device[] = "/dev/sda";
4748     int r;
4749     suppress_error = 0;
4750     r = guestfs_blockdev_setrw (g, device);
4751     if (r == -1)
4752       return -1;
4753   }
4754   {
4755     int r;
4756     suppress_error = 0;
4757     r = guestfs_umount_all (g);
4758     if (r == -1)
4759       return -1;
4760   }
4761   {
4762     int r;
4763     suppress_error = 0;
4764     r = guestfs_lvm_remove_all (g);
4765     if (r == -1)
4766       return -1;
4767   }
4768   {
4769     char device[] = "/dev/sda";
4770     char lines_0[] = ",";
4771     char *lines[] = {
4772       lines_0,
4773       NULL
4774     };
4775     int r;
4776     suppress_error = 0;
4777     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4778     if (r == -1)
4779       return -1;
4780   }
4781   {
4782     char fstype[] = "ext2";
4783     char device[] = "/dev/sda1";
4784     int r;
4785     suppress_error = 0;
4786     r = guestfs_mkfs (g, fstype, device);
4787     if (r == -1)
4788       return -1;
4789   }
4790   {
4791     char device[] = "/dev/sda1";
4792     char mountpoint[] = "/";
4793     int r;
4794     suppress_error = 0;
4795     r = guestfs_mount (g, device, mountpoint);
4796     if (r == -1)
4797       return -1;
4798   }
4799   /* TestOutputList for strings (1) */
4800   {
4801     char path[] = "/new";
4802     int r;
4803     suppress_error = 0;
4804     r = guestfs_touch (g, path);
4805     if (r == -1)
4806       return -1;
4807   }
4808   {
4809     char path[] = "/new";
4810     char **r;
4811     int i;
4812     suppress_error = 0;
4813     r = guestfs_strings (g, path);
4814     if (r == NULL)
4815       return -1;
4816     if (r[0] != NULL) {
4817       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4818       print_strings (r);
4819       return -1;
4820     }
4821     for (i = 0; r[i] != NULL; ++i)
4822       free (r[i]);
4823     free (r);
4824   }
4825   return 0;
4826 }
4827
4828 static int test_equal_0_skip (void)
4829 {
4830   const char *str;
4831
4832   str = getenv ("TEST_ONLY");
4833   if (str)
4834     return strstr (str, "equal") == NULL;
4835   str = getenv ("SKIP_TEST_EQUAL_0");
4836   if (str && strcmp (str, "1") == 0) return 1;
4837   str = getenv ("SKIP_TEST_EQUAL");
4838   if (str && strcmp (str, "1") == 0) return 1;
4839   return 0;
4840 }
4841
4842 static int test_equal_0 (void)
4843 {
4844   if (test_equal_0_skip ()) {
4845     printf ("        %s skipped (reason: environment variable set)\n", "test_equal_0");
4846     return 0;
4847   }
4848
4849   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4850   {
4851     char device[] = "/dev/sda";
4852     int r;
4853     suppress_error = 0;
4854     r = guestfs_blockdev_setrw (g, device);
4855     if (r == -1)
4856       return -1;
4857   }
4858   {
4859     int r;
4860     suppress_error = 0;
4861     r = guestfs_umount_all (g);
4862     if (r == -1)
4863       return -1;
4864   }
4865   {
4866     int r;
4867     suppress_error = 0;
4868     r = guestfs_lvm_remove_all (g);
4869     if (r == -1)
4870       return -1;
4871   }
4872   {
4873     char device[] = "/dev/sda";
4874     char lines_0[] = ",";
4875     char *lines[] = {
4876       lines_0,
4877       NULL
4878     };
4879     int r;
4880     suppress_error = 0;
4881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4882     if (r == -1)
4883       return -1;
4884   }
4885   {
4886     char fstype[] = "ext2";
4887     char device[] = "/dev/sda1";
4888     int r;
4889     suppress_error = 0;
4890     r = guestfs_mkfs (g, fstype, device);
4891     if (r == -1)
4892       return -1;
4893   }
4894   {
4895     char device[] = "/dev/sda1";
4896     char mountpoint[] = "/";
4897     int r;
4898     suppress_error = 0;
4899     r = guestfs_mount (g, device, mountpoint);
4900     if (r == -1)
4901       return -1;
4902   }
4903   /* TestOutputTrue for equal (0) */
4904   {
4905     char path[] = "/file1";
4906     char content[] = "contents of a file";
4907     int r;
4908     suppress_error = 0;
4909     r = guestfs_write_file (g, path, content, 0);
4910     if (r == -1)
4911       return -1;
4912   }
4913   {
4914     char src[] = "/file1";
4915     char dest[] = "/file2";
4916     int r;
4917     suppress_error = 0;
4918     r = guestfs_cp (g, src, dest);
4919     if (r == -1)
4920       return -1;
4921   }
4922   {
4923     char file1[] = "/file1";
4924     char file2[] = "/file2";
4925     int r;
4926     suppress_error = 0;
4927     r = guestfs_equal (g, file1, file2);
4928     if (r == -1)
4929       return -1;
4930     if (!r) {
4931       fprintf (stderr, "test_equal_0: expected true, got false\n");
4932       return -1;
4933     }
4934   }
4935   return 0;
4936 }
4937
4938 static int test_equal_1_skip (void)
4939 {
4940   const char *str;
4941
4942   str = getenv ("TEST_ONLY");
4943   if (str)
4944     return strstr (str, "equal") == NULL;
4945   str = getenv ("SKIP_TEST_EQUAL_1");
4946   if (str && strcmp (str, "1") == 0) return 1;
4947   str = getenv ("SKIP_TEST_EQUAL");
4948   if (str && strcmp (str, "1") == 0) return 1;
4949   return 0;
4950 }
4951
4952 static int test_equal_1 (void)
4953 {
4954   if (test_equal_1_skip ()) {
4955     printf ("        %s skipped (reason: environment variable set)\n", "test_equal_1");
4956     return 0;
4957   }
4958
4959   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4960   {
4961     char device[] = "/dev/sda";
4962     int r;
4963     suppress_error = 0;
4964     r = guestfs_blockdev_setrw (g, device);
4965     if (r == -1)
4966       return -1;
4967   }
4968   {
4969     int r;
4970     suppress_error = 0;
4971     r = guestfs_umount_all (g);
4972     if (r == -1)
4973       return -1;
4974   }
4975   {
4976     int r;
4977     suppress_error = 0;
4978     r = guestfs_lvm_remove_all (g);
4979     if (r == -1)
4980       return -1;
4981   }
4982   {
4983     char device[] = "/dev/sda";
4984     char lines_0[] = ",";
4985     char *lines[] = {
4986       lines_0,
4987       NULL
4988     };
4989     int r;
4990     suppress_error = 0;
4991     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4992     if (r == -1)
4993       return -1;
4994   }
4995   {
4996     char fstype[] = "ext2";
4997     char device[] = "/dev/sda1";
4998     int r;
4999     suppress_error = 0;
5000     r = guestfs_mkfs (g, fstype, device);
5001     if (r == -1)
5002       return -1;
5003   }
5004   {
5005     char device[] = "/dev/sda1";
5006     char mountpoint[] = "/";
5007     int r;
5008     suppress_error = 0;
5009     r = guestfs_mount (g, device, mountpoint);
5010     if (r == -1)
5011       return -1;
5012   }
5013   /* TestOutputFalse for equal (1) */
5014   {
5015     char path[] = "/file1";
5016     char content[] = "contents of a file";
5017     int r;
5018     suppress_error = 0;
5019     r = guestfs_write_file (g, path, content, 0);
5020     if (r == -1)
5021       return -1;
5022   }
5023   {
5024     char path[] = "/file2";
5025     char content[] = "contents of another file";
5026     int r;
5027     suppress_error = 0;
5028     r = guestfs_write_file (g, path, content, 0);
5029     if (r == -1)
5030       return -1;
5031   }
5032   {
5033     char file1[] = "/file1";
5034     char file2[] = "/file2";
5035     int r;
5036     suppress_error = 0;
5037     r = guestfs_equal (g, file1, file2);
5038     if (r == -1)
5039       return -1;
5040     if (r) {
5041       fprintf (stderr, "test_equal_1: expected false, got true\n");
5042       return -1;
5043     }
5044   }
5045   return 0;
5046 }
5047
5048 static int test_equal_2_skip (void)
5049 {
5050   const char *str;
5051
5052   str = getenv ("TEST_ONLY");
5053   if (str)
5054     return strstr (str, "equal") == NULL;
5055   str = getenv ("SKIP_TEST_EQUAL_2");
5056   if (str && strcmp (str, "1") == 0) return 1;
5057   str = getenv ("SKIP_TEST_EQUAL");
5058   if (str && strcmp (str, "1") == 0) return 1;
5059   return 0;
5060 }
5061
5062 static int test_equal_2 (void)
5063 {
5064   if (test_equal_2_skip ()) {
5065     printf ("        %s skipped (reason: environment variable set)\n", "test_equal_2");
5066     return 0;
5067   }
5068
5069   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
5070   {
5071     char device[] = "/dev/sda";
5072     int r;
5073     suppress_error = 0;
5074     r = guestfs_blockdev_setrw (g, device);
5075     if (r == -1)
5076       return -1;
5077   }
5078   {
5079     int r;
5080     suppress_error = 0;
5081     r = guestfs_umount_all (g);
5082     if (r == -1)
5083       return -1;
5084   }
5085   {
5086     int r;
5087     suppress_error = 0;
5088     r = guestfs_lvm_remove_all (g);
5089     if (r == -1)
5090       return -1;
5091   }
5092   {
5093     char device[] = "/dev/sda";
5094     char lines_0[] = ",";
5095     char *lines[] = {
5096       lines_0,
5097       NULL
5098     };
5099     int r;
5100     suppress_error = 0;
5101     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5102     if (r == -1)
5103       return -1;
5104   }
5105   {
5106     char fstype[] = "ext2";
5107     char device[] = "/dev/sda1";
5108     int r;
5109     suppress_error = 0;
5110     r = guestfs_mkfs (g, fstype, device);
5111     if (r == -1)
5112       return -1;
5113   }
5114   {
5115     char device[] = "/dev/sda1";
5116     char mountpoint[] = "/";
5117     int r;
5118     suppress_error = 0;
5119     r = guestfs_mount (g, device, mountpoint);
5120     if (r == -1)
5121       return -1;
5122   }
5123   /* TestLastFail for equal (2) */
5124   {
5125     char file1[] = "/file1";
5126     char file2[] = "/file2";
5127     int r;
5128     suppress_error = 1;
5129     r = guestfs_equal (g, file1, file2);
5130     if (r != -1)
5131       return -1;
5132   }
5133   return 0;
5134 }
5135
5136 static int test_ping_daemon_0_skip (void)
5137 {
5138   const char *str;
5139
5140   str = getenv ("TEST_ONLY");
5141   if (str)
5142     return strstr (str, "ping_daemon") == NULL;
5143   str = getenv ("SKIP_TEST_PING_DAEMON_0");
5144   if (str && strcmp (str, "1") == 0) return 1;
5145   str = getenv ("SKIP_TEST_PING_DAEMON");
5146   if (str && strcmp (str, "1") == 0) return 1;
5147   return 0;
5148 }
5149
5150 static int test_ping_daemon_0 (void)
5151 {
5152   if (test_ping_daemon_0_skip ()) {
5153     printf ("        %s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
5154     return 0;
5155   }
5156
5157   /* InitNone|InitEmpty for test_ping_daemon_0 */
5158   {
5159     char device[] = "/dev/sda";
5160     int r;
5161     suppress_error = 0;
5162     r = guestfs_blockdev_setrw (g, device);
5163     if (r == -1)
5164       return -1;
5165   }
5166   {
5167     int r;
5168     suppress_error = 0;
5169     r = guestfs_umount_all (g);
5170     if (r == -1)
5171       return -1;
5172   }
5173   {
5174     int r;
5175     suppress_error = 0;
5176     r = guestfs_lvm_remove_all (g);
5177     if (r == -1)
5178       return -1;
5179   }
5180   /* TestRun for ping_daemon (0) */
5181   {
5182     int r;
5183     suppress_error = 0;
5184     r = guestfs_ping_daemon (g);
5185     if (r == -1)
5186       return -1;
5187   }
5188   return 0;
5189 }
5190
5191 static int test_dmesg_0_skip (void)
5192 {
5193   const char *str;
5194
5195   str = getenv ("TEST_ONLY");
5196   if (str)
5197     return strstr (str, "dmesg") == NULL;
5198   str = getenv ("SKIP_TEST_DMESG_0");
5199   if (str && strcmp (str, "1") == 0) return 1;
5200   str = getenv ("SKIP_TEST_DMESG");
5201   if (str && strcmp (str, "1") == 0) return 1;
5202   return 0;
5203 }
5204
5205 static int test_dmesg_0 (void)
5206 {
5207   if (test_dmesg_0_skip ()) {
5208     printf ("        %s skipped (reason: environment variable set)\n", "test_dmesg_0");
5209     return 0;
5210   }
5211
5212   /* InitNone|InitEmpty for test_dmesg_0 */
5213   {
5214     char device[] = "/dev/sda";
5215     int r;
5216     suppress_error = 0;
5217     r = guestfs_blockdev_setrw (g, device);
5218     if (r == -1)
5219       return -1;
5220   }
5221   {
5222     int r;
5223     suppress_error = 0;
5224     r = guestfs_umount_all (g);
5225     if (r == -1)
5226       return -1;
5227   }
5228   {
5229     int r;
5230     suppress_error = 0;
5231     r = guestfs_lvm_remove_all (g);
5232     if (r == -1)
5233       return -1;
5234   }
5235   /* TestRun for dmesg (0) */
5236   {
5237     char *r;
5238     suppress_error = 0;
5239     r = guestfs_dmesg (g);
5240     if (r == NULL)
5241       return -1;
5242     free (r);
5243   }
5244   return 0;
5245 }
5246
5247 static int test_drop_caches_0_skip (void)
5248 {
5249   const char *str;
5250
5251   str = getenv ("TEST_ONLY");
5252   if (str)
5253     return strstr (str, "drop_caches") == NULL;
5254   str = getenv ("SKIP_TEST_DROP_CACHES_0");
5255   if (str && strcmp (str, "1") == 0) return 1;
5256   str = getenv ("SKIP_TEST_DROP_CACHES");
5257   if (str && strcmp (str, "1") == 0) return 1;
5258   return 0;
5259 }
5260
5261 static int test_drop_caches_0 (void)
5262 {
5263   if (test_drop_caches_0_skip ()) {
5264     printf ("        %s skipped (reason: environment variable set)\n", "test_drop_caches_0");
5265     return 0;
5266   }
5267
5268   /* InitNone|InitEmpty for test_drop_caches_0 */
5269   {
5270     char device[] = "/dev/sda";
5271     int r;
5272     suppress_error = 0;
5273     r = guestfs_blockdev_setrw (g, device);
5274     if (r == -1)
5275       return -1;
5276   }
5277   {
5278     int r;
5279     suppress_error = 0;
5280     r = guestfs_umount_all (g);
5281     if (r == -1)
5282       return -1;
5283   }
5284   {
5285     int r;
5286     suppress_error = 0;
5287     r = guestfs_lvm_remove_all (g);
5288     if (r == -1)
5289       return -1;
5290   }
5291   /* TestRun for drop_caches (0) */
5292   {
5293     int r;
5294     suppress_error = 0;
5295     r = guestfs_drop_caches (g, 3);
5296     if (r == -1)
5297       return -1;
5298   }
5299   return 0;
5300 }
5301
5302 static int test_mv_0_skip (void)
5303 {
5304   const char *str;
5305
5306   str = getenv ("TEST_ONLY");
5307   if (str)
5308     return strstr (str, "mv") == NULL;
5309   str = getenv ("SKIP_TEST_MV_0");
5310   if (str && strcmp (str, "1") == 0) return 1;
5311   str = getenv ("SKIP_TEST_MV");
5312   if (str && strcmp (str, "1") == 0) return 1;
5313   return 0;
5314 }
5315
5316 static int test_mv_0 (void)
5317 {
5318   if (test_mv_0_skip ()) {
5319     printf ("        %s skipped (reason: environment variable set)\n", "test_mv_0");
5320     return 0;
5321   }
5322
5323   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
5324   {
5325     char device[] = "/dev/sda";
5326     int r;
5327     suppress_error = 0;
5328     r = guestfs_blockdev_setrw (g, device);
5329     if (r == -1)
5330       return -1;
5331   }
5332   {
5333     int r;
5334     suppress_error = 0;
5335     r = guestfs_umount_all (g);
5336     if (r == -1)
5337       return -1;
5338   }
5339   {
5340     int r;
5341     suppress_error = 0;
5342     r = guestfs_lvm_remove_all (g);
5343     if (r == -1)
5344       return -1;
5345   }
5346   {
5347     char device[] = "/dev/sda";
5348     char lines_0[] = ",";
5349     char *lines[] = {
5350       lines_0,
5351       NULL
5352     };
5353     int r;
5354     suppress_error = 0;
5355     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5356     if (r == -1)
5357       return -1;
5358   }
5359   {
5360     char fstype[] = "ext2";
5361     char device[] = "/dev/sda1";
5362     int r;
5363     suppress_error = 0;
5364     r = guestfs_mkfs (g, fstype, device);
5365     if (r == -1)
5366       return -1;
5367   }
5368   {
5369     char device[] = "/dev/sda1";
5370     char mountpoint[] = "/";
5371     int r;
5372     suppress_error = 0;
5373     r = guestfs_mount (g, device, mountpoint);
5374     if (r == -1)
5375       return -1;
5376   }
5377   /* TestOutput for mv (0) */
5378   char expected[] = "file content";
5379   {
5380     char path[] = "/old";
5381     char content[] = "file content";
5382     int r;
5383     suppress_error = 0;
5384     r = guestfs_write_file (g, path, content, 0);
5385     if (r == -1)
5386       return -1;
5387   }
5388   {
5389     char src[] = "/old";
5390     char dest[] = "/new";
5391     int r;
5392     suppress_error = 0;
5393     r = guestfs_mv (g, src, dest);
5394     if (r == -1)
5395       return -1;
5396   }
5397   {
5398     char path[] = "/new";
5399     char *r;
5400     suppress_error = 0;
5401     r = guestfs_cat (g, path);
5402     if (r == NULL)
5403       return -1;
5404     if (strcmp (r, expected) != 0) {
5405       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
5406       return -1;
5407     }
5408     free (r);
5409   }
5410   return 0;
5411 }
5412
5413 static int test_mv_1_skip (void)
5414 {
5415   const char *str;
5416
5417   str = getenv ("TEST_ONLY");
5418   if (str)
5419     return strstr (str, "mv") == NULL;
5420   str = getenv ("SKIP_TEST_MV_1");
5421   if (str && strcmp (str, "1") == 0) return 1;
5422   str = getenv ("SKIP_TEST_MV");
5423   if (str && strcmp (str, "1") == 0) return 1;
5424   return 0;
5425 }
5426
5427 static int test_mv_1 (void)
5428 {
5429   if (test_mv_1_skip ()) {
5430     printf ("        %s skipped (reason: environment variable set)\n", "test_mv_1");
5431     return 0;
5432   }
5433
5434   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
5435   {
5436     char device[] = "/dev/sda";
5437     int r;
5438     suppress_error = 0;
5439     r = guestfs_blockdev_setrw (g, device);
5440     if (r == -1)
5441       return -1;
5442   }
5443   {
5444     int r;
5445     suppress_error = 0;
5446     r = guestfs_umount_all (g);
5447     if (r == -1)
5448       return -1;
5449   }
5450   {
5451     int r;
5452     suppress_error = 0;
5453     r = guestfs_lvm_remove_all (g);
5454     if (r == -1)
5455       return -1;
5456   }
5457   {
5458     char device[] = "/dev/sda";
5459     char lines_0[] = ",";
5460     char *lines[] = {
5461       lines_0,
5462       NULL
5463     };
5464     int r;
5465     suppress_error = 0;
5466     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5467     if (r == -1)
5468       return -1;
5469   }
5470   {
5471     char fstype[] = "ext2";
5472     char device[] = "/dev/sda1";
5473     int r;
5474     suppress_error = 0;
5475     r = guestfs_mkfs (g, fstype, device);
5476     if (r == -1)
5477       return -1;
5478   }
5479   {
5480     char device[] = "/dev/sda1";
5481     char mountpoint[] = "/";
5482     int r;
5483     suppress_error = 0;
5484     r = guestfs_mount (g, device, mountpoint);
5485     if (r == -1)
5486       return -1;
5487   }
5488   /* TestOutputFalse for mv (1) */
5489   {
5490     char path[] = "/old";
5491     char content[] = "file content";
5492     int r;
5493     suppress_error = 0;
5494     r = guestfs_write_file (g, path, content, 0);
5495     if (r == -1)
5496       return -1;
5497   }
5498   {
5499     char src[] = "/old";
5500     char dest[] = "/new";
5501     int r;
5502     suppress_error = 0;
5503     r = guestfs_mv (g, src, dest);
5504     if (r == -1)
5505       return -1;
5506   }
5507   {
5508     char path[] = "/old";
5509     int r;
5510     suppress_error = 0;
5511     r = guestfs_is_file (g, path);
5512     if (r == -1)
5513       return -1;
5514     if (r) {
5515       fprintf (stderr, "test_mv_1: expected false, got true\n");
5516       return -1;
5517     }
5518   }
5519   return 0;
5520 }
5521
5522 static int test_cp_a_0_skip (void)
5523 {
5524   const char *str;
5525
5526   str = getenv ("TEST_ONLY");
5527   if (str)
5528     return strstr (str, "cp_a") == NULL;
5529   str = getenv ("SKIP_TEST_CP_A_0");
5530   if (str && strcmp (str, "1") == 0) return 1;
5531   str = getenv ("SKIP_TEST_CP_A");
5532   if (str && strcmp (str, "1") == 0) return 1;
5533   return 0;
5534 }
5535
5536 static int test_cp_a_0 (void)
5537 {
5538   if (test_cp_a_0_skip ()) {
5539     printf ("        %s skipped (reason: environment variable set)\n", "test_cp_a_0");
5540     return 0;
5541   }
5542
5543   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
5544   {
5545     char device[] = "/dev/sda";
5546     int r;
5547     suppress_error = 0;
5548     r = guestfs_blockdev_setrw (g, device);
5549     if (r == -1)
5550       return -1;
5551   }
5552   {
5553     int r;
5554     suppress_error = 0;
5555     r = guestfs_umount_all (g);
5556     if (r == -1)
5557       return -1;
5558   }
5559   {
5560     int r;
5561     suppress_error = 0;
5562     r = guestfs_lvm_remove_all (g);
5563     if (r == -1)
5564       return -1;
5565   }
5566   {
5567     char device[] = "/dev/sda";
5568     char lines_0[] = ",";
5569     char *lines[] = {
5570       lines_0,
5571       NULL
5572     };
5573     int r;
5574     suppress_error = 0;
5575     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5576     if (r == -1)
5577       return -1;
5578   }
5579   {
5580     char fstype[] = "ext2";
5581     char device[] = "/dev/sda1";
5582     int r;
5583     suppress_error = 0;
5584     r = guestfs_mkfs (g, fstype, device);
5585     if (r == -1)
5586       return -1;
5587   }
5588   {
5589     char device[] = "/dev/sda1";
5590     char mountpoint[] = "/";
5591     int r;
5592     suppress_error = 0;
5593     r = guestfs_mount (g, device, mountpoint);
5594     if (r == -1)
5595       return -1;
5596   }
5597   /* TestOutput for cp_a (0) */
5598   char expected[] = "file content";
5599   {
5600     char path[] = "/olddir";
5601     int r;
5602     suppress_error = 0;
5603     r = guestfs_mkdir (g, path);
5604     if (r == -1)
5605       return -1;
5606   }
5607   {
5608     char path[] = "/newdir";
5609     int r;
5610     suppress_error = 0;
5611     r = guestfs_mkdir (g, path);
5612     if (r == -1)
5613       return -1;
5614   }
5615   {
5616     char path[] = "/olddir/file";
5617     char content[] = "file content";
5618     int r;
5619     suppress_error = 0;
5620     r = guestfs_write_file (g, path, content, 0);
5621     if (r == -1)
5622       return -1;
5623   }
5624   {
5625     char src[] = "/olddir";
5626     char dest[] = "/newdir";
5627     int r;
5628     suppress_error = 0;
5629     r = guestfs_cp_a (g, src, dest);
5630     if (r == -1)
5631       return -1;
5632   }
5633   {
5634     char path[] = "/newdir/olddir/file";
5635     char *r;
5636     suppress_error = 0;
5637     r = guestfs_cat (g, path);
5638     if (r == NULL)
5639       return -1;
5640     if (strcmp (r, expected) != 0) {
5641       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
5642       return -1;
5643     }
5644     free (r);
5645   }
5646   return 0;
5647 }
5648
5649 static int test_cp_0_skip (void)
5650 {
5651   const char *str;
5652
5653   str = getenv ("TEST_ONLY");
5654   if (str)
5655     return strstr (str, "cp") == NULL;
5656   str = getenv ("SKIP_TEST_CP_0");
5657   if (str && strcmp (str, "1") == 0) return 1;
5658   str = getenv ("SKIP_TEST_CP");
5659   if (str && strcmp (str, "1") == 0) return 1;
5660   return 0;
5661 }
5662
5663 static int test_cp_0 (void)
5664 {
5665   if (test_cp_0_skip ()) {
5666     printf ("        %s skipped (reason: environment variable set)\n", "test_cp_0");
5667     return 0;
5668   }
5669
5670   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
5671   {
5672     char device[] = "/dev/sda";
5673     int r;
5674     suppress_error = 0;
5675     r = guestfs_blockdev_setrw (g, device);
5676     if (r == -1)
5677       return -1;
5678   }
5679   {
5680     int r;
5681     suppress_error = 0;
5682     r = guestfs_umount_all (g);
5683     if (r == -1)
5684       return -1;
5685   }
5686   {
5687     int r;
5688     suppress_error = 0;
5689     r = guestfs_lvm_remove_all (g);
5690     if (r == -1)
5691       return -1;
5692   }
5693   {
5694     char device[] = "/dev/sda";
5695     char lines_0[] = ",";
5696     char *lines[] = {
5697       lines_0,
5698       NULL
5699     };
5700     int r;
5701     suppress_error = 0;
5702     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5703     if (r == -1)
5704       return -1;
5705   }
5706   {
5707     char fstype[] = "ext2";
5708     char device[] = "/dev/sda1";
5709     int r;
5710     suppress_error = 0;
5711     r = guestfs_mkfs (g, fstype, device);
5712     if (r == -1)
5713       return -1;
5714   }
5715   {
5716     char device[] = "/dev/sda1";
5717     char mountpoint[] = "/";
5718     int r;
5719     suppress_error = 0;
5720     r = guestfs_mount (g, device, mountpoint);
5721     if (r == -1)
5722       return -1;
5723   }
5724   /* TestOutput for cp (0) */
5725   char expected[] = "file content";
5726   {
5727     char path[] = "/old";
5728     char content[] = "file content";
5729     int r;
5730     suppress_error = 0;
5731     r = guestfs_write_file (g, path, content, 0);
5732     if (r == -1)
5733       return -1;
5734   }
5735   {
5736     char src[] = "/old";
5737     char dest[] = "/new";
5738     int r;
5739     suppress_error = 0;
5740     r = guestfs_cp (g, src, dest);
5741     if (r == -1)
5742       return -1;
5743   }
5744   {
5745     char path[] = "/new";
5746     char *r;
5747     suppress_error = 0;
5748     r = guestfs_cat (g, path);
5749     if (r == NULL)
5750       return -1;
5751     if (strcmp (r, expected) != 0) {
5752       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5753       return -1;
5754     }
5755     free (r);
5756   }
5757   return 0;
5758 }
5759
5760 static int test_cp_1_skip (void)
5761 {
5762   const char *str;
5763
5764   str = getenv ("TEST_ONLY");
5765   if (str)
5766     return strstr (str, "cp") == NULL;
5767   str = getenv ("SKIP_TEST_CP_1");
5768   if (str && strcmp (str, "1") == 0) return 1;
5769   str = getenv ("SKIP_TEST_CP");
5770   if (str && strcmp (str, "1") == 0) return 1;
5771   return 0;
5772 }
5773
5774 static int test_cp_1 (void)
5775 {
5776   if (test_cp_1_skip ()) {
5777     printf ("        %s skipped (reason: environment variable set)\n", "test_cp_1");
5778     return 0;
5779   }
5780
5781   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5782   {
5783     char device[] = "/dev/sda";
5784     int r;
5785     suppress_error = 0;
5786     r = guestfs_blockdev_setrw (g, device);
5787     if (r == -1)
5788       return -1;
5789   }
5790   {
5791     int r;
5792     suppress_error = 0;
5793     r = guestfs_umount_all (g);
5794     if (r == -1)
5795       return -1;
5796   }
5797   {
5798     int r;
5799     suppress_error = 0;
5800     r = guestfs_lvm_remove_all (g);
5801     if (r == -1)
5802       return -1;
5803   }
5804   {
5805     char device[] = "/dev/sda";
5806     char lines_0[] = ",";
5807     char *lines[] = {
5808       lines_0,
5809       NULL
5810     };
5811     int r;
5812     suppress_error = 0;
5813     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5814     if (r == -1)
5815       return -1;
5816   }
5817   {
5818     char fstype[] = "ext2";
5819     char device[] = "/dev/sda1";
5820     int r;
5821     suppress_error = 0;
5822     r = guestfs_mkfs (g, fstype, device);
5823     if (r == -1)
5824       return -1;
5825   }
5826   {
5827     char device[] = "/dev/sda1";
5828     char mountpoint[] = "/";
5829     int r;
5830     suppress_error = 0;
5831     r = guestfs_mount (g, device, mountpoint);
5832     if (r == -1)
5833       return -1;
5834   }
5835   /* TestOutputTrue for cp (1) */
5836   {
5837     char path[] = "/old";
5838     char content[] = "file content";
5839     int r;
5840     suppress_error = 0;
5841     r = guestfs_write_file (g, path, content, 0);
5842     if (r == -1)
5843       return -1;
5844   }
5845   {
5846     char src[] = "/old";
5847     char dest[] = "/new";
5848     int r;
5849     suppress_error = 0;
5850     r = guestfs_cp (g, src, dest);
5851     if (r == -1)
5852       return -1;
5853   }
5854   {
5855     char path[] = "/old";
5856     int r;
5857     suppress_error = 0;
5858     r = guestfs_is_file (g, path);
5859     if (r == -1)
5860       return -1;
5861     if (!r) {
5862       fprintf (stderr, "test_cp_1: expected true, got false\n");
5863       return -1;
5864     }
5865   }
5866   return 0;
5867 }
5868
5869 static int test_cp_2_skip (void)
5870 {
5871   const char *str;
5872
5873   str = getenv ("TEST_ONLY");
5874   if (str)
5875     return strstr (str, "cp") == NULL;
5876   str = getenv ("SKIP_TEST_CP_2");
5877   if (str && strcmp (str, "1") == 0) return 1;
5878   str = getenv ("SKIP_TEST_CP");
5879   if (str && strcmp (str, "1") == 0) return 1;
5880   return 0;
5881 }
5882
5883 static int test_cp_2 (void)
5884 {
5885   if (test_cp_2_skip ()) {
5886     printf ("        %s skipped (reason: environment variable set)\n", "test_cp_2");
5887     return 0;
5888   }
5889
5890   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5891   {
5892     char device[] = "/dev/sda";
5893     int r;
5894     suppress_error = 0;
5895     r = guestfs_blockdev_setrw (g, device);
5896     if (r == -1)
5897       return -1;
5898   }
5899   {
5900     int r;
5901     suppress_error = 0;
5902     r = guestfs_umount_all (g);
5903     if (r == -1)
5904       return -1;
5905   }
5906   {
5907     int r;
5908     suppress_error = 0;
5909     r = guestfs_lvm_remove_all (g);
5910     if (r == -1)
5911       return -1;
5912   }
5913   {
5914     char device[] = "/dev/sda";
5915     char lines_0[] = ",";
5916     char *lines[] = {
5917       lines_0,
5918       NULL
5919     };
5920     int r;
5921     suppress_error = 0;
5922     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5923     if (r == -1)
5924       return -1;
5925   }
5926   {
5927     char fstype[] = "ext2";
5928     char device[] = "/dev/sda1";
5929     int r;
5930     suppress_error = 0;
5931     r = guestfs_mkfs (g, fstype, device);
5932     if (r == -1)
5933       return -1;
5934   }
5935   {
5936     char device[] = "/dev/sda1";
5937     char mountpoint[] = "/";
5938     int r;
5939     suppress_error = 0;
5940     r = guestfs_mount (g, device, mountpoint);
5941     if (r == -1)
5942       return -1;
5943   }
5944   /* TestOutput for cp (2) */
5945   char expected[] = "file content";
5946   {
5947     char path[] = "/old";
5948     char content[] = "file content";
5949     int r;
5950     suppress_error = 0;
5951     r = guestfs_write_file (g, path, content, 0);
5952     if (r == -1)
5953       return -1;
5954   }
5955   {
5956     char path[] = "/dir";
5957     int r;
5958     suppress_error = 0;
5959     r = guestfs_mkdir (g, path);
5960     if (r == -1)
5961       return -1;
5962   }
5963   {
5964     char src[] = "/old";
5965     char dest[] = "/dir/new";
5966     int r;
5967     suppress_error = 0;
5968     r = guestfs_cp (g, src, dest);
5969     if (r == -1)
5970       return -1;
5971   }
5972   {
5973     char path[] = "/dir/new";
5974     char *r;
5975     suppress_error = 0;
5976     r = guestfs_cat (g, path);
5977     if (r == NULL)
5978       return -1;
5979     if (strcmp (r, expected) != 0) {
5980       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5981       return -1;
5982     }
5983     free (r);
5984   }
5985   return 0;
5986 }
5987
5988 static int test_grub_install_0_skip (void)
5989 {
5990   const char *str;
5991
5992   str = getenv ("TEST_ONLY");
5993   if (str)
5994     return strstr (str, "grub_install") == NULL;
5995   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5996   if (str && strcmp (str, "1") == 0) return 1;
5997   str = getenv ("SKIP_TEST_GRUB_INSTALL");
5998   if (str && strcmp (str, "1") == 0) return 1;
5999   return 0;
6000 }
6001
6002 static int test_grub_install_0 (void)
6003 {
6004   if (test_grub_install_0_skip ()) {
6005     printf ("        %s skipped (reason: environment variable set)\n", "test_grub_install_0");
6006     return 0;
6007   }
6008
6009   printf ("        %s skipped (reason: test disabled in generator)\n", "test_grub_install_0");
6010   return 0;
6011 }
6012
6013 static int test_zero_0_skip (void)
6014 {
6015   const char *str;
6016
6017   str = getenv ("TEST_ONLY");
6018   if (str)
6019     return strstr (str, "zero") == NULL;
6020   str = getenv ("SKIP_TEST_ZERO_0");
6021   if (str && strcmp (str, "1") == 0) return 1;
6022   str = getenv ("SKIP_TEST_ZERO");
6023   if (str && strcmp (str, "1") == 0) return 1;
6024   return 0;
6025 }
6026
6027 static int test_zero_0 (void)
6028 {
6029   if (test_zero_0_skip ()) {
6030     printf ("        %s skipped (reason: environment variable set)\n", "test_zero_0");
6031     return 0;
6032   }
6033
6034   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
6035   {
6036     char device[] = "/dev/sda";
6037     int r;
6038     suppress_error = 0;
6039     r = guestfs_blockdev_setrw (g, device);
6040     if (r == -1)
6041       return -1;
6042   }
6043   {
6044     int r;
6045     suppress_error = 0;
6046     r = guestfs_umount_all (g);
6047     if (r == -1)
6048       return -1;
6049   }
6050   {
6051     int r;
6052     suppress_error = 0;
6053     r = guestfs_lvm_remove_all (g);
6054     if (r == -1)
6055       return -1;
6056   }
6057   {
6058     char device[] = "/dev/sda";
6059     char lines_0[] = ",";
6060     char *lines[] = {
6061       lines_0,
6062       NULL
6063     };
6064     int r;
6065     suppress_error = 0;
6066     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6067     if (r == -1)
6068       return -1;
6069   }
6070   {
6071     char fstype[] = "ext2";
6072     char device[] = "/dev/sda1";
6073     int r;
6074     suppress_error = 0;
6075     r = guestfs_mkfs (g, fstype, device);
6076     if (r == -1)
6077       return -1;
6078   }
6079   {
6080     char device[] = "/dev/sda1";
6081     char mountpoint[] = "/";
6082     int r;
6083     suppress_error = 0;
6084     r = guestfs_mount (g, device, mountpoint);
6085     if (r == -1)
6086       return -1;
6087   }
6088   /* TestOutput for zero (0) */
6089   char expected[] = "data";
6090   {
6091     char pathordevice[] = "/dev/sda1";
6092     int r;
6093     suppress_error = 0;
6094     r = guestfs_umount (g, pathordevice);
6095     if (r == -1)
6096       return -1;
6097   }
6098   {
6099     char device[] = "/dev/sda1";
6100     int r;
6101     suppress_error = 0;
6102     r = guestfs_zero (g, device);
6103     if (r == -1)
6104       return -1;
6105   }
6106   {
6107     char path[] = "/dev/sda1";
6108     char *r;
6109     suppress_error = 0;
6110     r = guestfs_file (g, path);
6111     if (r == NULL)
6112       return -1;
6113     if (strcmp (r, expected) != 0) {
6114       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
6115       return -1;
6116     }
6117     free (r);
6118   }
6119   return 0;
6120 }
6121
6122 static int test_fsck_0_skip (void)
6123 {
6124   const char *str;
6125
6126   str = getenv ("TEST_ONLY");
6127   if (str)
6128     return strstr (str, "fsck") == NULL;
6129   str = getenv ("SKIP_TEST_FSCK_0");
6130   if (str && strcmp (str, "1") == 0) return 1;
6131   str = getenv ("SKIP_TEST_FSCK");
6132   if (str && strcmp (str, "1") == 0) return 1;
6133   return 0;
6134 }
6135
6136 static int test_fsck_0 (void)
6137 {
6138   if (test_fsck_0_skip ()) {
6139     printf ("        %s skipped (reason: environment variable set)\n", "test_fsck_0");
6140     return 0;
6141   }
6142
6143   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
6144   {
6145     char device[] = "/dev/sda";
6146     int r;
6147     suppress_error = 0;
6148     r = guestfs_blockdev_setrw (g, device);
6149     if (r == -1)
6150       return -1;
6151   }
6152   {
6153     int r;
6154     suppress_error = 0;
6155     r = guestfs_umount_all (g);
6156     if (r == -1)
6157       return -1;
6158   }
6159   {
6160     int r;
6161     suppress_error = 0;
6162     r = guestfs_lvm_remove_all (g);
6163     if (r == -1)
6164       return -1;
6165   }
6166   {
6167     char device[] = "/dev/sda";
6168     char lines_0[] = ",";
6169     char *lines[] = {
6170       lines_0,
6171       NULL
6172     };
6173     int r;
6174     suppress_error = 0;
6175     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6176     if (r == -1)
6177       return -1;
6178   }
6179   {
6180     char fstype[] = "ext2";
6181     char device[] = "/dev/sda1";
6182     int r;
6183     suppress_error = 0;
6184     r = guestfs_mkfs (g, fstype, device);
6185     if (r == -1)
6186       return -1;
6187   }
6188   {
6189     char device[] = "/dev/sda1";
6190     char mountpoint[] = "/";
6191     int r;
6192     suppress_error = 0;
6193     r = guestfs_mount (g, device, mountpoint);
6194     if (r == -1)
6195       return -1;
6196   }
6197   /* TestOutputInt for fsck (0) */
6198   {
6199     char pathordevice[] = "/dev/sda1";
6200     int r;
6201     suppress_error = 0;
6202     r = guestfs_umount (g, pathordevice);
6203     if (r == -1)
6204       return -1;
6205   }
6206   {
6207     char fstype[] = "ext2";
6208     char device[] = "/dev/sda1";
6209     int r;
6210     suppress_error = 0;
6211     r = guestfs_fsck (g, fstype, device);
6212     if (r == -1)
6213       return -1;
6214     if (r != 0) {
6215       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
6216       return -1;
6217     }
6218   }
6219   return 0;
6220 }
6221
6222 static int test_fsck_1_skip (void)
6223 {
6224   const char *str;
6225
6226   str = getenv ("TEST_ONLY");
6227   if (str)
6228     return strstr (str, "fsck") == NULL;
6229   str = getenv ("SKIP_TEST_FSCK_1");
6230   if (str && strcmp (str, "1") == 0) return 1;
6231   str = getenv ("SKIP_TEST_FSCK");
6232   if (str && strcmp (str, "1") == 0) return 1;
6233   return 0;
6234 }
6235
6236 static int test_fsck_1 (void)
6237 {
6238   if (test_fsck_1_skip ()) {
6239     printf ("        %s skipped (reason: environment variable set)\n", "test_fsck_1");
6240     return 0;
6241   }
6242
6243   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
6244   {
6245     char device[] = "/dev/sda";
6246     int r;
6247     suppress_error = 0;
6248     r = guestfs_blockdev_setrw (g, device);
6249     if (r == -1)
6250       return -1;
6251   }
6252   {
6253     int r;
6254     suppress_error = 0;
6255     r = guestfs_umount_all (g);
6256     if (r == -1)
6257       return -1;
6258   }
6259   {
6260     int r;
6261     suppress_error = 0;
6262     r = guestfs_lvm_remove_all (g);
6263     if (r == -1)
6264       return -1;
6265   }
6266   {
6267     char device[] = "/dev/sda";
6268     char lines_0[] = ",";
6269     char *lines[] = {
6270       lines_0,
6271       NULL
6272     };
6273     int r;
6274     suppress_error = 0;
6275     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6276     if (r == -1)
6277       return -1;
6278   }
6279   {
6280     char fstype[] = "ext2";
6281     char device[] = "/dev/sda1";
6282     int r;
6283     suppress_error = 0;
6284     r = guestfs_mkfs (g, fstype, device);
6285     if (r == -1)
6286       return -1;
6287   }
6288   {
6289     char device[] = "/dev/sda1";
6290     char mountpoint[] = "/";
6291     int r;
6292     suppress_error = 0;
6293     r = guestfs_mount (g, device, mountpoint);
6294     if (r == -1)
6295       return -1;
6296   }
6297   /* TestOutputInt for fsck (1) */
6298   {
6299     char pathordevice[] = "/dev/sda1";
6300     int r;
6301     suppress_error = 0;
6302     r = guestfs_umount (g, pathordevice);
6303     if (r == -1)
6304       return -1;
6305   }
6306   {
6307     char device[] = "/dev/sda1";
6308     int r;
6309     suppress_error = 0;
6310     r = guestfs_zero (g, device);
6311     if (r == -1)
6312       return -1;
6313   }
6314   {
6315     char fstype[] = "ext2";
6316     char device[] = "/dev/sda1";
6317     int r;
6318     suppress_error = 0;
6319     r = guestfs_fsck (g, fstype, device);
6320     if (r == -1)
6321       return -1;
6322     if (r != 8) {
6323       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
6324       return -1;
6325     }
6326   }
6327   return 0;
6328 }
6329
6330 static int test_set_e2uuid_0_skip (void)
6331 {
6332   const char *str;
6333
6334   str = getenv ("TEST_ONLY");
6335   if (str)
6336     return strstr (str, "set_e2uuid") == NULL;
6337   str = getenv ("SKIP_TEST_SET_E2UUID_0");
6338   if (str && strcmp (str, "1") == 0) return 1;
6339   str = getenv ("SKIP_TEST_SET_E2UUID");
6340   if (str && strcmp (str, "1") == 0) return 1;
6341   return 0;
6342 }
6343
6344 static int test_set_e2uuid_0 (void)
6345 {
6346   if (test_set_e2uuid_0_skip ()) {
6347     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
6348     return 0;
6349   }
6350
6351   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
6352   {
6353     char device[] = "/dev/sda";
6354     int r;
6355     suppress_error = 0;
6356     r = guestfs_blockdev_setrw (g, device);
6357     if (r == -1)
6358       return -1;
6359   }
6360   {
6361     int r;
6362     suppress_error = 0;
6363     r = guestfs_umount_all (g);
6364     if (r == -1)
6365       return -1;
6366   }
6367   {
6368     int r;
6369     suppress_error = 0;
6370     r = guestfs_lvm_remove_all (g);
6371     if (r == -1)
6372       return -1;
6373   }
6374   {
6375     char device[] = "/dev/sda";
6376     char lines_0[] = ",";
6377     char *lines[] = {
6378       lines_0,
6379       NULL
6380     };
6381     int r;
6382     suppress_error = 0;
6383     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6384     if (r == -1)
6385       return -1;
6386   }
6387   {
6388     char fstype[] = "ext2";
6389     char device[] = "/dev/sda1";
6390     int r;
6391     suppress_error = 0;
6392     r = guestfs_mkfs (g, fstype, device);
6393     if (r == -1)
6394       return -1;
6395   }
6396   {
6397     char device[] = "/dev/sda1";
6398     char mountpoint[] = "/";
6399     int r;
6400     suppress_error = 0;
6401     r = guestfs_mount (g, device, mountpoint);
6402     if (r == -1)
6403       return -1;
6404   }
6405   /* TestOutput for set_e2uuid (0) */
6406   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6407   {
6408     char device[] = "/dev/sda1";
6409     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6410     int r;
6411     suppress_error = 0;
6412     r = guestfs_set_e2uuid (g, device, uuid);
6413     if (r == -1)
6414       return -1;
6415   }
6416   {
6417     char device[] = "/dev/sda1";
6418     char *r;
6419     suppress_error = 0;
6420     r = guestfs_get_e2uuid (g, device);
6421     if (r == NULL)
6422       return -1;
6423     if (strcmp (r, expected) != 0) {
6424       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
6425       return -1;
6426     }
6427     free (r);
6428   }
6429   return 0;
6430 }
6431
6432 static int test_set_e2uuid_1_skip (void)
6433 {
6434   const char *str;
6435
6436   str = getenv ("TEST_ONLY");
6437   if (str)
6438     return strstr (str, "set_e2uuid") == NULL;
6439   str = getenv ("SKIP_TEST_SET_E2UUID_1");
6440   if (str && strcmp (str, "1") == 0) return 1;
6441   str = getenv ("SKIP_TEST_SET_E2UUID");
6442   if (str && strcmp (str, "1") == 0) return 1;
6443   return 0;
6444 }
6445
6446 static int test_set_e2uuid_1 (void)
6447 {
6448   if (test_set_e2uuid_1_skip ()) {
6449     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
6450     return 0;
6451   }
6452
6453   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
6454   {
6455     char device[] = "/dev/sda";
6456     int r;
6457     suppress_error = 0;
6458     r = guestfs_blockdev_setrw (g, device);
6459     if (r == -1)
6460       return -1;
6461   }
6462   {
6463     int r;
6464     suppress_error = 0;
6465     r = guestfs_umount_all (g);
6466     if (r == -1)
6467       return -1;
6468   }
6469   {
6470     int r;
6471     suppress_error = 0;
6472     r = guestfs_lvm_remove_all (g);
6473     if (r == -1)
6474       return -1;
6475   }
6476   {
6477     char device[] = "/dev/sda";
6478     char lines_0[] = ",";
6479     char *lines[] = {
6480       lines_0,
6481       NULL
6482     };
6483     int r;
6484     suppress_error = 0;
6485     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6486     if (r == -1)
6487       return -1;
6488   }
6489   {
6490     char fstype[] = "ext2";
6491     char device[] = "/dev/sda1";
6492     int r;
6493     suppress_error = 0;
6494     r = guestfs_mkfs (g, fstype, device);
6495     if (r == -1)
6496       return -1;
6497   }
6498   {
6499     char device[] = "/dev/sda1";
6500     char mountpoint[] = "/";
6501     int r;
6502     suppress_error = 0;
6503     r = guestfs_mount (g, device, mountpoint);
6504     if (r == -1)
6505       return -1;
6506   }
6507   /* TestOutput for set_e2uuid (1) */
6508   char expected[] = "";
6509   {
6510     char device[] = "/dev/sda1";
6511     char uuid[] = "clear";
6512     int r;
6513     suppress_error = 0;
6514     r = guestfs_set_e2uuid (g, device, uuid);
6515     if (r == -1)
6516       return -1;
6517   }
6518   {
6519     char device[] = "/dev/sda1";
6520     char *r;
6521     suppress_error = 0;
6522     r = guestfs_get_e2uuid (g, device);
6523     if (r == NULL)
6524       return -1;
6525     if (strcmp (r, expected) != 0) {
6526       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
6527       return -1;
6528     }
6529     free (r);
6530   }
6531   return 0;
6532 }
6533
6534 static int test_set_e2uuid_2_skip (void)
6535 {
6536   const char *str;
6537
6538   str = getenv ("TEST_ONLY");
6539   if (str)
6540     return strstr (str, "set_e2uuid") == NULL;
6541   str = getenv ("SKIP_TEST_SET_E2UUID_2");
6542   if (str && strcmp (str, "1") == 0) return 1;
6543   str = getenv ("SKIP_TEST_SET_E2UUID");
6544   if (str && strcmp (str, "1") == 0) return 1;
6545   return 0;
6546 }
6547
6548 static int test_set_e2uuid_2 (void)
6549 {
6550   if (test_set_e2uuid_2_skip ()) {
6551     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
6552     return 0;
6553   }
6554
6555   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
6556   {
6557     char device[] = "/dev/sda";
6558     int r;
6559     suppress_error = 0;
6560     r = guestfs_blockdev_setrw (g, device);
6561     if (r == -1)
6562       return -1;
6563   }
6564   {
6565     int r;
6566     suppress_error = 0;
6567     r = guestfs_umount_all (g);
6568     if (r == -1)
6569       return -1;
6570   }
6571   {
6572     int r;
6573     suppress_error = 0;
6574     r = guestfs_lvm_remove_all (g);
6575     if (r == -1)
6576       return -1;
6577   }
6578   {
6579     char device[] = "/dev/sda";
6580     char lines_0[] = ",";
6581     char *lines[] = {
6582       lines_0,
6583       NULL
6584     };
6585     int r;
6586     suppress_error = 0;
6587     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6588     if (r == -1)
6589       return -1;
6590   }
6591   {
6592     char fstype[] = "ext2";
6593     char device[] = "/dev/sda1";
6594     int r;
6595     suppress_error = 0;
6596     r = guestfs_mkfs (g, fstype, device);
6597     if (r == -1)
6598       return -1;
6599   }
6600   {
6601     char device[] = "/dev/sda1";
6602     char mountpoint[] = "/";
6603     int r;
6604     suppress_error = 0;
6605     r = guestfs_mount (g, device, mountpoint);
6606     if (r == -1)
6607       return -1;
6608   }
6609   /* TestRun for set_e2uuid (2) */
6610   {
6611     char device[] = "/dev/sda1";
6612     char uuid[] = "random";
6613     int r;
6614     suppress_error = 0;
6615     r = guestfs_set_e2uuid (g, device, uuid);
6616     if (r == -1)
6617       return -1;
6618   }
6619   return 0;
6620 }
6621
6622 static int test_set_e2uuid_3_skip (void)
6623 {
6624   const char *str;
6625
6626   str = getenv ("TEST_ONLY");
6627   if (str)
6628     return strstr (str, "set_e2uuid") == NULL;
6629   str = getenv ("SKIP_TEST_SET_E2UUID_3");
6630   if (str && strcmp (str, "1") == 0) return 1;
6631   str = getenv ("SKIP_TEST_SET_E2UUID");
6632   if (str && strcmp (str, "1") == 0) return 1;
6633   return 0;
6634 }
6635
6636 static int test_set_e2uuid_3 (void)
6637 {
6638   if (test_set_e2uuid_3_skip ()) {
6639     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6640     return 0;
6641   }
6642
6643   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6644   {
6645     char device[] = "/dev/sda";
6646     int r;
6647     suppress_error = 0;
6648     r = guestfs_blockdev_setrw (g, device);
6649     if (r == -1)
6650       return -1;
6651   }
6652   {
6653     int r;
6654     suppress_error = 0;
6655     r = guestfs_umount_all (g);
6656     if (r == -1)
6657       return -1;
6658   }
6659   {
6660     int r;
6661     suppress_error = 0;
6662     r = guestfs_lvm_remove_all (g);
6663     if (r == -1)
6664       return -1;
6665   }
6666   {
6667     char device[] = "/dev/sda";
6668     char lines_0[] = ",";
6669     char *lines[] = {
6670       lines_0,
6671       NULL
6672     };
6673     int r;
6674     suppress_error = 0;
6675     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6676     if (r == -1)
6677       return -1;
6678   }
6679   {
6680     char fstype[] = "ext2";
6681     char device[] = "/dev/sda1";
6682     int r;
6683     suppress_error = 0;
6684     r = guestfs_mkfs (g, fstype, device);
6685     if (r == -1)
6686       return -1;
6687   }
6688   {
6689     char device[] = "/dev/sda1";
6690     char mountpoint[] = "/";
6691     int r;
6692     suppress_error = 0;
6693     r = guestfs_mount (g, device, mountpoint);
6694     if (r == -1)
6695       return -1;
6696   }
6697   /* TestRun for set_e2uuid (3) */
6698   {
6699     char device[] = "/dev/sda1";
6700     char uuid[] = "time";
6701     int r;
6702     suppress_error = 0;
6703     r = guestfs_set_e2uuid (g, device, uuid);
6704     if (r == -1)
6705       return -1;
6706   }
6707   return 0;
6708 }
6709
6710 static int test_set_e2label_0_skip (void)
6711 {
6712   const char *str;
6713
6714   str = getenv ("TEST_ONLY");
6715   if (str)
6716     return strstr (str, "set_e2label") == NULL;
6717   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6718   if (str && strcmp (str, "1") == 0) return 1;
6719   str = getenv ("SKIP_TEST_SET_E2LABEL");
6720   if (str && strcmp (str, "1") == 0) return 1;
6721   return 0;
6722 }
6723
6724 static int test_set_e2label_0 (void)
6725 {
6726   if (test_set_e2label_0_skip ()) {
6727     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6728     return 0;
6729   }
6730
6731   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6732   {
6733     char device[] = "/dev/sda";
6734     int r;
6735     suppress_error = 0;
6736     r = guestfs_blockdev_setrw (g, device);
6737     if (r == -1)
6738       return -1;
6739   }
6740   {
6741     int r;
6742     suppress_error = 0;
6743     r = guestfs_umount_all (g);
6744     if (r == -1)
6745       return -1;
6746   }
6747   {
6748     int r;
6749     suppress_error = 0;
6750     r = guestfs_lvm_remove_all (g);
6751     if (r == -1)
6752       return -1;
6753   }
6754   {
6755     char device[] = "/dev/sda";
6756     char lines_0[] = ",";
6757     char *lines[] = {
6758       lines_0,
6759       NULL
6760     };
6761     int r;
6762     suppress_error = 0;
6763     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6764     if (r == -1)
6765       return -1;
6766   }
6767   {
6768     char fstype[] = "ext2";
6769     char device[] = "/dev/sda1";
6770     int r;
6771     suppress_error = 0;
6772     r = guestfs_mkfs (g, fstype, device);
6773     if (r == -1)
6774       return -1;
6775   }
6776   {
6777     char device[] = "/dev/sda1";
6778     char mountpoint[] = "/";
6779     int r;
6780     suppress_error = 0;
6781     r = guestfs_mount (g, device, mountpoint);
6782     if (r == -1)
6783       return -1;
6784   }
6785   /* TestOutput for set_e2label (0) */
6786   char expected[] = "testlabel";
6787   {
6788     char device[] = "/dev/sda1";
6789     char label[] = "testlabel";
6790     int r;
6791     suppress_error = 0;
6792     r = guestfs_set_e2label (g, device, label);
6793     if (r == -1)
6794       return -1;
6795   }
6796   {
6797     char device[] = "/dev/sda1";
6798     char *r;
6799     suppress_error = 0;
6800     r = guestfs_get_e2label (g, device);
6801     if (r == NULL)
6802       return -1;
6803     if (strcmp (r, expected) != 0) {
6804       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6805       return -1;
6806     }
6807     free (r);
6808   }
6809   return 0;
6810 }
6811
6812 static int test_pvremove_0_skip (void)
6813 {
6814   const char *str;
6815
6816   str = getenv ("TEST_ONLY");
6817   if (str)
6818     return strstr (str, "pvremove") == NULL;
6819   str = getenv ("SKIP_TEST_PVREMOVE_0");
6820   if (str && strcmp (str, "1") == 0) return 1;
6821   str = getenv ("SKIP_TEST_PVREMOVE");
6822   if (str && strcmp (str, "1") == 0) return 1;
6823   return 0;
6824 }
6825
6826 static int test_pvremove_0 (void)
6827 {
6828   if (test_pvremove_0_skip ()) {
6829     printf ("        %s skipped (reason: environment variable set)\n", "test_pvremove_0");
6830     return 0;
6831   }
6832
6833   /* InitNone|InitEmpty for test_pvremove_0 */
6834   {
6835     char device[] = "/dev/sda";
6836     int r;
6837     suppress_error = 0;
6838     r = guestfs_blockdev_setrw (g, device);
6839     if (r == -1)
6840       return -1;
6841   }
6842   {
6843     int r;
6844     suppress_error = 0;
6845     r = guestfs_umount_all (g);
6846     if (r == -1)
6847       return -1;
6848   }
6849   {
6850     int r;
6851     suppress_error = 0;
6852     r = guestfs_lvm_remove_all (g);
6853     if (r == -1)
6854       return -1;
6855   }
6856   /* TestOutputListOfDevices for pvremove (0) */
6857   {
6858     char device[] = "/dev/sda";
6859     char lines_0[] = ",";
6860     char *lines[] = {
6861       lines_0,
6862       NULL
6863     };
6864     int r;
6865     suppress_error = 0;
6866     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6867     if (r == -1)
6868       return -1;
6869   }
6870   {
6871     char device[] = "/dev/sda1";
6872     int r;
6873     suppress_error = 0;
6874     r = guestfs_pvcreate (g, device);
6875     if (r == -1)
6876       return -1;
6877   }
6878   {
6879     char volgroup[] = "VG";
6880     char physvols_0[] = "/dev/sda1";
6881     char *physvols[] = {
6882       physvols_0,
6883       NULL
6884     };
6885     int r;
6886     suppress_error = 0;
6887     r = guestfs_vgcreate (g, volgroup, physvols);
6888     if (r == -1)
6889       return -1;
6890   }
6891   {
6892     char logvol[] = "LV1";
6893     char volgroup[] = "VG";
6894     int r;
6895     suppress_error = 0;
6896     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6897     if (r == -1)
6898       return -1;
6899   }
6900   {
6901     char logvol[] = "LV2";
6902     char volgroup[] = "VG";
6903     int r;
6904     suppress_error = 0;
6905     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6906     if (r == -1)
6907       return -1;
6908   }
6909   {
6910     char vgname[] = "VG";
6911     int r;
6912     suppress_error = 0;
6913     r = guestfs_vgremove (g, vgname);
6914     if (r == -1)
6915       return -1;
6916   }
6917   {
6918     char device[] = "/dev/sda1";
6919     int r;
6920     suppress_error = 0;
6921     r = guestfs_pvremove (g, device);
6922     if (r == -1)
6923       return -1;
6924   }
6925   {
6926     char **r;
6927     int i;
6928     suppress_error = 0;
6929     r = guestfs_lvs (g);
6930     if (r == NULL)
6931       return -1;
6932     if (r[0] != NULL) {
6933       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6934       print_strings (r);
6935       return -1;
6936     }
6937     for (i = 0; r[i] != NULL; ++i)
6938       free (r[i]);
6939     free (r);
6940   }
6941   return 0;
6942 }
6943
6944 static int test_pvremove_1_skip (void)
6945 {
6946   const char *str;
6947
6948   str = getenv ("TEST_ONLY");
6949   if (str)
6950     return strstr (str, "pvremove") == NULL;
6951   str = getenv ("SKIP_TEST_PVREMOVE_1");
6952   if (str && strcmp (str, "1") == 0) return 1;
6953   str = getenv ("SKIP_TEST_PVREMOVE");
6954   if (str && strcmp (str, "1") == 0) return 1;
6955   return 0;
6956 }
6957
6958 static int test_pvremove_1 (void)
6959 {
6960   if (test_pvremove_1_skip ()) {
6961     printf ("        %s skipped (reason: environment variable set)\n", "test_pvremove_1");
6962     return 0;
6963   }
6964
6965   /* InitNone|InitEmpty for test_pvremove_1 */
6966   {
6967     char device[] = "/dev/sda";
6968     int r;
6969     suppress_error = 0;
6970     r = guestfs_blockdev_setrw (g, device);
6971     if (r == -1)
6972       return -1;
6973   }
6974   {
6975     int r;
6976     suppress_error = 0;
6977     r = guestfs_umount_all (g);
6978     if (r == -1)
6979       return -1;
6980   }
6981   {
6982     int r;
6983     suppress_error = 0;
6984     r = guestfs_lvm_remove_all (g);
6985     if (r == -1)
6986       return -1;
6987   }
6988   /* TestOutputListOfDevices for pvremove (1) */
6989   {
6990     char device[] = "/dev/sda";
6991     char lines_0[] = ",";
6992     char *lines[] = {
6993       lines_0,
6994       NULL
6995     };
6996     int r;
6997     suppress_error = 0;
6998     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6999     if (r == -1)
7000       return -1;
7001   }
7002   {
7003     char device[] = "/dev/sda1";
7004     int r;
7005     suppress_error = 0;
7006     r = guestfs_pvcreate (g, device);
7007     if (r == -1)
7008       return -1;
7009   }
7010   {
7011     char volgroup[] = "VG";
7012     char physvols_0[] = "/dev/sda1";
7013     char *physvols[] = {
7014       physvols_0,
7015       NULL
7016     };
7017     int r;
7018     suppress_error = 0;
7019     r = guestfs_vgcreate (g, volgroup, physvols);
7020     if (r == -1)
7021       return -1;
7022   }
7023   {
7024     char logvol[] = "LV1";
7025     char volgroup[] = "VG";
7026     int r;
7027     suppress_error = 0;
7028     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7029     if (r == -1)
7030       return -1;
7031   }
7032   {
7033     char logvol[] = "LV2";
7034     char volgroup[] = "VG";
7035     int r;
7036     suppress_error = 0;
7037     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7038     if (r == -1)
7039       return -1;
7040   }
7041   {
7042     char vgname[] = "VG";
7043     int r;
7044     suppress_error = 0;
7045     r = guestfs_vgremove (g, vgname);
7046     if (r == -1)
7047       return -1;
7048   }
7049   {
7050     char device[] = "/dev/sda1";
7051     int r;
7052     suppress_error = 0;
7053     r = guestfs_pvremove (g, device);
7054     if (r == -1)
7055       return -1;
7056   }
7057   {
7058     char **r;
7059     int i;
7060     suppress_error = 0;
7061     r = guestfs_vgs (g);
7062     if (r == NULL)
7063       return -1;
7064     if (r[0] != NULL) {
7065       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
7066       print_strings (r);
7067       return -1;
7068     }
7069     for (i = 0; r[i] != NULL; ++i)
7070       free (r[i]);
7071     free (r);
7072   }
7073   return 0;
7074 }
7075
7076 static int test_pvremove_2_skip (void)
7077 {
7078   const char *str;
7079
7080   str = getenv ("TEST_ONLY");
7081   if (str)
7082     return strstr (str, "pvremove") == NULL;
7083   str = getenv ("SKIP_TEST_PVREMOVE_2");
7084   if (str && strcmp (str, "1") == 0) return 1;
7085   str = getenv ("SKIP_TEST_PVREMOVE");
7086   if (str && strcmp (str, "1") == 0) return 1;
7087   return 0;
7088 }
7089
7090 static int test_pvremove_2 (void)
7091 {
7092   if (test_pvremove_2_skip ()) {
7093     printf ("        %s skipped (reason: environment variable set)\n", "test_pvremove_2");
7094     return 0;
7095   }
7096
7097   /* InitNone|InitEmpty for test_pvremove_2 */
7098   {
7099     char device[] = "/dev/sda";
7100     int r;
7101     suppress_error = 0;
7102     r = guestfs_blockdev_setrw (g, device);
7103     if (r == -1)
7104       return -1;
7105   }
7106   {
7107     int r;
7108     suppress_error = 0;
7109     r = guestfs_umount_all (g);
7110     if (r == -1)
7111       return -1;
7112   }
7113   {
7114     int r;
7115     suppress_error = 0;
7116     r = guestfs_lvm_remove_all (g);
7117     if (r == -1)
7118       return -1;
7119   }
7120   /* TestOutputListOfDevices for pvremove (2) */
7121   {
7122     char device[] = "/dev/sda";
7123     char lines_0[] = ",";
7124     char *lines[] = {
7125       lines_0,
7126       NULL
7127     };
7128     int r;
7129     suppress_error = 0;
7130     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7131     if (r == -1)
7132       return -1;
7133   }
7134   {
7135     char device[] = "/dev/sda1";
7136     int r;
7137     suppress_error = 0;
7138     r = guestfs_pvcreate (g, device);
7139     if (r == -1)
7140       return -1;
7141   }
7142   {
7143     char volgroup[] = "VG";
7144     char physvols_0[] = "/dev/sda1";
7145     char *physvols[] = {
7146       physvols_0,
7147       NULL
7148     };
7149     int r;
7150     suppress_error = 0;
7151     r = guestfs_vgcreate (g, volgroup, physvols);
7152     if (r == -1)
7153       return -1;
7154   }
7155   {
7156     char logvol[] = "LV1";
7157     char volgroup[] = "VG";
7158     int r;
7159     suppress_error = 0;
7160     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7161     if (r == -1)
7162       return -1;
7163   }
7164   {
7165     char logvol[] = "LV2";
7166     char volgroup[] = "VG";
7167     int r;
7168     suppress_error = 0;
7169     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7170     if (r == -1)
7171       return -1;
7172   }
7173   {
7174     char vgname[] = "VG";
7175     int r;
7176     suppress_error = 0;
7177     r = guestfs_vgremove (g, vgname);
7178     if (r == -1)
7179       return -1;
7180   }
7181   {
7182     char device[] = "/dev/sda1";
7183     int r;
7184     suppress_error = 0;
7185     r = guestfs_pvremove (g, device);
7186     if (r == -1)
7187       return -1;
7188   }
7189   {
7190     char **r;
7191     int i;
7192     suppress_error = 0;
7193     r = guestfs_pvs (g);
7194     if (r == NULL)
7195       return -1;
7196     if (r[0] != NULL) {
7197       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
7198       print_strings (r);
7199       return -1;
7200     }
7201     for (i = 0; r[i] != NULL; ++i)
7202       free (r[i]);
7203     free (r);
7204   }
7205   return 0;
7206 }
7207
7208 static int test_vgremove_0_skip (void)
7209 {
7210   const char *str;
7211
7212   str = getenv ("TEST_ONLY");
7213   if (str)
7214     return strstr (str, "vgremove") == NULL;
7215   str = getenv ("SKIP_TEST_VGREMOVE_0");
7216   if (str && strcmp (str, "1") == 0) return 1;
7217   str = getenv ("SKIP_TEST_VGREMOVE");
7218   if (str && strcmp (str, "1") == 0) return 1;
7219   return 0;
7220 }
7221
7222 static int test_vgremove_0 (void)
7223 {
7224   if (test_vgremove_0_skip ()) {
7225     printf ("        %s skipped (reason: environment variable set)\n", "test_vgremove_0");
7226     return 0;
7227   }
7228
7229   /* InitNone|InitEmpty for test_vgremove_0 */
7230   {
7231     char device[] = "/dev/sda";
7232     int r;
7233     suppress_error = 0;
7234     r = guestfs_blockdev_setrw (g, device);
7235     if (r == -1)
7236       return -1;
7237   }
7238   {
7239     int r;
7240     suppress_error = 0;
7241     r = guestfs_umount_all (g);
7242     if (r == -1)
7243       return -1;
7244   }
7245   {
7246     int r;
7247     suppress_error = 0;
7248     r = guestfs_lvm_remove_all (g);
7249     if (r == -1)
7250       return -1;
7251   }
7252   /* TestOutputList for vgremove (0) */
7253   {
7254     char device[] = "/dev/sda";
7255     char lines_0[] = ",";
7256     char *lines[] = {
7257       lines_0,
7258       NULL
7259     };
7260     int r;
7261     suppress_error = 0;
7262     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7263     if (r == -1)
7264       return -1;
7265   }
7266   {
7267     char device[] = "/dev/sda1";
7268     int r;
7269     suppress_error = 0;
7270     r = guestfs_pvcreate (g, device);
7271     if (r == -1)
7272       return -1;
7273   }
7274   {
7275     char volgroup[] = "VG";
7276     char physvols_0[] = "/dev/sda1";
7277     char *physvols[] = {
7278       physvols_0,
7279       NULL
7280     };
7281     int r;
7282     suppress_error = 0;
7283     r = guestfs_vgcreate (g, volgroup, physvols);
7284     if (r == -1)
7285       return -1;
7286   }
7287   {
7288     char logvol[] = "LV1";
7289     char volgroup[] = "VG";
7290     int r;
7291     suppress_error = 0;
7292     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7293     if (r == -1)
7294       return -1;
7295   }
7296   {
7297     char logvol[] = "LV2";
7298     char volgroup[] = "VG";
7299     int r;
7300     suppress_error = 0;
7301     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7302     if (r == -1)
7303       return -1;
7304   }
7305   {
7306     char vgname[] = "VG";
7307     int r;
7308     suppress_error = 0;
7309     r = guestfs_vgremove (g, vgname);
7310     if (r == -1)
7311       return -1;
7312   }
7313   {
7314     char **r;
7315     int i;
7316     suppress_error = 0;
7317     r = guestfs_lvs (g);
7318     if (r == NULL)
7319       return -1;
7320     if (r[0] != NULL) {
7321       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
7322       print_strings (r);
7323       return -1;
7324     }
7325     for (i = 0; r[i] != NULL; ++i)
7326       free (r[i]);
7327     free (r);
7328   }
7329   return 0;
7330 }
7331
7332 static int test_vgremove_1_skip (void)
7333 {
7334   const char *str;
7335
7336   str = getenv ("TEST_ONLY");
7337   if (str)
7338     return strstr (str, "vgremove") == NULL;
7339   str = getenv ("SKIP_TEST_VGREMOVE_1");
7340   if (str && strcmp (str, "1") == 0) return 1;
7341   str = getenv ("SKIP_TEST_VGREMOVE");
7342   if (str && strcmp (str, "1") == 0) return 1;
7343   return 0;
7344 }
7345
7346 static int test_vgremove_1 (void)
7347 {
7348   if (test_vgremove_1_skip ()) {
7349     printf ("        %s skipped (reason: environment variable set)\n", "test_vgremove_1");
7350     return 0;
7351   }
7352
7353   /* InitNone|InitEmpty for test_vgremove_1 */
7354   {
7355     char device[] = "/dev/sda";
7356     int r;
7357     suppress_error = 0;
7358     r = guestfs_blockdev_setrw (g, device);
7359     if (r == -1)
7360       return -1;
7361   }
7362   {
7363     int r;
7364     suppress_error = 0;
7365     r = guestfs_umount_all (g);
7366     if (r == -1)
7367       return -1;
7368   }
7369   {
7370     int r;
7371     suppress_error = 0;
7372     r = guestfs_lvm_remove_all (g);
7373     if (r == -1)
7374       return -1;
7375   }
7376   /* TestOutputList for vgremove (1) */
7377   {
7378     char device[] = "/dev/sda";
7379     char lines_0[] = ",";
7380     char *lines[] = {
7381       lines_0,
7382       NULL
7383     };
7384     int r;
7385     suppress_error = 0;
7386     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7387     if (r == -1)
7388       return -1;
7389   }
7390   {
7391     char device[] = "/dev/sda1";
7392     int r;
7393     suppress_error = 0;
7394     r = guestfs_pvcreate (g, device);
7395     if (r == -1)
7396       return -1;
7397   }
7398   {
7399     char volgroup[] = "VG";
7400     char physvols_0[] = "/dev/sda1";
7401     char *physvols[] = {
7402       physvols_0,
7403       NULL
7404     };
7405     int r;
7406     suppress_error = 0;
7407     r = guestfs_vgcreate (g, volgroup, physvols);
7408     if (r == -1)
7409       return -1;
7410   }
7411   {
7412     char logvol[] = "LV1";
7413     char volgroup[] = "VG";
7414     int r;
7415     suppress_error = 0;
7416     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7417     if (r == -1)
7418       return -1;
7419   }
7420   {
7421     char logvol[] = "LV2";
7422     char volgroup[] = "VG";
7423     int r;
7424     suppress_error = 0;
7425     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7426     if (r == -1)
7427       return -1;
7428   }
7429   {
7430     char vgname[] = "VG";
7431     int r;
7432     suppress_error = 0;
7433     r = guestfs_vgremove (g, vgname);
7434     if (r == -1)
7435       return -1;
7436   }
7437   {
7438     char **r;
7439     int i;
7440     suppress_error = 0;
7441     r = guestfs_vgs (g);
7442     if (r == NULL)
7443       return -1;
7444     if (r[0] != NULL) {
7445       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
7446       print_strings (r);
7447       return -1;
7448     }
7449     for (i = 0; r[i] != NULL; ++i)
7450       free (r[i]);
7451     free (r);
7452   }
7453   return 0;
7454 }
7455
7456 static int test_lvremove_0_skip (void)
7457 {
7458   const char *str;
7459
7460   str = getenv ("TEST_ONLY");
7461   if (str)
7462     return strstr (str, "lvremove") == NULL;
7463   str = getenv ("SKIP_TEST_LVREMOVE_0");
7464   if (str && strcmp (str, "1") == 0) return 1;
7465   str = getenv ("SKIP_TEST_LVREMOVE");
7466   if (str && strcmp (str, "1") == 0) return 1;
7467   return 0;
7468 }
7469
7470 static int test_lvremove_0 (void)
7471 {
7472   if (test_lvremove_0_skip ()) {
7473     printf ("        %s skipped (reason: environment variable set)\n", "test_lvremove_0");
7474     return 0;
7475   }
7476
7477   /* InitNone|InitEmpty for test_lvremove_0 */
7478   {
7479     char device[] = "/dev/sda";
7480     int r;
7481     suppress_error = 0;
7482     r = guestfs_blockdev_setrw (g, device);
7483     if (r == -1)
7484       return -1;
7485   }
7486   {
7487     int r;
7488     suppress_error = 0;
7489     r = guestfs_umount_all (g);
7490     if (r == -1)
7491       return -1;
7492   }
7493   {
7494     int r;
7495     suppress_error = 0;
7496     r = guestfs_lvm_remove_all (g);
7497     if (r == -1)
7498       return -1;
7499   }
7500   /* TestOutputList for lvremove (0) */
7501   {
7502     char device[] = "/dev/sda";
7503     char lines_0[] = ",";
7504     char *lines[] = {
7505       lines_0,
7506       NULL
7507     };
7508     int r;
7509     suppress_error = 0;
7510     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7511     if (r == -1)
7512       return -1;
7513   }
7514   {
7515     char device[] = "/dev/sda1";
7516     int r;
7517     suppress_error = 0;
7518     r = guestfs_pvcreate (g, device);
7519     if (r == -1)
7520       return -1;
7521   }
7522   {
7523     char volgroup[] = "VG";
7524     char physvols_0[] = "/dev/sda1";
7525     char *physvols[] = {
7526       physvols_0,
7527       NULL
7528     };
7529     int r;
7530     suppress_error = 0;
7531     r = guestfs_vgcreate (g, volgroup, physvols);
7532     if (r == -1)
7533       return -1;
7534   }
7535   {
7536     char logvol[] = "LV1";
7537     char volgroup[] = "VG";
7538     int r;
7539     suppress_error = 0;
7540     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7541     if (r == -1)
7542       return -1;
7543   }
7544   {
7545     char logvol[] = "LV2";
7546     char volgroup[] = "VG";
7547     int r;
7548     suppress_error = 0;
7549     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7550     if (r == -1)
7551       return -1;
7552   }
7553   {
7554     char device[] = "/dev/VG/LV1";
7555     int r;
7556     suppress_error = 0;
7557     r = guestfs_lvremove (g, device);
7558     if (r == -1)
7559       return -1;
7560   }
7561   {
7562     char **r;
7563     int i;
7564     suppress_error = 0;
7565     r = guestfs_lvs (g);
7566     if (r == NULL)
7567       return -1;
7568     if (!r[0]) {
7569       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
7570       print_strings (r);
7571       return -1;
7572     }
7573     {
7574       char expected[] = "/dev/VG/LV2";
7575       if (strcmp (r[0], expected) != 0) {
7576         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7577         return -1;
7578       }
7579     }
7580     if (r[1] != NULL) {
7581       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
7582       print_strings (r);
7583       return -1;
7584     }
7585     for (i = 0; r[i] != NULL; ++i)
7586       free (r[i]);
7587     free (r);
7588   }
7589   return 0;
7590 }
7591
7592 static int test_lvremove_1_skip (void)
7593 {
7594   const char *str;
7595
7596   str = getenv ("TEST_ONLY");
7597   if (str)
7598     return strstr (str, "lvremove") == NULL;
7599   str = getenv ("SKIP_TEST_LVREMOVE_1");
7600   if (str && strcmp (str, "1") == 0) return 1;
7601   str = getenv ("SKIP_TEST_LVREMOVE");
7602   if (str && strcmp (str, "1") == 0) return 1;
7603   return 0;
7604 }
7605
7606 static int test_lvremove_1 (void)
7607 {
7608   if (test_lvremove_1_skip ()) {
7609     printf ("        %s skipped (reason: environment variable set)\n", "test_lvremove_1");
7610     return 0;
7611   }
7612
7613   /* InitNone|InitEmpty for test_lvremove_1 */
7614   {
7615     char device[] = "/dev/sda";
7616     int r;
7617     suppress_error = 0;
7618     r = guestfs_blockdev_setrw (g, device);
7619     if (r == -1)
7620       return -1;
7621   }
7622   {
7623     int r;
7624     suppress_error = 0;
7625     r = guestfs_umount_all (g);
7626     if (r == -1)
7627       return -1;
7628   }
7629   {
7630     int r;
7631     suppress_error = 0;
7632     r = guestfs_lvm_remove_all (g);
7633     if (r == -1)
7634       return -1;
7635   }
7636   /* TestOutputList for lvremove (1) */
7637   {
7638     char device[] = "/dev/sda";
7639     char lines_0[] = ",";
7640     char *lines[] = {
7641       lines_0,
7642       NULL
7643     };
7644     int r;
7645     suppress_error = 0;
7646     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7647     if (r == -1)
7648       return -1;
7649   }
7650   {
7651     char device[] = "/dev/sda1";
7652     int r;
7653     suppress_error = 0;
7654     r = guestfs_pvcreate (g, device);
7655     if (r == -1)
7656       return -1;
7657   }
7658   {
7659     char volgroup[] = "VG";
7660     char physvols_0[] = "/dev/sda1";
7661     char *physvols[] = {
7662       physvols_0,
7663       NULL
7664     };
7665     int r;
7666     suppress_error = 0;
7667     r = guestfs_vgcreate (g, volgroup, physvols);
7668     if (r == -1)
7669       return -1;
7670   }
7671   {
7672     char logvol[] = "LV1";
7673     char volgroup[] = "VG";
7674     int r;
7675     suppress_error = 0;
7676     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7677     if (r == -1)
7678       return -1;
7679   }
7680   {
7681     char logvol[] = "LV2";
7682     char volgroup[] = "VG";
7683     int r;
7684     suppress_error = 0;
7685     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7686     if (r == -1)
7687       return -1;
7688   }
7689   {
7690     char device[] = "/dev/VG";
7691     int r;
7692     suppress_error = 0;
7693     r = guestfs_lvremove (g, device);
7694     if (r == -1)
7695       return -1;
7696   }
7697   {
7698     char **r;
7699     int i;
7700     suppress_error = 0;
7701     r = guestfs_lvs (g);
7702     if (r == NULL)
7703       return -1;
7704     if (r[0] != NULL) {
7705       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7706       print_strings (r);
7707       return -1;
7708     }
7709     for (i = 0; r[i] != NULL; ++i)
7710       free (r[i]);
7711     free (r);
7712   }
7713   return 0;
7714 }
7715
7716 static int test_lvremove_2_skip (void)
7717 {
7718   const char *str;
7719
7720   str = getenv ("TEST_ONLY");
7721   if (str)
7722     return strstr (str, "lvremove") == NULL;
7723   str = getenv ("SKIP_TEST_LVREMOVE_2");
7724   if (str && strcmp (str, "1") == 0) return 1;
7725   str = getenv ("SKIP_TEST_LVREMOVE");
7726   if (str && strcmp (str, "1") == 0) return 1;
7727   return 0;
7728 }
7729
7730 static int test_lvremove_2 (void)
7731 {
7732   if (test_lvremove_2_skip ()) {
7733     printf ("        %s skipped (reason: environment variable set)\n", "test_lvremove_2");
7734     return 0;
7735   }
7736
7737   /* InitNone|InitEmpty for test_lvremove_2 */
7738   {
7739     char device[] = "/dev/sda";
7740     int r;
7741     suppress_error = 0;
7742     r = guestfs_blockdev_setrw (g, device);
7743     if (r == -1)
7744       return -1;
7745   }
7746   {
7747     int r;
7748     suppress_error = 0;
7749     r = guestfs_umount_all (g);
7750     if (r == -1)
7751       return -1;
7752   }
7753   {
7754     int r;
7755     suppress_error = 0;
7756     r = guestfs_lvm_remove_all (g);
7757     if (r == -1)
7758       return -1;
7759   }
7760   /* TestOutputList for lvremove (2) */
7761   {
7762     char device[] = "/dev/sda";
7763     char lines_0[] = ",";
7764     char *lines[] = {
7765       lines_0,
7766       NULL
7767     };
7768     int r;
7769     suppress_error = 0;
7770     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7771     if (r == -1)
7772       return -1;
7773   }
7774   {
7775     char device[] = "/dev/sda1";
7776     int r;
7777     suppress_error = 0;
7778     r = guestfs_pvcreate (g, device);
7779     if (r == -1)
7780       return -1;
7781   }
7782   {
7783     char volgroup[] = "VG";
7784     char physvols_0[] = "/dev/sda1";
7785     char *physvols[] = {
7786       physvols_0,
7787       NULL
7788     };
7789     int r;
7790     suppress_error = 0;
7791     r = guestfs_vgcreate (g, volgroup, physvols);
7792     if (r == -1)
7793       return -1;
7794   }
7795   {
7796     char logvol[] = "LV1";
7797     char volgroup[] = "VG";
7798     int r;
7799     suppress_error = 0;
7800     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7801     if (r == -1)
7802       return -1;
7803   }
7804   {
7805     char logvol[] = "LV2";
7806     char volgroup[] = "VG";
7807     int r;
7808     suppress_error = 0;
7809     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7810     if (r == -1)
7811       return -1;
7812   }
7813   {
7814     char device[] = "/dev/VG";
7815     int r;
7816     suppress_error = 0;
7817     r = guestfs_lvremove (g, device);
7818     if (r == -1)
7819       return -1;
7820   }
7821   {
7822     char **r;
7823     int i;
7824     suppress_error = 0;
7825     r = guestfs_vgs (g);
7826     if (r == NULL)
7827       return -1;
7828     if (!r[0]) {
7829       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7830       print_strings (r);
7831       return -1;
7832     }
7833     {
7834       char expected[] = "VG";
7835       if (strcmp (r[0], expected) != 0) {
7836         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7837         return -1;
7838       }
7839     }
7840     if (r[1] != NULL) {
7841       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7842       print_strings (r);
7843       return -1;
7844     }
7845     for (i = 0; r[i] != NULL; ++i)
7846       free (r[i]);
7847     free (r);
7848   }
7849   return 0;
7850 }
7851
7852 static int test_mount_ro_0_skip (void)
7853 {
7854   const char *str;
7855
7856   str = getenv ("TEST_ONLY");
7857   if (str)
7858     return strstr (str, "mount_ro") == NULL;
7859   str = getenv ("SKIP_TEST_MOUNT_RO_0");
7860   if (str && strcmp (str, "1") == 0) return 1;
7861   str = getenv ("SKIP_TEST_MOUNT_RO");
7862   if (str && strcmp (str, "1") == 0) return 1;
7863   return 0;
7864 }
7865
7866 static int test_mount_ro_0 (void)
7867 {
7868   if (test_mount_ro_0_skip ()) {
7869     printf ("        %s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7870     return 0;
7871   }
7872
7873   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7874   {
7875     char device[] = "/dev/sda";
7876     int r;
7877     suppress_error = 0;
7878     r = guestfs_blockdev_setrw (g, device);
7879     if (r == -1)
7880       return -1;
7881   }
7882   {
7883     int r;
7884     suppress_error = 0;
7885     r = guestfs_umount_all (g);
7886     if (r == -1)
7887       return -1;
7888   }
7889   {
7890     int r;
7891     suppress_error = 0;
7892     r = guestfs_lvm_remove_all (g);
7893     if (r == -1)
7894       return -1;
7895   }
7896   {
7897     char device[] = "/dev/sda";
7898     char lines_0[] = ",";
7899     char *lines[] = {
7900       lines_0,
7901       NULL
7902     };
7903     int r;
7904     suppress_error = 0;
7905     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7906     if (r == -1)
7907       return -1;
7908   }
7909   {
7910     char fstype[] = "ext2";
7911     char device[] = "/dev/sda1";
7912     int r;
7913     suppress_error = 0;
7914     r = guestfs_mkfs (g, fstype, device);
7915     if (r == -1)
7916       return -1;
7917   }
7918   {
7919     char device[] = "/dev/sda1";
7920     char mountpoint[] = "/";
7921     int r;
7922     suppress_error = 0;
7923     r = guestfs_mount (g, device, mountpoint);
7924     if (r == -1)
7925       return -1;
7926   }
7927   /* TestLastFail for mount_ro (0) */
7928   {
7929     char pathordevice[] = "/";
7930     int r;
7931     suppress_error = 0;
7932     r = guestfs_umount (g, pathordevice);
7933     if (r == -1)
7934       return -1;
7935   }
7936   {
7937     char device[] = "/dev/sda1";
7938     char mountpoint[] = "/";
7939     int r;
7940     suppress_error = 0;
7941     r = guestfs_mount_ro (g, device, mountpoint);
7942     if (r == -1)
7943       return -1;
7944   }
7945   {
7946     char path[] = "/new";
7947     int r;
7948     suppress_error = 1;
7949     r = guestfs_touch (g, path);
7950     if (r != -1)
7951       return -1;
7952   }
7953   return 0;
7954 }
7955
7956 static int test_mount_ro_1_skip (void)
7957 {
7958   const char *str;
7959
7960   str = getenv ("TEST_ONLY");
7961   if (str)
7962     return strstr (str, "mount_ro") == NULL;
7963   str = getenv ("SKIP_TEST_MOUNT_RO_1");
7964   if (str && strcmp (str, "1") == 0) return 1;
7965   str = getenv ("SKIP_TEST_MOUNT_RO");
7966   if (str && strcmp (str, "1") == 0) return 1;
7967   return 0;
7968 }
7969
7970 static int test_mount_ro_1 (void)
7971 {
7972   if (test_mount_ro_1_skip ()) {
7973     printf ("        %s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7974     return 0;
7975   }
7976
7977   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7978   {
7979     char device[] = "/dev/sda";
7980     int r;
7981     suppress_error = 0;
7982     r = guestfs_blockdev_setrw (g, device);
7983     if (r == -1)
7984       return -1;
7985   }
7986   {
7987     int r;
7988     suppress_error = 0;
7989     r = guestfs_umount_all (g);
7990     if (r == -1)
7991       return -1;
7992   }
7993   {
7994     int r;
7995     suppress_error = 0;
7996     r = guestfs_lvm_remove_all (g);
7997     if (r == -1)
7998       return -1;
7999   }
8000   {
8001     char device[] = "/dev/sda";
8002     char lines_0[] = ",";
8003     char *lines[] = {
8004       lines_0,
8005       NULL
8006     };
8007     int r;
8008     suppress_error = 0;
8009     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8010     if (r == -1)
8011       return -1;
8012   }
8013   {
8014     char fstype[] = "ext2";
8015     char device[] = "/dev/sda1";
8016     int r;
8017     suppress_error = 0;
8018     r = guestfs_mkfs (g, fstype, device);
8019     if (r == -1)
8020       return -1;
8021   }
8022   {
8023     char device[] = "/dev/sda1";
8024     char mountpoint[] = "/";
8025     int r;
8026     suppress_error = 0;
8027     r = guestfs_mount (g, device, mountpoint);
8028     if (r == -1)
8029       return -1;
8030   }
8031   /* TestOutput for mount_ro (1) */
8032   char expected[] = "data";
8033   {
8034     char path[] = "/new";
8035     char content[] = "data";
8036     int r;
8037     suppress_error = 0;
8038     r = guestfs_write_file (g, path, content, 0);
8039     if (r == -1)
8040       return -1;
8041   }
8042   {
8043     char pathordevice[] = "/";
8044     int r;
8045     suppress_error = 0;
8046     r = guestfs_umount (g, pathordevice);
8047     if (r == -1)
8048       return -1;
8049   }
8050   {
8051     char device[] = "/dev/sda1";
8052     char mountpoint[] = "/";
8053     int r;
8054     suppress_error = 0;
8055     r = guestfs_mount_ro (g, device, mountpoint);
8056     if (r == -1)
8057       return -1;
8058   }
8059   {
8060     char path[] = "/new";
8061     char *r;
8062     suppress_error = 0;
8063     r = guestfs_cat (g, path);
8064     if (r == NULL)
8065       return -1;
8066     if (strcmp (r, expected) != 0) {
8067       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
8068       return -1;
8069     }
8070     free (r);
8071   }
8072   return 0;
8073 }
8074
8075 static int test_tgz_in_0_skip (void)
8076 {
8077   const char *str;
8078
8079   str = getenv ("TEST_ONLY");
8080   if (str)
8081     return strstr (str, "tgz_in") == NULL;
8082   str = getenv ("SKIP_TEST_TGZ_IN_0");
8083   if (str && strcmp (str, "1") == 0) return 1;
8084   str = getenv ("SKIP_TEST_TGZ_IN");
8085   if (str && strcmp (str, "1") == 0) return 1;
8086   return 0;
8087 }
8088
8089 static int test_tgz_in_0 (void)
8090 {
8091   if (test_tgz_in_0_skip ()) {
8092     printf ("        %s skipped (reason: environment variable set)\n", "test_tgz_in_0");
8093     return 0;
8094   }
8095
8096   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
8097   {
8098     char device[] = "/dev/sda";
8099     int r;
8100     suppress_error = 0;
8101     r = guestfs_blockdev_setrw (g, device);
8102     if (r == -1)
8103       return -1;
8104   }
8105   {
8106     int r;
8107     suppress_error = 0;
8108     r = guestfs_umount_all (g);
8109     if (r == -1)
8110       return -1;
8111   }
8112   {
8113     int r;
8114     suppress_error = 0;
8115     r = guestfs_lvm_remove_all (g);
8116     if (r == -1)
8117       return -1;
8118   }
8119   {
8120     char device[] = "/dev/sda";
8121     char lines_0[] = ",";
8122     char *lines[] = {
8123       lines_0,
8124       NULL
8125     };
8126     int r;
8127     suppress_error = 0;
8128     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8129     if (r == -1)
8130       return -1;
8131   }
8132   {
8133     char fstype[] = "ext2";
8134     char device[] = "/dev/sda1";
8135     int r;
8136     suppress_error = 0;
8137     r = guestfs_mkfs (g, fstype, device);
8138     if (r == -1)
8139       return -1;
8140   }
8141   {
8142     char device[] = "/dev/sda1";
8143     char mountpoint[] = "/";
8144     int r;
8145     suppress_error = 0;
8146     r = guestfs_mount (g, device, mountpoint);
8147     if (r == -1)
8148       return -1;
8149   }
8150   /* TestOutput for tgz_in (0) */
8151   char expected[] = "hello\n";
8152   {
8153     char directory[] = "/";
8154     int r;
8155     suppress_error = 0;
8156     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
8157     if (r == -1)
8158       return -1;
8159   }
8160   {
8161     char path[] = "/hello";
8162     char *r;
8163     suppress_error = 0;
8164     r = guestfs_cat (g, path);
8165     if (r == NULL)
8166       return -1;
8167     if (strcmp (r, expected) != 0) {
8168       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8169       return -1;
8170     }
8171     free (r);
8172   }
8173   return 0;
8174 }
8175
8176 static int test_tar_in_0_skip (void)
8177 {
8178   const char *str;
8179
8180   str = getenv ("TEST_ONLY");
8181   if (str)
8182     return strstr (str, "tar_in") == NULL;
8183   str = getenv ("SKIP_TEST_TAR_IN_0");
8184   if (str && strcmp (str, "1") == 0) return 1;
8185   str = getenv ("SKIP_TEST_TAR_IN");
8186   if (str && strcmp (str, "1") == 0) return 1;
8187   return 0;
8188 }
8189
8190 static int test_tar_in_0 (void)
8191 {
8192   if (test_tar_in_0_skip ()) {
8193     printf ("        %s skipped (reason: environment variable set)\n", "test_tar_in_0");
8194     return 0;
8195   }
8196
8197   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
8198   {
8199     char device[] = "/dev/sda";
8200     int r;
8201     suppress_error = 0;
8202     r = guestfs_blockdev_setrw (g, device);
8203     if (r == -1)
8204       return -1;
8205   }
8206   {
8207     int r;
8208     suppress_error = 0;
8209     r = guestfs_umount_all (g);
8210     if (r == -1)
8211       return -1;
8212   }
8213   {
8214     int r;
8215     suppress_error = 0;
8216     r = guestfs_lvm_remove_all (g);
8217     if (r == -1)
8218       return -1;
8219   }
8220   {
8221     char device[] = "/dev/sda";
8222     char lines_0[] = ",";
8223     char *lines[] = {
8224       lines_0,
8225       NULL
8226     };
8227     int r;
8228     suppress_error = 0;
8229     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8230     if (r == -1)
8231       return -1;
8232   }
8233   {
8234     char fstype[] = "ext2";
8235     char device[] = "/dev/sda1";
8236     int r;
8237     suppress_error = 0;
8238     r = guestfs_mkfs (g, fstype, device);
8239     if (r == -1)
8240       return -1;
8241   }
8242   {
8243     char device[] = "/dev/sda1";
8244     char mountpoint[] = "/";
8245     int r;
8246     suppress_error = 0;
8247     r = guestfs_mount (g, device, mountpoint);
8248     if (r == -1)
8249       return -1;
8250   }
8251   /* TestOutput for tar_in (0) */
8252   char expected[] = "hello\n";
8253   {
8254     char directory[] = "/";
8255     int r;
8256     suppress_error = 0;
8257     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
8258     if (r == -1)
8259       return -1;
8260   }
8261   {
8262     char path[] = "/hello";
8263     char *r;
8264     suppress_error = 0;
8265     r = guestfs_cat (g, path);
8266     if (r == NULL)
8267       return -1;
8268     if (strcmp (r, expected) != 0) {
8269       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8270       return -1;
8271     }
8272     free (r);
8273   }
8274   return 0;
8275 }
8276
8277 static int test_checksum_0_skip (void)
8278 {
8279   const char *str;
8280
8281   str = getenv ("TEST_ONLY");
8282   if (str)
8283     return strstr (str, "checksum") == NULL;
8284   str = getenv ("SKIP_TEST_CHECKSUM_0");
8285   if (str && strcmp (str, "1") == 0) return 1;
8286   str = getenv ("SKIP_TEST_CHECKSUM");
8287   if (str && strcmp (str, "1") == 0) return 1;
8288   return 0;
8289 }
8290
8291 static int test_checksum_0 (void)
8292 {
8293   if (test_checksum_0_skip ()) {
8294     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_0");
8295     return 0;
8296   }
8297
8298   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
8299   {
8300     char device[] = "/dev/sda";
8301     int r;
8302     suppress_error = 0;
8303     r = guestfs_blockdev_setrw (g, device);
8304     if (r == -1)
8305       return -1;
8306   }
8307   {
8308     int r;
8309     suppress_error = 0;
8310     r = guestfs_umount_all (g);
8311     if (r == -1)
8312       return -1;
8313   }
8314   {
8315     int r;
8316     suppress_error = 0;
8317     r = guestfs_lvm_remove_all (g);
8318     if (r == -1)
8319       return -1;
8320   }
8321   {
8322     char device[] = "/dev/sda";
8323     char lines_0[] = ",";
8324     char *lines[] = {
8325       lines_0,
8326       NULL
8327     };
8328     int r;
8329     suppress_error = 0;
8330     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8331     if (r == -1)
8332       return -1;
8333   }
8334   {
8335     char fstype[] = "ext2";
8336     char device[] = "/dev/sda1";
8337     int r;
8338     suppress_error = 0;
8339     r = guestfs_mkfs (g, fstype, device);
8340     if (r == -1)
8341       return -1;
8342   }
8343   {
8344     char device[] = "/dev/sda1";
8345     char mountpoint[] = "/";
8346     int r;
8347     suppress_error = 0;
8348     r = guestfs_mount (g, device, mountpoint);
8349     if (r == -1)
8350       return -1;
8351   }
8352   /* TestOutput for checksum (0) */
8353   char expected[] = "935282863";
8354   {
8355     char path[] = "/new";
8356     char content[] = "test\n";
8357     int r;
8358     suppress_error = 0;
8359     r = guestfs_write_file (g, path, content, 0);
8360     if (r == -1)
8361       return -1;
8362   }
8363   {
8364     char csumtype[] = "crc";
8365     char path[] = "/new";
8366     char *r;
8367     suppress_error = 0;
8368     r = guestfs_checksum (g, csumtype, path);
8369     if (r == NULL)
8370       return -1;
8371     if (strcmp (r, expected) != 0) {
8372       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
8373       return -1;
8374     }
8375     free (r);
8376   }
8377   return 0;
8378 }
8379
8380 static int test_checksum_1_skip (void)
8381 {
8382   const char *str;
8383
8384   str = getenv ("TEST_ONLY");
8385   if (str)
8386     return strstr (str, "checksum") == NULL;
8387   str = getenv ("SKIP_TEST_CHECKSUM_1");
8388   if (str && strcmp (str, "1") == 0) return 1;
8389   str = getenv ("SKIP_TEST_CHECKSUM");
8390   if (str && strcmp (str, "1") == 0) return 1;
8391   return 0;
8392 }
8393
8394 static int test_checksum_1 (void)
8395 {
8396   if (test_checksum_1_skip ()) {
8397     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_1");
8398     return 0;
8399   }
8400
8401   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
8402   {
8403     char device[] = "/dev/sda";
8404     int r;
8405     suppress_error = 0;
8406     r = guestfs_blockdev_setrw (g, device);
8407     if (r == -1)
8408       return -1;
8409   }
8410   {
8411     int r;
8412     suppress_error = 0;
8413     r = guestfs_umount_all (g);
8414     if (r == -1)
8415       return -1;
8416   }
8417   {
8418     int r;
8419     suppress_error = 0;
8420     r = guestfs_lvm_remove_all (g);
8421     if (r == -1)
8422       return -1;
8423   }
8424   {
8425     char device[] = "/dev/sda";
8426     char lines_0[] = ",";
8427     char *lines[] = {
8428       lines_0,
8429       NULL
8430     };
8431     int r;
8432     suppress_error = 0;
8433     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8434     if (r == -1)
8435       return -1;
8436   }
8437   {
8438     char fstype[] = "ext2";
8439     char device[] = "/dev/sda1";
8440     int r;
8441     suppress_error = 0;
8442     r = guestfs_mkfs (g, fstype, device);
8443     if (r == -1)
8444       return -1;
8445   }
8446   {
8447     char device[] = "/dev/sda1";
8448     char mountpoint[] = "/";
8449     int r;
8450     suppress_error = 0;
8451     r = guestfs_mount (g, device, mountpoint);
8452     if (r == -1)
8453       return -1;
8454   }
8455   /* TestLastFail for checksum (1) */
8456   {
8457     char csumtype[] = "crc";
8458     char path[] = "/new";
8459     char *r;
8460     suppress_error = 1;
8461     r = guestfs_checksum (g, csumtype, path);
8462     if (r != NULL)
8463       return -1;
8464     free (r);
8465   }
8466   return 0;
8467 }
8468
8469 static int test_checksum_2_skip (void)
8470 {
8471   const char *str;
8472
8473   str = getenv ("TEST_ONLY");
8474   if (str)
8475     return strstr (str, "checksum") == NULL;
8476   str = getenv ("SKIP_TEST_CHECKSUM_2");
8477   if (str && strcmp (str, "1") == 0) return 1;
8478   str = getenv ("SKIP_TEST_CHECKSUM");
8479   if (str && strcmp (str, "1") == 0) return 1;
8480   return 0;
8481 }
8482
8483 static int test_checksum_2 (void)
8484 {
8485   if (test_checksum_2_skip ()) {
8486     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_2");
8487     return 0;
8488   }
8489
8490   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
8491   {
8492     char device[] = "/dev/sda";
8493     int r;
8494     suppress_error = 0;
8495     r = guestfs_blockdev_setrw (g, device);
8496     if (r == -1)
8497       return -1;
8498   }
8499   {
8500     int r;
8501     suppress_error = 0;
8502     r = guestfs_umount_all (g);
8503     if (r == -1)
8504       return -1;
8505   }
8506   {
8507     int r;
8508     suppress_error = 0;
8509     r = guestfs_lvm_remove_all (g);
8510     if (r == -1)
8511       return -1;
8512   }
8513   {
8514     char device[] = "/dev/sda";
8515     char lines_0[] = ",";
8516     char *lines[] = {
8517       lines_0,
8518       NULL
8519     };
8520     int r;
8521     suppress_error = 0;
8522     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8523     if (r == -1)
8524       return -1;
8525   }
8526   {
8527     char fstype[] = "ext2";
8528     char device[] = "/dev/sda1";
8529     int r;
8530     suppress_error = 0;
8531     r = guestfs_mkfs (g, fstype, device);
8532     if (r == -1)
8533       return -1;
8534   }
8535   {
8536     char device[] = "/dev/sda1";
8537     char mountpoint[] = "/";
8538     int r;
8539     suppress_error = 0;
8540     r = guestfs_mount (g, device, mountpoint);
8541     if (r == -1)
8542       return -1;
8543   }
8544   /* TestOutput for checksum (2) */
8545   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
8546   {
8547     char path[] = "/new";
8548     char content[] = "test\n";
8549     int r;
8550     suppress_error = 0;
8551     r = guestfs_write_file (g, path, content, 0);
8552     if (r == -1)
8553       return -1;
8554   }
8555   {
8556     char csumtype[] = "md5";
8557     char path[] = "/new";
8558     char *r;
8559     suppress_error = 0;
8560     r = guestfs_checksum (g, csumtype, path);
8561     if (r == NULL)
8562       return -1;
8563     if (strcmp (r, expected) != 0) {
8564       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
8565       return -1;
8566     }
8567     free (r);
8568   }
8569   return 0;
8570 }
8571
8572 static int test_checksum_3_skip (void)
8573 {
8574   const char *str;
8575
8576   str = getenv ("TEST_ONLY");
8577   if (str)
8578     return strstr (str, "checksum") == NULL;
8579   str = getenv ("SKIP_TEST_CHECKSUM_3");
8580   if (str && strcmp (str, "1") == 0) return 1;
8581   str = getenv ("SKIP_TEST_CHECKSUM");
8582   if (str && strcmp (str, "1") == 0) return 1;
8583   return 0;
8584 }
8585
8586 static int test_checksum_3 (void)
8587 {
8588   if (test_checksum_3_skip ()) {
8589     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_3");
8590     return 0;
8591   }
8592
8593   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
8594   {
8595     char device[] = "/dev/sda";
8596     int r;
8597     suppress_error = 0;
8598     r = guestfs_blockdev_setrw (g, device);
8599     if (r == -1)
8600       return -1;
8601   }
8602   {
8603     int r;
8604     suppress_error = 0;
8605     r = guestfs_umount_all (g);
8606     if (r == -1)
8607       return -1;
8608   }
8609   {
8610     int r;
8611     suppress_error = 0;
8612     r = guestfs_lvm_remove_all (g);
8613     if (r == -1)
8614       return -1;
8615   }
8616   {
8617     char device[] = "/dev/sda";
8618     char lines_0[] = ",";
8619     char *lines[] = {
8620       lines_0,
8621       NULL
8622     };
8623     int r;
8624     suppress_error = 0;
8625     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8626     if (r == -1)
8627       return -1;
8628   }
8629   {
8630     char fstype[] = "ext2";
8631     char device[] = "/dev/sda1";
8632     int r;
8633     suppress_error = 0;
8634     r = guestfs_mkfs (g, fstype, device);
8635     if (r == -1)
8636       return -1;
8637   }
8638   {
8639     char device[] = "/dev/sda1";
8640     char mountpoint[] = "/";
8641     int r;
8642     suppress_error = 0;
8643     r = guestfs_mount (g, device, mountpoint);
8644     if (r == -1)
8645       return -1;
8646   }
8647   /* TestOutput for checksum (3) */
8648   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8649   {
8650     char path[] = "/new";
8651     char content[] = "test\n";
8652     int r;
8653     suppress_error = 0;
8654     r = guestfs_write_file (g, path, content, 0);
8655     if (r == -1)
8656       return -1;
8657   }
8658   {
8659     char csumtype[] = "sha1";
8660     char path[] = "/new";
8661     char *r;
8662     suppress_error = 0;
8663     r = guestfs_checksum (g, csumtype, path);
8664     if (r == NULL)
8665       return -1;
8666     if (strcmp (r, expected) != 0) {
8667       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8668       return -1;
8669     }
8670     free (r);
8671   }
8672   return 0;
8673 }
8674
8675 static int test_checksum_4_skip (void)
8676 {
8677   const char *str;
8678
8679   str = getenv ("TEST_ONLY");
8680   if (str)
8681     return strstr (str, "checksum") == NULL;
8682   str = getenv ("SKIP_TEST_CHECKSUM_4");
8683   if (str && strcmp (str, "1") == 0) return 1;
8684   str = getenv ("SKIP_TEST_CHECKSUM");
8685   if (str && strcmp (str, "1") == 0) return 1;
8686   return 0;
8687 }
8688
8689 static int test_checksum_4 (void)
8690 {
8691   if (test_checksum_4_skip ()) {
8692     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_4");
8693     return 0;
8694   }
8695
8696   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8697   {
8698     char device[] = "/dev/sda";
8699     int r;
8700     suppress_error = 0;
8701     r = guestfs_blockdev_setrw (g, device);
8702     if (r == -1)
8703       return -1;
8704   }
8705   {
8706     int r;
8707     suppress_error = 0;
8708     r = guestfs_umount_all (g);
8709     if (r == -1)
8710       return -1;
8711   }
8712   {
8713     int r;
8714     suppress_error = 0;
8715     r = guestfs_lvm_remove_all (g);
8716     if (r == -1)
8717       return -1;
8718   }
8719   {
8720     char device[] = "/dev/sda";
8721     char lines_0[] = ",";
8722     char *lines[] = {
8723       lines_0,
8724       NULL
8725     };
8726     int r;
8727     suppress_error = 0;
8728     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8729     if (r == -1)
8730       return -1;
8731   }
8732   {
8733     char fstype[] = "ext2";
8734     char device[] = "/dev/sda1";
8735     int r;
8736     suppress_error = 0;
8737     r = guestfs_mkfs (g, fstype, device);
8738     if (r == -1)
8739       return -1;
8740   }
8741   {
8742     char device[] = "/dev/sda1";
8743     char mountpoint[] = "/";
8744     int r;
8745     suppress_error = 0;
8746     r = guestfs_mount (g, device, mountpoint);
8747     if (r == -1)
8748       return -1;
8749   }
8750   /* TestOutput for checksum (4) */
8751   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8752   {
8753     char path[] = "/new";
8754     char content[] = "test\n";
8755     int r;
8756     suppress_error = 0;
8757     r = guestfs_write_file (g, path, content, 0);
8758     if (r == -1)
8759       return -1;
8760   }
8761   {
8762     char csumtype[] = "sha224";
8763     char path[] = "/new";
8764     char *r;
8765     suppress_error = 0;
8766     r = guestfs_checksum (g, csumtype, path);
8767     if (r == NULL)
8768       return -1;
8769     if (strcmp (r, expected) != 0) {
8770       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8771       return -1;
8772     }
8773     free (r);
8774   }
8775   return 0;
8776 }
8777
8778 static int test_checksum_5_skip (void)
8779 {
8780   const char *str;
8781
8782   str = getenv ("TEST_ONLY");
8783   if (str)
8784     return strstr (str, "checksum") == NULL;
8785   str = getenv ("SKIP_TEST_CHECKSUM_5");
8786   if (str && strcmp (str, "1") == 0) return 1;
8787   str = getenv ("SKIP_TEST_CHECKSUM");
8788   if (str && strcmp (str, "1") == 0) return 1;
8789   return 0;
8790 }
8791
8792 static int test_checksum_5 (void)
8793 {
8794   if (test_checksum_5_skip ()) {
8795     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_5");
8796     return 0;
8797   }
8798
8799   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8800   {
8801     char device[] = "/dev/sda";
8802     int r;
8803     suppress_error = 0;
8804     r = guestfs_blockdev_setrw (g, device);
8805     if (r == -1)
8806       return -1;
8807   }
8808   {
8809     int r;
8810     suppress_error = 0;
8811     r = guestfs_umount_all (g);
8812     if (r == -1)
8813       return -1;
8814   }
8815   {
8816     int r;
8817     suppress_error = 0;
8818     r = guestfs_lvm_remove_all (g);
8819     if (r == -1)
8820       return -1;
8821   }
8822   {
8823     char device[] = "/dev/sda";
8824     char lines_0[] = ",";
8825     char *lines[] = {
8826       lines_0,
8827       NULL
8828     };
8829     int r;
8830     suppress_error = 0;
8831     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8832     if (r == -1)
8833       return -1;
8834   }
8835   {
8836     char fstype[] = "ext2";
8837     char device[] = "/dev/sda1";
8838     int r;
8839     suppress_error = 0;
8840     r = guestfs_mkfs (g, fstype, device);
8841     if (r == -1)
8842       return -1;
8843   }
8844   {
8845     char device[] = "/dev/sda1";
8846     char mountpoint[] = "/";
8847     int r;
8848     suppress_error = 0;
8849     r = guestfs_mount (g, device, mountpoint);
8850     if (r == -1)
8851       return -1;
8852   }
8853   /* TestOutput for checksum (5) */
8854   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8855   {
8856     char path[] = "/new";
8857     char content[] = "test\n";
8858     int r;
8859     suppress_error = 0;
8860     r = guestfs_write_file (g, path, content, 0);
8861     if (r == -1)
8862       return -1;
8863   }
8864   {
8865     char csumtype[] = "sha256";
8866     char path[] = "/new";
8867     char *r;
8868     suppress_error = 0;
8869     r = guestfs_checksum (g, csumtype, path);
8870     if (r == NULL)
8871       return -1;
8872     if (strcmp (r, expected) != 0) {
8873       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8874       return -1;
8875     }
8876     free (r);
8877   }
8878   return 0;
8879 }
8880
8881 static int test_checksum_6_skip (void)
8882 {
8883   const char *str;
8884
8885   str = getenv ("TEST_ONLY");
8886   if (str)
8887     return strstr (str, "checksum") == NULL;
8888   str = getenv ("SKIP_TEST_CHECKSUM_6");
8889   if (str && strcmp (str, "1") == 0) return 1;
8890   str = getenv ("SKIP_TEST_CHECKSUM");
8891   if (str && strcmp (str, "1") == 0) return 1;
8892   return 0;
8893 }
8894
8895 static int test_checksum_6 (void)
8896 {
8897   if (test_checksum_6_skip ()) {
8898     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_6");
8899     return 0;
8900   }
8901
8902   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8903   {
8904     char device[] = "/dev/sda";
8905     int r;
8906     suppress_error = 0;
8907     r = guestfs_blockdev_setrw (g, device);
8908     if (r == -1)
8909       return -1;
8910   }
8911   {
8912     int r;
8913     suppress_error = 0;
8914     r = guestfs_umount_all (g);
8915     if (r == -1)
8916       return -1;
8917   }
8918   {
8919     int r;
8920     suppress_error = 0;
8921     r = guestfs_lvm_remove_all (g);
8922     if (r == -1)
8923       return -1;
8924   }
8925   {
8926     char device[] = "/dev/sda";
8927     char lines_0[] = ",";
8928     char *lines[] = {
8929       lines_0,
8930       NULL
8931     };
8932     int r;
8933     suppress_error = 0;
8934     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8935     if (r == -1)
8936       return -1;
8937   }
8938   {
8939     char fstype[] = "ext2";
8940     char device[] = "/dev/sda1";
8941     int r;
8942     suppress_error = 0;
8943     r = guestfs_mkfs (g, fstype, device);
8944     if (r == -1)
8945       return -1;
8946   }
8947   {
8948     char device[] = "/dev/sda1";
8949     char mountpoint[] = "/";
8950     int r;
8951     suppress_error = 0;
8952     r = guestfs_mount (g, device, mountpoint);
8953     if (r == -1)
8954       return -1;
8955   }
8956   /* TestOutput for checksum (6) */
8957   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8958   {
8959     char path[] = "/new";
8960     char content[] = "test\n";
8961     int r;
8962     suppress_error = 0;
8963     r = guestfs_write_file (g, path, content, 0);
8964     if (r == -1)
8965       return -1;
8966   }
8967   {
8968     char csumtype[] = "sha384";
8969     char path[] = "/new";
8970     char *r;
8971     suppress_error = 0;
8972     r = guestfs_checksum (g, csumtype, path);
8973     if (r == NULL)
8974       return -1;
8975     if (strcmp (r, expected) != 0) {
8976       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8977       return -1;
8978     }
8979     free (r);
8980   }
8981   return 0;
8982 }
8983
8984 static int test_checksum_7_skip (void)
8985 {
8986   const char *str;
8987
8988   str = getenv ("TEST_ONLY");
8989   if (str)
8990     return strstr (str, "checksum") == NULL;
8991   str = getenv ("SKIP_TEST_CHECKSUM_7");
8992   if (str && strcmp (str, "1") == 0) return 1;
8993   str = getenv ("SKIP_TEST_CHECKSUM");
8994   if (str && strcmp (str, "1") == 0) return 1;
8995   return 0;
8996 }
8997
8998 static int test_checksum_7 (void)
8999 {
9000   if (test_checksum_7_skip ()) {
9001     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_7");
9002     return 0;
9003   }
9004
9005   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
9006   {
9007     char device[] = "/dev/sda";
9008     int r;
9009     suppress_error = 0;
9010     r = guestfs_blockdev_setrw (g, device);
9011     if (r == -1)
9012       return -1;
9013   }
9014   {
9015     int r;
9016     suppress_error = 0;
9017     r = guestfs_umount_all (g);
9018     if (r == -1)
9019       return -1;
9020   }
9021   {
9022     int r;
9023     suppress_error = 0;
9024     r = guestfs_lvm_remove_all (g);
9025     if (r == -1)
9026       return -1;
9027   }
9028   {
9029     char device[] = "/dev/sda";
9030     char lines_0[] = ",";
9031     char *lines[] = {
9032       lines_0,
9033       NULL
9034     };
9035     int r;
9036     suppress_error = 0;
9037     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9038     if (r == -1)
9039       return -1;
9040   }
9041   {
9042     char fstype[] = "ext2";
9043     char device[] = "/dev/sda1";
9044     int r;
9045     suppress_error = 0;
9046     r = guestfs_mkfs (g, fstype, device);
9047     if (r == -1)
9048       return -1;
9049   }
9050   {
9051     char device[] = "/dev/sda1";
9052     char mountpoint[] = "/";
9053     int r;
9054     suppress_error = 0;
9055     r = guestfs_mount (g, device, mountpoint);
9056     if (r == -1)
9057       return -1;
9058   }
9059   /* TestOutput for checksum (7) */
9060   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
9061   {
9062     char path[] = "/new";
9063     char content[] = "test\n";
9064     int r;
9065     suppress_error = 0;
9066     r = guestfs_write_file (g, path, content, 0);
9067     if (r == -1)
9068       return -1;
9069   }
9070   {
9071     char csumtype[] = "sha512";
9072     char path[] = "/new";
9073     char *r;
9074     suppress_error = 0;
9075     r = guestfs_checksum (g, csumtype, path);
9076     if (r == NULL)
9077       return -1;
9078     if (strcmp (r, expected) != 0) {
9079       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
9080       return -1;
9081     }
9082     free (r);
9083   }
9084   return 0;
9085 }
9086
9087 static int test_checksum_8_skip (void)
9088 {
9089   const char *str;
9090
9091   str = getenv ("TEST_ONLY");
9092   if (str)
9093     return strstr (str, "checksum") == NULL;
9094   str = getenv ("SKIP_TEST_CHECKSUM_8");
9095   if (str && strcmp (str, "1") == 0) return 1;
9096   str = getenv ("SKIP_TEST_CHECKSUM");
9097   if (str && strcmp (str, "1") == 0) return 1;
9098   return 0;
9099 }
9100
9101 static int test_checksum_8 (void)
9102 {
9103   if (test_checksum_8_skip ()) {
9104     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_8");
9105     return 0;
9106   }
9107
9108   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
9109   {
9110     char device[] = "/dev/sda";
9111     int r;
9112     suppress_error = 0;
9113     r = guestfs_blockdev_setrw (g, device);
9114     if (r == -1)
9115       return -1;
9116   }
9117   {
9118     int r;
9119     suppress_error = 0;
9120     r = guestfs_umount_all (g);
9121     if (r == -1)
9122       return -1;
9123   }
9124   {
9125     int r;
9126     suppress_error = 0;
9127     r = guestfs_lvm_remove_all (g);
9128     if (r == -1)
9129       return -1;
9130   }
9131   {
9132     char device[] = "/dev/sda";
9133     char lines_0[] = ",";
9134     char *lines[] = {
9135       lines_0,
9136       NULL
9137     };
9138     int r;
9139     suppress_error = 0;
9140     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9141     if (r == -1)
9142       return -1;
9143   }
9144   {
9145     char fstype[] = "ext2";
9146     char device[] = "/dev/sda1";
9147     int r;
9148     suppress_error = 0;
9149     r = guestfs_mkfs (g, fstype, device);
9150     if (r == -1)
9151       return -1;
9152   }
9153   {
9154     char device[] = "/dev/sda1";
9155     char mountpoint[] = "/";
9156     int r;
9157     suppress_error = 0;
9158     r = guestfs_mount (g, device, mountpoint);
9159     if (r == -1)
9160       return -1;
9161   }
9162   /* TestOutput for checksum (8) */
9163   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
9164   {
9165     char options[] = "ro";
9166     char vfstype[] = "squashfs";
9167     char device[] = "/dev/sdd";
9168     char mountpoint[] = "/";
9169     int r;
9170     suppress_error = 0;
9171     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
9172     if (r == -1)
9173       return -1;
9174   }
9175   {
9176     char csumtype[] = "md5";
9177     char path[] = "/known-3";
9178     char *r;
9179     suppress_error = 0;
9180     r = guestfs_checksum (g, csumtype, path);
9181     if (r == NULL)
9182       return -1;
9183     if (strcmp (r, expected) != 0) {
9184       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
9185       return -1;
9186     }
9187     free (r);
9188   }
9189   return 0;
9190 }
9191
9192 static int test_download_0_skip (void)
9193 {
9194   const char *str;
9195
9196   str = getenv ("TEST_ONLY");
9197   if (str)
9198     return strstr (str, "download") == NULL;
9199   str = getenv ("SKIP_TEST_DOWNLOAD_0");
9200   if (str && strcmp (str, "1") == 0) return 1;
9201   str = getenv ("SKIP_TEST_DOWNLOAD");
9202   if (str && strcmp (str, "1") == 0) return 1;
9203   return 0;
9204 }
9205
9206 static int test_download_0 (void)
9207 {
9208   if (test_download_0_skip ()) {
9209     printf ("        %s skipped (reason: environment variable set)\n", "test_download_0");
9210     return 0;
9211   }
9212
9213   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
9214   {
9215     char device[] = "/dev/sda";
9216     int r;
9217     suppress_error = 0;
9218     r = guestfs_blockdev_setrw (g, device);
9219     if (r == -1)
9220       return -1;
9221   }
9222   {
9223     int r;
9224     suppress_error = 0;
9225     r = guestfs_umount_all (g);
9226     if (r == -1)
9227       return -1;
9228   }
9229   {
9230     int r;
9231     suppress_error = 0;
9232     r = guestfs_lvm_remove_all (g);
9233     if (r == -1)
9234       return -1;
9235   }
9236   {
9237     char device[] = "/dev/sda";
9238     char lines_0[] = ",";
9239     char *lines[] = {
9240       lines_0,
9241       NULL
9242     };
9243     int r;
9244     suppress_error = 0;
9245     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9246     if (r == -1)
9247       return -1;
9248   }
9249   {
9250     char fstype[] = "ext2";
9251     char device[] = "/dev/sda1";
9252     int r;
9253     suppress_error = 0;
9254     r = guestfs_mkfs (g, fstype, device);
9255     if (r == -1)
9256       return -1;
9257   }
9258   {
9259     char device[] = "/dev/sda1";
9260     char mountpoint[] = "/";
9261     int r;
9262     suppress_error = 0;
9263     r = guestfs_mount (g, device, mountpoint);
9264     if (r == -1)
9265       return -1;
9266   }
9267   /* TestOutput for download (0) */
9268   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9269   {
9270     char remotefilename[] = "/COPYING.LIB";
9271     int r;
9272     suppress_error = 0;
9273     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9274     if (r == -1)
9275       return -1;
9276   }
9277   {
9278     char remotefilename[] = "/COPYING.LIB";
9279     int r;
9280     suppress_error = 0;
9281     r = guestfs_download (g, remotefilename, "testdownload.tmp");
9282     if (r == -1)
9283       return -1;
9284   }
9285   {
9286     char remotefilename[] = "/upload";
9287     int r;
9288     suppress_error = 0;
9289     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
9290     if (r == -1)
9291       return -1;
9292   }
9293   {
9294     char csumtype[] = "md5";
9295     char path[] = "/upload";
9296     char *r;
9297     suppress_error = 0;
9298     r = guestfs_checksum (g, csumtype, path);
9299     if (r == NULL)
9300       return -1;
9301     if (strcmp (r, expected) != 0) {
9302       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
9303       return -1;
9304     }
9305     free (r);
9306   }
9307   return 0;
9308 }
9309
9310 static int test_upload_0_skip (void)
9311 {
9312   const char *str;
9313
9314   str = getenv ("TEST_ONLY");
9315   if (str)
9316     return strstr (str, "upload") == NULL;
9317   str = getenv ("SKIP_TEST_UPLOAD_0");
9318   if (str && strcmp (str, "1") == 0) return 1;
9319   str = getenv ("SKIP_TEST_UPLOAD");
9320   if (str && strcmp (str, "1") == 0) return 1;
9321   return 0;
9322 }
9323
9324 static int test_upload_0 (void)
9325 {
9326   if (test_upload_0_skip ()) {
9327     printf ("        %s skipped (reason: environment variable set)\n", "test_upload_0");
9328     return 0;
9329   }
9330
9331   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
9332   {
9333     char device[] = "/dev/sda";
9334     int r;
9335     suppress_error = 0;
9336     r = guestfs_blockdev_setrw (g, device);
9337     if (r == -1)
9338       return -1;
9339   }
9340   {
9341     int r;
9342     suppress_error = 0;
9343     r = guestfs_umount_all (g);
9344     if (r == -1)
9345       return -1;
9346   }
9347   {
9348     int r;
9349     suppress_error = 0;
9350     r = guestfs_lvm_remove_all (g);
9351     if (r == -1)
9352       return -1;
9353   }
9354   {
9355     char device[] = "/dev/sda";
9356     char lines_0[] = ",";
9357     char *lines[] = {
9358       lines_0,
9359       NULL
9360     };
9361     int r;
9362     suppress_error = 0;
9363     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9364     if (r == -1)
9365       return -1;
9366   }
9367   {
9368     char fstype[] = "ext2";
9369     char device[] = "/dev/sda1";
9370     int r;
9371     suppress_error = 0;
9372     r = guestfs_mkfs (g, fstype, device);
9373     if (r == -1)
9374       return -1;
9375   }
9376   {
9377     char device[] = "/dev/sda1";
9378     char mountpoint[] = "/";
9379     int r;
9380     suppress_error = 0;
9381     r = guestfs_mount (g, device, mountpoint);
9382     if (r == -1)
9383       return -1;
9384   }
9385   /* TestOutput for upload (0) */
9386   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9387   {
9388     char remotefilename[] = "/COPYING.LIB";
9389     int r;
9390     suppress_error = 0;
9391     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9392     if (r == -1)
9393       return -1;
9394   }
9395   {
9396     char csumtype[] = "md5";
9397     char path[] = "/COPYING.LIB";
9398     char *r;
9399     suppress_error = 0;
9400     r = guestfs_checksum (g, csumtype, path);
9401     if (r == NULL)
9402       return -1;
9403     if (strcmp (r, expected) != 0) {
9404       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
9405       return -1;
9406     }
9407     free (r);
9408   }
9409   return 0;
9410 }
9411
9412 static int test_blockdev_rereadpt_0_skip (void)
9413 {
9414   const char *str;
9415
9416   str = getenv ("TEST_ONLY");
9417   if (str)
9418     return strstr (str, "blockdev_rereadpt") == NULL;
9419   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
9420   if (str && strcmp (str, "1") == 0) return 1;
9421   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
9422   if (str && strcmp (str, "1") == 0) return 1;
9423   return 0;
9424 }
9425
9426 static int test_blockdev_rereadpt_0 (void)
9427 {
9428   if (test_blockdev_rereadpt_0_skip ()) {
9429     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
9430     return 0;
9431   }
9432
9433   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
9434   {
9435     char device[] = "/dev/sda";
9436     int r;
9437     suppress_error = 0;
9438     r = guestfs_blockdev_setrw (g, device);
9439     if (r == -1)
9440       return -1;
9441   }
9442   {
9443     int r;
9444     suppress_error = 0;
9445     r = guestfs_umount_all (g);
9446     if (r == -1)
9447       return -1;
9448   }
9449   {
9450     int r;
9451     suppress_error = 0;
9452     r = guestfs_lvm_remove_all (g);
9453     if (r == -1)
9454       return -1;
9455   }
9456   /* TestRun for blockdev_rereadpt (0) */
9457   {
9458     char device[] = "/dev/sda";
9459     int r;
9460     suppress_error = 0;
9461     r = guestfs_blockdev_rereadpt (g, device);
9462     if (r == -1)
9463       return -1;
9464   }
9465   return 0;
9466 }
9467
9468 static int test_blockdev_flushbufs_0_skip (void)
9469 {
9470   const char *str;
9471
9472   str = getenv ("TEST_ONLY");
9473   if (str)
9474     return strstr (str, "blockdev_flushbufs") == NULL;
9475   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
9476   if (str && strcmp (str, "1") == 0) return 1;
9477   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
9478   if (str && strcmp (str, "1") == 0) return 1;
9479   return 0;
9480 }
9481
9482 static int test_blockdev_flushbufs_0 (void)
9483 {
9484   if (test_blockdev_flushbufs_0_skip ()) {
9485     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
9486     return 0;
9487   }
9488
9489   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
9490   {
9491     char device[] = "/dev/sda";
9492     int r;
9493     suppress_error = 0;
9494     r = guestfs_blockdev_setrw (g, device);
9495     if (r == -1)
9496       return -1;
9497   }
9498   {
9499     int r;
9500     suppress_error = 0;
9501     r = guestfs_umount_all (g);
9502     if (r == -1)
9503       return -1;
9504   }
9505   {
9506     int r;
9507     suppress_error = 0;
9508     r = guestfs_lvm_remove_all (g);
9509     if (r == -1)
9510       return -1;
9511   }
9512   /* TestRun for blockdev_flushbufs (0) */
9513   {
9514     char device[] = "/dev/sda";
9515     int r;
9516     suppress_error = 0;
9517     r = guestfs_blockdev_flushbufs (g, device);
9518     if (r == -1)
9519       return -1;
9520   }
9521   return 0;
9522 }
9523
9524 static int test_blockdev_getsize64_0_skip (void)
9525 {
9526   const char *str;
9527
9528   str = getenv ("TEST_ONLY");
9529   if (str)
9530     return strstr (str, "blockdev_getsize64") == NULL;
9531   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
9532   if (str && strcmp (str, "1") == 0) return 1;
9533   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
9534   if (str && strcmp (str, "1") == 0) return 1;
9535   return 0;
9536 }
9537
9538 static int test_blockdev_getsize64_0 (void)
9539 {
9540   if (test_blockdev_getsize64_0_skip ()) {
9541     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
9542     return 0;
9543   }
9544
9545   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
9546   {
9547     char device[] = "/dev/sda";
9548     int r;
9549     suppress_error = 0;
9550     r = guestfs_blockdev_setrw (g, device);
9551     if (r == -1)
9552       return -1;
9553   }
9554   {
9555     int r;
9556     suppress_error = 0;
9557     r = guestfs_umount_all (g);
9558     if (r == -1)
9559       return -1;
9560   }
9561   {
9562     int r;
9563     suppress_error = 0;
9564     r = guestfs_lvm_remove_all (g);
9565     if (r == -1)
9566       return -1;
9567   }
9568   /* TestOutputInt for blockdev_getsize64 (0) */
9569   {
9570     char device[] = "/dev/sda";
9571     int64_t r;
9572     suppress_error = 0;
9573     r = guestfs_blockdev_getsize64 (g, device);
9574     if (r == -1)
9575       return -1;
9576     if (r != 524288000) {
9577       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
9578       return -1;
9579     }
9580   }
9581   return 0;
9582 }
9583
9584 static int test_blockdev_getsz_0_skip (void)
9585 {
9586   const char *str;
9587
9588   str = getenv ("TEST_ONLY");
9589   if (str)
9590     return strstr (str, "blockdev_getsz") == NULL;
9591   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
9592   if (str && strcmp (str, "1") == 0) return 1;
9593   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
9594   if (str && strcmp (str, "1") == 0) return 1;
9595   return 0;
9596 }
9597
9598 static int test_blockdev_getsz_0 (void)
9599 {
9600   if (test_blockdev_getsz_0_skip ()) {
9601     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
9602     return 0;
9603   }
9604
9605   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
9606   {
9607     char device[] = "/dev/sda";
9608     int r;
9609     suppress_error = 0;
9610     r = guestfs_blockdev_setrw (g, device);
9611     if (r == -1)
9612       return -1;
9613   }
9614   {
9615     int r;
9616     suppress_error = 0;
9617     r = guestfs_umount_all (g);
9618     if (r == -1)
9619       return -1;
9620   }
9621   {
9622     int r;
9623     suppress_error = 0;
9624     r = guestfs_lvm_remove_all (g);
9625     if (r == -1)
9626       return -1;
9627   }
9628   /* TestOutputInt for blockdev_getsz (0) */
9629   {
9630     char device[] = "/dev/sda";
9631     int64_t r;
9632     suppress_error = 0;
9633     r = guestfs_blockdev_getsz (g, device);
9634     if (r == -1)
9635       return -1;
9636     if (r != 1024000) {
9637       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
9638       return -1;
9639     }
9640   }
9641   return 0;
9642 }
9643
9644 static int test_blockdev_getbsz_0_skip (void)
9645 {
9646   const char *str;
9647
9648   str = getenv ("TEST_ONLY");
9649   if (str)
9650     return strstr (str, "blockdev_getbsz") == NULL;
9651   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9652   if (str && strcmp (str, "1") == 0) return 1;
9653   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9654   if (str && strcmp (str, "1") == 0) return 1;
9655   return 0;
9656 }
9657
9658 static int test_blockdev_getbsz_0 (void)
9659 {
9660   if (test_blockdev_getbsz_0_skip ()) {
9661     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9662     return 0;
9663   }
9664
9665   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9666   {
9667     char device[] = "/dev/sda";
9668     int r;
9669     suppress_error = 0;
9670     r = guestfs_blockdev_setrw (g, device);
9671     if (r == -1)
9672       return -1;
9673   }
9674   {
9675     int r;
9676     suppress_error = 0;
9677     r = guestfs_umount_all (g);
9678     if (r == -1)
9679       return -1;
9680   }
9681   {
9682     int r;
9683     suppress_error = 0;
9684     r = guestfs_lvm_remove_all (g);
9685     if (r == -1)
9686       return -1;
9687   }
9688   /* TestOutputInt for blockdev_getbsz (0) */
9689   {
9690     char device[] = "/dev/sda";
9691     int r;
9692     suppress_error = 0;
9693     r = guestfs_blockdev_getbsz (g, device);
9694     if (r == -1)
9695       return -1;
9696     if (r != 4096) {
9697       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
9698       return -1;
9699     }
9700   }
9701   return 0;
9702 }
9703
9704 static int test_blockdev_getss_0_skip (void)
9705 {
9706   const char *str;
9707
9708   str = getenv ("TEST_ONLY");
9709   if (str)
9710     return strstr (str, "blockdev_getss") == NULL;
9711   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9712   if (str && strcmp (str, "1") == 0) return 1;
9713   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9714   if (str && strcmp (str, "1") == 0) return 1;
9715   return 0;
9716 }
9717
9718 static int test_blockdev_getss_0 (void)
9719 {
9720   if (test_blockdev_getss_0_skip ()) {
9721     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9722     return 0;
9723   }
9724
9725   /* InitNone|InitEmpty for test_blockdev_getss_0 */
9726   {
9727     char device[] = "/dev/sda";
9728     int r;
9729     suppress_error = 0;
9730     r = guestfs_blockdev_setrw (g, device);
9731     if (r == -1)
9732       return -1;
9733   }
9734   {
9735     int r;
9736     suppress_error = 0;
9737     r = guestfs_umount_all (g);
9738     if (r == -1)
9739       return -1;
9740   }
9741   {
9742     int r;
9743     suppress_error = 0;
9744     r = guestfs_lvm_remove_all (g);
9745     if (r == -1)
9746       return -1;
9747   }
9748   /* TestOutputInt for blockdev_getss (0) */
9749   {
9750     char device[] = "/dev/sda";
9751     int r;
9752     suppress_error = 0;
9753     r = guestfs_blockdev_getss (g, device);
9754     if (r == -1)
9755       return -1;
9756     if (r != 512) {
9757       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
9758       return -1;
9759     }
9760   }
9761   return 0;
9762 }
9763
9764 static int test_blockdev_getro_0_skip (void)
9765 {
9766   const char *str;
9767
9768   str = getenv ("TEST_ONLY");
9769   if (str)
9770     return strstr (str, "blockdev_getro") == NULL;
9771   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9772   if (str && strcmp (str, "1") == 0) return 1;
9773   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9774   if (str && strcmp (str, "1") == 0) return 1;
9775   return 0;
9776 }
9777
9778 static int test_blockdev_getro_0 (void)
9779 {
9780   if (test_blockdev_getro_0_skip ()) {
9781     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9782     return 0;
9783   }
9784
9785   /* InitNone|InitEmpty for test_blockdev_getro_0 */
9786   {
9787     char device[] = "/dev/sda";
9788     int r;
9789     suppress_error = 0;
9790     r = guestfs_blockdev_setrw (g, device);
9791     if (r == -1)
9792       return -1;
9793   }
9794   {
9795     int r;
9796     suppress_error = 0;
9797     r = guestfs_umount_all (g);
9798     if (r == -1)
9799       return -1;
9800   }
9801   {
9802     int r;
9803     suppress_error = 0;
9804     r = guestfs_lvm_remove_all (g);
9805     if (r == -1)
9806       return -1;
9807   }
9808   /* TestOutputTrue for blockdev_getro (0) */
9809   {
9810     char device[] = "/dev/sda";
9811     int r;
9812     suppress_error = 0;
9813     r = guestfs_blockdev_setro (g, device);
9814     if (r == -1)
9815       return -1;
9816   }
9817   {
9818     char device[] = "/dev/sda";
9819     int r;
9820     suppress_error = 0;
9821     r = guestfs_blockdev_getro (g, device);
9822     if (r == -1)
9823       return -1;
9824     if (!r) {
9825       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9826       return -1;
9827     }
9828   }
9829   return 0;
9830 }
9831
9832 static int test_blockdev_setrw_0_skip (void)
9833 {
9834   const char *str;
9835
9836   str = getenv ("TEST_ONLY");
9837   if (str)
9838     return strstr (str, "blockdev_setrw") == NULL;
9839   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9840   if (str && strcmp (str, "1") == 0) return 1;
9841   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9842   if (str && strcmp (str, "1") == 0) return 1;
9843   return 0;
9844 }
9845
9846 static int test_blockdev_setrw_0 (void)
9847 {
9848   if (test_blockdev_setrw_0_skip ()) {
9849     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9850     return 0;
9851   }
9852
9853   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9854   {
9855     char device[] = "/dev/sda";
9856     int r;
9857     suppress_error = 0;
9858     r = guestfs_blockdev_setrw (g, device);
9859     if (r == -1)
9860       return -1;
9861   }
9862   {
9863     int r;
9864     suppress_error = 0;
9865     r = guestfs_umount_all (g);
9866     if (r == -1)
9867       return -1;
9868   }
9869   {
9870     int r;
9871     suppress_error = 0;
9872     r = guestfs_lvm_remove_all (g);
9873     if (r == -1)
9874       return -1;
9875   }
9876   /* TestOutputFalse for blockdev_setrw (0) */
9877   {
9878     char device[] = "/dev/sda";
9879     int r;
9880     suppress_error = 0;
9881     r = guestfs_blockdev_setrw (g, device);
9882     if (r == -1)
9883       return -1;
9884   }
9885   {
9886     char device[] = "/dev/sda";
9887     int r;
9888     suppress_error = 0;
9889     r = guestfs_blockdev_getro (g, device);
9890     if (r == -1)
9891       return -1;
9892     if (r) {
9893       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9894       return -1;
9895     }
9896   }
9897   return 0;
9898 }
9899
9900 static int test_blockdev_setro_0_skip (void)
9901 {
9902   const char *str;
9903
9904   str = getenv ("TEST_ONLY");
9905   if (str)
9906     return strstr (str, "blockdev_setro") == NULL;
9907   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9908   if (str && strcmp (str, "1") == 0) return 1;
9909   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9910   if (str && strcmp (str, "1") == 0) return 1;
9911   return 0;
9912 }
9913
9914 static int test_blockdev_setro_0 (void)
9915 {
9916   if (test_blockdev_setro_0_skip ()) {
9917     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9918     return 0;
9919   }
9920
9921   /* InitNone|InitEmpty for test_blockdev_setro_0 */
9922   {
9923     char device[] = "/dev/sda";
9924     int r;
9925     suppress_error = 0;
9926     r = guestfs_blockdev_setrw (g, device);
9927     if (r == -1)
9928       return -1;
9929   }
9930   {
9931     int r;
9932     suppress_error = 0;
9933     r = guestfs_umount_all (g);
9934     if (r == -1)
9935       return -1;
9936   }
9937   {
9938     int r;
9939     suppress_error = 0;
9940     r = guestfs_lvm_remove_all (g);
9941     if (r == -1)
9942       return -1;
9943   }
9944   /* TestOutputTrue for blockdev_setro (0) */
9945   {
9946     char device[] = "/dev/sda";
9947     int r;
9948     suppress_error = 0;
9949     r = guestfs_blockdev_setro (g, device);
9950     if (r == -1)
9951       return -1;
9952   }
9953   {
9954     char device[] = "/dev/sda";
9955     int r;
9956     suppress_error = 0;
9957     r = guestfs_blockdev_getro (g, device);
9958     if (r == -1)
9959       return -1;
9960     if (!r) {
9961       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9962       return -1;
9963     }
9964   }
9965   return 0;
9966 }
9967
9968 static int test_statvfs_0_skip (void)
9969 {
9970   const char *str;
9971
9972   str = getenv ("TEST_ONLY");
9973   if (str)
9974     return strstr (str, "statvfs") == NULL;
9975   str = getenv ("SKIP_TEST_STATVFS_0");
9976   if (str && strcmp (str, "1") == 0) return 1;
9977   str = getenv ("SKIP_TEST_STATVFS");
9978   if (str && strcmp (str, "1") == 0) return 1;
9979   return 0;
9980 }
9981
9982 static int test_statvfs_0 (void)
9983 {
9984   if (test_statvfs_0_skip ()) {
9985     printf ("        %s skipped (reason: environment variable set)\n", "test_statvfs_0");
9986     return 0;
9987   }
9988
9989   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9990   {
9991     char device[] = "/dev/sda";
9992     int r;
9993     suppress_error = 0;
9994     r = guestfs_blockdev_setrw (g, device);
9995     if (r == -1)
9996       return -1;
9997   }
9998   {
9999     int r;
10000     suppress_error = 0;
10001     r = guestfs_umount_all (g);
10002     if (r == -1)
10003       return -1;
10004   }
10005   {
10006     int r;
10007     suppress_error = 0;
10008     r = guestfs_lvm_remove_all (g);
10009     if (r == -1)
10010       return -1;
10011   }
10012   {
10013     char device[] = "/dev/sda";
10014     char lines_0[] = ",";
10015     char *lines[] = {
10016       lines_0,
10017       NULL
10018     };
10019     int r;
10020     suppress_error = 0;
10021     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10022     if (r == -1)
10023       return -1;
10024   }
10025   {
10026     char fstype[] = "ext2";
10027     char device[] = "/dev/sda1";
10028     int r;
10029     suppress_error = 0;
10030     r = guestfs_mkfs (g, fstype, device);
10031     if (r == -1)
10032       return -1;
10033   }
10034   {
10035     char device[] = "/dev/sda1";
10036     char mountpoint[] = "/";
10037     int r;
10038     suppress_error = 0;
10039     r = guestfs_mount (g, device, mountpoint);
10040     if (r == -1)
10041       return -1;
10042   }
10043   /* TestOutputStruct for statvfs (0) */
10044   {
10045     char path[] = "/";
10046     struct guestfs_statvfs *r;
10047     suppress_error = 0;
10048     r = guestfs_statvfs (g, path);
10049     if (r == NULL)
10050       return -1;
10051     if (r->namemax != 255) {
10052       fprintf (stderr, "test_statvfs_0: namemax was %d, expected 255\n",
10053                (int) r->namemax);
10054       return -1;
10055     }
10056     if (r->bsize != 1024) {
10057       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
10058                (int) r->bsize);
10059       return -1;
10060     }
10061     free (r);
10062   }
10063   return 0;
10064 }
10065
10066 static int test_lstat_0_skip (void)
10067 {
10068   const char *str;
10069
10070   str = getenv ("TEST_ONLY");
10071   if (str)
10072     return strstr (str, "lstat") == NULL;
10073   str = getenv ("SKIP_TEST_LSTAT_0");
10074   if (str && strcmp (str, "1") == 0) return 1;
10075   str = getenv ("SKIP_TEST_LSTAT");
10076   if (str && strcmp (str, "1") == 0) return 1;
10077   return 0;
10078 }
10079
10080 static int test_lstat_0 (void)
10081 {
10082   if (test_lstat_0_skip ()) {
10083     printf ("        %s skipped (reason: environment variable set)\n", "test_lstat_0");
10084     return 0;
10085   }
10086
10087   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
10088   {
10089     char device[] = "/dev/sda";
10090     int r;
10091     suppress_error = 0;
10092     r = guestfs_blockdev_setrw (g, device);
10093     if (r == -1)
10094       return -1;
10095   }
10096   {
10097     int r;
10098     suppress_error = 0;
10099     r = guestfs_umount_all (g);
10100     if (r == -1)
10101       return -1;
10102   }
10103   {
10104     int r;
10105     suppress_error = 0;
10106     r = guestfs_lvm_remove_all (g);
10107     if (r == -1)
10108       return -1;
10109   }
10110   {
10111     char device[] = "/dev/sda";
10112     char lines_0[] = ",";
10113     char *lines[] = {
10114       lines_0,
10115       NULL
10116     };
10117     int r;
10118     suppress_error = 0;
10119     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10120     if (r == -1)
10121       return -1;
10122   }
10123   {
10124     char fstype[] = "ext2";
10125     char device[] = "/dev/sda1";
10126     int r;
10127     suppress_error = 0;
10128     r = guestfs_mkfs (g, fstype, device);
10129     if (r == -1)
10130       return -1;
10131   }
10132   {
10133     char device[] = "/dev/sda1";
10134     char mountpoint[] = "/";
10135     int r;
10136     suppress_error = 0;
10137     r = guestfs_mount (g, device, mountpoint);
10138     if (r == -1)
10139       return -1;
10140   }
10141   /* TestOutputStruct for lstat (0) */
10142   {
10143     char path[] = "/new";
10144     int r;
10145     suppress_error = 0;
10146     r = guestfs_touch (g, path);
10147     if (r == -1)
10148       return -1;
10149   }
10150   {
10151     char path[] = "/new";
10152     struct guestfs_stat *r;
10153     suppress_error = 0;
10154     r = guestfs_lstat (g, path);
10155     if (r == NULL)
10156       return -1;
10157     if (r->size != 0) {
10158       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
10159                (int) r->size);
10160       return -1;
10161     }
10162     free (r);
10163   }
10164   return 0;
10165 }
10166
10167 static int test_stat_0_skip (void)
10168 {
10169   const char *str;
10170
10171   str = getenv ("TEST_ONLY");
10172   if (str)
10173     return strstr (str, "stat") == NULL;
10174   str = getenv ("SKIP_TEST_STAT_0");
10175   if (str && strcmp (str, "1") == 0) return 1;
10176   str = getenv ("SKIP_TEST_STAT");
10177   if (str && strcmp (str, "1") == 0) return 1;
10178   return 0;
10179 }
10180
10181 static int test_stat_0 (void)
10182 {
10183   if (test_stat_0_skip ()) {
10184     printf ("        %s skipped (reason: environment variable set)\n", "test_stat_0");
10185     return 0;
10186   }
10187
10188   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
10189   {
10190     char device[] = "/dev/sda";
10191     int r;
10192     suppress_error = 0;
10193     r = guestfs_blockdev_setrw (g, device);
10194     if (r == -1)
10195       return -1;
10196   }
10197   {
10198     int r;
10199     suppress_error = 0;
10200     r = guestfs_umount_all (g);
10201     if (r == -1)
10202       return -1;
10203   }
10204   {
10205     int r;
10206     suppress_error = 0;
10207     r = guestfs_lvm_remove_all (g);
10208     if (r == -1)
10209       return -1;
10210   }
10211   {
10212     char device[] = "/dev/sda";
10213     char lines_0[] = ",";
10214     char *lines[] = {
10215       lines_0,
10216       NULL
10217     };
10218     int r;
10219     suppress_error = 0;
10220     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10221     if (r == -1)
10222       return -1;
10223   }
10224   {
10225     char fstype[] = "ext2";
10226     char device[] = "/dev/sda1";
10227     int r;
10228     suppress_error = 0;
10229     r = guestfs_mkfs (g, fstype, device);
10230     if (r == -1)
10231       return -1;
10232   }
10233   {
10234     char device[] = "/dev/sda1";
10235     char mountpoint[] = "/";
10236     int r;
10237     suppress_error = 0;
10238     r = guestfs_mount (g, device, mountpoint);
10239     if (r == -1)
10240       return -1;
10241   }
10242   /* TestOutputStruct for stat (0) */
10243   {
10244     char path[] = "/new";
10245     int r;
10246     suppress_error = 0;
10247     r = guestfs_touch (g, path);
10248     if (r == -1)
10249       return -1;
10250   }
10251   {
10252     char path[] = "/new";
10253     struct guestfs_stat *r;
10254     suppress_error = 0;
10255     r = guestfs_stat (g, path);
10256     if (r == NULL)
10257       return -1;
10258     if (r->size != 0) {
10259       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
10260                (int) r->size);
10261       return -1;
10262     }
10263     free (r);
10264   }
10265   return 0;
10266 }
10267
10268 static int test_command_lines_0_skip (void)
10269 {
10270   const char *str;
10271
10272   str = getenv ("TEST_ONLY");
10273   if (str)
10274     return strstr (str, "command_lines") == NULL;
10275   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
10276   if (str && strcmp (str, "1") == 0) return 1;
10277   str = getenv ("SKIP_TEST_COMMAND_LINES");
10278   if (str && strcmp (str, "1") == 0) return 1;
10279   return 0;
10280 }
10281
10282 static int test_command_lines_0 (void)
10283 {
10284   if (test_command_lines_0_skip ()) {
10285     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_0");
10286     return 0;
10287   }
10288
10289   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
10290   {
10291     char device[] = "/dev/sda";
10292     int r;
10293     suppress_error = 0;
10294     r = guestfs_blockdev_setrw (g, device);
10295     if (r == -1)
10296       return -1;
10297   }
10298   {
10299     int r;
10300     suppress_error = 0;
10301     r = guestfs_umount_all (g);
10302     if (r == -1)
10303       return -1;
10304   }
10305   {
10306     int r;
10307     suppress_error = 0;
10308     r = guestfs_lvm_remove_all (g);
10309     if (r == -1)
10310       return -1;
10311   }
10312   {
10313     char device[] = "/dev/sda";
10314     char lines_0[] = ",";
10315     char *lines[] = {
10316       lines_0,
10317       NULL
10318     };
10319     int r;
10320     suppress_error = 0;
10321     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10322     if (r == -1)
10323       return -1;
10324   }
10325   {
10326     char fstype[] = "ext2";
10327     char device[] = "/dev/sda1";
10328     int r;
10329     suppress_error = 0;
10330     r = guestfs_mkfs (g, fstype, device);
10331     if (r == -1)
10332       return -1;
10333   }
10334   {
10335     char device[] = "/dev/sda1";
10336     char mountpoint[] = "/";
10337     int r;
10338     suppress_error = 0;
10339     r = guestfs_mount (g, device, mountpoint);
10340     if (r == -1)
10341       return -1;
10342   }
10343   /* TestOutputList for command_lines (0) */
10344   {
10345     char remotefilename[] = "/test-command";
10346     int r;
10347     suppress_error = 0;
10348     r = guestfs_upload (g, "test-command", remotefilename);
10349     if (r == -1)
10350       return -1;
10351   }
10352   {
10353     char path[] = "/test-command";
10354     int r;
10355     suppress_error = 0;
10356     r = guestfs_chmod (g, 493, path);
10357     if (r == -1)
10358       return -1;
10359   }
10360   {
10361     char arguments_0[] = "/test-command";
10362     char arguments_1[] = "1";
10363     char *arguments[] = {
10364       arguments_0,
10365       arguments_1,
10366       NULL
10367     };
10368     char **r;
10369     int i;
10370     suppress_error = 0;
10371     r = guestfs_command_lines (g, arguments);
10372     if (r == NULL)
10373       return -1;
10374     if (!r[0]) {
10375       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
10376       print_strings (r);
10377       return -1;
10378     }
10379     {
10380       char expected[] = "Result1";
10381       if (strcmp (r[0], expected) != 0) {
10382         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10383         return -1;
10384       }
10385     }
10386     if (r[1] != NULL) {
10387       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
10388       print_strings (r);
10389       return -1;
10390     }
10391     for (i = 0; r[i] != NULL; ++i)
10392       free (r[i]);
10393     free (r);
10394   }
10395   return 0;
10396 }
10397
10398 static int test_command_lines_1_skip (void)
10399 {
10400   const char *str;
10401
10402   str = getenv ("TEST_ONLY");
10403   if (str)
10404     return strstr (str, "command_lines") == NULL;
10405   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
10406   if (str && strcmp (str, "1") == 0) return 1;
10407   str = getenv ("SKIP_TEST_COMMAND_LINES");
10408   if (str && strcmp (str, "1") == 0) return 1;
10409   return 0;
10410 }
10411
10412 static int test_command_lines_1 (void)
10413 {
10414   if (test_command_lines_1_skip ()) {
10415     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_1");
10416     return 0;
10417   }
10418
10419   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
10420   {
10421     char device[] = "/dev/sda";
10422     int r;
10423     suppress_error = 0;
10424     r = guestfs_blockdev_setrw (g, device);
10425     if (r == -1)
10426       return -1;
10427   }
10428   {
10429     int r;
10430     suppress_error = 0;
10431     r = guestfs_umount_all (g);
10432     if (r == -1)
10433       return -1;
10434   }
10435   {
10436     int r;
10437     suppress_error = 0;
10438     r = guestfs_lvm_remove_all (g);
10439     if (r == -1)
10440       return -1;
10441   }
10442   {
10443     char device[] = "/dev/sda";
10444     char lines_0[] = ",";
10445     char *lines[] = {
10446       lines_0,
10447       NULL
10448     };
10449     int r;
10450     suppress_error = 0;
10451     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10452     if (r == -1)
10453       return -1;
10454   }
10455   {
10456     char fstype[] = "ext2";
10457     char device[] = "/dev/sda1";
10458     int r;
10459     suppress_error = 0;
10460     r = guestfs_mkfs (g, fstype, device);
10461     if (r == -1)
10462       return -1;
10463   }
10464   {
10465     char device[] = "/dev/sda1";
10466     char mountpoint[] = "/";
10467     int r;
10468     suppress_error = 0;
10469     r = guestfs_mount (g, device, mountpoint);
10470     if (r == -1)
10471       return -1;
10472   }
10473   /* TestOutputList for command_lines (1) */
10474   {
10475     char remotefilename[] = "/test-command";
10476     int r;
10477     suppress_error = 0;
10478     r = guestfs_upload (g, "test-command", remotefilename);
10479     if (r == -1)
10480       return -1;
10481   }
10482   {
10483     char path[] = "/test-command";
10484     int r;
10485     suppress_error = 0;
10486     r = guestfs_chmod (g, 493, path);
10487     if (r == -1)
10488       return -1;
10489   }
10490   {
10491     char arguments_0[] = "/test-command";
10492     char arguments_1[] = "2";
10493     char *arguments[] = {
10494       arguments_0,
10495       arguments_1,
10496       NULL
10497     };
10498     char **r;
10499     int i;
10500     suppress_error = 0;
10501     r = guestfs_command_lines (g, arguments);
10502     if (r == NULL)
10503       return -1;
10504     if (!r[0]) {
10505       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
10506       print_strings (r);
10507       return -1;
10508     }
10509     {
10510       char expected[] = "Result2";
10511       if (strcmp (r[0], expected) != 0) {
10512         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10513         return -1;
10514       }
10515     }
10516     if (r[1] != NULL) {
10517       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
10518       print_strings (r);
10519       return -1;
10520     }
10521     for (i = 0; r[i] != NULL; ++i)
10522       free (r[i]);
10523     free (r);
10524   }
10525   return 0;
10526 }
10527
10528 static int test_command_lines_2_skip (void)
10529 {
10530   const char *str;
10531
10532   str = getenv ("TEST_ONLY");
10533   if (str)
10534     return strstr (str, "command_lines") == NULL;
10535   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
10536   if (str && strcmp (str, "1") == 0) return 1;
10537   str = getenv ("SKIP_TEST_COMMAND_LINES");
10538   if (str && strcmp (str, "1") == 0) return 1;
10539   return 0;
10540 }
10541
10542 static int test_command_lines_2 (void)
10543 {
10544   if (test_command_lines_2_skip ()) {
10545     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_2");
10546     return 0;
10547   }
10548
10549   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
10550   {
10551     char device[] = "/dev/sda";
10552     int r;
10553     suppress_error = 0;
10554     r = guestfs_blockdev_setrw (g, device);
10555     if (r == -1)
10556       return -1;
10557   }
10558   {
10559     int r;
10560     suppress_error = 0;
10561     r = guestfs_umount_all (g);
10562     if (r == -1)
10563       return -1;
10564   }
10565   {
10566     int r;
10567     suppress_error = 0;
10568     r = guestfs_lvm_remove_all (g);
10569     if (r == -1)
10570       return -1;
10571   }
10572   {
10573     char device[] = "/dev/sda";
10574     char lines_0[] = ",";
10575     char *lines[] = {
10576       lines_0,
10577       NULL
10578     };
10579     int r;
10580     suppress_error = 0;
10581     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10582     if (r == -1)
10583       return -1;
10584   }
10585   {
10586     char fstype[] = "ext2";
10587     char device[] = "/dev/sda1";
10588     int r;
10589     suppress_error = 0;
10590     r = guestfs_mkfs (g, fstype, device);
10591     if (r == -1)
10592       return -1;
10593   }
10594   {
10595     char device[] = "/dev/sda1";
10596     char mountpoint[] = "/";
10597     int r;
10598     suppress_error = 0;
10599     r = guestfs_mount (g, device, mountpoint);
10600     if (r == -1)
10601       return -1;
10602   }
10603   /* TestOutputList for command_lines (2) */
10604   {
10605     char remotefilename[] = "/test-command";
10606     int r;
10607     suppress_error = 0;
10608     r = guestfs_upload (g, "test-command", remotefilename);
10609     if (r == -1)
10610       return -1;
10611   }
10612   {
10613     char path[] = "/test-command";
10614     int r;
10615     suppress_error = 0;
10616     r = guestfs_chmod (g, 493, path);
10617     if (r == -1)
10618       return -1;
10619   }
10620   {
10621     char arguments_0[] = "/test-command";
10622     char arguments_1[] = "3";
10623     char *arguments[] = {
10624       arguments_0,
10625       arguments_1,
10626       NULL
10627     };
10628     char **r;
10629     int i;
10630     suppress_error = 0;
10631     r = guestfs_command_lines (g, arguments);
10632     if (r == NULL)
10633       return -1;
10634     if (!r[0]) {
10635       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10636       print_strings (r);
10637       return -1;
10638     }
10639     {
10640       char expected[] = "";
10641       if (strcmp (r[0], expected) != 0) {
10642         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10643         return -1;
10644       }
10645     }
10646     if (!r[1]) {
10647       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10648       print_strings (r);
10649       return -1;
10650     }
10651     {
10652       char expected[] = "Result3";
10653       if (strcmp (r[1], expected) != 0) {
10654         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10655         return -1;
10656       }
10657     }
10658     if (r[2] != NULL) {
10659       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10660       print_strings (r);
10661       return -1;
10662     }
10663     for (i = 0; r[i] != NULL; ++i)
10664       free (r[i]);
10665     free (r);
10666   }
10667   return 0;
10668 }
10669
10670 static int test_command_lines_3_skip (void)
10671 {
10672   const char *str;
10673
10674   str = getenv ("TEST_ONLY");
10675   if (str)
10676     return strstr (str, "command_lines") == NULL;
10677   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10678   if (str && strcmp (str, "1") == 0) return 1;
10679   str = getenv ("SKIP_TEST_COMMAND_LINES");
10680   if (str && strcmp (str, "1") == 0) return 1;
10681   return 0;
10682 }
10683
10684 static int test_command_lines_3 (void)
10685 {
10686   if (test_command_lines_3_skip ()) {
10687     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_3");
10688     return 0;
10689   }
10690
10691   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10692   {
10693     char device[] = "/dev/sda";
10694     int r;
10695     suppress_error = 0;
10696     r = guestfs_blockdev_setrw (g, device);
10697     if (r == -1)
10698       return -1;
10699   }
10700   {
10701     int r;
10702     suppress_error = 0;
10703     r = guestfs_umount_all (g);
10704     if (r == -1)
10705       return -1;
10706   }
10707   {
10708     int r;
10709     suppress_error = 0;
10710     r = guestfs_lvm_remove_all (g);
10711     if (r == -1)
10712       return -1;
10713   }
10714   {
10715     char device[] = "/dev/sda";
10716     char lines_0[] = ",";
10717     char *lines[] = {
10718       lines_0,
10719       NULL
10720     };
10721     int r;
10722     suppress_error = 0;
10723     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10724     if (r == -1)
10725       return -1;
10726   }
10727   {
10728     char fstype[] = "ext2";
10729     char device[] = "/dev/sda1";
10730     int r;
10731     suppress_error = 0;
10732     r = guestfs_mkfs (g, fstype, device);
10733     if (r == -1)
10734       return -1;
10735   }
10736   {
10737     char device[] = "/dev/sda1";
10738     char mountpoint[] = "/";
10739     int r;
10740     suppress_error = 0;
10741     r = guestfs_mount (g, device, mountpoint);
10742     if (r == -1)
10743       return -1;
10744   }
10745   /* TestOutputList for command_lines (3) */
10746   {
10747     char remotefilename[] = "/test-command";
10748     int r;
10749     suppress_error = 0;
10750     r = guestfs_upload (g, "test-command", remotefilename);
10751     if (r == -1)
10752       return -1;
10753   }
10754   {
10755     char path[] = "/test-command";
10756     int r;
10757     suppress_error = 0;
10758     r = guestfs_chmod (g, 493, path);
10759     if (r == -1)
10760       return -1;
10761   }
10762   {
10763     char arguments_0[] = "/test-command";
10764     char arguments_1[] = "4";
10765     char *arguments[] = {
10766       arguments_0,
10767       arguments_1,
10768       NULL
10769     };
10770     char **r;
10771     int i;
10772     suppress_error = 0;
10773     r = guestfs_command_lines (g, arguments);
10774     if (r == NULL)
10775       return -1;
10776     if (!r[0]) {
10777       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10778       print_strings (r);
10779       return -1;
10780     }
10781     {
10782       char expected[] = "";
10783       if (strcmp (r[0], expected) != 0) {
10784         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10785         return -1;
10786       }
10787     }
10788     if (!r[1]) {
10789       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10790       print_strings (r);
10791       return -1;
10792     }
10793     {
10794       char expected[] = "Result4";
10795       if (strcmp (r[1], expected) != 0) {
10796         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10797         return -1;
10798       }
10799     }
10800     if (r[2] != NULL) {
10801       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10802       print_strings (r);
10803       return -1;
10804     }
10805     for (i = 0; r[i] != NULL; ++i)
10806       free (r[i]);
10807     free (r);
10808   }
10809   return 0;
10810 }
10811
10812 static int test_command_lines_4_skip (void)
10813 {
10814   const char *str;
10815
10816   str = getenv ("TEST_ONLY");
10817   if (str)
10818     return strstr (str, "command_lines") == NULL;
10819   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10820   if (str && strcmp (str, "1") == 0) return 1;
10821   str = getenv ("SKIP_TEST_COMMAND_LINES");
10822   if (str && strcmp (str, "1") == 0) return 1;
10823   return 0;
10824 }
10825
10826 static int test_command_lines_4 (void)
10827 {
10828   if (test_command_lines_4_skip ()) {
10829     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_4");
10830     return 0;
10831   }
10832
10833   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10834   {
10835     char device[] = "/dev/sda";
10836     int r;
10837     suppress_error = 0;
10838     r = guestfs_blockdev_setrw (g, device);
10839     if (r == -1)
10840       return -1;
10841   }
10842   {
10843     int r;
10844     suppress_error = 0;
10845     r = guestfs_umount_all (g);
10846     if (r == -1)
10847       return -1;
10848   }
10849   {
10850     int r;
10851     suppress_error = 0;
10852     r = guestfs_lvm_remove_all (g);
10853     if (r == -1)
10854       return -1;
10855   }
10856   {
10857     char device[] = "/dev/sda";
10858     char lines_0[] = ",";
10859     char *lines[] = {
10860       lines_0,
10861       NULL
10862     };
10863     int r;
10864     suppress_error = 0;
10865     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10866     if (r == -1)
10867       return -1;
10868   }
10869   {
10870     char fstype[] = "ext2";
10871     char device[] = "/dev/sda1";
10872     int r;
10873     suppress_error = 0;
10874     r = guestfs_mkfs (g, fstype, device);
10875     if (r == -1)
10876       return -1;
10877   }
10878   {
10879     char device[] = "/dev/sda1";
10880     char mountpoint[] = "/";
10881     int r;
10882     suppress_error = 0;
10883     r = guestfs_mount (g, device, mountpoint);
10884     if (r == -1)
10885       return -1;
10886   }
10887   /* TestOutputList for command_lines (4) */
10888   {
10889     char remotefilename[] = "/test-command";
10890     int r;
10891     suppress_error = 0;
10892     r = guestfs_upload (g, "test-command", remotefilename);
10893     if (r == -1)
10894       return -1;
10895   }
10896   {
10897     char path[] = "/test-command";
10898     int r;
10899     suppress_error = 0;
10900     r = guestfs_chmod (g, 493, path);
10901     if (r == -1)
10902       return -1;
10903   }
10904   {
10905     char arguments_0[] = "/test-command";
10906     char arguments_1[] = "5";
10907     char *arguments[] = {
10908       arguments_0,
10909       arguments_1,
10910       NULL
10911     };
10912     char **r;
10913     int i;
10914     suppress_error = 0;
10915     r = guestfs_command_lines (g, arguments);
10916     if (r == NULL)
10917       return -1;
10918     if (!r[0]) {
10919       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10920       print_strings (r);
10921       return -1;
10922     }
10923     {
10924       char expected[] = "";
10925       if (strcmp (r[0], expected) != 0) {
10926         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10927         return -1;
10928       }
10929     }
10930     if (!r[1]) {
10931       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10932       print_strings (r);
10933       return -1;
10934     }
10935     {
10936       char expected[] = "Result5";
10937       if (strcmp (r[1], expected) != 0) {
10938         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10939         return -1;
10940       }
10941     }
10942     if (!r[2]) {
10943       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10944       print_strings (r);
10945       return -1;
10946     }
10947     {
10948       char expected[] = "";
10949       if (strcmp (r[2], expected) != 0) {
10950         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10951         return -1;
10952       }
10953     }
10954     if (r[3] != NULL) {
10955       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10956       print_strings (r);
10957       return -1;
10958     }
10959     for (i = 0; r[i] != NULL; ++i)
10960       free (r[i]);
10961     free (r);
10962   }
10963   return 0;
10964 }
10965
10966 static int test_command_lines_5_skip (void)
10967 {
10968   const char *str;
10969
10970   str = getenv ("TEST_ONLY");
10971   if (str)
10972     return strstr (str, "command_lines") == NULL;
10973   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10974   if (str && strcmp (str, "1") == 0) return 1;
10975   str = getenv ("SKIP_TEST_COMMAND_LINES");
10976   if (str && strcmp (str, "1") == 0) return 1;
10977   return 0;
10978 }
10979
10980 static int test_command_lines_5 (void)
10981 {
10982   if (test_command_lines_5_skip ()) {
10983     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_5");
10984     return 0;
10985   }
10986
10987   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10988   {
10989     char device[] = "/dev/sda";
10990     int r;
10991     suppress_error = 0;
10992     r = guestfs_blockdev_setrw (g, device);
10993     if (r == -1)
10994       return -1;
10995   }
10996   {
10997     int r;
10998     suppress_error = 0;
10999     r = guestfs_umount_all (g);
11000     if (r == -1)
11001       return -1;
11002   }
11003   {
11004     int r;
11005     suppress_error = 0;
11006     r = guestfs_lvm_remove_all (g);
11007     if (r == -1)
11008       return -1;
11009   }
11010   {
11011     char device[] = "/dev/sda";
11012     char lines_0[] = ",";
11013     char *lines[] = {
11014       lines_0,
11015       NULL
11016     };
11017     int r;
11018     suppress_error = 0;
11019     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11020     if (r == -1)
11021       return -1;
11022   }
11023   {
11024     char fstype[] = "ext2";
11025     char device[] = "/dev/sda1";
11026     int r;
11027     suppress_error = 0;
11028     r = guestfs_mkfs (g, fstype, device);
11029     if (r == -1)
11030       return -1;
11031   }
11032   {
11033     char device[] = "/dev/sda1";
11034     char mountpoint[] = "/";
11035     int r;
11036     suppress_error = 0;
11037     r = guestfs_mount (g, device, mountpoint);
11038     if (r == -1)
11039       return -1;
11040   }
11041   /* TestOutputList for command_lines (5) */
11042   {
11043     char remotefilename[] = "/test-command";
11044     int r;
11045     suppress_error = 0;
11046     r = guestfs_upload (g, "test-command", remotefilename);
11047     if (r == -1)
11048       return -1;
11049   }
11050   {
11051     char path[] = "/test-command";
11052     int r;
11053     suppress_error = 0;
11054     r = guestfs_chmod (g, 493, path);
11055     if (r == -1)
11056       return -1;
11057   }
11058   {
11059     char arguments_0[] = "/test-command";
11060     char arguments_1[] = "6";
11061     char *arguments[] = {
11062       arguments_0,
11063       arguments_1,
11064       NULL
11065     };
11066     char **r;
11067     int i;
11068     suppress_error = 0;
11069     r = guestfs_command_lines (g, arguments);
11070     if (r == NULL)
11071       return -1;
11072     if (!r[0]) {
11073       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11074       print_strings (r);
11075       return -1;
11076     }
11077     {
11078       char expected[] = "";
11079       if (strcmp (r[0], expected) != 0) {
11080         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11081         return -1;
11082       }
11083     }
11084     if (!r[1]) {
11085       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11086       print_strings (r);
11087       return -1;
11088     }
11089     {
11090       char expected[] = "";
11091       if (strcmp (r[1], expected) != 0) {
11092         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11093         return -1;
11094       }
11095     }
11096     if (!r[2]) {
11097       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11098       print_strings (r);
11099       return -1;
11100     }
11101     {
11102       char expected[] = "Result6";
11103       if (strcmp (r[2], expected) != 0) {
11104         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11105         return -1;
11106       }
11107     }
11108     if (!r[3]) {
11109       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11110       print_strings (r);
11111       return -1;
11112     }
11113     {
11114       char expected[] = "";
11115       if (strcmp (r[3], expected) != 0) {
11116         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11117         return -1;
11118       }
11119     }
11120     if (r[4] != NULL) {
11121       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
11122       print_strings (r);
11123       return -1;
11124     }
11125     for (i = 0; r[i] != NULL; ++i)
11126       free (r[i]);
11127     free (r);
11128   }
11129   return 0;
11130 }
11131
11132 static int test_command_lines_6_skip (void)
11133 {
11134   const char *str;
11135
11136   str = getenv ("TEST_ONLY");
11137   if (str)
11138     return strstr (str, "command_lines") == NULL;
11139   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
11140   if (str && strcmp (str, "1") == 0) return 1;
11141   str = getenv ("SKIP_TEST_COMMAND_LINES");
11142   if (str && strcmp (str, "1") == 0) return 1;
11143   return 0;
11144 }
11145
11146 static int test_command_lines_6 (void)
11147 {
11148   if (test_command_lines_6_skip ()) {
11149     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_6");
11150     return 0;
11151   }
11152
11153   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
11154   {
11155     char device[] = "/dev/sda";
11156     int r;
11157     suppress_error = 0;
11158     r = guestfs_blockdev_setrw (g, device);
11159     if (r == -1)
11160       return -1;
11161   }
11162   {
11163     int r;
11164     suppress_error = 0;
11165     r = guestfs_umount_all (g);
11166     if (r == -1)
11167       return -1;
11168   }
11169   {
11170     int r;
11171     suppress_error = 0;
11172     r = guestfs_lvm_remove_all (g);
11173     if (r == -1)
11174       return -1;
11175   }
11176   {
11177     char device[] = "/dev/sda";
11178     char lines_0[] = ",";
11179     char *lines[] = {
11180       lines_0,
11181       NULL
11182     };
11183     int r;
11184     suppress_error = 0;
11185     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11186     if (r == -1)
11187       return -1;
11188   }
11189   {
11190     char fstype[] = "ext2";
11191     char device[] = "/dev/sda1";
11192     int r;
11193     suppress_error = 0;
11194     r = guestfs_mkfs (g, fstype, device);
11195     if (r == -1)
11196       return -1;
11197   }
11198   {
11199     char device[] = "/dev/sda1";
11200     char mountpoint[] = "/";
11201     int r;
11202     suppress_error = 0;
11203     r = guestfs_mount (g, device, mountpoint);
11204     if (r == -1)
11205       return -1;
11206   }
11207   /* TestOutputList for command_lines (6) */
11208   {
11209     char remotefilename[] = "/test-command";
11210     int r;
11211     suppress_error = 0;
11212     r = guestfs_upload (g, "test-command", remotefilename);
11213     if (r == -1)
11214       return -1;
11215   }
11216   {
11217     char path[] = "/test-command";
11218     int r;
11219     suppress_error = 0;
11220     r = guestfs_chmod (g, 493, path);
11221     if (r == -1)
11222       return -1;
11223   }
11224   {
11225     char arguments_0[] = "/test-command";
11226     char arguments_1[] = "7";
11227     char *arguments[] = {
11228       arguments_0,
11229       arguments_1,
11230       NULL
11231     };
11232     char **r;
11233     int i;
11234     suppress_error = 0;
11235     r = guestfs_command_lines (g, arguments);
11236     if (r == NULL)
11237       return -1;
11238     if (r[0] != NULL) {
11239       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
11240       print_strings (r);
11241       return -1;
11242     }
11243     for (i = 0; r[i] != NULL; ++i)
11244       free (r[i]);
11245     free (r);
11246   }
11247   return 0;
11248 }
11249
11250 static int test_command_lines_7_skip (void)
11251 {
11252   const char *str;
11253
11254   str = getenv ("TEST_ONLY");
11255   if (str)
11256     return strstr (str, "command_lines") == NULL;
11257   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
11258   if (str && strcmp (str, "1") == 0) return 1;
11259   str = getenv ("SKIP_TEST_COMMAND_LINES");
11260   if (str && strcmp (str, "1") == 0) return 1;
11261   return 0;
11262 }
11263
11264 static int test_command_lines_7 (void)
11265 {
11266   if (test_command_lines_7_skip ()) {
11267     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_7");
11268     return 0;
11269   }
11270
11271   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
11272   {
11273     char device[] = "/dev/sda";
11274     int r;
11275     suppress_error = 0;
11276     r = guestfs_blockdev_setrw (g, device);
11277     if (r == -1)
11278       return -1;
11279   }
11280   {
11281     int r;
11282     suppress_error = 0;
11283     r = guestfs_umount_all (g);
11284     if (r == -1)
11285       return -1;
11286   }
11287   {
11288     int r;
11289     suppress_error = 0;
11290     r = guestfs_lvm_remove_all (g);
11291     if (r == -1)
11292       return -1;
11293   }
11294   {
11295     char device[] = "/dev/sda";
11296     char lines_0[] = ",";
11297     char *lines[] = {
11298       lines_0,
11299       NULL
11300     };
11301     int r;
11302     suppress_error = 0;
11303     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11304     if (r == -1)
11305       return -1;
11306   }
11307   {
11308     char fstype[] = "ext2";
11309     char device[] = "/dev/sda1";
11310     int r;
11311     suppress_error = 0;
11312     r = guestfs_mkfs (g, fstype, device);
11313     if (r == -1)
11314       return -1;
11315   }
11316   {
11317     char device[] = "/dev/sda1";
11318     char mountpoint[] = "/";
11319     int r;
11320     suppress_error = 0;
11321     r = guestfs_mount (g, device, mountpoint);
11322     if (r == -1)
11323       return -1;
11324   }
11325   /* TestOutputList for command_lines (7) */
11326   {
11327     char remotefilename[] = "/test-command";
11328     int r;
11329     suppress_error = 0;
11330     r = guestfs_upload (g, "test-command", remotefilename);
11331     if (r == -1)
11332       return -1;
11333   }
11334   {
11335     char path[] = "/test-command";
11336     int r;
11337     suppress_error = 0;
11338     r = guestfs_chmod (g, 493, path);
11339     if (r == -1)
11340       return -1;
11341   }
11342   {
11343     char arguments_0[] = "/test-command";
11344     char arguments_1[] = "8";
11345     char *arguments[] = {
11346       arguments_0,
11347       arguments_1,
11348       NULL
11349     };
11350     char **r;
11351     int i;
11352     suppress_error = 0;
11353     r = guestfs_command_lines (g, arguments);
11354     if (r == NULL)
11355       return -1;
11356     if (!r[0]) {
11357       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
11358       print_strings (r);
11359       return -1;
11360     }
11361     {
11362       char expected[] = "";
11363       if (strcmp (r[0], expected) != 0) {
11364         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11365         return -1;
11366       }
11367     }
11368     if (r[1] != NULL) {
11369       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
11370       print_strings (r);
11371       return -1;
11372     }
11373     for (i = 0; r[i] != NULL; ++i)
11374       free (r[i]);
11375     free (r);
11376   }
11377   return 0;
11378 }
11379
11380 static int test_command_lines_8_skip (void)
11381 {
11382   const char *str;
11383
11384   str = getenv ("TEST_ONLY");
11385   if (str)
11386     return strstr (str, "command_lines") == NULL;
11387   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
11388   if (str && strcmp (str, "1") == 0) return 1;
11389   str = getenv ("SKIP_TEST_COMMAND_LINES");
11390   if (str && strcmp (str, "1") == 0) return 1;
11391   return 0;
11392 }
11393
11394 static int test_command_lines_8 (void)
11395 {
11396   if (test_command_lines_8_skip ()) {
11397     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_8");
11398     return 0;
11399   }
11400
11401   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
11402   {
11403     char device[] = "/dev/sda";
11404     int r;
11405     suppress_error = 0;
11406     r = guestfs_blockdev_setrw (g, device);
11407     if (r == -1)
11408       return -1;
11409   }
11410   {
11411     int r;
11412     suppress_error = 0;
11413     r = guestfs_umount_all (g);
11414     if (r == -1)
11415       return -1;
11416   }
11417   {
11418     int r;
11419     suppress_error = 0;
11420     r = guestfs_lvm_remove_all (g);
11421     if (r == -1)
11422       return -1;
11423   }
11424   {
11425     char device[] = "/dev/sda";
11426     char lines_0[] = ",";
11427     char *lines[] = {
11428       lines_0,
11429       NULL
11430     };
11431     int r;
11432     suppress_error = 0;
11433     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11434     if (r == -1)
11435       return -1;
11436   }
11437   {
11438     char fstype[] = "ext2";
11439     char device[] = "/dev/sda1";
11440     int r;
11441     suppress_error = 0;
11442     r = guestfs_mkfs (g, fstype, device);
11443     if (r == -1)
11444       return -1;
11445   }
11446   {
11447     char device[] = "/dev/sda1";
11448     char mountpoint[] = "/";
11449     int r;
11450     suppress_error = 0;
11451     r = guestfs_mount (g, device, mountpoint);
11452     if (r == -1)
11453       return -1;
11454   }
11455   /* TestOutputList for command_lines (8) */
11456   {
11457     char remotefilename[] = "/test-command";
11458     int r;
11459     suppress_error = 0;
11460     r = guestfs_upload (g, "test-command", remotefilename);
11461     if (r == -1)
11462       return -1;
11463   }
11464   {
11465     char path[] = "/test-command";
11466     int r;
11467     suppress_error = 0;
11468     r = guestfs_chmod (g, 493, path);
11469     if (r == -1)
11470       return -1;
11471   }
11472   {
11473     char arguments_0[] = "/test-command";
11474     char arguments_1[] = "9";
11475     char *arguments[] = {
11476       arguments_0,
11477       arguments_1,
11478       NULL
11479     };
11480     char **r;
11481     int i;
11482     suppress_error = 0;
11483     r = guestfs_command_lines (g, arguments);
11484     if (r == NULL)
11485       return -1;
11486     if (!r[0]) {
11487       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11488       print_strings (r);
11489       return -1;
11490     }
11491     {
11492       char expected[] = "";
11493       if (strcmp (r[0], expected) != 0) {
11494         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11495         return -1;
11496       }
11497     }
11498     if (!r[1]) {
11499       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11500       print_strings (r);
11501       return -1;
11502     }
11503     {
11504       char expected[] = "";
11505       if (strcmp (r[1], expected) != 0) {
11506         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11507         return -1;
11508       }
11509     }
11510     if (r[2] != NULL) {
11511       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
11512       print_strings (r);
11513       return -1;
11514     }
11515     for (i = 0; r[i] != NULL; ++i)
11516       free (r[i]);
11517     free (r);
11518   }
11519   return 0;
11520 }
11521
11522 static int test_command_lines_9_skip (void)
11523 {
11524   const char *str;
11525
11526   str = getenv ("TEST_ONLY");
11527   if (str)
11528     return strstr (str, "command_lines") == NULL;
11529   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
11530   if (str && strcmp (str, "1") == 0) return 1;
11531   str = getenv ("SKIP_TEST_COMMAND_LINES");
11532   if (str && strcmp (str, "1") == 0) return 1;
11533   return 0;
11534 }
11535
11536 static int test_command_lines_9 (void)
11537 {
11538   if (test_command_lines_9_skip ()) {
11539     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_9");
11540     return 0;
11541   }
11542
11543   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
11544   {
11545     char device[] = "/dev/sda";
11546     int r;
11547     suppress_error = 0;
11548     r = guestfs_blockdev_setrw (g, device);
11549     if (r == -1)
11550       return -1;
11551   }
11552   {
11553     int r;
11554     suppress_error = 0;
11555     r = guestfs_umount_all (g);
11556     if (r == -1)
11557       return -1;
11558   }
11559   {
11560     int r;
11561     suppress_error = 0;
11562     r = guestfs_lvm_remove_all (g);
11563     if (r == -1)
11564       return -1;
11565   }
11566   {
11567     char device[] = "/dev/sda";
11568     char lines_0[] = ",";
11569     char *lines[] = {
11570       lines_0,
11571       NULL
11572     };
11573     int r;
11574     suppress_error = 0;
11575     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11576     if (r == -1)
11577       return -1;
11578   }
11579   {
11580     char fstype[] = "ext2";
11581     char device[] = "/dev/sda1";
11582     int r;
11583     suppress_error = 0;
11584     r = guestfs_mkfs (g, fstype, device);
11585     if (r == -1)
11586       return -1;
11587   }
11588   {
11589     char device[] = "/dev/sda1";
11590     char mountpoint[] = "/";
11591     int r;
11592     suppress_error = 0;
11593     r = guestfs_mount (g, device, mountpoint);
11594     if (r == -1)
11595       return -1;
11596   }
11597   /* TestOutputList for command_lines (9) */
11598   {
11599     char remotefilename[] = "/test-command";
11600     int r;
11601     suppress_error = 0;
11602     r = guestfs_upload (g, "test-command", remotefilename);
11603     if (r == -1)
11604       return -1;
11605   }
11606   {
11607     char path[] = "/test-command";
11608     int r;
11609     suppress_error = 0;
11610     r = guestfs_chmod (g, 493, path);
11611     if (r == -1)
11612       return -1;
11613   }
11614   {
11615     char arguments_0[] = "/test-command";
11616     char arguments_1[] = "10";
11617     char *arguments[] = {
11618       arguments_0,
11619       arguments_1,
11620       NULL
11621     };
11622     char **r;
11623     int i;
11624     suppress_error = 0;
11625     r = guestfs_command_lines (g, arguments);
11626     if (r == NULL)
11627       return -1;
11628     if (!r[0]) {
11629       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11630       print_strings (r);
11631       return -1;
11632     }
11633     {
11634       char expected[] = "Result10-1";
11635       if (strcmp (r[0], expected) != 0) {
11636         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11637         return -1;
11638       }
11639     }
11640     if (!r[1]) {
11641       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11642       print_strings (r);
11643       return -1;
11644     }
11645     {
11646       char expected[] = "Result10-2";
11647       if (strcmp (r[1], expected) != 0) {
11648         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11649         return -1;
11650       }
11651     }
11652     if (r[2] != NULL) {
11653       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11654       print_strings (r);
11655       return -1;
11656     }
11657     for (i = 0; r[i] != NULL; ++i)
11658       free (r[i]);
11659     free (r);
11660   }
11661   return 0;
11662 }
11663
11664 static int test_command_lines_10_skip (void)
11665 {
11666   const char *str;
11667
11668   str = getenv ("TEST_ONLY");
11669   if (str)
11670     return strstr (str, "command_lines") == NULL;
11671   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11672   if (str && strcmp (str, "1") == 0) return 1;
11673   str = getenv ("SKIP_TEST_COMMAND_LINES");
11674   if (str && strcmp (str, "1") == 0) return 1;
11675   return 0;
11676 }
11677
11678 static int test_command_lines_10 (void)
11679 {
11680   if (test_command_lines_10_skip ()) {
11681     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_10");
11682     return 0;
11683   }
11684
11685   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11686   {
11687     char device[] = "/dev/sda";
11688     int r;
11689     suppress_error = 0;
11690     r = guestfs_blockdev_setrw (g, device);
11691     if (r == -1)
11692       return -1;
11693   }
11694   {
11695     int r;
11696     suppress_error = 0;
11697     r = guestfs_umount_all (g);
11698     if (r == -1)
11699       return -1;
11700   }
11701   {
11702     int r;
11703     suppress_error = 0;
11704     r = guestfs_lvm_remove_all (g);
11705     if (r == -1)
11706       return -1;
11707   }
11708   {
11709     char device[] = "/dev/sda";
11710     char lines_0[] = ",";
11711     char *lines[] = {
11712       lines_0,
11713       NULL
11714     };
11715     int r;
11716     suppress_error = 0;
11717     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11718     if (r == -1)
11719       return -1;
11720   }
11721   {
11722     char fstype[] = "ext2";
11723     char device[] = "/dev/sda1";
11724     int r;
11725     suppress_error = 0;
11726     r = guestfs_mkfs (g, fstype, device);
11727     if (r == -1)
11728       return -1;
11729   }
11730   {
11731     char device[] = "/dev/sda1";
11732     char mountpoint[] = "/";
11733     int r;
11734     suppress_error = 0;
11735     r = guestfs_mount (g, device, mountpoint);
11736     if (r == -1)
11737       return -1;
11738   }
11739   /* TestOutputList for command_lines (10) */
11740   {
11741     char remotefilename[] = "/test-command";
11742     int r;
11743     suppress_error = 0;
11744     r = guestfs_upload (g, "test-command", remotefilename);
11745     if (r == -1)
11746       return -1;
11747   }
11748   {
11749     char path[] = "/test-command";
11750     int r;
11751     suppress_error = 0;
11752     r = guestfs_chmod (g, 493, path);
11753     if (r == -1)
11754       return -1;
11755   }
11756   {
11757     char arguments_0[] = "/test-command";
11758     char arguments_1[] = "11";
11759     char *arguments[] = {
11760       arguments_0,
11761       arguments_1,
11762       NULL
11763     };
11764     char **r;
11765     int i;
11766     suppress_error = 0;
11767     r = guestfs_command_lines (g, arguments);
11768     if (r == NULL)
11769       return -1;
11770     if (!r[0]) {
11771       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11772       print_strings (r);
11773       return -1;
11774     }
11775     {
11776       char expected[] = "Result11-1";
11777       if (strcmp (r[0], expected) != 0) {
11778         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11779         return -1;
11780       }
11781     }
11782     if (!r[1]) {
11783       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11784       print_strings (r);
11785       return -1;
11786     }
11787     {
11788       char expected[] = "Result11-2";
11789       if (strcmp (r[1], expected) != 0) {
11790         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11791         return -1;
11792       }
11793     }
11794     if (r[2] != NULL) {
11795       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11796       print_strings (r);
11797       return -1;
11798     }
11799     for (i = 0; r[i] != NULL; ++i)
11800       free (r[i]);
11801     free (r);
11802   }
11803   return 0;
11804 }
11805
11806 static int test_command_0_skip (void)
11807 {
11808   const char *str;
11809
11810   str = getenv ("TEST_ONLY");
11811   if (str)
11812     return strstr (str, "command") == NULL;
11813   str = getenv ("SKIP_TEST_COMMAND_0");
11814   if (str && strcmp (str, "1") == 0) return 1;
11815   str = getenv ("SKIP_TEST_COMMAND");
11816   if (str && strcmp (str, "1") == 0) return 1;
11817   return 0;
11818 }
11819
11820 static int test_command_0 (void)
11821 {
11822   if (test_command_0_skip ()) {
11823     printf ("        %s skipped (reason: environment variable set)\n", "test_command_0");
11824     return 0;
11825   }
11826
11827   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11828   {
11829     char device[] = "/dev/sda";
11830     int r;
11831     suppress_error = 0;
11832     r = guestfs_blockdev_setrw (g, device);
11833     if (r == -1)
11834       return -1;
11835   }
11836   {
11837     int r;
11838     suppress_error = 0;
11839     r = guestfs_umount_all (g);
11840     if (r == -1)
11841       return -1;
11842   }
11843   {
11844     int r;
11845     suppress_error = 0;
11846     r = guestfs_lvm_remove_all (g);
11847     if (r == -1)
11848       return -1;
11849   }
11850   {
11851     char device[] = "/dev/sda";
11852     char lines_0[] = ",";
11853     char *lines[] = {
11854       lines_0,
11855       NULL
11856     };
11857     int r;
11858     suppress_error = 0;
11859     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11860     if (r == -1)
11861       return -1;
11862   }
11863   {
11864     char fstype[] = "ext2";
11865     char device[] = "/dev/sda1";
11866     int r;
11867     suppress_error = 0;
11868     r = guestfs_mkfs (g, fstype, device);
11869     if (r == -1)
11870       return -1;
11871   }
11872   {
11873     char device[] = "/dev/sda1";
11874     char mountpoint[] = "/";
11875     int r;
11876     suppress_error = 0;
11877     r = guestfs_mount (g, device, mountpoint);
11878     if (r == -1)
11879       return -1;
11880   }
11881   /* TestOutput for command (0) */
11882   char expected[] = "Result1";
11883   {
11884     char remotefilename[] = "/test-command";
11885     int r;
11886     suppress_error = 0;
11887     r = guestfs_upload (g, "test-command", remotefilename);
11888     if (r == -1)
11889       return -1;
11890   }
11891   {
11892     char path[] = "/test-command";
11893     int r;
11894     suppress_error = 0;
11895     r = guestfs_chmod (g, 493, path);
11896     if (r == -1)
11897       return -1;
11898   }
11899   {
11900     char arguments_0[] = "/test-command";
11901     char arguments_1[] = "1";
11902     char *arguments[] = {
11903       arguments_0,
11904       arguments_1,
11905       NULL
11906     };
11907     char *r;
11908     suppress_error = 0;
11909     r = guestfs_command (g, arguments);
11910     if (r == NULL)
11911       return -1;
11912     if (strcmp (r, expected) != 0) {
11913       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11914       return -1;
11915     }
11916     free (r);
11917   }
11918   return 0;
11919 }
11920
11921 static int test_command_1_skip (void)
11922 {
11923   const char *str;
11924
11925   str = getenv ("TEST_ONLY");
11926   if (str)
11927     return strstr (str, "command") == NULL;
11928   str = getenv ("SKIP_TEST_COMMAND_1");
11929   if (str && strcmp (str, "1") == 0) return 1;
11930   str = getenv ("SKIP_TEST_COMMAND");
11931   if (str && strcmp (str, "1") == 0) return 1;
11932   return 0;
11933 }
11934
11935 static int test_command_1 (void)
11936 {
11937   if (test_command_1_skip ()) {
11938     printf ("        %s skipped (reason: environment variable set)\n", "test_command_1");
11939     return 0;
11940   }
11941
11942   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11943   {
11944     char device[] = "/dev/sda";
11945     int r;
11946     suppress_error = 0;
11947     r = guestfs_blockdev_setrw (g, device);
11948     if (r == -1)
11949       return -1;
11950   }
11951   {
11952     int r;
11953     suppress_error = 0;
11954     r = guestfs_umount_all (g);
11955     if (r == -1)
11956       return -1;
11957   }
11958   {
11959     int r;
11960     suppress_error = 0;
11961     r = guestfs_lvm_remove_all (g);
11962     if (r == -1)
11963       return -1;
11964   }
11965   {
11966     char device[] = "/dev/sda";
11967     char lines_0[] = ",";
11968     char *lines[] = {
11969       lines_0,
11970       NULL
11971     };
11972     int r;
11973     suppress_error = 0;
11974     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11975     if (r == -1)
11976       return -1;
11977   }
11978   {
11979     char fstype[] = "ext2";
11980     char device[] = "/dev/sda1";
11981     int r;
11982     suppress_error = 0;
11983     r = guestfs_mkfs (g, fstype, device);
11984     if (r == -1)
11985       return -1;
11986   }
11987   {
11988     char device[] = "/dev/sda1";
11989     char mountpoint[] = "/";
11990     int r;
11991     suppress_error = 0;
11992     r = guestfs_mount (g, device, mountpoint);
11993     if (r == -1)
11994       return -1;
11995   }
11996   /* TestOutput for command (1) */
11997   char expected[] = "Result2\n";
11998   {
11999     char remotefilename[] = "/test-command";
12000     int r;
12001     suppress_error = 0;
12002     r = guestfs_upload (g, "test-command", remotefilename);
12003     if (r == -1)
12004       return -1;
12005   }
12006   {
12007     char path[] = "/test-command";
12008     int r;
12009     suppress_error = 0;
12010     r = guestfs_chmod (g, 493, path);
12011     if (r == -1)
12012       return -1;
12013   }
12014   {
12015     char arguments_0[] = "/test-command";
12016     char arguments_1[] = "2";
12017     char *arguments[] = {
12018       arguments_0,
12019       arguments_1,
12020       NULL
12021     };
12022     char *r;
12023     suppress_error = 0;
12024     r = guestfs_command (g, arguments);
12025     if (r == NULL)
12026       return -1;
12027     if (strcmp (r, expected) != 0) {
12028       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
12029       return -1;
12030     }
12031     free (r);
12032   }
12033   return 0;
12034 }
12035
12036 static int test_command_2_skip (void)
12037 {
12038   const char *str;
12039
12040   str = getenv ("TEST_ONLY");
12041   if (str)
12042     return strstr (str, "command") == NULL;
12043   str = getenv ("SKIP_TEST_COMMAND_2");
12044   if (str && strcmp (str, "1") == 0) return 1;
12045   str = getenv ("SKIP_TEST_COMMAND");
12046   if (str && strcmp (str, "1") == 0) return 1;
12047   return 0;
12048 }
12049
12050 static int test_command_2 (void)
12051 {
12052   if (test_command_2_skip ()) {
12053     printf ("        %s skipped (reason: environment variable set)\n", "test_command_2");
12054     return 0;
12055   }
12056
12057   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
12058   {
12059     char device[] = "/dev/sda";
12060     int r;
12061     suppress_error = 0;
12062     r = guestfs_blockdev_setrw (g, device);
12063     if (r == -1)
12064       return -1;
12065   }
12066   {
12067     int r;
12068     suppress_error = 0;
12069     r = guestfs_umount_all (g);
12070     if (r == -1)
12071       return -1;
12072   }
12073   {
12074     int r;
12075     suppress_error = 0;
12076     r = guestfs_lvm_remove_all (g);
12077     if (r == -1)
12078       return -1;
12079   }
12080   {
12081     char device[] = "/dev/sda";
12082     char lines_0[] = ",";
12083     char *lines[] = {
12084       lines_0,
12085       NULL
12086     };
12087     int r;
12088     suppress_error = 0;
12089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12090     if (r == -1)
12091       return -1;
12092   }
12093   {
12094     char fstype[] = "ext2";
12095     char device[] = "/dev/sda1";
12096     int r;
12097     suppress_error = 0;
12098     r = guestfs_mkfs (g, fstype, device);
12099     if (r == -1)
12100       return -1;
12101   }
12102   {
12103     char device[] = "/dev/sda1";
12104     char mountpoint[] = "/";
12105     int r;
12106     suppress_error = 0;
12107     r = guestfs_mount (g, device, mountpoint);
12108     if (r == -1)
12109       return -1;
12110   }
12111   /* TestOutput for command (2) */
12112   char expected[] = "\nResult3";
12113   {
12114     char remotefilename[] = "/test-command";
12115     int r;
12116     suppress_error = 0;
12117     r = guestfs_upload (g, "test-command", remotefilename);
12118     if (r == -1)
12119       return -1;
12120   }
12121   {
12122     char path[] = "/test-command";
12123     int r;
12124     suppress_error = 0;
12125     r = guestfs_chmod (g, 493, path);
12126     if (r == -1)
12127       return -1;
12128   }
12129   {
12130     char arguments_0[] = "/test-command";
12131     char arguments_1[] = "3";
12132     char *arguments[] = {
12133       arguments_0,
12134       arguments_1,
12135       NULL
12136     };
12137     char *r;
12138     suppress_error = 0;
12139     r = guestfs_command (g, arguments);
12140     if (r == NULL)
12141       return -1;
12142     if (strcmp (r, expected) != 0) {
12143       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
12144       return -1;
12145     }
12146     free (r);
12147   }
12148   return 0;
12149 }
12150
12151 static int test_command_3_skip (void)
12152 {
12153   const char *str;
12154
12155   str = getenv ("TEST_ONLY");
12156   if (str)
12157     return strstr (str, "command") == NULL;
12158   str = getenv ("SKIP_TEST_COMMAND_3");
12159   if (str && strcmp (str, "1") == 0) return 1;
12160   str = getenv ("SKIP_TEST_COMMAND");
12161   if (str && strcmp (str, "1") == 0) return 1;
12162   return 0;
12163 }
12164
12165 static int test_command_3 (void)
12166 {
12167   if (test_command_3_skip ()) {
12168     printf ("        %s skipped (reason: environment variable set)\n", "test_command_3");
12169     return 0;
12170   }
12171
12172   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
12173   {
12174     char device[] = "/dev/sda";
12175     int r;
12176     suppress_error = 0;
12177     r = guestfs_blockdev_setrw (g, device);
12178     if (r == -1)
12179       return -1;
12180   }
12181   {
12182     int r;
12183     suppress_error = 0;
12184     r = guestfs_umount_all (g);
12185     if (r == -1)
12186       return -1;
12187   }
12188   {
12189     int r;
12190     suppress_error = 0;
12191     r = guestfs_lvm_remove_all (g);
12192     if (r == -1)
12193       return -1;
12194   }
12195   {
12196     char device[] = "/dev/sda";
12197     char lines_0[] = ",";
12198     char *lines[] = {
12199       lines_0,
12200       NULL
12201     };
12202     int r;
12203     suppress_error = 0;
12204     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12205     if (r == -1)
12206       return -1;
12207   }
12208   {
12209     char fstype[] = "ext2";
12210     char device[] = "/dev/sda1";
12211     int r;
12212     suppress_error = 0;
12213     r = guestfs_mkfs (g, fstype, device);
12214     if (r == -1)
12215       return -1;
12216   }
12217   {
12218     char device[] = "/dev/sda1";
12219     char mountpoint[] = "/";
12220     int r;
12221     suppress_error = 0;
12222     r = guestfs_mount (g, device, mountpoint);
12223     if (r == -1)
12224       return -1;
12225   }
12226   /* TestOutput for command (3) */
12227   char expected[] = "\nResult4\n";
12228   {
12229     char remotefilename[] = "/test-command";
12230     int r;
12231     suppress_error = 0;
12232     r = guestfs_upload (g, "test-command", remotefilename);
12233     if (r == -1)
12234       return -1;
12235   }
12236   {
12237     char path[] = "/test-command";
12238     int r;
12239     suppress_error = 0;
12240     r = guestfs_chmod (g, 493, path);
12241     if (r == -1)
12242       return -1;
12243   }
12244   {
12245     char arguments_0[] = "/test-command";
12246     char arguments_1[] = "4";
12247     char *arguments[] = {
12248       arguments_0,
12249       arguments_1,
12250       NULL
12251     };
12252     char *r;
12253     suppress_error = 0;
12254     r = guestfs_command (g, arguments);
12255     if (r == NULL)
12256       return -1;
12257     if (strcmp (r, expected) != 0) {
12258       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
12259       return -1;
12260     }
12261     free (r);
12262   }
12263   return 0;
12264 }
12265
12266 static int test_command_4_skip (void)
12267 {
12268   const char *str;
12269
12270   str = getenv ("TEST_ONLY");
12271   if (str)
12272     return strstr (str, "command") == NULL;
12273   str = getenv ("SKIP_TEST_COMMAND_4");
12274   if (str && strcmp (str, "1") == 0) return 1;
12275   str = getenv ("SKIP_TEST_COMMAND");
12276   if (str && strcmp (str, "1") == 0) return 1;
12277   return 0;
12278 }
12279
12280 static int test_command_4 (void)
12281 {
12282   if (test_command_4_skip ()) {
12283     printf ("        %s skipped (reason: environment variable set)\n", "test_command_4");
12284     return 0;
12285   }
12286
12287   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
12288   {
12289     char device[] = "/dev/sda";
12290     int r;
12291     suppress_error = 0;
12292     r = guestfs_blockdev_setrw (g, device);
12293     if (r == -1)
12294       return -1;
12295   }
12296   {
12297     int r;
12298     suppress_error = 0;
12299     r = guestfs_umount_all (g);
12300     if (r == -1)
12301       return -1;
12302   }
12303   {
12304     int r;
12305     suppress_error = 0;
12306     r = guestfs_lvm_remove_all (g);
12307     if (r == -1)
12308       return -1;
12309   }
12310   {
12311     char device[] = "/dev/sda";
12312     char lines_0[] = ",";
12313     char *lines[] = {
12314       lines_0,
12315       NULL
12316     };
12317     int r;
12318     suppress_error = 0;
12319     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12320     if (r == -1)
12321       return -1;
12322   }
12323   {
12324     char fstype[] = "ext2";
12325     char device[] = "/dev/sda1";
12326     int r;
12327     suppress_error = 0;
12328     r = guestfs_mkfs (g, fstype, device);
12329     if (r == -1)
12330       return -1;
12331   }
12332   {
12333     char device[] = "/dev/sda1";
12334     char mountpoint[] = "/";
12335     int r;
12336     suppress_error = 0;
12337     r = guestfs_mount (g, device, mountpoint);
12338     if (r == -1)
12339       return -1;
12340   }
12341   /* TestOutput for command (4) */
12342   char expected[] = "\nResult5\n\n";
12343   {
12344     char remotefilename[] = "/test-command";
12345     int r;
12346     suppress_error = 0;
12347     r = guestfs_upload (g, "test-command", remotefilename);
12348     if (r == -1)
12349       return -1;
12350   }
12351   {
12352     char path[] = "/test-command";
12353     int r;
12354     suppress_error = 0;
12355     r = guestfs_chmod (g, 493, path);
12356     if (r == -1)
12357       return -1;
12358   }
12359   {
12360     char arguments_0[] = "/test-command";
12361     char arguments_1[] = "5";
12362     char *arguments[] = {
12363       arguments_0,
12364       arguments_1,
12365       NULL
12366     };
12367     char *r;
12368     suppress_error = 0;
12369     r = guestfs_command (g, arguments);
12370     if (r == NULL)
12371       return -1;
12372     if (strcmp (r, expected) != 0) {
12373       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
12374       return -1;
12375     }
12376     free (r);
12377   }
12378   return 0;
12379 }
12380
12381 static int test_command_5_skip (void)
12382 {
12383   const char *str;
12384
12385   str = getenv ("TEST_ONLY");
12386   if (str)
12387     return strstr (str, "command") == NULL;
12388   str = getenv ("SKIP_TEST_COMMAND_5");
12389   if (str && strcmp (str, "1") == 0) return 1;
12390   str = getenv ("SKIP_TEST_COMMAND");
12391   if (str && strcmp (str, "1") == 0) return 1;
12392   return 0;
12393 }
12394
12395 static int test_command_5 (void)
12396 {
12397   if (test_command_5_skip ()) {
12398     printf ("        %s skipped (reason: environment variable set)\n", "test_command_5");
12399     return 0;
12400   }
12401
12402   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
12403   {
12404     char device[] = "/dev/sda";
12405     int r;
12406     suppress_error = 0;
12407     r = guestfs_blockdev_setrw (g, device);
12408     if (r == -1)
12409       return -1;
12410   }
12411   {
12412     int r;
12413     suppress_error = 0;
12414     r = guestfs_umount_all (g);
12415     if (r == -1)
12416       return -1;
12417   }
12418   {
12419     int r;
12420     suppress_error = 0;
12421     r = guestfs_lvm_remove_all (g);
12422     if (r == -1)
12423       return -1;
12424   }
12425   {
12426     char device[] = "/dev/sda";
12427     char lines_0[] = ",";
12428     char *lines[] = {
12429       lines_0,
12430       NULL
12431     };
12432     int r;
12433     suppress_error = 0;
12434     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12435     if (r == -1)
12436       return -1;
12437   }
12438   {
12439     char fstype[] = "ext2";
12440     char device[] = "/dev/sda1";
12441     int r;
12442     suppress_error = 0;
12443     r = guestfs_mkfs (g, fstype, device);
12444     if (r == -1)
12445       return -1;
12446   }
12447   {
12448     char device[] = "/dev/sda1";
12449     char mountpoint[] = "/";
12450     int r;
12451     suppress_error = 0;
12452     r = guestfs_mount (g, device, mountpoint);
12453     if (r == -1)
12454       return -1;
12455   }
12456   /* TestOutput for command (5) */
12457   char expected[] = "\n\nResult6\n\n";
12458   {
12459     char remotefilename[] = "/test-command";
12460     int r;
12461     suppress_error = 0;
12462     r = guestfs_upload (g, "test-command", remotefilename);
12463     if (r == -1)
12464       return -1;
12465   }
12466   {
12467     char path[] = "/test-command";
12468     int r;
12469     suppress_error = 0;
12470     r = guestfs_chmod (g, 493, path);
12471     if (r == -1)
12472       return -1;
12473   }
12474   {
12475     char arguments_0[] = "/test-command";
12476     char arguments_1[] = "6";
12477     char *arguments[] = {
12478       arguments_0,
12479       arguments_1,
12480       NULL
12481     };
12482     char *r;
12483     suppress_error = 0;
12484     r = guestfs_command (g, arguments);
12485     if (r == NULL)
12486       return -1;
12487     if (strcmp (r, expected) != 0) {
12488       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
12489       return -1;
12490     }
12491     free (r);
12492   }
12493   return 0;
12494 }
12495
12496 static int test_command_6_skip (void)
12497 {
12498   const char *str;
12499
12500   str = getenv ("TEST_ONLY");
12501   if (str)
12502     return strstr (str, "command") == NULL;
12503   str = getenv ("SKIP_TEST_COMMAND_6");
12504   if (str && strcmp (str, "1") == 0) return 1;
12505   str = getenv ("SKIP_TEST_COMMAND");
12506   if (str && strcmp (str, "1") == 0) return 1;
12507   return 0;
12508 }
12509
12510 static int test_command_6 (void)
12511 {
12512   if (test_command_6_skip ()) {
12513     printf ("        %s skipped (reason: environment variable set)\n", "test_command_6");
12514     return 0;
12515   }
12516
12517   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
12518   {
12519     char device[] = "/dev/sda";
12520     int r;
12521     suppress_error = 0;
12522     r = guestfs_blockdev_setrw (g, device);
12523     if (r == -1)
12524       return -1;
12525   }
12526   {
12527     int r;
12528     suppress_error = 0;
12529     r = guestfs_umount_all (g);
12530     if (r == -1)
12531       return -1;
12532   }
12533   {
12534     int r;
12535     suppress_error = 0;
12536     r = guestfs_lvm_remove_all (g);
12537     if (r == -1)
12538       return -1;
12539   }
12540   {
12541     char device[] = "/dev/sda";
12542     char lines_0[] = ",";
12543     char *lines[] = {
12544       lines_0,
12545       NULL
12546     };
12547     int r;
12548     suppress_error = 0;
12549     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12550     if (r == -1)
12551       return -1;
12552   }
12553   {
12554     char fstype[] = "ext2";
12555     char device[] = "/dev/sda1";
12556     int r;
12557     suppress_error = 0;
12558     r = guestfs_mkfs (g, fstype, device);
12559     if (r == -1)
12560       return -1;
12561   }
12562   {
12563     char device[] = "/dev/sda1";
12564     char mountpoint[] = "/";
12565     int r;
12566     suppress_error = 0;
12567     r = guestfs_mount (g, device, mountpoint);
12568     if (r == -1)
12569       return -1;
12570   }
12571   /* TestOutput for command (6) */
12572   char expected[] = "";
12573   {
12574     char remotefilename[] = "/test-command";
12575     int r;
12576     suppress_error = 0;
12577     r = guestfs_upload (g, "test-command", remotefilename);
12578     if (r == -1)
12579       return -1;
12580   }
12581   {
12582     char path[] = "/test-command";
12583     int r;
12584     suppress_error = 0;
12585     r = guestfs_chmod (g, 493, path);
12586     if (r == -1)
12587       return -1;
12588   }
12589   {
12590     char arguments_0[] = "/test-command";
12591     char arguments_1[] = "7";
12592     char *arguments[] = {
12593       arguments_0,
12594       arguments_1,
12595       NULL
12596     };
12597     char *r;
12598     suppress_error = 0;
12599     r = guestfs_command (g, arguments);
12600     if (r == NULL)
12601       return -1;
12602     if (strcmp (r, expected) != 0) {
12603       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
12604       return -1;
12605     }
12606     free (r);
12607   }
12608   return 0;
12609 }
12610
12611 static int test_command_7_skip (void)
12612 {
12613   const char *str;
12614
12615   str = getenv ("TEST_ONLY");
12616   if (str)
12617     return strstr (str, "command") == NULL;
12618   str = getenv ("SKIP_TEST_COMMAND_7");
12619   if (str && strcmp (str, "1") == 0) return 1;
12620   str = getenv ("SKIP_TEST_COMMAND");
12621   if (str && strcmp (str, "1") == 0) return 1;
12622   return 0;
12623 }
12624
12625 static int test_command_7 (void)
12626 {
12627   if (test_command_7_skip ()) {
12628     printf ("        %s skipped (reason: environment variable set)\n", "test_command_7");
12629     return 0;
12630   }
12631
12632   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
12633   {
12634     char device[] = "/dev/sda";
12635     int r;
12636     suppress_error = 0;
12637     r = guestfs_blockdev_setrw (g, device);
12638     if (r == -1)
12639       return -1;
12640   }
12641   {
12642     int r;
12643     suppress_error = 0;
12644     r = guestfs_umount_all (g);
12645     if (r == -1)
12646       return -1;
12647   }
12648   {
12649     int r;
12650     suppress_error = 0;
12651     r = guestfs_lvm_remove_all (g);
12652     if (r == -1)
12653       return -1;
12654   }
12655   {
12656     char device[] = "/dev/sda";
12657     char lines_0[] = ",";
12658     char *lines[] = {
12659       lines_0,
12660       NULL
12661     };
12662     int r;
12663     suppress_error = 0;
12664     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12665     if (r == -1)
12666       return -1;
12667   }
12668   {
12669     char fstype[] = "ext2";
12670     char device[] = "/dev/sda1";
12671     int r;
12672     suppress_error = 0;
12673     r = guestfs_mkfs (g, fstype, device);
12674     if (r == -1)
12675       return -1;
12676   }
12677   {
12678     char device[] = "/dev/sda1";
12679     char mountpoint[] = "/";
12680     int r;
12681     suppress_error = 0;
12682     r = guestfs_mount (g, device, mountpoint);
12683     if (r == -1)
12684       return -1;
12685   }
12686   /* TestOutput for command (7) */
12687   char expected[] = "\n";
12688   {
12689     char remotefilename[] = "/test-command";
12690     int r;
12691     suppress_error = 0;
12692     r = guestfs_upload (g, "test-command", remotefilename);
12693     if (r == -1)
12694       return -1;
12695   }
12696   {
12697     char path[] = "/test-command";
12698     int r;
12699     suppress_error = 0;
12700     r = guestfs_chmod (g, 493, path);
12701     if (r == -1)
12702       return -1;
12703   }
12704   {
12705     char arguments_0[] = "/test-command";
12706     char arguments_1[] = "8";
12707     char *arguments[] = {
12708       arguments_0,
12709       arguments_1,
12710       NULL
12711     };
12712     char *r;
12713     suppress_error = 0;
12714     r = guestfs_command (g, arguments);
12715     if (r == NULL)
12716       return -1;
12717     if (strcmp (r, expected) != 0) {
12718       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12719       return -1;
12720     }
12721     free (r);
12722   }
12723   return 0;
12724 }
12725
12726 static int test_command_8_skip (void)
12727 {
12728   const char *str;
12729
12730   str = getenv ("TEST_ONLY");
12731   if (str)
12732     return strstr (str, "command") == NULL;
12733   str = getenv ("SKIP_TEST_COMMAND_8");
12734   if (str && strcmp (str, "1") == 0) return 1;
12735   str = getenv ("SKIP_TEST_COMMAND");
12736   if (str && strcmp (str, "1") == 0) return 1;
12737   return 0;
12738 }
12739
12740 static int test_command_8 (void)
12741 {
12742   if (test_command_8_skip ()) {
12743     printf ("        %s skipped (reason: environment variable set)\n", "test_command_8");
12744     return 0;
12745   }
12746
12747   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12748   {
12749     char device[] = "/dev/sda";
12750     int r;
12751     suppress_error = 0;
12752     r = guestfs_blockdev_setrw (g, device);
12753     if (r == -1)
12754       return -1;
12755   }
12756   {
12757     int r;
12758     suppress_error = 0;
12759     r = guestfs_umount_all (g);
12760     if (r == -1)
12761       return -1;
12762   }
12763   {
12764     int r;
12765     suppress_error = 0;
12766     r = guestfs_lvm_remove_all (g);
12767     if (r == -1)
12768       return -1;
12769   }
12770   {
12771     char device[] = "/dev/sda";
12772     char lines_0[] = ",";
12773     char *lines[] = {
12774       lines_0,
12775       NULL
12776     };
12777     int r;
12778     suppress_error = 0;
12779     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12780     if (r == -1)
12781       return -1;
12782   }
12783   {
12784     char fstype[] = "ext2";
12785     char device[] = "/dev/sda1";
12786     int r;
12787     suppress_error = 0;
12788     r = guestfs_mkfs (g, fstype, device);
12789     if (r == -1)
12790       return -1;
12791   }
12792   {
12793     char device[] = "/dev/sda1";
12794     char mountpoint[] = "/";
12795     int r;
12796     suppress_error = 0;
12797     r = guestfs_mount (g, device, mountpoint);
12798     if (r == -1)
12799       return -1;
12800   }
12801   /* TestOutput for command (8) */
12802   char expected[] = "\n\n";
12803   {
12804     char remotefilename[] = "/test-command";
12805     int r;
12806     suppress_error = 0;
12807     r = guestfs_upload (g, "test-command", remotefilename);
12808     if (r == -1)
12809       return -1;
12810   }
12811   {
12812     char path[] = "/test-command";
12813     int r;
12814     suppress_error = 0;
12815     r = guestfs_chmod (g, 493, path);
12816     if (r == -1)
12817       return -1;
12818   }
12819   {
12820     char arguments_0[] = "/test-command";
12821     char arguments_1[] = "9";
12822     char *arguments[] = {
12823       arguments_0,
12824       arguments_1,
12825       NULL
12826     };
12827     char *r;
12828     suppress_error = 0;
12829     r = guestfs_command (g, arguments);
12830     if (r == NULL)
12831       return -1;
12832     if (strcmp (r, expected) != 0) {
12833       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12834       return -1;
12835     }
12836     free (r);
12837   }
12838   return 0;
12839 }
12840
12841 static int test_command_9_skip (void)
12842 {
12843   const char *str;
12844
12845   str = getenv ("TEST_ONLY");
12846   if (str)
12847     return strstr (str, "command") == NULL;
12848   str = getenv ("SKIP_TEST_COMMAND_9");
12849   if (str && strcmp (str, "1") == 0) return 1;
12850   str = getenv ("SKIP_TEST_COMMAND");
12851   if (str && strcmp (str, "1") == 0) return 1;
12852   return 0;
12853 }
12854
12855 static int test_command_9 (void)
12856 {
12857   if (test_command_9_skip ()) {
12858     printf ("        %s skipped (reason: environment variable set)\n", "test_command_9");
12859     return 0;
12860   }
12861
12862   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12863   {
12864     char device[] = "/dev/sda";
12865     int r;
12866     suppress_error = 0;
12867     r = guestfs_blockdev_setrw (g, device);
12868     if (r == -1)
12869       return -1;
12870   }
12871   {
12872     int r;
12873     suppress_error = 0;
12874     r = guestfs_umount_all (g);
12875     if (r == -1)
12876       return -1;
12877   }
12878   {
12879     int r;
12880     suppress_error = 0;
12881     r = guestfs_lvm_remove_all (g);
12882     if (r == -1)
12883       return -1;
12884   }
12885   {
12886     char device[] = "/dev/sda";
12887     char lines_0[] = ",";
12888     char *lines[] = {
12889       lines_0,
12890       NULL
12891     };
12892     int r;
12893     suppress_error = 0;
12894     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12895     if (r == -1)
12896       return -1;
12897   }
12898   {
12899     char fstype[] = "ext2";
12900     char device[] = "/dev/sda1";
12901     int r;
12902     suppress_error = 0;
12903     r = guestfs_mkfs (g, fstype, device);
12904     if (r == -1)
12905       return -1;
12906   }
12907   {
12908     char device[] = "/dev/sda1";
12909     char mountpoint[] = "/";
12910     int r;
12911     suppress_error = 0;
12912     r = guestfs_mount (g, device, mountpoint);
12913     if (r == -1)
12914       return -1;
12915   }
12916   /* TestOutput for command (9) */
12917   char expected[] = "Result10-1\nResult10-2\n";
12918   {
12919     char remotefilename[] = "/test-command";
12920     int r;
12921     suppress_error = 0;
12922     r = guestfs_upload (g, "test-command", remotefilename);
12923     if (r == -1)
12924       return -1;
12925   }
12926   {
12927     char path[] = "/test-command";
12928     int r;
12929     suppress_error = 0;
12930     r = guestfs_chmod (g, 493, path);
12931     if (r == -1)
12932       return -1;
12933   }
12934   {
12935     char arguments_0[] = "/test-command";
12936     char arguments_1[] = "10";
12937     char *arguments[] = {
12938       arguments_0,
12939       arguments_1,
12940       NULL
12941     };
12942     char *r;
12943     suppress_error = 0;
12944     r = guestfs_command (g, arguments);
12945     if (r == NULL)
12946       return -1;
12947     if (strcmp (r, expected) != 0) {
12948       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12949       return -1;
12950     }
12951     free (r);
12952   }
12953   return 0;
12954 }
12955
12956 static int test_command_10_skip (void)
12957 {
12958   const char *str;
12959
12960   str = getenv ("TEST_ONLY");
12961   if (str)
12962     return strstr (str, "command") == NULL;
12963   str = getenv ("SKIP_TEST_COMMAND_10");
12964   if (str && strcmp (str, "1") == 0) return 1;
12965   str = getenv ("SKIP_TEST_COMMAND");
12966   if (str && strcmp (str, "1") == 0) return 1;
12967   return 0;
12968 }
12969
12970 static int test_command_10 (void)
12971 {
12972   if (test_command_10_skip ()) {
12973     printf ("        %s skipped (reason: environment variable set)\n", "test_command_10");
12974     return 0;
12975   }
12976
12977   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12978   {
12979     char device[] = "/dev/sda";
12980     int r;
12981     suppress_error = 0;
12982     r = guestfs_blockdev_setrw (g, device);
12983     if (r == -1)
12984       return -1;
12985   }
12986   {
12987     int r;
12988     suppress_error = 0;
12989     r = guestfs_umount_all (g);
12990     if (r == -1)
12991       return -1;
12992   }
12993   {
12994     int r;
12995     suppress_error = 0;
12996     r = guestfs_lvm_remove_all (g);
12997     if (r == -1)
12998       return -1;
12999   }
13000   {
13001     char device[] = "/dev/sda";
13002     char lines_0[] = ",";
13003     char *lines[] = {
13004       lines_0,
13005       NULL
13006     };
13007     int r;
13008     suppress_error = 0;
13009     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13010     if (r == -1)
13011       return -1;
13012   }
13013   {
13014     char fstype[] = "ext2";
13015     char device[] = "/dev/sda1";
13016     int r;
13017     suppress_error = 0;
13018     r = guestfs_mkfs (g, fstype, device);
13019     if (r == -1)
13020       return -1;
13021   }
13022   {
13023     char device[] = "/dev/sda1";
13024     char mountpoint[] = "/";
13025     int r;
13026     suppress_error = 0;
13027     r = guestfs_mount (g, device, mountpoint);
13028     if (r == -1)
13029       return -1;
13030   }
13031   /* TestOutput for command (10) */
13032   char expected[] = "Result11-1\nResult11-2";
13033   {
13034     char remotefilename[] = "/test-command";
13035     int r;
13036     suppress_error = 0;
13037     r = guestfs_upload (g, "test-command", remotefilename);
13038     if (r == -1)
13039       return -1;
13040   }
13041   {
13042     char path[] = "/test-command";
13043     int r;
13044     suppress_error = 0;
13045     r = guestfs_chmod (g, 493, path);
13046     if (r == -1)
13047       return -1;
13048   }
13049   {
13050     char arguments_0[] = "/test-command";
13051     char arguments_1[] = "11";
13052     char *arguments[] = {
13053       arguments_0,
13054       arguments_1,
13055       NULL
13056     };
13057     char *r;
13058     suppress_error = 0;
13059     r = guestfs_command (g, arguments);
13060     if (r == NULL)
13061       return -1;
13062     if (strcmp (r, expected) != 0) {
13063       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
13064       return -1;
13065     }
13066     free (r);
13067   }
13068   return 0;
13069 }
13070
13071 static int test_command_11_skip (void)
13072 {
13073   const char *str;
13074
13075   str = getenv ("TEST_ONLY");
13076   if (str)
13077     return strstr (str, "command") == NULL;
13078   str = getenv ("SKIP_TEST_COMMAND_11");
13079   if (str && strcmp (str, "1") == 0) return 1;
13080   str = getenv ("SKIP_TEST_COMMAND");
13081   if (str && strcmp (str, "1") == 0) return 1;
13082   return 0;
13083 }
13084
13085 static int test_command_11 (void)
13086 {
13087   if (test_command_11_skip ()) {
13088     printf ("        %s skipped (reason: environment variable set)\n", "test_command_11");
13089     return 0;
13090   }
13091
13092   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
13093   {
13094     char device[] = "/dev/sda";
13095     int r;
13096     suppress_error = 0;
13097     r = guestfs_blockdev_setrw (g, device);
13098     if (r == -1)
13099       return -1;
13100   }
13101   {
13102     int r;
13103     suppress_error = 0;
13104     r = guestfs_umount_all (g);
13105     if (r == -1)
13106       return -1;
13107   }
13108   {
13109     int r;
13110     suppress_error = 0;
13111     r = guestfs_lvm_remove_all (g);
13112     if (r == -1)
13113       return -1;
13114   }
13115   {
13116     char device[] = "/dev/sda";
13117     char lines_0[] = ",";
13118     char *lines[] = {
13119       lines_0,
13120       NULL
13121     };
13122     int r;
13123     suppress_error = 0;
13124     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13125     if (r == -1)
13126       return -1;
13127   }
13128   {
13129     char fstype[] = "ext2";
13130     char device[] = "/dev/sda1";
13131     int r;
13132     suppress_error = 0;
13133     r = guestfs_mkfs (g, fstype, device);
13134     if (r == -1)
13135       return -1;
13136   }
13137   {
13138     char device[] = "/dev/sda1";
13139     char mountpoint[] = "/";
13140     int r;
13141     suppress_error = 0;
13142     r = guestfs_mount (g, device, mountpoint);
13143     if (r == -1)
13144       return -1;
13145   }
13146   /* TestLastFail for command (11) */
13147   {
13148     char remotefilename[] = "/test-command";
13149     int r;
13150     suppress_error = 0;
13151     r = guestfs_upload (g, "test-command", remotefilename);
13152     if (r == -1)
13153       return -1;
13154   }
13155   {
13156     char path[] = "/test-command";
13157     int r;
13158     suppress_error = 0;
13159     r = guestfs_chmod (g, 493, path);
13160     if (r == -1)
13161       return -1;
13162   }
13163   {
13164     char arguments_0[] = "/test-command";
13165     char *arguments[] = {
13166       arguments_0,
13167       NULL
13168     };
13169     char *r;
13170     suppress_error = 1;
13171     r = guestfs_command (g, arguments);
13172     if (r != NULL)
13173       return -1;
13174     free (r);
13175   }
13176   return 0;
13177 }
13178
13179 static int test_file_0_skip (void)
13180 {
13181   const char *str;
13182
13183   str = getenv ("TEST_ONLY");
13184   if (str)
13185     return strstr (str, "file") == NULL;
13186   str = getenv ("SKIP_TEST_FILE_0");
13187   if (str && strcmp (str, "1") == 0) return 1;
13188   str = getenv ("SKIP_TEST_FILE");
13189   if (str && strcmp (str, "1") == 0) return 1;
13190   return 0;
13191 }
13192
13193 static int test_file_0 (void)
13194 {
13195   if (test_file_0_skip ()) {
13196     printf ("        %s skipped (reason: environment variable set)\n", "test_file_0");
13197     return 0;
13198   }
13199
13200   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
13201   {
13202     char device[] = "/dev/sda";
13203     int r;
13204     suppress_error = 0;
13205     r = guestfs_blockdev_setrw (g, device);
13206     if (r == -1)
13207       return -1;
13208   }
13209   {
13210     int r;
13211     suppress_error = 0;
13212     r = guestfs_umount_all (g);
13213     if (r == -1)
13214       return -1;
13215   }
13216   {
13217     int r;
13218     suppress_error = 0;
13219     r = guestfs_lvm_remove_all (g);
13220     if (r == -1)
13221       return -1;
13222   }
13223   {
13224     char device[] = "/dev/sda";
13225     char lines_0[] = ",";
13226     char *lines[] = {
13227       lines_0,
13228       NULL
13229     };
13230     int r;
13231     suppress_error = 0;
13232     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13233     if (r == -1)
13234       return -1;
13235   }
13236   {
13237     char fstype[] = "ext2";
13238     char device[] = "/dev/sda1";
13239     int r;
13240     suppress_error = 0;
13241     r = guestfs_mkfs (g, fstype, device);
13242     if (r == -1)
13243       return -1;
13244   }
13245   {
13246     char device[] = "/dev/sda1";
13247     char mountpoint[] = "/";
13248     int r;
13249     suppress_error = 0;
13250     r = guestfs_mount (g, device, mountpoint);
13251     if (r == -1)
13252       return -1;
13253   }
13254   /* TestOutput for file (0) */
13255   char expected[] = "empty";
13256   {
13257     char path[] = "/new";
13258     int r;
13259     suppress_error = 0;
13260     r = guestfs_touch (g, path);
13261     if (r == -1)
13262       return -1;
13263   }
13264   {
13265     char path[] = "/new";
13266     char *r;
13267     suppress_error = 0;
13268     r = guestfs_file (g, path);
13269     if (r == NULL)
13270       return -1;
13271     if (strcmp (r, expected) != 0) {
13272       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13273       return -1;
13274     }
13275     free (r);
13276   }
13277   return 0;
13278 }
13279
13280 static int test_file_1_skip (void)
13281 {
13282   const char *str;
13283
13284   str = getenv ("TEST_ONLY");
13285   if (str)
13286     return strstr (str, "file") == NULL;
13287   str = getenv ("SKIP_TEST_FILE_1");
13288   if (str && strcmp (str, "1") == 0) return 1;
13289   str = getenv ("SKIP_TEST_FILE");
13290   if (str && strcmp (str, "1") == 0) return 1;
13291   return 0;
13292 }
13293
13294 static int test_file_1 (void)
13295 {
13296   if (test_file_1_skip ()) {
13297     printf ("        %s skipped (reason: environment variable set)\n", "test_file_1");
13298     return 0;
13299   }
13300
13301   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
13302   {
13303     char device[] = "/dev/sda";
13304     int r;
13305     suppress_error = 0;
13306     r = guestfs_blockdev_setrw (g, device);
13307     if (r == -1)
13308       return -1;
13309   }
13310   {
13311     int r;
13312     suppress_error = 0;
13313     r = guestfs_umount_all (g);
13314     if (r == -1)
13315       return -1;
13316   }
13317   {
13318     int r;
13319     suppress_error = 0;
13320     r = guestfs_lvm_remove_all (g);
13321     if (r == -1)
13322       return -1;
13323   }
13324   {
13325     char device[] = "/dev/sda";
13326     char lines_0[] = ",";
13327     char *lines[] = {
13328       lines_0,
13329       NULL
13330     };
13331     int r;
13332     suppress_error = 0;
13333     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13334     if (r == -1)
13335       return -1;
13336   }
13337   {
13338     char fstype[] = "ext2";
13339     char device[] = "/dev/sda1";
13340     int r;
13341     suppress_error = 0;
13342     r = guestfs_mkfs (g, fstype, device);
13343     if (r == -1)
13344       return -1;
13345   }
13346   {
13347     char device[] = "/dev/sda1";
13348     char mountpoint[] = "/";
13349     int r;
13350     suppress_error = 0;
13351     r = guestfs_mount (g, device, mountpoint);
13352     if (r == -1)
13353       return -1;
13354   }
13355   /* TestOutput for file (1) */
13356   char expected[] = "ASCII text";
13357   {
13358     char path[] = "/new";
13359     char content[] = "some content\n";
13360     int r;
13361     suppress_error = 0;
13362     r = guestfs_write_file (g, path, content, 0);
13363     if (r == -1)
13364       return -1;
13365   }
13366   {
13367     char path[] = "/new";
13368     char *r;
13369     suppress_error = 0;
13370     r = guestfs_file (g, path);
13371     if (r == NULL)
13372       return -1;
13373     if (strcmp (r, expected) != 0) {
13374       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13375       return -1;
13376     }
13377     free (r);
13378   }
13379   return 0;
13380 }
13381
13382 static int test_file_2_skip (void)
13383 {
13384   const char *str;
13385
13386   str = getenv ("TEST_ONLY");
13387   if (str)
13388     return strstr (str, "file") == NULL;
13389   str = getenv ("SKIP_TEST_FILE_2");
13390   if (str && strcmp (str, "1") == 0) return 1;
13391   str = getenv ("SKIP_TEST_FILE");
13392   if (str && strcmp (str, "1") == 0) return 1;
13393   return 0;
13394 }
13395
13396 static int test_file_2 (void)
13397 {
13398   if (test_file_2_skip ()) {
13399     printf ("        %s skipped (reason: environment variable set)\n", "test_file_2");
13400     return 0;
13401   }
13402
13403   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
13404   {
13405     char device[] = "/dev/sda";
13406     int r;
13407     suppress_error = 0;
13408     r = guestfs_blockdev_setrw (g, device);
13409     if (r == -1)
13410       return -1;
13411   }
13412   {
13413     int r;
13414     suppress_error = 0;
13415     r = guestfs_umount_all (g);
13416     if (r == -1)
13417       return -1;
13418   }
13419   {
13420     int r;
13421     suppress_error = 0;
13422     r = guestfs_lvm_remove_all (g);
13423     if (r == -1)
13424       return -1;
13425   }
13426   {
13427     char device[] = "/dev/sda";
13428     char lines_0[] = ",";
13429     char *lines[] = {
13430       lines_0,
13431       NULL
13432     };
13433     int r;
13434     suppress_error = 0;
13435     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13436     if (r == -1)
13437       return -1;
13438   }
13439   {
13440     char fstype[] = "ext2";
13441     char device[] = "/dev/sda1";
13442     int r;
13443     suppress_error = 0;
13444     r = guestfs_mkfs (g, fstype, device);
13445     if (r == -1)
13446       return -1;
13447   }
13448   {
13449     char device[] = "/dev/sda1";
13450     char mountpoint[] = "/";
13451     int r;
13452     suppress_error = 0;
13453     r = guestfs_mount (g, device, mountpoint);
13454     if (r == -1)
13455       return -1;
13456   }
13457   /* TestLastFail for file (2) */
13458   {
13459     char path[] = "/nofile";
13460     char *r;
13461     suppress_error = 1;
13462     r = guestfs_file (g, path);
13463     if (r != NULL)
13464       return -1;
13465     free (r);
13466   }
13467   return 0;
13468 }
13469
13470 static int test_umount_all_0_skip (void)
13471 {
13472   const char *str;
13473
13474   str = getenv ("TEST_ONLY");
13475   if (str)
13476     return strstr (str, "umount_all") == NULL;
13477   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
13478   if (str && strcmp (str, "1") == 0) return 1;
13479   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13480   if (str && strcmp (str, "1") == 0) return 1;
13481   return 0;
13482 }
13483
13484 static int test_umount_all_0 (void)
13485 {
13486   if (test_umount_all_0_skip ()) {
13487     printf ("        %s skipped (reason: environment variable set)\n", "test_umount_all_0");
13488     return 0;
13489   }
13490
13491   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
13492   {
13493     char device[] = "/dev/sda";
13494     int r;
13495     suppress_error = 0;
13496     r = guestfs_blockdev_setrw (g, device);
13497     if (r == -1)
13498       return -1;
13499   }
13500   {
13501     int r;
13502     suppress_error = 0;
13503     r = guestfs_umount_all (g);
13504     if (r == -1)
13505       return -1;
13506   }
13507   {
13508     int r;
13509     suppress_error = 0;
13510     r = guestfs_lvm_remove_all (g);
13511     if (r == -1)
13512       return -1;
13513   }
13514   {
13515     char device[] = "/dev/sda";
13516     char lines_0[] = ",";
13517     char *lines[] = {
13518       lines_0,
13519       NULL
13520     };
13521     int r;
13522     suppress_error = 0;
13523     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13524     if (r == -1)
13525       return -1;
13526   }
13527   {
13528     char fstype[] = "ext2";
13529     char device[] = "/dev/sda1";
13530     int r;
13531     suppress_error = 0;
13532     r = guestfs_mkfs (g, fstype, device);
13533     if (r == -1)
13534       return -1;
13535   }
13536   {
13537     char device[] = "/dev/sda1";
13538     char mountpoint[] = "/";
13539     int r;
13540     suppress_error = 0;
13541     r = guestfs_mount (g, device, mountpoint);
13542     if (r == -1)
13543       return -1;
13544   }
13545   /* TestOutputList for umount_all (0) */
13546   {
13547     int r;
13548     suppress_error = 0;
13549     r = guestfs_umount_all (g);
13550     if (r == -1)
13551       return -1;
13552   }
13553   {
13554     char **r;
13555     int i;
13556     suppress_error = 0;
13557     r = guestfs_mounts (g);
13558     if (r == NULL)
13559       return -1;
13560     if (r[0] != NULL) {
13561       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
13562       print_strings (r);
13563       return -1;
13564     }
13565     for (i = 0; r[i] != NULL; ++i)
13566       free (r[i]);
13567     free (r);
13568   }
13569   return 0;
13570 }
13571
13572 static int test_umount_all_1_skip (void)
13573 {
13574   const char *str;
13575
13576   str = getenv ("TEST_ONLY");
13577   if (str)
13578     return strstr (str, "umount_all") == NULL;
13579   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
13580   if (str && strcmp (str, "1") == 0) return 1;
13581   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13582   if (str && strcmp (str, "1") == 0) return 1;
13583   return 0;
13584 }
13585
13586 static int test_umount_all_1 (void)
13587 {
13588   if (test_umount_all_1_skip ()) {
13589     printf ("        %s skipped (reason: environment variable set)\n", "test_umount_all_1");
13590     return 0;
13591   }
13592
13593   /* InitNone|InitEmpty for test_umount_all_1 */
13594   {
13595     char device[] = "/dev/sda";
13596     int r;
13597     suppress_error = 0;
13598     r = guestfs_blockdev_setrw (g, device);
13599     if (r == -1)
13600       return -1;
13601   }
13602   {
13603     int r;
13604     suppress_error = 0;
13605     r = guestfs_umount_all (g);
13606     if (r == -1)
13607       return -1;
13608   }
13609   {
13610     int r;
13611     suppress_error = 0;
13612     r = guestfs_lvm_remove_all (g);
13613     if (r == -1)
13614       return -1;
13615   }
13616   /* TestOutputList for umount_all (1) */
13617   {
13618     char device[] = "/dev/sda";
13619     char lines_0[] = ",200";
13620     char lines_1[] = ",400";
13621     char lines_2[] = ",";
13622     char *lines[] = {
13623       lines_0,
13624       lines_1,
13625       lines_2,
13626       NULL
13627     };
13628     int r;
13629     suppress_error = 0;
13630     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13631     if (r == -1)
13632       return -1;
13633   }
13634   {
13635     char fstype[] = "ext2";
13636     char device[] = "/dev/sda1";
13637     int r;
13638     suppress_error = 0;
13639     r = guestfs_mkfs (g, fstype, device);
13640     if (r == -1)
13641       return -1;
13642   }
13643   {
13644     char fstype[] = "ext2";
13645     char device[] = "/dev/sda2";
13646     int r;
13647     suppress_error = 0;
13648     r = guestfs_mkfs (g, fstype, device);
13649     if (r == -1)
13650       return -1;
13651   }
13652   {
13653     char fstype[] = "ext2";
13654     char device[] = "/dev/sda3";
13655     int r;
13656     suppress_error = 0;
13657     r = guestfs_mkfs (g, fstype, device);
13658     if (r == -1)
13659       return -1;
13660   }
13661   {
13662     char device[] = "/dev/sda1";
13663     char mountpoint[] = "/";
13664     int r;
13665     suppress_error = 0;
13666     r = guestfs_mount (g, device, mountpoint);
13667     if (r == -1)
13668       return -1;
13669   }
13670   {
13671     char path[] = "/mp1";
13672     int r;
13673     suppress_error = 0;
13674     r = guestfs_mkdir (g, path);
13675     if (r == -1)
13676       return -1;
13677   }
13678   {
13679     char device[] = "/dev/sda2";
13680     char mountpoint[] = "/mp1";
13681     int r;
13682     suppress_error = 0;
13683     r = guestfs_mount (g, device, mountpoint);
13684     if (r == -1)
13685       return -1;
13686   }
13687   {
13688     char path[] = "/mp1/mp2";
13689     int r;
13690     suppress_error = 0;
13691     r = guestfs_mkdir (g, path);
13692     if (r == -1)
13693       return -1;
13694   }
13695   {
13696     char device[] = "/dev/sda3";
13697     char mountpoint[] = "/mp1/mp2";
13698     int r;
13699     suppress_error = 0;
13700     r = guestfs_mount (g, device, mountpoint);
13701     if (r == -1)
13702       return -1;
13703   }
13704   {
13705     char path[] = "/mp1/mp2/mp3";
13706     int r;
13707     suppress_error = 0;
13708     r = guestfs_mkdir (g, path);
13709     if (r == -1)
13710       return -1;
13711   }
13712   {
13713     int r;
13714     suppress_error = 0;
13715     r = guestfs_umount_all (g);
13716     if (r == -1)
13717       return -1;
13718   }
13719   {
13720     char **r;
13721     int i;
13722     suppress_error = 0;
13723     r = guestfs_mounts (g);
13724     if (r == NULL)
13725       return -1;
13726     if (r[0] != NULL) {
13727       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13728       print_strings (r);
13729       return -1;
13730     }
13731     for (i = 0; r[i] != NULL; ++i)
13732       free (r[i]);
13733     free (r);
13734   }
13735   return 0;
13736 }
13737
13738 static int test_mounts_0_skip (void)
13739 {
13740   const char *str;
13741
13742   str = getenv ("TEST_ONLY");
13743   if (str)
13744     return strstr (str, "mounts") == NULL;
13745   str = getenv ("SKIP_TEST_MOUNTS_0");
13746   if (str && strcmp (str, "1") == 0) return 1;
13747   str = getenv ("SKIP_TEST_MOUNTS");
13748   if (str && strcmp (str, "1") == 0) return 1;
13749   return 0;
13750 }
13751
13752 static int test_mounts_0 (void)
13753 {
13754   if (test_mounts_0_skip ()) {
13755     printf ("        %s skipped (reason: environment variable set)\n", "test_mounts_0");
13756     return 0;
13757   }
13758
13759   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13760   {
13761     char device[] = "/dev/sda";
13762     int r;
13763     suppress_error = 0;
13764     r = guestfs_blockdev_setrw (g, device);
13765     if (r == -1)
13766       return -1;
13767   }
13768   {
13769     int r;
13770     suppress_error = 0;
13771     r = guestfs_umount_all (g);
13772     if (r == -1)
13773       return -1;
13774   }
13775   {
13776     int r;
13777     suppress_error = 0;
13778     r = guestfs_lvm_remove_all (g);
13779     if (r == -1)
13780       return -1;
13781   }
13782   {
13783     char device[] = "/dev/sda";
13784     char lines_0[] = ",";
13785     char *lines[] = {
13786       lines_0,
13787       NULL
13788     };
13789     int r;
13790     suppress_error = 0;
13791     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13792     if (r == -1)
13793       return -1;
13794   }
13795   {
13796     char fstype[] = "ext2";
13797     char device[] = "/dev/sda1";
13798     int r;
13799     suppress_error = 0;
13800     r = guestfs_mkfs (g, fstype, device);
13801     if (r == -1)
13802       return -1;
13803   }
13804   {
13805     char device[] = "/dev/sda1";
13806     char mountpoint[] = "/";
13807     int r;
13808     suppress_error = 0;
13809     r = guestfs_mount (g, device, mountpoint);
13810     if (r == -1)
13811       return -1;
13812   }
13813   /* TestOutputListOfDevices for mounts (0) */
13814   {
13815     char **r;
13816     int i;
13817     suppress_error = 0;
13818     r = guestfs_mounts (g);
13819     if (r == NULL)
13820       return -1;
13821     if (!r[0]) {
13822       fprintf (stderr, "test_mounts_0: short list returned from command\n");
13823       print_strings (r);
13824       return -1;
13825     }
13826     {
13827       char expected[] = "/dev/sda1";
13828       r[0][5] = 's';
13829       if (strcmp (r[0], expected) != 0) {
13830         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13831         return -1;
13832       }
13833     }
13834     if (r[1] != NULL) {
13835       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13836       print_strings (r);
13837       return -1;
13838     }
13839     for (i = 0; r[i] != NULL; ++i)
13840       free (r[i]);
13841     free (r);
13842   }
13843   return 0;
13844 }
13845
13846 static int test_umount_0_skip (void)
13847 {
13848   const char *str;
13849
13850   str = getenv ("TEST_ONLY");
13851   if (str)
13852     return strstr (str, "umount") == NULL;
13853   str = getenv ("SKIP_TEST_UMOUNT_0");
13854   if (str && strcmp (str, "1") == 0) return 1;
13855   str = getenv ("SKIP_TEST_UMOUNT");
13856   if (str && strcmp (str, "1") == 0) return 1;
13857   return 0;
13858 }
13859
13860 static int test_umount_0 (void)
13861 {
13862   if (test_umount_0_skip ()) {
13863     printf ("        %s skipped (reason: environment variable set)\n", "test_umount_0");
13864     return 0;
13865   }
13866
13867   /* InitNone|InitEmpty for test_umount_0 */
13868   {
13869     char device[] = "/dev/sda";
13870     int r;
13871     suppress_error = 0;
13872     r = guestfs_blockdev_setrw (g, device);
13873     if (r == -1)
13874       return -1;
13875   }
13876   {
13877     int r;
13878     suppress_error = 0;
13879     r = guestfs_umount_all (g);
13880     if (r == -1)
13881       return -1;
13882   }
13883   {
13884     int r;
13885     suppress_error = 0;
13886     r = guestfs_lvm_remove_all (g);
13887     if (r == -1)
13888       return -1;
13889   }
13890   /* TestOutputListOfDevices for umount (0) */
13891   {
13892     char device[] = "/dev/sda";
13893     char lines_0[] = ",";
13894     char *lines[] = {
13895       lines_0,
13896       NULL
13897     };
13898     int r;
13899     suppress_error = 0;
13900     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13901     if (r == -1)
13902       return -1;
13903   }
13904   {
13905     char fstype[] = "ext2";
13906     char device[] = "/dev/sda1";
13907     int r;
13908     suppress_error = 0;
13909     r = guestfs_mkfs (g, fstype, device);
13910     if (r == -1)
13911       return -1;
13912   }
13913   {
13914     char device[] = "/dev/sda1";
13915     char mountpoint[] = "/";
13916     int r;
13917     suppress_error = 0;
13918     r = guestfs_mount (g, device, mountpoint);
13919     if (r == -1)
13920       return -1;
13921   }
13922   {
13923     char **r;
13924     int i;
13925     suppress_error = 0;
13926     r = guestfs_mounts (g);
13927     if (r == NULL)
13928       return -1;
13929     if (!r[0]) {
13930       fprintf (stderr, "test_umount_0: short list returned from command\n");
13931       print_strings (r);
13932       return -1;
13933     }
13934     {
13935       char expected[] = "/dev/sda1";
13936       r[0][5] = 's';
13937       if (strcmp (r[0], expected) != 0) {
13938         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13939         return -1;
13940       }
13941     }
13942     if (r[1] != NULL) {
13943       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13944       print_strings (r);
13945       return -1;
13946     }
13947     for (i = 0; r[i] != NULL; ++i)
13948       free (r[i]);
13949     free (r);
13950   }
13951   return 0;
13952 }
13953
13954 static int test_umount_1_skip (void)
13955 {
13956   const char *str;
13957
13958   str = getenv ("TEST_ONLY");
13959   if (str)
13960     return strstr (str, "umount") == NULL;
13961   str = getenv ("SKIP_TEST_UMOUNT_1");
13962   if (str && strcmp (str, "1") == 0) return 1;
13963   str = getenv ("SKIP_TEST_UMOUNT");
13964   if (str && strcmp (str, "1") == 0) return 1;
13965   return 0;
13966 }
13967
13968 static int test_umount_1 (void)
13969 {
13970   if (test_umount_1_skip ()) {
13971     printf ("        %s skipped (reason: environment variable set)\n", "test_umount_1");
13972     return 0;
13973   }
13974
13975   /* InitNone|InitEmpty for test_umount_1 */
13976   {
13977     char device[] = "/dev/sda";
13978     int r;
13979     suppress_error = 0;
13980     r = guestfs_blockdev_setrw (g, device);
13981     if (r == -1)
13982       return -1;
13983   }
13984   {
13985     int r;
13986     suppress_error = 0;
13987     r = guestfs_umount_all (g);
13988     if (r == -1)
13989       return -1;
13990   }
13991   {
13992     int r;
13993     suppress_error = 0;
13994     r = guestfs_lvm_remove_all (g);
13995     if (r == -1)
13996       return -1;
13997   }
13998   /* TestOutputList for umount (1) */
13999   {
14000     char device[] = "/dev/sda";
14001     char lines_0[] = ",";
14002     char *lines[] = {
14003       lines_0,
14004       NULL
14005     };
14006     int r;
14007     suppress_error = 0;
14008     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14009     if (r == -1)
14010       return -1;
14011   }
14012   {
14013     char fstype[] = "ext2";
14014     char device[] = "/dev/sda1";
14015     int r;
14016     suppress_error = 0;
14017     r = guestfs_mkfs (g, fstype, device);
14018     if (r == -1)
14019       return -1;
14020   }
14021   {
14022     char device[] = "/dev/sda1";
14023     char mountpoint[] = "/";
14024     int r;
14025     suppress_error = 0;
14026     r = guestfs_mount (g, device, mountpoint);
14027     if (r == -1)
14028       return -1;
14029   }
14030   {
14031     char pathordevice[] = "/";
14032     int r;
14033     suppress_error = 0;
14034     r = guestfs_umount (g, pathordevice);
14035     if (r == -1)
14036       return -1;
14037   }
14038   {
14039     char **r;
14040     int i;
14041     suppress_error = 0;
14042     r = guestfs_mounts (g);
14043     if (r == NULL)
14044       return -1;
14045     if (r[0] != NULL) {
14046       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
14047       print_strings (r);
14048       return -1;
14049     }
14050     for (i = 0; r[i] != NULL; ++i)
14051       free (r[i]);
14052     free (r);
14053   }
14054   return 0;
14055 }
14056
14057 static int test_write_file_0_skip (void)
14058 {
14059   const char *str;
14060
14061   str = getenv ("TEST_ONLY");
14062   if (str)
14063     return strstr (str, "write_file") == NULL;
14064   str = getenv ("SKIP_TEST_WRITE_FILE_0");
14065   if (str && strcmp (str, "1") == 0) return 1;
14066   str = getenv ("SKIP_TEST_WRITE_FILE");
14067   if (str && strcmp (str, "1") == 0) return 1;
14068   return 0;
14069 }
14070
14071 static int test_write_file_0 (void)
14072 {
14073   if (test_write_file_0_skip ()) {
14074     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_0");
14075     return 0;
14076   }
14077
14078   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
14079   {
14080     char device[] = "/dev/sda";
14081     int r;
14082     suppress_error = 0;
14083     r = guestfs_blockdev_setrw (g, device);
14084     if (r == -1)
14085       return -1;
14086   }
14087   {
14088     int r;
14089     suppress_error = 0;
14090     r = guestfs_umount_all (g);
14091     if (r == -1)
14092       return -1;
14093   }
14094   {
14095     int r;
14096     suppress_error = 0;
14097     r = guestfs_lvm_remove_all (g);
14098     if (r == -1)
14099       return -1;
14100   }
14101   {
14102     char device[] = "/dev/sda";
14103     char lines_0[] = ",";
14104     char *lines[] = {
14105       lines_0,
14106       NULL
14107     };
14108     int r;
14109     suppress_error = 0;
14110     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14111     if (r == -1)
14112       return -1;
14113   }
14114   {
14115     char fstype[] = "ext2";
14116     char device[] = "/dev/sda1";
14117     int r;
14118     suppress_error = 0;
14119     r = guestfs_mkfs (g, fstype, device);
14120     if (r == -1)
14121       return -1;
14122   }
14123   {
14124     char device[] = "/dev/sda1";
14125     char mountpoint[] = "/";
14126     int r;
14127     suppress_error = 0;
14128     r = guestfs_mount (g, device, mountpoint);
14129     if (r == -1)
14130       return -1;
14131   }
14132   /* TestOutput for write_file (0) */
14133   char expected[] = "new file contents";
14134   {
14135     char path[] = "/new";
14136     char content[] = "new file contents";
14137     int r;
14138     suppress_error = 0;
14139     r = guestfs_write_file (g, path, content, 0);
14140     if (r == -1)
14141       return -1;
14142   }
14143   {
14144     char path[] = "/new";
14145     char *r;
14146     suppress_error = 0;
14147     r = guestfs_cat (g, path);
14148     if (r == NULL)
14149       return -1;
14150     if (strcmp (r, expected) != 0) {
14151       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
14152       return -1;
14153     }
14154     free (r);
14155   }
14156   return 0;
14157 }
14158
14159 static int test_write_file_1_skip (void)
14160 {
14161   const char *str;
14162
14163   str = getenv ("TEST_ONLY");
14164   if (str)
14165     return strstr (str, "write_file") == NULL;
14166   str = getenv ("SKIP_TEST_WRITE_FILE_1");
14167   if (str && strcmp (str, "1") == 0) return 1;
14168   str = getenv ("SKIP_TEST_WRITE_FILE");
14169   if (str && strcmp (str, "1") == 0) return 1;
14170   return 0;
14171 }
14172
14173 static int test_write_file_1 (void)
14174 {
14175   if (test_write_file_1_skip ()) {
14176     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_1");
14177     return 0;
14178   }
14179
14180   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
14181   {
14182     char device[] = "/dev/sda";
14183     int r;
14184     suppress_error = 0;
14185     r = guestfs_blockdev_setrw (g, device);
14186     if (r == -1)
14187       return -1;
14188   }
14189   {
14190     int r;
14191     suppress_error = 0;
14192     r = guestfs_umount_all (g);
14193     if (r == -1)
14194       return -1;
14195   }
14196   {
14197     int r;
14198     suppress_error = 0;
14199     r = guestfs_lvm_remove_all (g);
14200     if (r == -1)
14201       return -1;
14202   }
14203   {
14204     char device[] = "/dev/sda";
14205     char lines_0[] = ",";
14206     char *lines[] = {
14207       lines_0,
14208       NULL
14209     };
14210     int r;
14211     suppress_error = 0;
14212     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14213     if (r == -1)
14214       return -1;
14215   }
14216   {
14217     char fstype[] = "ext2";
14218     char device[] = "/dev/sda1";
14219     int r;
14220     suppress_error = 0;
14221     r = guestfs_mkfs (g, fstype, device);
14222     if (r == -1)
14223       return -1;
14224   }
14225   {
14226     char device[] = "/dev/sda1";
14227     char mountpoint[] = "/";
14228     int r;
14229     suppress_error = 0;
14230     r = guestfs_mount (g, device, mountpoint);
14231     if (r == -1)
14232       return -1;
14233   }
14234   /* TestOutput for write_file (1) */
14235   char expected[] = "\nnew file contents\n";
14236   {
14237     char path[] = "/new";
14238     char content[] = "\nnew file contents\n";
14239     int r;
14240     suppress_error = 0;
14241     r = guestfs_write_file (g, path, content, 0);
14242     if (r == -1)
14243       return -1;
14244   }
14245   {
14246     char path[] = "/new";
14247     char *r;
14248     suppress_error = 0;
14249     r = guestfs_cat (g, path);
14250     if (r == NULL)
14251       return -1;
14252     if (strcmp (r, expected) != 0) {
14253       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
14254       return -1;
14255     }
14256     free (r);
14257   }
14258   return 0;
14259 }
14260
14261 static int test_write_file_2_skip (void)
14262 {
14263   const char *str;
14264
14265   str = getenv ("TEST_ONLY");
14266   if (str)
14267     return strstr (str, "write_file") == NULL;
14268   str = getenv ("SKIP_TEST_WRITE_FILE_2");
14269   if (str && strcmp (str, "1") == 0) return 1;
14270   str = getenv ("SKIP_TEST_WRITE_FILE");
14271   if (str && strcmp (str, "1") == 0) return 1;
14272   return 0;
14273 }
14274
14275 static int test_write_file_2 (void)
14276 {
14277   if (test_write_file_2_skip ()) {
14278     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_2");
14279     return 0;
14280   }
14281
14282   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
14283   {
14284     char device[] = "/dev/sda";
14285     int r;
14286     suppress_error = 0;
14287     r = guestfs_blockdev_setrw (g, device);
14288     if (r == -1)
14289       return -1;
14290   }
14291   {
14292     int r;
14293     suppress_error = 0;
14294     r = guestfs_umount_all (g);
14295     if (r == -1)
14296       return -1;
14297   }
14298   {
14299     int r;
14300     suppress_error = 0;
14301     r = guestfs_lvm_remove_all (g);
14302     if (r == -1)
14303       return -1;
14304   }
14305   {
14306     char device[] = "/dev/sda";
14307     char lines_0[] = ",";
14308     char *lines[] = {
14309       lines_0,
14310       NULL
14311     };
14312     int r;
14313     suppress_error = 0;
14314     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14315     if (r == -1)
14316       return -1;
14317   }
14318   {
14319     char fstype[] = "ext2";
14320     char device[] = "/dev/sda1";
14321     int r;
14322     suppress_error = 0;
14323     r = guestfs_mkfs (g, fstype, device);
14324     if (r == -1)
14325       return -1;
14326   }
14327   {
14328     char device[] = "/dev/sda1";
14329     char mountpoint[] = "/";
14330     int r;
14331     suppress_error = 0;
14332     r = guestfs_mount (g, device, mountpoint);
14333     if (r == -1)
14334       return -1;
14335   }
14336   /* TestOutput for write_file (2) */
14337   char expected[] = "\n\n";
14338   {
14339     char path[] = "/new";
14340     char content[] = "\n\n";
14341     int r;
14342     suppress_error = 0;
14343     r = guestfs_write_file (g, path, content, 0);
14344     if (r == -1)
14345       return -1;
14346   }
14347   {
14348     char path[] = "/new";
14349     char *r;
14350     suppress_error = 0;
14351     r = guestfs_cat (g, path);
14352     if (r == NULL)
14353       return -1;
14354     if (strcmp (r, expected) != 0) {
14355       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
14356       return -1;
14357     }
14358     free (r);
14359   }
14360   return 0;
14361 }
14362
14363 static int test_write_file_3_skip (void)
14364 {
14365   const char *str;
14366
14367   str = getenv ("TEST_ONLY");
14368   if (str)
14369     return strstr (str, "write_file") == NULL;
14370   str = getenv ("SKIP_TEST_WRITE_FILE_3");
14371   if (str && strcmp (str, "1") == 0) return 1;
14372   str = getenv ("SKIP_TEST_WRITE_FILE");
14373   if (str && strcmp (str, "1") == 0) return 1;
14374   return 0;
14375 }
14376
14377 static int test_write_file_3 (void)
14378 {
14379   if (test_write_file_3_skip ()) {
14380     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_3");
14381     return 0;
14382   }
14383
14384   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
14385   {
14386     char device[] = "/dev/sda";
14387     int r;
14388     suppress_error = 0;
14389     r = guestfs_blockdev_setrw (g, device);
14390     if (r == -1)
14391       return -1;
14392   }
14393   {
14394     int r;
14395     suppress_error = 0;
14396     r = guestfs_umount_all (g);
14397     if (r == -1)
14398       return -1;
14399   }
14400   {
14401     int r;
14402     suppress_error = 0;
14403     r = guestfs_lvm_remove_all (g);
14404     if (r == -1)
14405       return -1;
14406   }
14407   {
14408     char device[] = "/dev/sda";
14409     char lines_0[] = ",";
14410     char *lines[] = {
14411       lines_0,
14412       NULL
14413     };
14414     int r;
14415     suppress_error = 0;
14416     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14417     if (r == -1)
14418       return -1;
14419   }
14420   {
14421     char fstype[] = "ext2";
14422     char device[] = "/dev/sda1";
14423     int r;
14424     suppress_error = 0;
14425     r = guestfs_mkfs (g, fstype, device);
14426     if (r == -1)
14427       return -1;
14428   }
14429   {
14430     char device[] = "/dev/sda1";
14431     char mountpoint[] = "/";
14432     int r;
14433     suppress_error = 0;
14434     r = guestfs_mount (g, device, mountpoint);
14435     if (r == -1)
14436       return -1;
14437   }
14438   /* TestOutput for write_file (3) */
14439   char expected[] = "";
14440   {
14441     char path[] = "/new";
14442     char content[] = "";
14443     int r;
14444     suppress_error = 0;
14445     r = guestfs_write_file (g, path, content, 0);
14446     if (r == -1)
14447       return -1;
14448   }
14449   {
14450     char path[] = "/new";
14451     char *r;
14452     suppress_error = 0;
14453     r = guestfs_cat (g, path);
14454     if (r == NULL)
14455       return -1;
14456     if (strcmp (r, expected) != 0) {
14457       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
14458       return -1;
14459     }
14460     free (r);
14461   }
14462   return 0;
14463 }
14464
14465 static int test_write_file_4_skip (void)
14466 {
14467   const char *str;
14468
14469   str = getenv ("TEST_ONLY");
14470   if (str)
14471     return strstr (str, "write_file") == NULL;
14472   str = getenv ("SKIP_TEST_WRITE_FILE_4");
14473   if (str && strcmp (str, "1") == 0) return 1;
14474   str = getenv ("SKIP_TEST_WRITE_FILE");
14475   if (str && strcmp (str, "1") == 0) return 1;
14476   return 0;
14477 }
14478
14479 static int test_write_file_4 (void)
14480 {
14481   if (test_write_file_4_skip ()) {
14482     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_4");
14483     return 0;
14484   }
14485
14486   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
14487   {
14488     char device[] = "/dev/sda";
14489     int r;
14490     suppress_error = 0;
14491     r = guestfs_blockdev_setrw (g, device);
14492     if (r == -1)
14493       return -1;
14494   }
14495   {
14496     int r;
14497     suppress_error = 0;
14498     r = guestfs_umount_all (g);
14499     if (r == -1)
14500       return -1;
14501   }
14502   {
14503     int r;
14504     suppress_error = 0;
14505     r = guestfs_lvm_remove_all (g);
14506     if (r == -1)
14507       return -1;
14508   }
14509   {
14510     char device[] = "/dev/sda";
14511     char lines_0[] = ",";
14512     char *lines[] = {
14513       lines_0,
14514       NULL
14515     };
14516     int r;
14517     suppress_error = 0;
14518     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14519     if (r == -1)
14520       return -1;
14521   }
14522   {
14523     char fstype[] = "ext2";
14524     char device[] = "/dev/sda1";
14525     int r;
14526     suppress_error = 0;
14527     r = guestfs_mkfs (g, fstype, device);
14528     if (r == -1)
14529       return -1;
14530   }
14531   {
14532     char device[] = "/dev/sda1";
14533     char mountpoint[] = "/";
14534     int r;
14535     suppress_error = 0;
14536     r = guestfs_mount (g, device, mountpoint);
14537     if (r == -1)
14538       return -1;
14539   }
14540   /* TestOutput for write_file (4) */
14541   char expected[] = "\n\n\n";
14542   {
14543     char path[] = "/new";
14544     char content[] = "\n\n\n";
14545     int r;
14546     suppress_error = 0;
14547     r = guestfs_write_file (g, path, content, 0);
14548     if (r == -1)
14549       return -1;
14550   }
14551   {
14552     char path[] = "/new";
14553     char *r;
14554     suppress_error = 0;
14555     r = guestfs_cat (g, path);
14556     if (r == NULL)
14557       return -1;
14558     if (strcmp (r, expected) != 0) {
14559       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
14560       return -1;
14561     }
14562     free (r);
14563   }
14564   return 0;
14565 }
14566
14567 static int test_write_file_5_skip (void)
14568 {
14569   const char *str;
14570
14571   str = getenv ("TEST_ONLY");
14572   if (str)
14573     return strstr (str, "write_file") == NULL;
14574   str = getenv ("SKIP_TEST_WRITE_FILE_5");
14575   if (str && strcmp (str, "1") == 0) return 1;
14576   str = getenv ("SKIP_TEST_WRITE_FILE");
14577   if (str && strcmp (str, "1") == 0) return 1;
14578   return 0;
14579 }
14580
14581 static int test_write_file_5 (void)
14582 {
14583   if (test_write_file_5_skip ()) {
14584     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_5");
14585     return 0;
14586   }
14587
14588   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
14589   {
14590     char device[] = "/dev/sda";
14591     int r;
14592     suppress_error = 0;
14593     r = guestfs_blockdev_setrw (g, device);
14594     if (r == -1)
14595       return -1;
14596   }
14597   {
14598     int r;
14599     suppress_error = 0;
14600     r = guestfs_umount_all (g);
14601     if (r == -1)
14602       return -1;
14603   }
14604   {
14605     int r;
14606     suppress_error = 0;
14607     r = guestfs_lvm_remove_all (g);
14608     if (r == -1)
14609       return -1;
14610   }
14611   {
14612     char device[] = "/dev/sda";
14613     char lines_0[] = ",";
14614     char *lines[] = {
14615       lines_0,
14616       NULL
14617     };
14618     int r;
14619     suppress_error = 0;
14620     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14621     if (r == -1)
14622       return -1;
14623   }
14624   {
14625     char fstype[] = "ext2";
14626     char device[] = "/dev/sda1";
14627     int r;
14628     suppress_error = 0;
14629     r = guestfs_mkfs (g, fstype, device);
14630     if (r == -1)
14631       return -1;
14632   }
14633   {
14634     char device[] = "/dev/sda1";
14635     char mountpoint[] = "/";
14636     int r;
14637     suppress_error = 0;
14638     r = guestfs_mount (g, device, mountpoint);
14639     if (r == -1)
14640       return -1;
14641   }
14642   /* TestOutput for write_file (5) */
14643   char expected[] = "\n";
14644   {
14645     char path[] = "/new";
14646     char content[] = "\n";
14647     int r;
14648     suppress_error = 0;
14649     r = guestfs_write_file (g, path, content, 0);
14650     if (r == -1)
14651       return -1;
14652   }
14653   {
14654     char path[] = "/new";
14655     char *r;
14656     suppress_error = 0;
14657     r = guestfs_cat (g, path);
14658     if (r == NULL)
14659       return -1;
14660     if (strcmp (r, expected) != 0) {
14661       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14662       return -1;
14663     }
14664     free (r);
14665   }
14666   return 0;
14667 }
14668
14669 static int test_mkfs_0_skip (void)
14670 {
14671   const char *str;
14672
14673   str = getenv ("TEST_ONLY");
14674   if (str)
14675     return strstr (str, "mkfs") == NULL;
14676   str = getenv ("SKIP_TEST_MKFS_0");
14677   if (str && strcmp (str, "1") == 0) return 1;
14678   str = getenv ("SKIP_TEST_MKFS");
14679   if (str && strcmp (str, "1") == 0) return 1;
14680   return 0;
14681 }
14682
14683 static int test_mkfs_0 (void)
14684 {
14685   if (test_mkfs_0_skip ()) {
14686     printf ("        %s skipped (reason: environment variable set)\n", "test_mkfs_0");
14687     return 0;
14688   }
14689
14690   /* InitNone|InitEmpty for test_mkfs_0 */
14691   {
14692     char device[] = "/dev/sda";
14693     int r;
14694     suppress_error = 0;
14695     r = guestfs_blockdev_setrw (g, device);
14696     if (r == -1)
14697       return -1;
14698   }
14699   {
14700     int r;
14701     suppress_error = 0;
14702     r = guestfs_umount_all (g);
14703     if (r == -1)
14704       return -1;
14705   }
14706   {
14707     int r;
14708     suppress_error = 0;
14709     r = guestfs_lvm_remove_all (g);
14710     if (r == -1)
14711       return -1;
14712   }
14713   /* TestOutput for mkfs (0) */
14714   char expected[] = "new file contents";
14715   {
14716     char device[] = "/dev/sda";
14717     char lines_0[] = ",";
14718     char *lines[] = {
14719       lines_0,
14720       NULL
14721     };
14722     int r;
14723     suppress_error = 0;
14724     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14725     if (r == -1)
14726       return -1;
14727   }
14728   {
14729     char fstype[] = "ext2";
14730     char device[] = "/dev/sda1";
14731     int r;
14732     suppress_error = 0;
14733     r = guestfs_mkfs (g, fstype, device);
14734     if (r == -1)
14735       return -1;
14736   }
14737   {
14738     char device[] = "/dev/sda1";
14739     char mountpoint[] = "/";
14740     int r;
14741     suppress_error = 0;
14742     r = guestfs_mount (g, device, mountpoint);
14743     if (r == -1)
14744       return -1;
14745   }
14746   {
14747     char path[] = "/new";
14748     char content[] = "new file contents";
14749     int r;
14750     suppress_error = 0;
14751     r = guestfs_write_file (g, path, content, 0);
14752     if (r == -1)
14753       return -1;
14754   }
14755   {
14756     char path[] = "/new";
14757     char *r;
14758     suppress_error = 0;
14759     r = guestfs_cat (g, path);
14760     if (r == NULL)
14761       return -1;
14762     if (strcmp (r, expected) != 0) {
14763       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14764       return -1;
14765     }
14766     free (r);
14767   }
14768   return 0;
14769 }
14770
14771 static int test_lvcreate_0_skip (void)
14772 {
14773   const char *str;
14774
14775   str = getenv ("TEST_ONLY");
14776   if (str)
14777     return strstr (str, "lvcreate") == NULL;
14778   str = getenv ("SKIP_TEST_LVCREATE_0");
14779   if (str && strcmp (str, "1") == 0) return 1;
14780   str = getenv ("SKIP_TEST_LVCREATE");
14781   if (str && strcmp (str, "1") == 0) return 1;
14782   return 0;
14783 }
14784
14785 static int test_lvcreate_0 (void)
14786 {
14787   if (test_lvcreate_0_skip ()) {
14788     printf ("        %s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14789     return 0;
14790   }
14791
14792   /* InitNone|InitEmpty for test_lvcreate_0 */
14793   {
14794     char device[] = "/dev/sda";
14795     int r;
14796     suppress_error = 0;
14797     r = guestfs_blockdev_setrw (g, device);
14798     if (r == -1)
14799       return -1;
14800   }
14801   {
14802     int r;
14803     suppress_error = 0;
14804     r = guestfs_umount_all (g);
14805     if (r == -1)
14806       return -1;
14807   }
14808   {
14809     int r;
14810     suppress_error = 0;
14811     r = guestfs_lvm_remove_all (g);
14812     if (r == -1)
14813       return -1;
14814   }
14815   /* TestOutputList for lvcreate (0) */
14816   {
14817     char device[] = "/dev/sda";
14818     char lines_0[] = ",200";
14819     char lines_1[] = ",400";
14820     char lines_2[] = ",";
14821     char *lines[] = {
14822       lines_0,
14823       lines_1,
14824       lines_2,
14825       NULL
14826     };
14827     int r;
14828     suppress_error = 0;
14829     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14830     if (r == -1)
14831       return -1;
14832   }
14833   {
14834     char device[] = "/dev/sda1";
14835     int r;
14836     suppress_error = 0;
14837     r = guestfs_pvcreate (g, device);
14838     if (r == -1)
14839       return -1;
14840   }
14841   {
14842     char device[] = "/dev/sda2";
14843     int r;
14844     suppress_error = 0;
14845     r = guestfs_pvcreate (g, device);
14846     if (r == -1)
14847       return -1;
14848   }
14849   {
14850     char device[] = "/dev/sda3";
14851     int r;
14852     suppress_error = 0;
14853     r = guestfs_pvcreate (g, device);
14854     if (r == -1)
14855       return -1;
14856   }
14857   {
14858     char volgroup[] = "VG1";
14859     char physvols_0[] = "/dev/sda1";
14860     char physvols_1[] = "/dev/sda2";
14861     char *physvols[] = {
14862       physvols_0,
14863       physvols_1,
14864       NULL
14865     };
14866     int r;
14867     suppress_error = 0;
14868     r = guestfs_vgcreate (g, volgroup, physvols);
14869     if (r == -1)
14870       return -1;
14871   }
14872   {
14873     char volgroup[] = "VG2";
14874     char physvols_0[] = "/dev/sda3";
14875     char *physvols[] = {
14876       physvols_0,
14877       NULL
14878     };
14879     int r;
14880     suppress_error = 0;
14881     r = guestfs_vgcreate (g, volgroup, physvols);
14882     if (r == -1)
14883       return -1;
14884   }
14885   {
14886     char logvol[] = "LV1";
14887     char volgroup[] = "VG1";
14888     int r;
14889     suppress_error = 0;
14890     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14891     if (r == -1)
14892       return -1;
14893   }
14894   {
14895     char logvol[] = "LV2";
14896     char volgroup[] = "VG1";
14897     int r;
14898     suppress_error = 0;
14899     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14900     if (r == -1)
14901       return -1;
14902   }
14903   {
14904     char logvol[] = "LV3";
14905     char volgroup[] = "VG2";
14906     int r;
14907     suppress_error = 0;
14908     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14909     if (r == -1)
14910       return -1;
14911   }
14912   {
14913     char logvol[] = "LV4";
14914     char volgroup[] = "VG2";
14915     int r;
14916     suppress_error = 0;
14917     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14918     if (r == -1)
14919       return -1;
14920   }
14921   {
14922     char logvol[] = "LV5";
14923     char volgroup[] = "VG2";
14924     int r;
14925     suppress_error = 0;
14926     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14927     if (r == -1)
14928       return -1;
14929   }
14930   {
14931     char **r;
14932     int i;
14933     suppress_error = 0;
14934     r = guestfs_lvs (g);
14935     if (r == NULL)
14936       return -1;
14937     if (!r[0]) {
14938       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14939       print_strings (r);
14940       return -1;
14941     }
14942     {
14943       char expected[] = "/dev/VG1/LV1";
14944       if (strcmp (r[0], expected) != 0) {
14945         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14946         return -1;
14947       }
14948     }
14949     if (!r[1]) {
14950       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14951       print_strings (r);
14952       return -1;
14953     }
14954     {
14955       char expected[] = "/dev/VG1/LV2";
14956       if (strcmp (r[1], expected) != 0) {
14957         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14958         return -1;
14959       }
14960     }
14961     if (!r[2]) {
14962       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14963       print_strings (r);
14964       return -1;
14965     }
14966     {
14967       char expected[] = "/dev/VG2/LV3";
14968       if (strcmp (r[2], expected) != 0) {
14969         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14970         return -1;
14971       }
14972     }
14973     if (!r[3]) {
14974       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14975       print_strings (r);
14976       return -1;
14977     }
14978     {
14979       char expected[] = "/dev/VG2/LV4";
14980       if (strcmp (r[3], expected) != 0) {
14981         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14982         return -1;
14983       }
14984     }
14985     if (!r[4]) {
14986       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14987       print_strings (r);
14988       return -1;
14989     }
14990     {
14991       char expected[] = "/dev/VG2/LV5";
14992       if (strcmp (r[4], expected) != 0) {
14993         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14994         return -1;
14995       }
14996     }
14997     if (r[5] != NULL) {
14998       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14999       print_strings (r);
15000       return -1;
15001     }
15002     for (i = 0; r[i] != NULL; ++i)
15003       free (r[i]);
15004     free (r);
15005   }
15006   return 0;
15007 }
15008
15009 static int test_vgcreate_0_skip (void)
15010 {
15011   const char *str;
15012
15013   str = getenv ("TEST_ONLY");
15014   if (str)
15015     return strstr (str, "vgcreate") == NULL;
15016   str = getenv ("SKIP_TEST_VGCREATE_0");
15017   if (str && strcmp (str, "1") == 0) return 1;
15018   str = getenv ("SKIP_TEST_VGCREATE");
15019   if (str && strcmp (str, "1") == 0) return 1;
15020   return 0;
15021 }
15022
15023 static int test_vgcreate_0 (void)
15024 {
15025   if (test_vgcreate_0_skip ()) {
15026     printf ("        %s skipped (reason: environment variable set)\n", "test_vgcreate_0");
15027     return 0;
15028   }
15029
15030   /* InitNone|InitEmpty for test_vgcreate_0 */
15031   {
15032     char device[] = "/dev/sda";
15033     int r;
15034     suppress_error = 0;
15035     r = guestfs_blockdev_setrw (g, device);
15036     if (r == -1)
15037       return -1;
15038   }
15039   {
15040     int r;
15041     suppress_error = 0;
15042     r = guestfs_umount_all (g);
15043     if (r == -1)
15044       return -1;
15045   }
15046   {
15047     int r;
15048     suppress_error = 0;
15049     r = guestfs_lvm_remove_all (g);
15050     if (r == -1)
15051       return -1;
15052   }
15053   /* TestOutputList for vgcreate (0) */
15054   {
15055     char device[] = "/dev/sda";
15056     char lines_0[] = ",200";
15057     char lines_1[] = ",400";
15058     char lines_2[] = ",";
15059     char *lines[] = {
15060       lines_0,
15061       lines_1,
15062       lines_2,
15063       NULL
15064     };
15065     int r;
15066     suppress_error = 0;
15067     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15068     if (r == -1)
15069       return -1;
15070   }
15071   {
15072     char device[] = "/dev/sda1";
15073     int r;
15074     suppress_error = 0;
15075     r = guestfs_pvcreate (g, device);
15076     if (r == -1)
15077       return -1;
15078   }
15079   {
15080     char device[] = "/dev/sda2";
15081     int r;
15082     suppress_error = 0;
15083     r = guestfs_pvcreate (g, device);
15084     if (r == -1)
15085       return -1;
15086   }
15087   {
15088     char device[] = "/dev/sda3";
15089     int r;
15090     suppress_error = 0;
15091     r = guestfs_pvcreate (g, device);
15092     if (r == -1)
15093       return -1;
15094   }
15095   {
15096     char volgroup[] = "VG1";
15097     char physvols_0[] = "/dev/sda1";
15098     char physvols_1[] = "/dev/sda2";
15099     char *physvols[] = {
15100       physvols_0,
15101       physvols_1,
15102       NULL
15103     };
15104     int r;
15105     suppress_error = 0;
15106     r = guestfs_vgcreate (g, volgroup, physvols);
15107     if (r == -1)
15108       return -1;
15109   }
15110   {
15111     char volgroup[] = "VG2";
15112     char physvols_0[] = "/dev/sda3";
15113     char *physvols[] = {
15114       physvols_0,
15115       NULL
15116     };
15117     int r;
15118     suppress_error = 0;
15119     r = guestfs_vgcreate (g, volgroup, physvols);
15120     if (r == -1)
15121       return -1;
15122   }
15123   {
15124     char **r;
15125     int i;
15126     suppress_error = 0;
15127     r = guestfs_vgs (g);
15128     if (r == NULL)
15129       return -1;
15130     if (!r[0]) {
15131       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15132       print_strings (r);
15133       return -1;
15134     }
15135     {
15136       char expected[] = "VG1";
15137       if (strcmp (r[0], expected) != 0) {
15138         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15139         return -1;
15140       }
15141     }
15142     if (!r[1]) {
15143       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15144       print_strings (r);
15145       return -1;
15146     }
15147     {
15148       char expected[] = "VG2";
15149       if (strcmp (r[1], expected) != 0) {
15150         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15151         return -1;
15152       }
15153     }
15154     if (r[2] != NULL) {
15155       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
15156       print_strings (r);
15157       return -1;
15158     }
15159     for (i = 0; r[i] != NULL; ++i)
15160       free (r[i]);
15161     free (r);
15162   }
15163   return 0;
15164 }
15165
15166 static int test_pvcreate_0_skip (void)
15167 {
15168   const char *str;
15169
15170   str = getenv ("TEST_ONLY");
15171   if (str)
15172     return strstr (str, "pvcreate") == NULL;
15173   str = getenv ("SKIP_TEST_PVCREATE_0");
15174   if (str && strcmp (str, "1") == 0) return 1;
15175   str = getenv ("SKIP_TEST_PVCREATE");
15176   if (str && strcmp (str, "1") == 0) return 1;
15177   return 0;
15178 }
15179
15180 static int test_pvcreate_0 (void)
15181 {
15182   if (test_pvcreate_0_skip ()) {
15183     printf ("        %s skipped (reason: environment variable set)\n", "test_pvcreate_0");
15184     return 0;
15185   }
15186
15187   /* InitNone|InitEmpty for test_pvcreate_0 */
15188   {
15189     char device[] = "/dev/sda";
15190     int r;
15191     suppress_error = 0;
15192     r = guestfs_blockdev_setrw (g, device);
15193     if (r == -1)
15194       return -1;
15195   }
15196   {
15197     int r;
15198     suppress_error = 0;
15199     r = guestfs_umount_all (g);
15200     if (r == -1)
15201       return -1;
15202   }
15203   {
15204     int r;
15205     suppress_error = 0;
15206     r = guestfs_lvm_remove_all (g);
15207     if (r == -1)
15208       return -1;
15209   }
15210   /* TestOutputListOfDevices for pvcreate (0) */
15211   {
15212     char device[] = "/dev/sda";
15213     char lines_0[] = ",200";
15214     char lines_1[] = ",400";
15215     char lines_2[] = ",";
15216     char *lines[] = {
15217       lines_0,
15218       lines_1,
15219       lines_2,
15220       NULL
15221     };
15222     int r;
15223     suppress_error = 0;
15224     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15225     if (r == -1)
15226       return -1;
15227   }
15228   {
15229     char device[] = "/dev/sda1";
15230     int r;
15231     suppress_error = 0;
15232     r = guestfs_pvcreate (g, device);
15233     if (r == -1)
15234       return -1;
15235   }
15236   {
15237     char device[] = "/dev/sda2";
15238     int r;
15239     suppress_error = 0;
15240     r = guestfs_pvcreate (g, device);
15241     if (r == -1)
15242       return -1;
15243   }
15244   {
15245     char device[] = "/dev/sda3";
15246     int r;
15247     suppress_error = 0;
15248     r = guestfs_pvcreate (g, device);
15249     if (r == -1)
15250       return -1;
15251   }
15252   {
15253     char **r;
15254     int i;
15255     suppress_error = 0;
15256     r = guestfs_pvs (g);
15257     if (r == NULL)
15258       return -1;
15259     if (!r[0]) {
15260       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15261       print_strings (r);
15262       return -1;
15263     }
15264     {
15265       char expected[] = "/dev/sda1";
15266       r[0][5] = 's';
15267       if (strcmp (r[0], expected) != 0) {
15268         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15269         return -1;
15270       }
15271     }
15272     if (!r[1]) {
15273       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15274       print_strings (r);
15275       return -1;
15276     }
15277     {
15278       char expected[] = "/dev/sda2";
15279       r[1][5] = 's';
15280       if (strcmp (r[1], expected) != 0) {
15281         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15282         return -1;
15283       }
15284     }
15285     if (!r[2]) {
15286       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15287       print_strings (r);
15288       return -1;
15289     }
15290     {
15291       char expected[] = "/dev/sda3";
15292       r[2][5] = 's';
15293       if (strcmp (r[2], expected) != 0) {
15294         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15295         return -1;
15296       }
15297     }
15298     if (r[3] != NULL) {
15299       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
15300       print_strings (r);
15301       return -1;
15302     }
15303     for (i = 0; r[i] != NULL; ++i)
15304       free (r[i]);
15305     free (r);
15306   }
15307   return 0;
15308 }
15309
15310 static int test_is_dir_0_skip (void)
15311 {
15312   const char *str;
15313
15314   str = getenv ("TEST_ONLY");
15315   if (str)
15316     return strstr (str, "is_dir") == NULL;
15317   str = getenv ("SKIP_TEST_IS_DIR_0");
15318   if (str && strcmp (str, "1") == 0) return 1;
15319   str = getenv ("SKIP_TEST_IS_DIR");
15320   if (str && strcmp (str, "1") == 0) return 1;
15321   return 0;
15322 }
15323
15324 static int test_is_dir_0 (void)
15325 {
15326   if (test_is_dir_0_skip ()) {
15327     printf ("        %s skipped (reason: environment variable set)\n", "test_is_dir_0");
15328     return 0;
15329   }
15330
15331   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
15332   {
15333     char device[] = "/dev/sda";
15334     int r;
15335     suppress_error = 0;
15336     r = guestfs_blockdev_setrw (g, device);
15337     if (r == -1)
15338       return -1;
15339   }
15340   {
15341     int r;
15342     suppress_error = 0;
15343     r = guestfs_umount_all (g);
15344     if (r == -1)
15345       return -1;
15346   }
15347   {
15348     int r;
15349     suppress_error = 0;
15350     r = guestfs_lvm_remove_all (g);
15351     if (r == -1)
15352       return -1;
15353   }
15354   {
15355     char device[] = "/dev/sda";
15356     char lines_0[] = ",";
15357     char *lines[] = {
15358       lines_0,
15359       NULL
15360     };
15361     int r;
15362     suppress_error = 0;
15363     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15364     if (r == -1)
15365       return -1;
15366   }
15367   {
15368     char fstype[] = "ext2";
15369     char device[] = "/dev/sda1";
15370     int r;
15371     suppress_error = 0;
15372     r = guestfs_mkfs (g, fstype, device);
15373     if (r == -1)
15374       return -1;
15375   }
15376   {
15377     char device[] = "/dev/sda1";
15378     char mountpoint[] = "/";
15379     int r;
15380     suppress_error = 0;
15381     r = guestfs_mount (g, device, mountpoint);
15382     if (r == -1)
15383       return -1;
15384   }
15385   /* TestOutputFalse for is_dir (0) */
15386   {
15387     char path[] = "/new";
15388     int r;
15389     suppress_error = 0;
15390     r = guestfs_touch (g, path);
15391     if (r == -1)
15392       return -1;
15393   }
15394   {
15395     char path[] = "/new";
15396     int r;
15397     suppress_error = 0;
15398     r = guestfs_is_dir (g, path);
15399     if (r == -1)
15400       return -1;
15401     if (r) {
15402       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
15403       return -1;
15404     }
15405   }
15406   return 0;
15407 }
15408
15409 static int test_is_dir_1_skip (void)
15410 {
15411   const char *str;
15412
15413   str = getenv ("TEST_ONLY");
15414   if (str)
15415     return strstr (str, "is_dir") == NULL;
15416   str = getenv ("SKIP_TEST_IS_DIR_1");
15417   if (str && strcmp (str, "1") == 0) return 1;
15418   str = getenv ("SKIP_TEST_IS_DIR");
15419   if (str && strcmp (str, "1") == 0) return 1;
15420   return 0;
15421 }
15422
15423 static int test_is_dir_1 (void)
15424 {
15425   if (test_is_dir_1_skip ()) {
15426     printf ("        %s skipped (reason: environment variable set)\n", "test_is_dir_1");
15427     return 0;
15428   }
15429
15430   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
15431   {
15432     char device[] = "/dev/sda";
15433     int r;
15434     suppress_error = 0;
15435     r = guestfs_blockdev_setrw (g, device);
15436     if (r == -1)
15437       return -1;
15438   }
15439   {
15440     int r;
15441     suppress_error = 0;
15442     r = guestfs_umount_all (g);
15443     if (r == -1)
15444       return -1;
15445   }
15446   {
15447     int r;
15448     suppress_error = 0;
15449     r = guestfs_lvm_remove_all (g);
15450     if (r == -1)
15451       return -1;
15452   }
15453   {
15454     char device[] = "/dev/sda";
15455     char lines_0[] = ",";
15456     char *lines[] = {
15457       lines_0,
15458       NULL
15459     };
15460     int r;
15461     suppress_error = 0;
15462     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15463     if (r == -1)
15464       return -1;
15465   }
15466   {
15467     char fstype[] = "ext2";
15468     char device[] = "/dev/sda1";
15469     int r;
15470     suppress_error = 0;
15471     r = guestfs_mkfs (g, fstype, device);
15472     if (r == -1)
15473       return -1;
15474   }
15475   {
15476     char device[] = "/dev/sda1";
15477     char mountpoint[] = "/";
15478     int r;
15479     suppress_error = 0;
15480     r = guestfs_mount (g, device, mountpoint);
15481     if (r == -1)
15482       return -1;
15483   }
15484   /* TestOutputTrue for is_dir (1) */
15485   {
15486     char path[] = "/new";
15487     int r;
15488     suppress_error = 0;
15489     r = guestfs_mkdir (g, path);
15490     if (r == -1)
15491       return -1;
15492   }
15493   {
15494     char path[] = "/new";
15495     int r;
15496     suppress_error = 0;
15497     r = guestfs_is_dir (g, path);
15498     if (r == -1)
15499       return -1;
15500     if (!r) {
15501       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
15502       return -1;
15503     }
15504   }
15505   return 0;
15506 }
15507
15508 static int test_is_file_0_skip (void)
15509 {
15510   const char *str;
15511
15512   str = getenv ("TEST_ONLY");
15513   if (str)
15514     return strstr (str, "is_file") == NULL;
15515   str = getenv ("SKIP_TEST_IS_FILE_0");
15516   if (str && strcmp (str, "1") == 0) return 1;
15517   str = getenv ("SKIP_TEST_IS_FILE");
15518   if (str && strcmp (str, "1") == 0) return 1;
15519   return 0;
15520 }
15521
15522 static int test_is_file_0 (void)
15523 {
15524   if (test_is_file_0_skip ()) {
15525     printf ("        %s skipped (reason: environment variable set)\n", "test_is_file_0");
15526     return 0;
15527   }
15528
15529   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
15530   {
15531     char device[] = "/dev/sda";
15532     int r;
15533     suppress_error = 0;
15534     r = guestfs_blockdev_setrw (g, device);
15535     if (r == -1)
15536       return -1;
15537   }
15538   {
15539     int r;
15540     suppress_error = 0;
15541     r = guestfs_umount_all (g);
15542     if (r == -1)
15543       return -1;
15544   }
15545   {
15546     int r;
15547     suppress_error = 0;
15548     r = guestfs_lvm_remove_all (g);
15549     if (r == -1)
15550       return -1;
15551   }
15552   {
15553     char device[] = "/dev/sda";
15554     char lines_0[] = ",";
15555     char *lines[] = {
15556       lines_0,
15557       NULL
15558     };
15559     int r;
15560     suppress_error = 0;
15561     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15562     if (r == -1)
15563       return -1;
15564   }
15565   {
15566     char fstype[] = "ext2";
15567     char device[] = "/dev/sda1";
15568     int r;
15569     suppress_error = 0;
15570     r = guestfs_mkfs (g, fstype, device);
15571     if (r == -1)
15572       return -1;
15573   }
15574   {
15575     char device[] = "/dev/sda1";
15576     char mountpoint[] = "/";
15577     int r;
15578     suppress_error = 0;
15579     r = guestfs_mount (g, device, mountpoint);
15580     if (r == -1)
15581       return -1;
15582   }
15583   /* TestOutputTrue for is_file (0) */
15584   {
15585     char path[] = "/new";
15586     int r;
15587     suppress_error = 0;
15588     r = guestfs_touch (g, path);
15589     if (r == -1)
15590       return -1;
15591   }
15592   {
15593     char path[] = "/new";
15594     int r;
15595     suppress_error = 0;
15596     r = guestfs_is_file (g, path);
15597     if (r == -1)
15598       return -1;
15599     if (!r) {
15600       fprintf (stderr, "test_is_file_0: expected true, got false\n");
15601       return -1;
15602     }
15603   }
15604   return 0;
15605 }
15606
15607 static int test_is_file_1_skip (void)
15608 {
15609   const char *str;
15610
15611   str = getenv ("TEST_ONLY");
15612   if (str)
15613     return strstr (str, "is_file") == NULL;
15614   str = getenv ("SKIP_TEST_IS_FILE_1");
15615   if (str && strcmp (str, "1") == 0) return 1;
15616   str = getenv ("SKIP_TEST_IS_FILE");
15617   if (str && strcmp (str, "1") == 0) return 1;
15618   return 0;
15619 }
15620
15621 static int test_is_file_1 (void)
15622 {
15623   if (test_is_file_1_skip ()) {
15624     printf ("        %s skipped (reason: environment variable set)\n", "test_is_file_1");
15625     return 0;
15626   }
15627
15628   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
15629   {
15630     char device[] = "/dev/sda";
15631     int r;
15632     suppress_error = 0;
15633     r = guestfs_blockdev_setrw (g, device);
15634     if (r == -1)
15635       return -1;
15636   }
15637   {
15638     int r;
15639     suppress_error = 0;
15640     r = guestfs_umount_all (g);
15641     if (r == -1)
15642       return -1;
15643   }
15644   {
15645     int r;
15646     suppress_error = 0;
15647     r = guestfs_lvm_remove_all (g);
15648     if (r == -1)
15649       return -1;
15650   }
15651   {
15652     char device[] = "/dev/sda";
15653     char lines_0[] = ",";
15654     char *lines[] = {
15655       lines_0,
15656       NULL
15657     };
15658     int r;
15659     suppress_error = 0;
15660     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15661     if (r == -1)
15662       return -1;
15663   }
15664   {
15665     char fstype[] = "ext2";
15666     char device[] = "/dev/sda1";
15667     int r;
15668     suppress_error = 0;
15669     r = guestfs_mkfs (g, fstype, device);
15670     if (r == -1)
15671       return -1;
15672   }
15673   {
15674     char device[] = "/dev/sda1";
15675     char mountpoint[] = "/";
15676     int r;
15677     suppress_error = 0;
15678     r = guestfs_mount (g, device, mountpoint);
15679     if (r == -1)
15680       return -1;
15681   }
15682   /* TestOutputFalse for is_file (1) */
15683   {
15684     char path[] = "/new";
15685     int r;
15686     suppress_error = 0;
15687     r = guestfs_mkdir (g, path);
15688     if (r == -1)
15689       return -1;
15690   }
15691   {
15692     char path[] = "/new";
15693     int r;
15694     suppress_error = 0;
15695     r = guestfs_is_file (g, path);
15696     if (r == -1)
15697       return -1;
15698     if (r) {
15699       fprintf (stderr, "test_is_file_1: expected false, got true\n");
15700       return -1;
15701     }
15702   }
15703   return 0;
15704 }
15705
15706 static int test_exists_0_skip (void)
15707 {
15708   const char *str;
15709
15710   str = getenv ("TEST_ONLY");
15711   if (str)
15712     return strstr (str, "exists") == NULL;
15713   str = getenv ("SKIP_TEST_EXISTS_0");
15714   if (str && strcmp (str, "1") == 0) return 1;
15715   str = getenv ("SKIP_TEST_EXISTS");
15716   if (str && strcmp (str, "1") == 0) return 1;
15717   return 0;
15718 }
15719
15720 static int test_exists_0 (void)
15721 {
15722   if (test_exists_0_skip ()) {
15723     printf ("        %s skipped (reason: environment variable set)\n", "test_exists_0");
15724     return 0;
15725   }
15726
15727   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15728   {
15729     char device[] = "/dev/sda";
15730     int r;
15731     suppress_error = 0;
15732     r = guestfs_blockdev_setrw (g, device);
15733     if (r == -1)
15734       return -1;
15735   }
15736   {
15737     int r;
15738     suppress_error = 0;
15739     r = guestfs_umount_all (g);
15740     if (r == -1)
15741       return -1;
15742   }
15743   {
15744     int r;
15745     suppress_error = 0;
15746     r = guestfs_lvm_remove_all (g);
15747     if (r == -1)
15748       return -1;
15749   }
15750   {
15751     char device[] = "/dev/sda";
15752     char lines_0[] = ",";
15753     char *lines[] = {
15754       lines_0,
15755       NULL
15756     };
15757     int r;
15758     suppress_error = 0;
15759     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15760     if (r == -1)
15761       return -1;
15762   }
15763   {
15764     char fstype[] = "ext2";
15765     char device[] = "/dev/sda1";
15766     int r;
15767     suppress_error = 0;
15768     r = guestfs_mkfs (g, fstype, device);
15769     if (r == -1)
15770       return -1;
15771   }
15772   {
15773     char device[] = "/dev/sda1";
15774     char mountpoint[] = "/";
15775     int r;
15776     suppress_error = 0;
15777     r = guestfs_mount (g, device, mountpoint);
15778     if (r == -1)
15779       return -1;
15780   }
15781   /* TestOutputTrue for exists (0) */
15782   {
15783     char path[] = "/new";
15784     int r;
15785     suppress_error = 0;
15786     r = guestfs_touch (g, path);
15787     if (r == -1)
15788       return -1;
15789   }
15790   {
15791     char path[] = "/new";
15792     int r;
15793     suppress_error = 0;
15794     r = guestfs_exists (g, path);
15795     if (r == -1)
15796       return -1;
15797     if (!r) {
15798       fprintf (stderr, "test_exists_0: expected true, got false\n");
15799       return -1;
15800     }
15801   }
15802   return 0;
15803 }
15804
15805 static int test_exists_1_skip (void)
15806 {
15807   const char *str;
15808
15809   str = getenv ("TEST_ONLY");
15810   if (str)
15811     return strstr (str, "exists") == NULL;
15812   str = getenv ("SKIP_TEST_EXISTS_1");
15813   if (str && strcmp (str, "1") == 0) return 1;
15814   str = getenv ("SKIP_TEST_EXISTS");
15815   if (str && strcmp (str, "1") == 0) return 1;
15816   return 0;
15817 }
15818
15819 static int test_exists_1 (void)
15820 {
15821   if (test_exists_1_skip ()) {
15822     printf ("        %s skipped (reason: environment variable set)\n", "test_exists_1");
15823     return 0;
15824   }
15825
15826   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15827   {
15828     char device[] = "/dev/sda";
15829     int r;
15830     suppress_error = 0;
15831     r = guestfs_blockdev_setrw (g, device);
15832     if (r == -1)
15833       return -1;
15834   }
15835   {
15836     int r;
15837     suppress_error = 0;
15838     r = guestfs_umount_all (g);
15839     if (r == -1)
15840       return -1;
15841   }
15842   {
15843     int r;
15844     suppress_error = 0;
15845     r = guestfs_lvm_remove_all (g);
15846     if (r == -1)
15847       return -1;
15848   }
15849   {
15850     char device[] = "/dev/sda";
15851     char lines_0[] = ",";
15852     char *lines[] = {
15853       lines_0,
15854       NULL
15855     };
15856     int r;
15857     suppress_error = 0;
15858     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15859     if (r == -1)
15860       return -1;
15861   }
15862   {
15863     char fstype[] = "ext2";
15864     char device[] = "/dev/sda1";
15865     int r;
15866     suppress_error = 0;
15867     r = guestfs_mkfs (g, fstype, device);
15868     if (r == -1)
15869       return -1;
15870   }
15871   {
15872     char device[] = "/dev/sda1";
15873     char mountpoint[] = "/";
15874     int r;
15875     suppress_error = 0;
15876     r = guestfs_mount (g, device, mountpoint);
15877     if (r == -1)
15878       return -1;
15879   }
15880   /* TestOutputTrue for exists (1) */
15881   {
15882     char path[] = "/new";
15883     int r;
15884     suppress_error = 0;
15885     r = guestfs_mkdir (g, path);
15886     if (r == -1)
15887       return -1;
15888   }
15889   {
15890     char path[] = "/new";
15891     int r;
15892     suppress_error = 0;
15893     r = guestfs_exists (g, path);
15894     if (r == -1)
15895       return -1;
15896     if (!r) {
15897       fprintf (stderr, "test_exists_1: expected true, got false\n");
15898       return -1;
15899     }
15900   }
15901   return 0;
15902 }
15903
15904 static int test_mkdir_p_0_skip (void)
15905 {
15906   const char *str;
15907
15908   str = getenv ("TEST_ONLY");
15909   if (str)
15910     return strstr (str, "mkdir_p") == NULL;
15911   str = getenv ("SKIP_TEST_MKDIR_P_0");
15912   if (str && strcmp (str, "1") == 0) return 1;
15913   str = getenv ("SKIP_TEST_MKDIR_P");
15914   if (str && strcmp (str, "1") == 0) return 1;
15915   return 0;
15916 }
15917
15918 static int test_mkdir_p_0 (void)
15919 {
15920   if (test_mkdir_p_0_skip ()) {
15921     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15922     return 0;
15923   }
15924
15925   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15926   {
15927     char device[] = "/dev/sda";
15928     int r;
15929     suppress_error = 0;
15930     r = guestfs_blockdev_setrw (g, device);
15931     if (r == -1)
15932       return -1;
15933   }
15934   {
15935     int r;
15936     suppress_error = 0;
15937     r = guestfs_umount_all (g);
15938     if (r == -1)
15939       return -1;
15940   }
15941   {
15942     int r;
15943     suppress_error = 0;
15944     r = guestfs_lvm_remove_all (g);
15945     if (r == -1)
15946       return -1;
15947   }
15948   {
15949     char device[] = "/dev/sda";
15950     char lines_0[] = ",";
15951     char *lines[] = {
15952       lines_0,
15953       NULL
15954     };
15955     int r;
15956     suppress_error = 0;
15957     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15958     if (r == -1)
15959       return -1;
15960   }
15961   {
15962     char fstype[] = "ext2";
15963     char device[] = "/dev/sda1";
15964     int r;
15965     suppress_error = 0;
15966     r = guestfs_mkfs (g, fstype, device);
15967     if (r == -1)
15968       return -1;
15969   }
15970   {
15971     char device[] = "/dev/sda1";
15972     char mountpoint[] = "/";
15973     int r;
15974     suppress_error = 0;
15975     r = guestfs_mount (g, device, mountpoint);
15976     if (r == -1)
15977       return -1;
15978   }
15979   /* TestOutputTrue for mkdir_p (0) */
15980   {
15981     char path[] = "/new/foo/bar";
15982     int r;
15983     suppress_error = 0;
15984     r = guestfs_mkdir_p (g, path);
15985     if (r == -1)
15986       return -1;
15987   }
15988   {
15989     char path[] = "/new/foo/bar";
15990     int r;
15991     suppress_error = 0;
15992     r = guestfs_is_dir (g, path);
15993     if (r == -1)
15994       return -1;
15995     if (!r) {
15996       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15997       return -1;
15998     }
15999   }
16000   return 0;
16001 }
16002
16003 static int test_mkdir_p_1_skip (void)
16004 {
16005   const char *str;
16006
16007   str = getenv ("TEST_ONLY");
16008   if (str)
16009     return strstr (str, "mkdir_p") == NULL;
16010   str = getenv ("SKIP_TEST_MKDIR_P_1");
16011   if (str && strcmp (str, "1") == 0) return 1;
16012   str = getenv ("SKIP_TEST_MKDIR_P");
16013   if (str && strcmp (str, "1") == 0) return 1;
16014   return 0;
16015 }
16016
16017 static int test_mkdir_p_1 (void)
16018 {
16019   if (test_mkdir_p_1_skip ()) {
16020     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
16021     return 0;
16022   }
16023
16024   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
16025   {
16026     char device[] = "/dev/sda";
16027     int r;
16028     suppress_error = 0;
16029     r = guestfs_blockdev_setrw (g, device);
16030     if (r == -1)
16031       return -1;
16032   }
16033   {
16034     int r;
16035     suppress_error = 0;
16036     r = guestfs_umount_all (g);
16037     if (r == -1)
16038       return -1;
16039   }
16040   {
16041     int r;
16042     suppress_error = 0;
16043     r = guestfs_lvm_remove_all (g);
16044     if (r == -1)
16045       return -1;
16046   }
16047   {
16048     char device[] = "/dev/sda";
16049     char lines_0[] = ",";
16050     char *lines[] = {
16051       lines_0,
16052       NULL
16053     };
16054     int r;
16055     suppress_error = 0;
16056     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16057     if (r == -1)
16058       return -1;
16059   }
16060   {
16061     char fstype[] = "ext2";
16062     char device[] = "/dev/sda1";
16063     int r;
16064     suppress_error = 0;
16065     r = guestfs_mkfs (g, fstype, device);
16066     if (r == -1)
16067       return -1;
16068   }
16069   {
16070     char device[] = "/dev/sda1";
16071     char mountpoint[] = "/";
16072     int r;
16073     suppress_error = 0;
16074     r = guestfs_mount (g, device, mountpoint);
16075     if (r == -1)
16076       return -1;
16077   }
16078   /* TestOutputTrue for mkdir_p (1) */
16079   {
16080     char path[] = "/new/foo/bar";
16081     int r;
16082     suppress_error = 0;
16083     r = guestfs_mkdir_p (g, path);
16084     if (r == -1)
16085       return -1;
16086   }
16087   {
16088     char path[] = "/new/foo";
16089     int r;
16090     suppress_error = 0;
16091     r = guestfs_is_dir (g, path);
16092     if (r == -1)
16093       return -1;
16094     if (!r) {
16095       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
16096       return -1;
16097     }
16098   }
16099   return 0;
16100 }
16101
16102 static int test_mkdir_p_2_skip (void)
16103 {
16104   const char *str;
16105
16106   str = getenv ("TEST_ONLY");
16107   if (str)
16108     return strstr (str, "mkdir_p") == NULL;
16109   str = getenv ("SKIP_TEST_MKDIR_P_2");
16110   if (str && strcmp (str, "1") == 0) return 1;
16111   str = getenv ("SKIP_TEST_MKDIR_P");
16112   if (str && strcmp (str, "1") == 0) return 1;
16113   return 0;
16114 }
16115
16116 static int test_mkdir_p_2 (void)
16117 {
16118   if (test_mkdir_p_2_skip ()) {
16119     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
16120     return 0;
16121   }
16122
16123   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
16124   {
16125     char device[] = "/dev/sda";
16126     int r;
16127     suppress_error = 0;
16128     r = guestfs_blockdev_setrw (g, device);
16129     if (r == -1)
16130       return -1;
16131   }
16132   {
16133     int r;
16134     suppress_error = 0;
16135     r = guestfs_umount_all (g);
16136     if (r == -1)
16137       return -1;
16138   }
16139   {
16140     int r;
16141     suppress_error = 0;
16142     r = guestfs_lvm_remove_all (g);
16143     if (r == -1)
16144       return -1;
16145   }
16146   {
16147     char device[] = "/dev/sda";
16148     char lines_0[] = ",";
16149     char *lines[] = {
16150       lines_0,
16151       NULL
16152     };
16153     int r;
16154     suppress_error = 0;
16155     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16156     if (r == -1)
16157       return -1;
16158   }
16159   {
16160     char fstype[] = "ext2";
16161     char device[] = "/dev/sda1";
16162     int r;
16163     suppress_error = 0;
16164     r = guestfs_mkfs (g, fstype, device);
16165     if (r == -1)
16166       return -1;
16167   }
16168   {
16169     char device[] = "/dev/sda1";
16170     char mountpoint[] = "/";
16171     int r;
16172     suppress_error = 0;
16173     r = guestfs_mount (g, device, mountpoint);
16174     if (r == -1)
16175       return -1;
16176   }
16177   /* TestOutputTrue for mkdir_p (2) */
16178   {
16179     char path[] = "/new/foo/bar";
16180     int r;
16181     suppress_error = 0;
16182     r = guestfs_mkdir_p (g, path);
16183     if (r == -1)
16184       return -1;
16185   }
16186   {
16187     char path[] = "/new";
16188     int r;
16189     suppress_error = 0;
16190     r = guestfs_is_dir (g, path);
16191     if (r == -1)
16192       return -1;
16193     if (!r) {
16194       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
16195       return -1;
16196     }
16197   }
16198   return 0;
16199 }
16200
16201 static int test_mkdir_p_3_skip (void)
16202 {
16203   const char *str;
16204
16205   str = getenv ("TEST_ONLY");
16206   if (str)
16207     return strstr (str, "mkdir_p") == NULL;
16208   str = getenv ("SKIP_TEST_MKDIR_P_3");
16209   if (str && strcmp (str, "1") == 0) return 1;
16210   str = getenv ("SKIP_TEST_MKDIR_P");
16211   if (str && strcmp (str, "1") == 0) return 1;
16212   return 0;
16213 }
16214
16215 static int test_mkdir_p_3 (void)
16216 {
16217   if (test_mkdir_p_3_skip ()) {
16218     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
16219     return 0;
16220   }
16221
16222   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
16223   {
16224     char device[] = "/dev/sda";
16225     int r;
16226     suppress_error = 0;
16227     r = guestfs_blockdev_setrw (g, device);
16228     if (r == -1)
16229       return -1;
16230   }
16231   {
16232     int r;
16233     suppress_error = 0;
16234     r = guestfs_umount_all (g);
16235     if (r == -1)
16236       return -1;
16237   }
16238   {
16239     int r;
16240     suppress_error = 0;
16241     r = guestfs_lvm_remove_all (g);
16242     if (r == -1)
16243       return -1;
16244   }
16245   {
16246     char device[] = "/dev/sda";
16247     char lines_0[] = ",";
16248     char *lines[] = {
16249       lines_0,
16250       NULL
16251     };
16252     int r;
16253     suppress_error = 0;
16254     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16255     if (r == -1)
16256       return -1;
16257   }
16258   {
16259     char fstype[] = "ext2";
16260     char device[] = "/dev/sda1";
16261     int r;
16262     suppress_error = 0;
16263     r = guestfs_mkfs (g, fstype, device);
16264     if (r == -1)
16265       return -1;
16266   }
16267   {
16268     char device[] = "/dev/sda1";
16269     char mountpoint[] = "/";
16270     int r;
16271     suppress_error = 0;
16272     r = guestfs_mount (g, device, mountpoint);
16273     if (r == -1)
16274       return -1;
16275   }
16276   /* TestRun for mkdir_p (3) */
16277   {
16278     char path[] = "/new";
16279     int r;
16280     suppress_error = 0;
16281     r = guestfs_mkdir (g, path);
16282     if (r == -1)
16283       return -1;
16284   }
16285   {
16286     char path[] = "/new";
16287     int r;
16288     suppress_error = 0;
16289     r = guestfs_mkdir_p (g, path);
16290     if (r == -1)
16291       return -1;
16292   }
16293   return 0;
16294 }
16295
16296 static int test_mkdir_p_4_skip (void)
16297 {
16298   const char *str;
16299
16300   str = getenv ("TEST_ONLY");
16301   if (str)
16302     return strstr (str, "mkdir_p") == NULL;
16303   str = getenv ("SKIP_TEST_MKDIR_P_4");
16304   if (str && strcmp (str, "1") == 0) return 1;
16305   str = getenv ("SKIP_TEST_MKDIR_P");
16306   if (str && strcmp (str, "1") == 0) return 1;
16307   return 0;
16308 }
16309
16310 static int test_mkdir_p_4 (void)
16311 {
16312   if (test_mkdir_p_4_skip ()) {
16313     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
16314     return 0;
16315   }
16316
16317   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
16318   {
16319     char device[] = "/dev/sda";
16320     int r;
16321     suppress_error = 0;
16322     r = guestfs_blockdev_setrw (g, device);
16323     if (r == -1)
16324       return -1;
16325   }
16326   {
16327     int r;
16328     suppress_error = 0;
16329     r = guestfs_umount_all (g);
16330     if (r == -1)
16331       return -1;
16332   }
16333   {
16334     int r;
16335     suppress_error = 0;
16336     r = guestfs_lvm_remove_all (g);
16337     if (r == -1)
16338       return -1;
16339   }
16340   {
16341     char device[] = "/dev/sda";
16342     char lines_0[] = ",";
16343     char *lines[] = {
16344       lines_0,
16345       NULL
16346     };
16347     int r;
16348     suppress_error = 0;
16349     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16350     if (r == -1)
16351       return -1;
16352   }
16353   {
16354     char fstype[] = "ext2";
16355     char device[] = "/dev/sda1";
16356     int r;
16357     suppress_error = 0;
16358     r = guestfs_mkfs (g, fstype, device);
16359     if (r == -1)
16360       return -1;
16361   }
16362   {
16363     char device[] = "/dev/sda1";
16364     char mountpoint[] = "/";
16365     int r;
16366     suppress_error = 0;
16367     r = guestfs_mount (g, device, mountpoint);
16368     if (r == -1)
16369       return -1;
16370   }
16371   /* TestLastFail for mkdir_p (4) */
16372   {
16373     char path[] = "/new";
16374     int r;
16375     suppress_error = 0;
16376     r = guestfs_touch (g, path);
16377     if (r == -1)
16378       return -1;
16379   }
16380   {
16381     char path[] = "/new";
16382     int r;
16383     suppress_error = 1;
16384     r = guestfs_mkdir_p (g, path);
16385     if (r != -1)
16386       return -1;
16387   }
16388   return 0;
16389 }
16390
16391 static int test_mkdir_0_skip (void)
16392 {
16393   const char *str;
16394
16395   str = getenv ("TEST_ONLY");
16396   if (str)
16397     return strstr (str, "mkdir") == NULL;
16398   str = getenv ("SKIP_TEST_MKDIR_0");
16399   if (str && strcmp (str, "1") == 0) return 1;
16400   str = getenv ("SKIP_TEST_MKDIR");
16401   if (str && strcmp (str, "1") == 0) return 1;
16402   return 0;
16403 }
16404
16405 static int test_mkdir_0 (void)
16406 {
16407   if (test_mkdir_0_skip ()) {
16408     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_0");
16409     return 0;
16410   }
16411
16412   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
16413   {
16414     char device[] = "/dev/sda";
16415     int r;
16416     suppress_error = 0;
16417     r = guestfs_blockdev_setrw (g, device);
16418     if (r == -1)
16419       return -1;
16420   }
16421   {
16422     int r;
16423     suppress_error = 0;
16424     r = guestfs_umount_all (g);
16425     if (r == -1)
16426       return -1;
16427   }
16428   {
16429     int r;
16430     suppress_error = 0;
16431     r = guestfs_lvm_remove_all (g);
16432     if (r == -1)
16433       return -1;
16434   }
16435   {
16436     char device[] = "/dev/sda";
16437     char lines_0[] = ",";
16438     char *lines[] = {
16439       lines_0,
16440       NULL
16441     };
16442     int r;
16443     suppress_error = 0;
16444     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16445     if (r == -1)
16446       return -1;
16447   }
16448   {
16449     char fstype[] = "ext2";
16450     char device[] = "/dev/sda1";
16451     int r;
16452     suppress_error = 0;
16453     r = guestfs_mkfs (g, fstype, device);
16454     if (r == -1)
16455       return -1;
16456   }
16457   {
16458     char device[] = "/dev/sda1";
16459     char mountpoint[] = "/";
16460     int r;
16461     suppress_error = 0;
16462     r = guestfs_mount (g, device, mountpoint);
16463     if (r == -1)
16464       return -1;
16465   }
16466   /* TestOutputTrue for mkdir (0) */
16467   {
16468     char path[] = "/new";
16469     int r;
16470     suppress_error = 0;
16471     r = guestfs_mkdir (g, path);
16472     if (r == -1)
16473       return -1;
16474   }
16475   {
16476     char path[] = "/new";
16477     int r;
16478     suppress_error = 0;
16479     r = guestfs_is_dir (g, path);
16480     if (r == -1)
16481       return -1;
16482     if (!r) {
16483       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
16484       return -1;
16485     }
16486   }
16487   return 0;
16488 }
16489
16490 static int test_mkdir_1_skip (void)
16491 {
16492   const char *str;
16493
16494   str = getenv ("TEST_ONLY");
16495   if (str)
16496     return strstr (str, "mkdir") == NULL;
16497   str = getenv ("SKIP_TEST_MKDIR_1");
16498   if (str && strcmp (str, "1") == 0) return 1;
16499   str = getenv ("SKIP_TEST_MKDIR");
16500   if (str && strcmp (str, "1") == 0) return 1;
16501   return 0;
16502 }
16503
16504 static int test_mkdir_1 (void)
16505 {
16506   if (test_mkdir_1_skip ()) {
16507     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_1");
16508     return 0;
16509   }
16510
16511   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
16512   {
16513     char device[] = "/dev/sda";
16514     int r;
16515     suppress_error = 0;
16516     r = guestfs_blockdev_setrw (g, device);
16517     if (r == -1)
16518       return -1;
16519   }
16520   {
16521     int r;
16522     suppress_error = 0;
16523     r = guestfs_umount_all (g);
16524     if (r == -1)
16525       return -1;
16526   }
16527   {
16528     int r;
16529     suppress_error = 0;
16530     r = guestfs_lvm_remove_all (g);
16531     if (r == -1)
16532       return -1;
16533   }
16534   {
16535     char device[] = "/dev/sda";
16536     char lines_0[] = ",";
16537     char *lines[] = {
16538       lines_0,
16539       NULL
16540     };
16541     int r;
16542     suppress_error = 0;
16543     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16544     if (r == -1)
16545       return -1;
16546   }
16547   {
16548     char fstype[] = "ext2";
16549     char device[] = "/dev/sda1";
16550     int r;
16551     suppress_error = 0;
16552     r = guestfs_mkfs (g, fstype, device);
16553     if (r == -1)
16554       return -1;
16555   }
16556   {
16557     char device[] = "/dev/sda1";
16558     char mountpoint[] = "/";
16559     int r;
16560     suppress_error = 0;
16561     r = guestfs_mount (g, device, mountpoint);
16562     if (r == -1)
16563       return -1;
16564   }
16565   /* TestLastFail for mkdir (1) */
16566   {
16567     char path[] = "/new/foo/bar";
16568     int r;
16569     suppress_error = 1;
16570     r = guestfs_mkdir (g, path);
16571     if (r != -1)
16572       return -1;
16573   }
16574   return 0;
16575 }
16576
16577 static int test_rm_rf_0_skip (void)
16578 {
16579   const char *str;
16580
16581   str = getenv ("TEST_ONLY");
16582   if (str)
16583     return strstr (str, "rm_rf") == NULL;
16584   str = getenv ("SKIP_TEST_RM_RF_0");
16585   if (str && strcmp (str, "1") == 0) return 1;
16586   str = getenv ("SKIP_TEST_RM_RF");
16587   if (str && strcmp (str, "1") == 0) return 1;
16588   return 0;
16589 }
16590
16591 static int test_rm_rf_0 (void)
16592 {
16593   if (test_rm_rf_0_skip ()) {
16594     printf ("        %s skipped (reason: environment variable set)\n", "test_rm_rf_0");
16595     return 0;
16596   }
16597
16598   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
16599   {
16600     char device[] = "/dev/sda";
16601     int r;
16602     suppress_error = 0;
16603     r = guestfs_blockdev_setrw (g, device);
16604     if (r == -1)
16605       return -1;
16606   }
16607   {
16608     int r;
16609     suppress_error = 0;
16610     r = guestfs_umount_all (g);
16611     if (r == -1)
16612       return -1;
16613   }
16614   {
16615     int r;
16616     suppress_error = 0;
16617     r = guestfs_lvm_remove_all (g);
16618     if (r == -1)
16619       return -1;
16620   }
16621   {
16622     char device[] = "/dev/sda";
16623     char lines_0[] = ",";
16624     char *lines[] = {
16625       lines_0,
16626       NULL
16627     };
16628     int r;
16629     suppress_error = 0;
16630     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16631     if (r == -1)
16632       return -1;
16633   }
16634   {
16635     char fstype[] = "ext2";
16636     char device[] = "/dev/sda1";
16637     int r;
16638     suppress_error = 0;
16639     r = guestfs_mkfs (g, fstype, device);
16640     if (r == -1)
16641       return -1;
16642   }
16643   {
16644     char device[] = "/dev/sda1";
16645     char mountpoint[] = "/";
16646     int r;
16647     suppress_error = 0;
16648     r = guestfs_mount (g, device, mountpoint);
16649     if (r == -1)
16650       return -1;
16651   }
16652   /* TestOutputFalse for rm_rf (0) */
16653   {
16654     char path[] = "/new";
16655     int r;
16656     suppress_error = 0;
16657     r = guestfs_mkdir (g, path);
16658     if (r == -1)
16659       return -1;
16660   }
16661   {
16662     char path[] = "/new/foo";
16663     int r;
16664     suppress_error = 0;
16665     r = guestfs_mkdir (g, path);
16666     if (r == -1)
16667       return -1;
16668   }
16669   {
16670     char path[] = "/new/foo/bar";
16671     int r;
16672     suppress_error = 0;
16673     r = guestfs_touch (g, path);
16674     if (r == -1)
16675       return -1;
16676   }
16677   {
16678     char path[] = "/new";
16679     int r;
16680     suppress_error = 0;
16681     r = guestfs_rm_rf (g, path);
16682     if (r == -1)
16683       return -1;
16684   }
16685   {
16686     char path[] = "/new";
16687     int r;
16688     suppress_error = 0;
16689     r = guestfs_exists (g, path);
16690     if (r == -1)
16691       return -1;
16692     if (r) {
16693       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16694       return -1;
16695     }
16696   }
16697   return 0;
16698 }
16699
16700 static int test_rmdir_0_skip (void)
16701 {
16702   const char *str;
16703
16704   str = getenv ("TEST_ONLY");
16705   if (str)
16706     return strstr (str, "rmdir") == NULL;
16707   str = getenv ("SKIP_TEST_RMDIR_0");
16708   if (str && strcmp (str, "1") == 0) return 1;
16709   str = getenv ("SKIP_TEST_RMDIR");
16710   if (str && strcmp (str, "1") == 0) return 1;
16711   return 0;
16712 }
16713
16714 static int test_rmdir_0 (void)
16715 {
16716   if (test_rmdir_0_skip ()) {
16717     printf ("        %s skipped (reason: environment variable set)\n", "test_rmdir_0");
16718     return 0;
16719   }
16720
16721   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16722   {
16723     char device[] = "/dev/sda";
16724     int r;
16725     suppress_error = 0;
16726     r = guestfs_blockdev_setrw (g, device);
16727     if (r == -1)
16728       return -1;
16729   }
16730   {
16731     int r;
16732     suppress_error = 0;
16733     r = guestfs_umount_all (g);
16734     if (r == -1)
16735       return -1;
16736   }
16737   {
16738     int r;
16739     suppress_error = 0;
16740     r = guestfs_lvm_remove_all (g);
16741     if (r == -1)
16742       return -1;
16743   }
16744   {
16745     char device[] = "/dev/sda";
16746     char lines_0[] = ",";
16747     char *lines[] = {
16748       lines_0,
16749       NULL
16750     };
16751     int r;
16752     suppress_error = 0;
16753     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16754     if (r == -1)
16755       return -1;
16756   }
16757   {
16758     char fstype[] = "ext2";
16759     char device[] = "/dev/sda1";
16760     int r;
16761     suppress_error = 0;
16762     r = guestfs_mkfs (g, fstype, device);
16763     if (r == -1)
16764       return -1;
16765   }
16766   {
16767     char device[] = "/dev/sda1";
16768     char mountpoint[] = "/";
16769     int r;
16770     suppress_error = 0;
16771     r = guestfs_mount (g, device, mountpoint);
16772     if (r == -1)
16773       return -1;
16774   }
16775   /* TestRun for rmdir (0) */
16776   {
16777     char path[] = "/new";
16778     int r;
16779     suppress_error = 0;
16780     r = guestfs_mkdir (g, path);
16781     if (r == -1)
16782       return -1;
16783   }
16784   {
16785     char path[] = "/new";
16786     int r;
16787     suppress_error = 0;
16788     r = guestfs_rmdir (g, path);
16789     if (r == -1)
16790       return -1;
16791   }
16792   return 0;
16793 }
16794
16795 static int test_rmdir_1_skip (void)
16796 {
16797   const char *str;
16798
16799   str = getenv ("TEST_ONLY");
16800   if (str)
16801     return strstr (str, "rmdir") == NULL;
16802   str = getenv ("SKIP_TEST_RMDIR_1");
16803   if (str && strcmp (str, "1") == 0) return 1;
16804   str = getenv ("SKIP_TEST_RMDIR");
16805   if (str && strcmp (str, "1") == 0) return 1;
16806   return 0;
16807 }
16808
16809 static int test_rmdir_1 (void)
16810 {
16811   if (test_rmdir_1_skip ()) {
16812     printf ("        %s skipped (reason: environment variable set)\n", "test_rmdir_1");
16813     return 0;
16814   }
16815
16816   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16817   {
16818     char device[] = "/dev/sda";
16819     int r;
16820     suppress_error = 0;
16821     r = guestfs_blockdev_setrw (g, device);
16822     if (r == -1)
16823       return -1;
16824   }
16825   {
16826     int r;
16827     suppress_error = 0;
16828     r = guestfs_umount_all (g);
16829     if (r == -1)
16830       return -1;
16831   }
16832   {
16833     int r;
16834     suppress_error = 0;
16835     r = guestfs_lvm_remove_all (g);
16836     if (r == -1)
16837       return -1;
16838   }
16839   {
16840     char device[] = "/dev/sda";
16841     char lines_0[] = ",";
16842     char *lines[] = {
16843       lines_0,
16844       NULL
16845     };
16846     int r;
16847     suppress_error = 0;
16848     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16849     if (r == -1)
16850       return -1;
16851   }
16852   {
16853     char fstype[] = "ext2";
16854     char device[] = "/dev/sda1";
16855     int r;
16856     suppress_error = 0;
16857     r = guestfs_mkfs (g, fstype, device);
16858     if (r == -1)
16859       return -1;
16860   }
16861   {
16862     char device[] = "/dev/sda1";
16863     char mountpoint[] = "/";
16864     int r;
16865     suppress_error = 0;
16866     r = guestfs_mount (g, device, mountpoint);
16867     if (r == -1)
16868       return -1;
16869   }
16870   /* TestLastFail for rmdir (1) */
16871   {
16872     char path[] = "/new";
16873     int r;
16874     suppress_error = 1;
16875     r = guestfs_rmdir (g, path);
16876     if (r != -1)
16877       return -1;
16878   }
16879   return 0;
16880 }
16881
16882 static int test_rmdir_2_skip (void)
16883 {
16884   const char *str;
16885
16886   str = getenv ("TEST_ONLY");
16887   if (str)
16888     return strstr (str, "rmdir") == NULL;
16889   str = getenv ("SKIP_TEST_RMDIR_2");
16890   if (str && strcmp (str, "1") == 0) return 1;
16891   str = getenv ("SKIP_TEST_RMDIR");
16892   if (str && strcmp (str, "1") == 0) return 1;
16893   return 0;
16894 }
16895
16896 static int test_rmdir_2 (void)
16897 {
16898   if (test_rmdir_2_skip ()) {
16899     printf ("        %s skipped (reason: environment variable set)\n", "test_rmdir_2");
16900     return 0;
16901   }
16902
16903   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16904   {
16905     char device[] = "/dev/sda";
16906     int r;
16907     suppress_error = 0;
16908     r = guestfs_blockdev_setrw (g, device);
16909     if (r == -1)
16910       return -1;
16911   }
16912   {
16913     int r;
16914     suppress_error = 0;
16915     r = guestfs_umount_all (g);
16916     if (r == -1)
16917       return -1;
16918   }
16919   {
16920     int r;
16921     suppress_error = 0;
16922     r = guestfs_lvm_remove_all (g);
16923     if (r == -1)
16924       return -1;
16925   }
16926   {
16927     char device[] = "/dev/sda";
16928     char lines_0[] = ",";
16929     char *lines[] = {
16930       lines_0,
16931       NULL
16932     };
16933     int r;
16934     suppress_error = 0;
16935     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16936     if (r == -1)
16937       return -1;
16938   }
16939   {
16940     char fstype[] = "ext2";
16941     char device[] = "/dev/sda1";
16942     int r;
16943     suppress_error = 0;
16944     r = guestfs_mkfs (g, fstype, device);
16945     if (r == -1)
16946       return -1;
16947   }
16948   {
16949     char device[] = "/dev/sda1";
16950     char mountpoint[] = "/";
16951     int r;
16952     suppress_error = 0;
16953     r = guestfs_mount (g, device, mountpoint);
16954     if (r == -1)
16955       return -1;
16956   }
16957   /* TestLastFail for rmdir (2) */
16958   {
16959     char path[] = "/new";
16960     int r;
16961     suppress_error = 0;
16962     r = guestfs_touch (g, path);
16963     if (r == -1)
16964       return -1;
16965   }
16966   {
16967     char path[] = "/new";
16968     int r;
16969     suppress_error = 1;
16970     r = guestfs_rmdir (g, path);
16971     if (r != -1)
16972       return -1;
16973   }
16974   return 0;
16975 }
16976
16977 static int test_rm_0_skip (void)
16978 {
16979   const char *str;
16980
16981   str = getenv ("TEST_ONLY");
16982   if (str)
16983     return strstr (str, "rm") == NULL;
16984   str = getenv ("SKIP_TEST_RM_0");
16985   if (str && strcmp (str, "1") == 0) return 1;
16986   str = getenv ("SKIP_TEST_RM");
16987   if (str && strcmp (str, "1") == 0) return 1;
16988   return 0;
16989 }
16990
16991 static int test_rm_0 (void)
16992 {
16993   if (test_rm_0_skip ()) {
16994     printf ("        %s skipped (reason: environment variable set)\n", "test_rm_0");
16995     return 0;
16996   }
16997
16998   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16999   {
17000     char device[] = "/dev/sda";
17001     int r;
17002     suppress_error = 0;
17003     r = guestfs_blockdev_setrw (g, device);
17004     if (r == -1)
17005       return -1;
17006   }
17007   {
17008     int r;
17009     suppress_error = 0;
17010     r = guestfs_umount_all (g);
17011     if (r == -1)
17012       return -1;
17013   }
17014   {
17015     int r;
17016     suppress_error = 0;
17017     r = guestfs_lvm_remove_all (g);
17018     if (r == -1)
17019       return -1;
17020   }
17021   {
17022     char device[] = "/dev/sda";
17023     char lines_0[] = ",";
17024     char *lines[] = {
17025       lines_0,
17026       NULL
17027     };
17028     int r;
17029     suppress_error = 0;
17030     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17031     if (r == -1)
17032       return -1;
17033   }
17034   {
17035     char fstype[] = "ext2";
17036     char device[] = "/dev/sda1";
17037     int r;
17038     suppress_error = 0;
17039     r = guestfs_mkfs (g, fstype, device);
17040     if (r == -1)
17041       return -1;
17042   }
17043   {
17044     char device[] = "/dev/sda1";
17045     char mountpoint[] = "/";
17046     int r;
17047     suppress_error = 0;
17048     r = guestfs_mount (g, device, mountpoint);
17049     if (r == -1)
17050       return -1;
17051   }
17052   /* TestRun for rm (0) */
17053   {
17054     char path[] = "/new";
17055     int r;
17056     suppress_error = 0;
17057     r = guestfs_touch (g, path);
17058     if (r == -1)
17059       return -1;
17060   }
17061   {
17062     char path[] = "/new";
17063     int r;
17064     suppress_error = 0;
17065     r = guestfs_rm (g, path);
17066     if (r == -1)
17067       return -1;
17068   }
17069   return 0;
17070 }
17071
17072 static int test_rm_1_skip (void)
17073 {
17074   const char *str;
17075
17076   str = getenv ("TEST_ONLY");
17077   if (str)
17078     return strstr (str, "rm") == NULL;
17079   str = getenv ("SKIP_TEST_RM_1");
17080   if (str && strcmp (str, "1") == 0) return 1;
17081   str = getenv ("SKIP_TEST_RM");
17082   if (str && strcmp (str, "1") == 0) return 1;
17083   return 0;
17084 }
17085
17086 static int test_rm_1 (void)
17087 {
17088   if (test_rm_1_skip ()) {
17089     printf ("        %s skipped (reason: environment variable set)\n", "test_rm_1");
17090     return 0;
17091   }
17092
17093   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
17094   {
17095     char device[] = "/dev/sda";
17096     int r;
17097     suppress_error = 0;
17098     r = guestfs_blockdev_setrw (g, device);
17099     if (r == -1)
17100       return -1;
17101   }
17102   {
17103     int r;
17104     suppress_error = 0;
17105     r = guestfs_umount_all (g);
17106     if (r == -1)
17107       return -1;
17108   }
17109   {
17110     int r;
17111     suppress_error = 0;
17112     r = guestfs_lvm_remove_all (g);
17113     if (r == -1)
17114       return -1;
17115   }
17116   {
17117     char device[] = "/dev/sda";
17118     char lines_0[] = ",";
17119     char *lines[] = {
17120       lines_0,
17121       NULL
17122     };
17123     int r;
17124     suppress_error = 0;
17125     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17126     if (r == -1)
17127       return -1;
17128   }
17129   {
17130     char fstype[] = "ext2";
17131     char device[] = "/dev/sda1";
17132     int r;
17133     suppress_error = 0;
17134     r = guestfs_mkfs (g, fstype, device);
17135     if (r == -1)
17136       return -1;
17137   }
17138   {
17139     char device[] = "/dev/sda1";
17140     char mountpoint[] = "/";
17141     int r;
17142     suppress_error = 0;
17143     r = guestfs_mount (g, device, mountpoint);
17144     if (r == -1)
17145       return -1;
17146   }
17147   /* TestLastFail for rm (1) */
17148   {
17149     char path[] = "/new";
17150     int r;
17151     suppress_error = 1;
17152     r = guestfs_rm (g, path);
17153     if (r != -1)
17154       return -1;
17155   }
17156   return 0;
17157 }
17158
17159 static int test_rm_2_skip (void)
17160 {
17161   const char *str;
17162
17163   str = getenv ("TEST_ONLY");
17164   if (str)
17165     return strstr (str, "rm") == NULL;
17166   str = getenv ("SKIP_TEST_RM_2");
17167   if (str && strcmp (str, "1") == 0) return 1;
17168   str = getenv ("SKIP_TEST_RM");
17169   if (str && strcmp (str, "1") == 0) return 1;
17170   return 0;
17171 }
17172
17173 static int test_rm_2 (void)
17174 {
17175   if (test_rm_2_skip ()) {
17176     printf ("        %s skipped (reason: environment variable set)\n", "test_rm_2");
17177     return 0;
17178   }
17179
17180   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
17181   {
17182     char device[] = "/dev/sda";
17183     int r;
17184     suppress_error = 0;
17185     r = guestfs_blockdev_setrw (g, device);
17186     if (r == -1)
17187       return -1;
17188   }
17189   {
17190     int r;
17191     suppress_error = 0;
17192     r = guestfs_umount_all (g);
17193     if (r == -1)
17194       return -1;
17195   }
17196   {
17197     int r;
17198     suppress_error = 0;
17199     r = guestfs_lvm_remove_all (g);
17200     if (r == -1)
17201       return -1;
17202   }
17203   {
17204     char device[] = "/dev/sda";
17205     char lines_0[] = ",";
17206     char *lines[] = {
17207       lines_0,
17208       NULL
17209     };
17210     int r;
17211     suppress_error = 0;
17212     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17213     if (r == -1)
17214       return -1;
17215   }
17216   {
17217     char fstype[] = "ext2";
17218     char device[] = "/dev/sda1";
17219     int r;
17220     suppress_error = 0;
17221     r = guestfs_mkfs (g, fstype, device);
17222     if (r == -1)
17223       return -1;
17224   }
17225   {
17226     char device[] = "/dev/sda1";
17227     char mountpoint[] = "/";
17228     int r;
17229     suppress_error = 0;
17230     r = guestfs_mount (g, device, mountpoint);
17231     if (r == -1)
17232       return -1;
17233   }
17234   /* TestLastFail for rm (2) */
17235   {
17236     char path[] = "/new";
17237     int r;
17238     suppress_error = 0;
17239     r = guestfs_mkdir (g, path);
17240     if (r == -1)
17241       return -1;
17242   }
17243   {
17244     char path[] = "/new";
17245     int r;
17246     suppress_error = 1;
17247     r = guestfs_rm (g, path);
17248     if (r != -1)
17249       return -1;
17250   }
17251   return 0;
17252 }
17253
17254 static int test_read_lines_0_skip (void)
17255 {
17256   const char *str;
17257
17258   str = getenv ("TEST_ONLY");
17259   if (str)
17260     return strstr (str, "read_lines") == NULL;
17261   str = getenv ("SKIP_TEST_READ_LINES_0");
17262   if (str && strcmp (str, "1") == 0) return 1;
17263   str = getenv ("SKIP_TEST_READ_LINES");
17264   if (str && strcmp (str, "1") == 0) return 1;
17265   return 0;
17266 }
17267
17268 static int test_read_lines_0 (void)
17269 {
17270   if (test_read_lines_0_skip ()) {
17271     printf ("        %s skipped (reason: environment variable set)\n", "test_read_lines_0");
17272     return 0;
17273   }
17274
17275   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
17276   {
17277     char device[] = "/dev/sda";
17278     int r;
17279     suppress_error = 0;
17280     r = guestfs_blockdev_setrw (g, device);
17281     if (r == -1)
17282       return -1;
17283   }
17284   {
17285     int r;
17286     suppress_error = 0;
17287     r = guestfs_umount_all (g);
17288     if (r == -1)
17289       return -1;
17290   }
17291   {
17292     int r;
17293     suppress_error = 0;
17294     r = guestfs_lvm_remove_all (g);
17295     if (r == -1)
17296       return -1;
17297   }
17298   {
17299     char device[] = "/dev/sda";
17300     char lines_0[] = ",";
17301     char *lines[] = {
17302       lines_0,
17303       NULL
17304     };
17305     int r;
17306     suppress_error = 0;
17307     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17308     if (r == -1)
17309       return -1;
17310   }
17311   {
17312     char fstype[] = "ext2";
17313     char device[] = "/dev/sda1";
17314     int r;
17315     suppress_error = 0;
17316     r = guestfs_mkfs (g, fstype, device);
17317     if (r == -1)
17318       return -1;
17319   }
17320   {
17321     char device[] = "/dev/sda1";
17322     char mountpoint[] = "/";
17323     int r;
17324     suppress_error = 0;
17325     r = guestfs_mount (g, device, mountpoint);
17326     if (r == -1)
17327       return -1;
17328   }
17329   /* TestOutputList for read_lines (0) */
17330   {
17331     char path[] = "/new";
17332     char content[] = "line1\r\nline2\nline3";
17333     int r;
17334     suppress_error = 0;
17335     r = guestfs_write_file (g, path, content, 0);
17336     if (r == -1)
17337       return -1;
17338   }
17339   {
17340     char path[] = "/new";
17341     char **r;
17342     int i;
17343     suppress_error = 0;
17344     r = guestfs_read_lines (g, path);
17345     if (r == NULL)
17346       return -1;
17347     if (!r[0]) {
17348       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17349       print_strings (r);
17350       return -1;
17351     }
17352     {
17353       char expected[] = "line1";
17354       if (strcmp (r[0], expected) != 0) {
17355         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17356         return -1;
17357       }
17358     }
17359     if (!r[1]) {
17360       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17361       print_strings (r);
17362       return -1;
17363     }
17364     {
17365       char expected[] = "line2";
17366       if (strcmp (r[1], expected) != 0) {
17367         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17368         return -1;
17369       }
17370     }
17371     if (!r[2]) {
17372       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17373       print_strings (r);
17374       return -1;
17375     }
17376     {
17377       char expected[] = "line3";
17378       if (strcmp (r[2], expected) != 0) {
17379         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17380         return -1;
17381       }
17382     }
17383     if (r[3] != NULL) {
17384       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
17385       print_strings (r);
17386       return -1;
17387     }
17388     for (i = 0; r[i] != NULL; ++i)
17389       free (r[i]);
17390     free (r);
17391   }
17392   return 0;
17393 }
17394
17395 static int test_read_lines_1_skip (void)
17396 {
17397   const char *str;
17398
17399   str = getenv ("TEST_ONLY");
17400   if (str)
17401     return strstr (str, "read_lines") == NULL;
17402   str = getenv ("SKIP_TEST_READ_LINES_1");
17403   if (str && strcmp (str, "1") == 0) return 1;
17404   str = getenv ("SKIP_TEST_READ_LINES");
17405   if (str && strcmp (str, "1") == 0) return 1;
17406   return 0;
17407 }
17408
17409 static int test_read_lines_1 (void)
17410 {
17411   if (test_read_lines_1_skip ()) {
17412     printf ("        %s skipped (reason: environment variable set)\n", "test_read_lines_1");
17413     return 0;
17414   }
17415
17416   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
17417   {
17418     char device[] = "/dev/sda";
17419     int r;
17420     suppress_error = 0;
17421     r = guestfs_blockdev_setrw (g, device);
17422     if (r == -1)
17423       return -1;
17424   }
17425   {
17426     int r;
17427     suppress_error = 0;
17428     r = guestfs_umount_all (g);
17429     if (r == -1)
17430       return -1;
17431   }
17432   {
17433     int r;
17434     suppress_error = 0;
17435     r = guestfs_lvm_remove_all (g);
17436     if (r == -1)
17437       return -1;
17438   }
17439   {
17440     char device[] = "/dev/sda";
17441     char lines_0[] = ",";
17442     char *lines[] = {
17443       lines_0,
17444       NULL
17445     };
17446     int r;
17447     suppress_error = 0;
17448     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17449     if (r == -1)
17450       return -1;
17451   }
17452   {
17453     char fstype[] = "ext2";
17454     char device[] = "/dev/sda1";
17455     int r;
17456     suppress_error = 0;
17457     r = guestfs_mkfs (g, fstype, device);
17458     if (r == -1)
17459       return -1;
17460   }
17461   {
17462     char device[] = "/dev/sda1";
17463     char mountpoint[] = "/";
17464     int r;
17465     suppress_error = 0;
17466     r = guestfs_mount (g, device, mountpoint);
17467     if (r == -1)
17468       return -1;
17469   }
17470   /* TestOutputList for read_lines (1) */
17471   {
17472     char path[] = "/new";
17473     char content[] = "";
17474     int r;
17475     suppress_error = 0;
17476     r = guestfs_write_file (g, path, content, 0);
17477     if (r == -1)
17478       return -1;
17479   }
17480   {
17481     char path[] = "/new";
17482     char **r;
17483     int i;
17484     suppress_error = 0;
17485     r = guestfs_read_lines (g, path);
17486     if (r == NULL)
17487       return -1;
17488     if (r[0] != NULL) {
17489       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
17490       print_strings (r);
17491       return -1;
17492     }
17493     for (i = 0; r[i] != NULL; ++i)
17494       free (r[i]);
17495     free (r);
17496   }
17497   return 0;
17498 }
17499
17500 static int test_lvs_0_skip (void)
17501 {
17502   const char *str;
17503
17504   str = getenv ("TEST_ONLY");
17505   if (str)
17506     return strstr (str, "lvs") == NULL;
17507   str = getenv ("SKIP_TEST_LVS_0");
17508   if (str && strcmp (str, "1") == 0) return 1;
17509   str = getenv ("SKIP_TEST_LVS");
17510   if (str && strcmp (str, "1") == 0) return 1;
17511   return 0;
17512 }
17513
17514 static int test_lvs_0 (void)
17515 {
17516   if (test_lvs_0_skip ()) {
17517     printf ("        %s skipped (reason: environment variable set)\n", "test_lvs_0");
17518     return 0;
17519   }
17520
17521   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
17522   {
17523     char device[] = "/dev/sda";
17524     int r;
17525     suppress_error = 0;
17526     r = guestfs_blockdev_setrw (g, device);
17527     if (r == -1)
17528       return -1;
17529   }
17530   {
17531     int r;
17532     suppress_error = 0;
17533     r = guestfs_umount_all (g);
17534     if (r == -1)
17535       return -1;
17536   }
17537   {
17538     int r;
17539     suppress_error = 0;
17540     r = guestfs_lvm_remove_all (g);
17541     if (r == -1)
17542       return -1;
17543   }
17544   {
17545     char device[] = "/dev/sda";
17546     char lines_0[] = ",";
17547     char *lines[] = {
17548       lines_0,
17549       NULL
17550     };
17551     int r;
17552     suppress_error = 0;
17553     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17554     if (r == -1)
17555       return -1;
17556   }
17557   {
17558     char device[] = "/dev/sda1";
17559     int r;
17560     suppress_error = 0;
17561     r = guestfs_pvcreate (g, device);
17562     if (r == -1)
17563       return -1;
17564   }
17565   {
17566     char volgroup[] = "VG";
17567     char physvols_0[] = "/dev/sda1";
17568     char *physvols[] = {
17569       physvols_0,
17570       NULL
17571     };
17572     int r;
17573     suppress_error = 0;
17574     r = guestfs_vgcreate (g, volgroup, physvols);
17575     if (r == -1)
17576       return -1;
17577   }
17578   {
17579     char logvol[] = "LV";
17580     char volgroup[] = "VG";
17581     int r;
17582     suppress_error = 0;
17583     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17584     if (r == -1)
17585       return -1;
17586   }
17587   {
17588     char fstype[] = "ext2";
17589     char device[] = "/dev/VG/LV";
17590     int r;
17591     suppress_error = 0;
17592     r = guestfs_mkfs (g, fstype, device);
17593     if (r == -1)
17594       return -1;
17595   }
17596   {
17597     char device[] = "/dev/VG/LV";
17598     char mountpoint[] = "/";
17599     int r;
17600     suppress_error = 0;
17601     r = guestfs_mount (g, device, mountpoint);
17602     if (r == -1)
17603       return -1;
17604   }
17605   /* TestOutputList for lvs (0) */
17606   {
17607     char **r;
17608     int i;
17609     suppress_error = 0;
17610     r = guestfs_lvs (g);
17611     if (r == NULL)
17612       return -1;
17613     if (!r[0]) {
17614       fprintf (stderr, "test_lvs_0: short list returned from command\n");
17615       print_strings (r);
17616       return -1;
17617     }
17618     {
17619       char expected[] = "/dev/VG/LV";
17620       if (strcmp (r[0], expected) != 0) {
17621         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17622         return -1;
17623       }
17624     }
17625     if (r[1] != NULL) {
17626       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
17627       print_strings (r);
17628       return -1;
17629     }
17630     for (i = 0; r[i] != NULL; ++i)
17631       free (r[i]);
17632     free (r);
17633   }
17634   return 0;
17635 }
17636
17637 static int test_lvs_1_skip (void)
17638 {
17639   const char *str;
17640
17641   str = getenv ("TEST_ONLY");
17642   if (str)
17643     return strstr (str, "lvs") == NULL;
17644   str = getenv ("SKIP_TEST_LVS_1");
17645   if (str && strcmp (str, "1") == 0) return 1;
17646   str = getenv ("SKIP_TEST_LVS");
17647   if (str && strcmp (str, "1") == 0) return 1;
17648   return 0;
17649 }
17650
17651 static int test_lvs_1 (void)
17652 {
17653   if (test_lvs_1_skip ()) {
17654     printf ("        %s skipped (reason: environment variable set)\n", "test_lvs_1");
17655     return 0;
17656   }
17657
17658   /* InitNone|InitEmpty for test_lvs_1 */
17659   {
17660     char device[] = "/dev/sda";
17661     int r;
17662     suppress_error = 0;
17663     r = guestfs_blockdev_setrw (g, device);
17664     if (r == -1)
17665       return -1;
17666   }
17667   {
17668     int r;
17669     suppress_error = 0;
17670     r = guestfs_umount_all (g);
17671     if (r == -1)
17672       return -1;
17673   }
17674   {
17675     int r;
17676     suppress_error = 0;
17677     r = guestfs_lvm_remove_all (g);
17678     if (r == -1)
17679       return -1;
17680   }
17681   /* TestOutputList for lvs (1) */
17682   {
17683     char device[] = "/dev/sda";
17684     char lines_0[] = ",200";
17685     char lines_1[] = ",400";
17686     char lines_2[] = ",";
17687     char *lines[] = {
17688       lines_0,
17689       lines_1,
17690       lines_2,
17691       NULL
17692     };
17693     int r;
17694     suppress_error = 0;
17695     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17696     if (r == -1)
17697       return -1;
17698   }
17699   {
17700     char device[] = "/dev/sda1";
17701     int r;
17702     suppress_error = 0;
17703     r = guestfs_pvcreate (g, device);
17704     if (r == -1)
17705       return -1;
17706   }
17707   {
17708     char device[] = "/dev/sda2";
17709     int r;
17710     suppress_error = 0;
17711     r = guestfs_pvcreate (g, device);
17712     if (r == -1)
17713       return -1;
17714   }
17715   {
17716     char device[] = "/dev/sda3";
17717     int r;
17718     suppress_error = 0;
17719     r = guestfs_pvcreate (g, device);
17720     if (r == -1)
17721       return -1;
17722   }
17723   {
17724     char volgroup[] = "VG1";
17725     char physvols_0[] = "/dev/sda1";
17726     char physvols_1[] = "/dev/sda2";
17727     char *physvols[] = {
17728       physvols_0,
17729       physvols_1,
17730       NULL
17731     };
17732     int r;
17733     suppress_error = 0;
17734     r = guestfs_vgcreate (g, volgroup, physvols);
17735     if (r == -1)
17736       return -1;
17737   }
17738   {
17739     char volgroup[] = "VG2";
17740     char physvols_0[] = "/dev/sda3";
17741     char *physvols[] = {
17742       physvols_0,
17743       NULL
17744     };
17745     int r;
17746     suppress_error = 0;
17747     r = guestfs_vgcreate (g, volgroup, physvols);
17748     if (r == -1)
17749       return -1;
17750   }
17751   {
17752     char logvol[] = "LV1";
17753     char volgroup[] = "VG1";
17754     int r;
17755     suppress_error = 0;
17756     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17757     if (r == -1)
17758       return -1;
17759   }
17760   {
17761     char logvol[] = "LV2";
17762     char volgroup[] = "VG1";
17763     int r;
17764     suppress_error = 0;
17765     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17766     if (r == -1)
17767       return -1;
17768   }
17769   {
17770     char logvol[] = "LV3";
17771     char volgroup[] = "VG2";
17772     int r;
17773     suppress_error = 0;
17774     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17775     if (r == -1)
17776       return -1;
17777   }
17778   {
17779     char **r;
17780     int i;
17781     suppress_error = 0;
17782     r = guestfs_lvs (g);
17783     if (r == NULL)
17784       return -1;
17785     if (!r[0]) {
17786       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17787       print_strings (r);
17788       return -1;
17789     }
17790     {
17791       char expected[] = "/dev/VG1/LV1";
17792       if (strcmp (r[0], expected) != 0) {
17793         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17794         return -1;
17795       }
17796     }
17797     if (!r[1]) {
17798       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17799       print_strings (r);
17800       return -1;
17801     }
17802     {
17803       char expected[] = "/dev/VG1/LV2";
17804       if (strcmp (r[1], expected) != 0) {
17805         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17806         return -1;
17807       }
17808     }
17809     if (!r[2]) {
17810       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17811       print_strings (r);
17812       return -1;
17813     }
17814     {
17815       char expected[] = "/dev/VG2/LV3";
17816       if (strcmp (r[2], expected) != 0) {
17817         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17818         return -1;
17819       }
17820     }
17821     if (r[3] != NULL) {
17822       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17823       print_strings (r);
17824       return -1;
17825     }
17826     for (i = 0; r[i] != NULL; ++i)
17827       free (r[i]);
17828     free (r);
17829   }
17830   return 0;
17831 }
17832
17833 static int test_vgs_0_skip (void)
17834 {
17835   const char *str;
17836
17837   str = getenv ("TEST_ONLY");
17838   if (str)
17839     return strstr (str, "vgs") == NULL;
17840   str = getenv ("SKIP_TEST_VGS_0");
17841   if (str && strcmp (str, "1") == 0) return 1;
17842   str = getenv ("SKIP_TEST_VGS");
17843   if (str && strcmp (str, "1") == 0) return 1;
17844   return 0;
17845 }
17846
17847 static int test_vgs_0 (void)
17848 {
17849   if (test_vgs_0_skip ()) {
17850     printf ("        %s skipped (reason: environment variable set)\n", "test_vgs_0");
17851     return 0;
17852   }
17853
17854   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17855   {
17856     char device[] = "/dev/sda";
17857     int r;
17858     suppress_error = 0;
17859     r = guestfs_blockdev_setrw (g, device);
17860     if (r == -1)
17861       return -1;
17862   }
17863   {
17864     int r;
17865     suppress_error = 0;
17866     r = guestfs_umount_all (g);
17867     if (r == -1)
17868       return -1;
17869   }
17870   {
17871     int r;
17872     suppress_error = 0;
17873     r = guestfs_lvm_remove_all (g);
17874     if (r == -1)
17875       return -1;
17876   }
17877   {
17878     char device[] = "/dev/sda";
17879     char lines_0[] = ",";
17880     char *lines[] = {
17881       lines_0,
17882       NULL
17883     };
17884     int r;
17885     suppress_error = 0;
17886     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17887     if (r == -1)
17888       return -1;
17889   }
17890   {
17891     char device[] = "/dev/sda1";
17892     int r;
17893     suppress_error = 0;
17894     r = guestfs_pvcreate (g, device);
17895     if (r == -1)
17896       return -1;
17897   }
17898   {
17899     char volgroup[] = "VG";
17900     char physvols_0[] = "/dev/sda1";
17901     char *physvols[] = {
17902       physvols_0,
17903       NULL
17904     };
17905     int r;
17906     suppress_error = 0;
17907     r = guestfs_vgcreate (g, volgroup, physvols);
17908     if (r == -1)
17909       return -1;
17910   }
17911   {
17912     char logvol[] = "LV";
17913     char volgroup[] = "VG";
17914     int r;
17915     suppress_error = 0;
17916     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17917     if (r == -1)
17918       return -1;
17919   }
17920   {
17921     char fstype[] = "ext2";
17922     char device[] = "/dev/VG/LV";
17923     int r;
17924     suppress_error = 0;
17925     r = guestfs_mkfs (g, fstype, device);
17926     if (r == -1)
17927       return -1;
17928   }
17929   {
17930     char device[] = "/dev/VG/LV";
17931     char mountpoint[] = "/";
17932     int r;
17933     suppress_error = 0;
17934     r = guestfs_mount (g, device, mountpoint);
17935     if (r == -1)
17936       return -1;
17937   }
17938   /* TestOutputList for vgs (0) */
17939   {
17940     char **r;
17941     int i;
17942     suppress_error = 0;
17943     r = guestfs_vgs (g);
17944     if (r == NULL)
17945       return -1;
17946     if (!r[0]) {
17947       fprintf (stderr, "test_vgs_0: short list returned from command\n");
17948       print_strings (r);
17949       return -1;
17950     }
17951     {
17952       char expected[] = "VG";
17953       if (strcmp (r[0], expected) != 0) {
17954         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17955         return -1;
17956       }
17957     }
17958     if (r[1] != NULL) {
17959       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17960       print_strings (r);
17961       return -1;
17962     }
17963     for (i = 0; r[i] != NULL; ++i)
17964       free (r[i]);
17965     free (r);
17966   }
17967   return 0;
17968 }
17969
17970 static int test_vgs_1_skip (void)
17971 {
17972   const char *str;
17973
17974   str = getenv ("TEST_ONLY");
17975   if (str)
17976     return strstr (str, "vgs") == NULL;
17977   str = getenv ("SKIP_TEST_VGS_1");
17978   if (str && strcmp (str, "1") == 0) return 1;
17979   str = getenv ("SKIP_TEST_VGS");
17980   if (str && strcmp (str, "1") == 0) return 1;
17981   return 0;
17982 }
17983
17984 static int test_vgs_1 (void)
17985 {
17986   if (test_vgs_1_skip ()) {
17987     printf ("        %s skipped (reason: environment variable set)\n", "test_vgs_1");
17988     return 0;
17989   }
17990
17991   /* InitNone|InitEmpty for test_vgs_1 */
17992   {
17993     char device[] = "/dev/sda";
17994     int r;
17995     suppress_error = 0;
17996     r = guestfs_blockdev_setrw (g, device);
17997     if (r == -1)
17998       return -1;
17999   }
18000   {
18001     int r;
18002     suppress_error = 0;
18003     r = guestfs_umount_all (g);
18004     if (r == -1)
18005       return -1;
18006   }
18007   {
18008     int r;
18009     suppress_error = 0;
18010     r = guestfs_lvm_remove_all (g);
18011     if (r == -1)
18012       return -1;
18013   }
18014   /* TestOutputList for vgs (1) */
18015   {
18016     char device[] = "/dev/sda";
18017     char lines_0[] = ",200";
18018     char lines_1[] = ",400";
18019     char lines_2[] = ",";
18020     char *lines[] = {
18021       lines_0,
18022       lines_1,
18023       lines_2,
18024       NULL
18025     };
18026     int r;
18027     suppress_error = 0;
18028     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18029     if (r == -1)
18030       return -1;
18031   }
18032   {
18033     char device[] = "/dev/sda1";
18034     int r;
18035     suppress_error = 0;
18036     r = guestfs_pvcreate (g, device);
18037     if (r == -1)
18038       return -1;
18039   }
18040   {
18041     char device[] = "/dev/sda2";
18042     int r;
18043     suppress_error = 0;
18044     r = guestfs_pvcreate (g, device);
18045     if (r == -1)
18046       return -1;
18047   }
18048   {
18049     char device[] = "/dev/sda3";
18050     int r;
18051     suppress_error = 0;
18052     r = guestfs_pvcreate (g, device);
18053     if (r == -1)
18054       return -1;
18055   }
18056   {
18057     char volgroup[] = "VG1";
18058     char physvols_0[] = "/dev/sda1";
18059     char physvols_1[] = "/dev/sda2";
18060     char *physvols[] = {
18061       physvols_0,
18062       physvols_1,
18063       NULL
18064     };
18065     int r;
18066     suppress_error = 0;
18067     r = guestfs_vgcreate (g, volgroup, physvols);
18068     if (r == -1)
18069       return -1;
18070   }
18071   {
18072     char volgroup[] = "VG2";
18073     char physvols_0[] = "/dev/sda3";
18074     char *physvols[] = {
18075       physvols_0,
18076       NULL
18077     };
18078     int r;
18079     suppress_error = 0;
18080     r = guestfs_vgcreate (g, volgroup, physvols);
18081     if (r == -1)
18082       return -1;
18083   }
18084   {
18085     char **r;
18086     int i;
18087     suppress_error = 0;
18088     r = guestfs_vgs (g);
18089     if (r == NULL)
18090       return -1;
18091     if (!r[0]) {
18092       fprintf (stderr, "test_vgs_1: short list returned from command\n");
18093       print_strings (r);
18094       return -1;
18095     }
18096     {
18097       char expected[] = "VG1";
18098       if (strcmp (r[0], expected) != 0) {
18099         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18100         return -1;
18101       }
18102     }
18103     if (!r[1]) {
18104       fprintf (stderr, "test_vgs_1: short list returned from command\n");
18105       print_strings (r);
18106       return -1;
18107     }
18108     {
18109       char expected[] = "VG2";
18110       if (strcmp (r[1], expected) != 0) {
18111         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18112         return -1;
18113       }
18114     }
18115     if (r[2] != NULL) {
18116       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
18117       print_strings (r);
18118       return -1;
18119     }
18120     for (i = 0; r[i] != NULL; ++i)
18121       free (r[i]);
18122     free (r);
18123   }
18124   return 0;
18125 }
18126
18127 static int test_pvs_0_skip (void)
18128 {
18129   const char *str;
18130
18131   str = getenv ("TEST_ONLY");
18132   if (str)
18133     return strstr (str, "pvs") == NULL;
18134   str = getenv ("SKIP_TEST_PVS_0");
18135   if (str && strcmp (str, "1") == 0) return 1;
18136   str = getenv ("SKIP_TEST_PVS");
18137   if (str && strcmp (str, "1") == 0) return 1;
18138   return 0;
18139 }
18140
18141 static int test_pvs_0 (void)
18142 {
18143   if (test_pvs_0_skip ()) {
18144     printf ("        %s skipped (reason: environment variable set)\n", "test_pvs_0");
18145     return 0;
18146   }
18147
18148   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
18149   {
18150     char device[] = "/dev/sda";
18151     int r;
18152     suppress_error = 0;
18153     r = guestfs_blockdev_setrw (g, device);
18154     if (r == -1)
18155       return -1;
18156   }
18157   {
18158     int r;
18159     suppress_error = 0;
18160     r = guestfs_umount_all (g);
18161     if (r == -1)
18162       return -1;
18163   }
18164   {
18165     int r;
18166     suppress_error = 0;
18167     r = guestfs_lvm_remove_all (g);
18168     if (r == -1)
18169       return -1;
18170   }
18171   {
18172     char device[] = "/dev/sda";
18173     char lines_0[] = ",";
18174     char *lines[] = {
18175       lines_0,
18176       NULL
18177     };
18178     int r;
18179     suppress_error = 0;
18180     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18181     if (r == -1)
18182       return -1;
18183   }
18184   {
18185     char device[] = "/dev/sda1";
18186     int r;
18187     suppress_error = 0;
18188     r = guestfs_pvcreate (g, device);
18189     if (r == -1)
18190       return -1;
18191   }
18192   {
18193     char volgroup[] = "VG";
18194     char physvols_0[] = "/dev/sda1";
18195     char *physvols[] = {
18196       physvols_0,
18197       NULL
18198     };
18199     int r;
18200     suppress_error = 0;
18201     r = guestfs_vgcreate (g, volgroup, physvols);
18202     if (r == -1)
18203       return -1;
18204   }
18205   {
18206     char logvol[] = "LV";
18207     char volgroup[] = "VG";
18208     int r;
18209     suppress_error = 0;
18210     r = guestfs_lvcreate (g, logvol, volgroup, 8);
18211     if (r == -1)
18212       return -1;
18213   }
18214   {
18215     char fstype[] = "ext2";
18216     char device[] = "/dev/VG/LV";
18217     int r;
18218     suppress_error = 0;
18219     r = guestfs_mkfs (g, fstype, device);
18220     if (r == -1)
18221       return -1;
18222   }
18223   {
18224     char device[] = "/dev/VG/LV";
18225     char mountpoint[] = "/";
18226     int r;
18227     suppress_error = 0;
18228     r = guestfs_mount (g, device, mountpoint);
18229     if (r == -1)
18230       return -1;
18231   }
18232   /* TestOutputListOfDevices for pvs (0) */
18233   {
18234     char **r;
18235     int i;
18236     suppress_error = 0;
18237     r = guestfs_pvs (g);
18238     if (r == NULL)
18239       return -1;
18240     if (!r[0]) {
18241       fprintf (stderr, "test_pvs_0: short list returned from command\n");
18242       print_strings (r);
18243       return -1;
18244     }
18245     {
18246       char expected[] = "/dev/sda1";
18247       r[0][5] = 's';
18248       if (strcmp (r[0], expected) != 0) {
18249         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18250         return -1;
18251       }
18252     }
18253     if (r[1] != NULL) {
18254       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
18255       print_strings (r);
18256       return -1;
18257     }
18258     for (i = 0; r[i] != NULL; ++i)
18259       free (r[i]);
18260     free (r);
18261   }
18262   return 0;
18263 }
18264
18265 static int test_pvs_1_skip (void)
18266 {
18267   const char *str;
18268
18269   str = getenv ("TEST_ONLY");
18270   if (str)
18271     return strstr (str, "pvs") == NULL;
18272   str = getenv ("SKIP_TEST_PVS_1");
18273   if (str && strcmp (str, "1") == 0) return 1;
18274   str = getenv ("SKIP_TEST_PVS");
18275   if (str && strcmp (str, "1") == 0) return 1;
18276   return 0;
18277 }
18278
18279 static int test_pvs_1 (void)
18280 {
18281   if (test_pvs_1_skip ()) {
18282     printf ("        %s skipped (reason: environment variable set)\n", "test_pvs_1");
18283     return 0;
18284   }
18285
18286   /* InitNone|InitEmpty for test_pvs_1 */
18287   {
18288     char device[] = "/dev/sda";
18289     int r;
18290     suppress_error = 0;
18291     r = guestfs_blockdev_setrw (g, device);
18292     if (r == -1)
18293       return -1;
18294   }
18295   {
18296     int r;
18297     suppress_error = 0;
18298     r = guestfs_umount_all (g);
18299     if (r == -1)
18300       return -1;
18301   }
18302   {
18303     int r;
18304     suppress_error = 0;
18305     r = guestfs_lvm_remove_all (g);
18306     if (r == -1)
18307       return -1;
18308   }
18309   /* TestOutputListOfDevices for pvs (1) */
18310   {
18311     char device[] = "/dev/sda";
18312     char lines_0[] = ",200";
18313     char lines_1[] = ",400";
18314     char lines_2[] = ",";
18315     char *lines[] = {
18316       lines_0,
18317       lines_1,
18318       lines_2,
18319       NULL
18320     };
18321     int r;
18322     suppress_error = 0;
18323     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18324     if (r == -1)
18325       return -1;
18326   }
18327   {
18328     char device[] = "/dev/sda1";
18329     int r;
18330     suppress_error = 0;
18331     r = guestfs_pvcreate (g, device);
18332     if (r == -1)
18333       return -1;
18334   }
18335   {
18336     char device[] = "/dev/sda2";
18337     int r;
18338     suppress_error = 0;
18339     r = guestfs_pvcreate (g, device);
18340     if (r == -1)
18341       return -1;
18342   }
18343   {
18344     char device[] = "/dev/sda3";
18345     int r;
18346     suppress_error = 0;
18347     r = guestfs_pvcreate (g, device);
18348     if (r == -1)
18349       return -1;
18350   }
18351   {
18352     char **r;
18353     int i;
18354     suppress_error = 0;
18355     r = guestfs_pvs (g);
18356     if (r == NULL)
18357       return -1;
18358     if (!r[0]) {
18359       fprintf (stderr, "test_pvs_1: short list returned from command\n");
18360       print_strings (r);
18361       return -1;
18362     }
18363     {
18364       char expected[] = "/dev/sda1";
18365       r[0][5] = 's';
18366       if (strcmp (r[0], expected) != 0) {
18367         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18368         return -1;
18369       }
18370     }
18371     if (!r[1]) {
18372       fprintf (stderr, "test_pvs_1: short list returned from command\n");
18373       print_strings (r);
18374       return -1;
18375     }
18376     {
18377       char expected[] = "/dev/sda2";
18378       r[1][5] = 's';
18379       if (strcmp (r[1], expected) != 0) {
18380         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18381         return -1;
18382       }
18383     }
18384     if (!r[2]) {
18385       fprintf (stderr, "test_pvs_1: short list returned from command\n");
18386       print_strings (r);
18387       return -1;
18388     }
18389     {
18390       char expected[] = "/dev/sda3";
18391       r[2][5] = 's';
18392       if (strcmp (r[2], expected) != 0) {
18393         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18394         return -1;
18395       }
18396     }
18397     if (r[3] != NULL) {
18398       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
18399       print_strings (r);
18400       return -1;
18401     }
18402     for (i = 0; r[i] != NULL; ++i)
18403       free (r[i]);
18404     free (r);
18405   }
18406   return 0;
18407 }
18408
18409 static int test_list_partitions_0_skip (void)
18410 {
18411   const char *str;
18412
18413   str = getenv ("TEST_ONLY");
18414   if (str)
18415     return strstr (str, "list_partitions") == NULL;
18416   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
18417   if (str && strcmp (str, "1") == 0) return 1;
18418   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18419   if (str && strcmp (str, "1") == 0) return 1;
18420   return 0;
18421 }
18422
18423 static int test_list_partitions_0 (void)
18424 {
18425   if (test_list_partitions_0_skip ()) {
18426     printf ("        %s skipped (reason: environment variable set)\n", "test_list_partitions_0");
18427     return 0;
18428   }
18429
18430   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
18431   {
18432     char device[] = "/dev/sda";
18433     int r;
18434     suppress_error = 0;
18435     r = guestfs_blockdev_setrw (g, device);
18436     if (r == -1)
18437       return -1;
18438   }
18439   {
18440     int r;
18441     suppress_error = 0;
18442     r = guestfs_umount_all (g);
18443     if (r == -1)
18444       return -1;
18445   }
18446   {
18447     int r;
18448     suppress_error = 0;
18449     r = guestfs_lvm_remove_all (g);
18450     if (r == -1)
18451       return -1;
18452   }
18453   {
18454     char device[] = "/dev/sda";
18455     char lines_0[] = ",";
18456     char *lines[] = {
18457       lines_0,
18458       NULL
18459     };
18460     int r;
18461     suppress_error = 0;
18462     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18463     if (r == -1)
18464       return -1;
18465   }
18466   {
18467     char fstype[] = "ext2";
18468     char device[] = "/dev/sda1";
18469     int r;
18470     suppress_error = 0;
18471     r = guestfs_mkfs (g, fstype, device);
18472     if (r == -1)
18473       return -1;
18474   }
18475   {
18476     char device[] = "/dev/sda1";
18477     char mountpoint[] = "/";
18478     int r;
18479     suppress_error = 0;
18480     r = guestfs_mount (g, device, mountpoint);
18481     if (r == -1)
18482       return -1;
18483   }
18484   /* TestOutputListOfDevices for list_partitions (0) */
18485   {
18486     char **r;
18487     int i;
18488     suppress_error = 0;
18489     r = guestfs_list_partitions (g);
18490     if (r == NULL)
18491       return -1;
18492     if (!r[0]) {
18493       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
18494       print_strings (r);
18495       return -1;
18496     }
18497     {
18498       char expected[] = "/dev/sda1";
18499       r[0][5] = 's';
18500       if (strcmp (r[0], expected) != 0) {
18501         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18502         return -1;
18503       }
18504     }
18505     if (r[1] != NULL) {
18506       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
18507       print_strings (r);
18508       return -1;
18509     }
18510     for (i = 0; r[i] != NULL; ++i)
18511       free (r[i]);
18512     free (r);
18513   }
18514   return 0;
18515 }
18516
18517 static int test_list_partitions_1_skip (void)
18518 {
18519   const char *str;
18520
18521   str = getenv ("TEST_ONLY");
18522   if (str)
18523     return strstr (str, "list_partitions") == NULL;
18524   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
18525   if (str && strcmp (str, "1") == 0) return 1;
18526   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18527   if (str && strcmp (str, "1") == 0) return 1;
18528   return 0;
18529 }
18530
18531 static int test_list_partitions_1 (void)
18532 {
18533   if (test_list_partitions_1_skip ()) {
18534     printf ("        %s skipped (reason: environment variable set)\n", "test_list_partitions_1");
18535     return 0;
18536   }
18537
18538   /* InitNone|InitEmpty for test_list_partitions_1 */
18539   {
18540     char device[] = "/dev/sda";
18541     int r;
18542     suppress_error = 0;
18543     r = guestfs_blockdev_setrw (g, device);
18544     if (r == -1)
18545       return -1;
18546   }
18547   {
18548     int r;
18549     suppress_error = 0;
18550     r = guestfs_umount_all (g);
18551     if (r == -1)
18552       return -1;
18553   }
18554   {
18555     int r;
18556     suppress_error = 0;
18557     r = guestfs_lvm_remove_all (g);
18558     if (r == -1)
18559       return -1;
18560   }
18561   /* TestOutputListOfDevices for list_partitions (1) */
18562   {
18563     char device[] = "/dev/sda";
18564     char lines_0[] = ",200";
18565     char lines_1[] = ",400";
18566     char lines_2[] = ",";
18567     char *lines[] = {
18568       lines_0,
18569       lines_1,
18570       lines_2,
18571       NULL
18572     };
18573     int r;
18574     suppress_error = 0;
18575     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18576     if (r == -1)
18577       return -1;
18578   }
18579   {
18580     char **r;
18581     int i;
18582     suppress_error = 0;
18583     r = guestfs_list_partitions (g);
18584     if (r == NULL)
18585       return -1;
18586     if (!r[0]) {
18587       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18588       print_strings (r);
18589       return -1;
18590     }
18591     {
18592       char expected[] = "/dev/sda1";
18593       r[0][5] = 's';
18594       if (strcmp (r[0], expected) != 0) {
18595         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18596         return -1;
18597       }
18598     }
18599     if (!r[1]) {
18600       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18601       print_strings (r);
18602       return -1;
18603     }
18604     {
18605       char expected[] = "/dev/sda2";
18606       r[1][5] = 's';
18607       if (strcmp (r[1], expected) != 0) {
18608         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18609         return -1;
18610       }
18611     }
18612     if (!r[2]) {
18613       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18614       print_strings (r);
18615       return -1;
18616     }
18617     {
18618       char expected[] = "/dev/sda3";
18619       r[2][5] = 's';
18620       if (strcmp (r[2], expected) != 0) {
18621         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18622         return -1;
18623       }
18624     }
18625     if (r[3] != NULL) {
18626       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
18627       print_strings (r);
18628       return -1;
18629     }
18630     for (i = 0; r[i] != NULL; ++i)
18631       free (r[i]);
18632     free (r);
18633   }
18634   return 0;
18635 }
18636
18637 static int test_list_devices_0_skip (void)
18638 {
18639   const char *str;
18640
18641   str = getenv ("TEST_ONLY");
18642   if (str)
18643     return strstr (str, "list_devices") == NULL;
18644   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18645   if (str && strcmp (str, "1") == 0) return 1;
18646   str = getenv ("SKIP_TEST_LIST_DEVICES");
18647   if (str && strcmp (str, "1") == 0) return 1;
18648   return 0;
18649 }
18650
18651 static int test_list_devices_0 (void)
18652 {
18653   if (test_list_devices_0_skip ()) {
18654     printf ("        %s skipped (reason: environment variable set)\n", "test_list_devices_0");
18655     return 0;
18656   }
18657
18658   /* InitNone|InitEmpty for test_list_devices_0 */
18659   {
18660     char device[] = "/dev/sda";
18661     int r;
18662     suppress_error = 0;
18663     r = guestfs_blockdev_setrw (g, device);
18664     if (r == -1)
18665       return -1;
18666   }
18667   {
18668     int r;
18669     suppress_error = 0;
18670     r = guestfs_umount_all (g);
18671     if (r == -1)
18672       return -1;
18673   }
18674   {
18675     int r;
18676     suppress_error = 0;
18677     r = guestfs_lvm_remove_all (g);
18678     if (r == -1)
18679       return -1;
18680   }
18681   /* TestOutputListOfDevices for list_devices (0) */
18682   {
18683     char **r;
18684     int i;
18685     suppress_error = 0;
18686     r = guestfs_list_devices (g);
18687     if (r == NULL)
18688       return -1;
18689     if (!r[0]) {
18690       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18691       print_strings (r);
18692       return -1;
18693     }
18694     {
18695       char expected[] = "/dev/sda";
18696       r[0][5] = 's';
18697       if (strcmp (r[0], expected) != 0) {
18698         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18699         return -1;
18700       }
18701     }
18702     if (!r[1]) {
18703       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18704       print_strings (r);
18705       return -1;
18706     }
18707     {
18708       char expected[] = "/dev/sdb";
18709       r[1][5] = 's';
18710       if (strcmp (r[1], expected) != 0) {
18711         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18712         return -1;
18713       }
18714     }
18715     if (!r[2]) {
18716       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18717       print_strings (r);
18718       return -1;
18719     }
18720     {
18721       char expected[] = "/dev/sdc";
18722       r[2][5] = 's';
18723       if (strcmp (r[2], expected) != 0) {
18724         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18725         return -1;
18726       }
18727     }
18728     if (!r[3]) {
18729       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18730       print_strings (r);
18731       return -1;
18732     }
18733     {
18734       char expected[] = "/dev/sdd";
18735       r[3][5] = 's';
18736       if (strcmp (r[3], expected) != 0) {
18737         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18738         return -1;
18739       }
18740     }
18741     if (r[4] != NULL) {
18742       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18743       print_strings (r);
18744       return -1;
18745     }
18746     for (i = 0; r[i] != NULL; ++i)
18747       free (r[i]);
18748     free (r);
18749   }
18750   return 0;
18751 }
18752
18753 static int test_ls_0_skip (void)
18754 {
18755   const char *str;
18756
18757   str = getenv ("TEST_ONLY");
18758   if (str)
18759     return strstr (str, "ls") == NULL;
18760   str = getenv ("SKIP_TEST_LS_0");
18761   if (str && strcmp (str, "1") == 0) return 1;
18762   str = getenv ("SKIP_TEST_LS");
18763   if (str && strcmp (str, "1") == 0) return 1;
18764   return 0;
18765 }
18766
18767 static int test_ls_0 (void)
18768 {
18769   if (test_ls_0_skip ()) {
18770     printf ("        %s skipped (reason: environment variable set)\n", "test_ls_0");
18771     return 0;
18772   }
18773
18774   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18775   {
18776     char device[] = "/dev/sda";
18777     int r;
18778     suppress_error = 0;
18779     r = guestfs_blockdev_setrw (g, device);
18780     if (r == -1)
18781       return -1;
18782   }
18783   {
18784     int r;
18785     suppress_error = 0;
18786     r = guestfs_umount_all (g);
18787     if (r == -1)
18788       return -1;
18789   }
18790   {
18791     int r;
18792     suppress_error = 0;
18793     r = guestfs_lvm_remove_all (g);
18794     if (r == -1)
18795       return -1;
18796   }
18797   {
18798     char device[] = "/dev/sda";
18799     char lines_0[] = ",";
18800     char *lines[] = {
18801       lines_0,
18802       NULL
18803     };
18804     int r;
18805     suppress_error = 0;
18806     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18807     if (r == -1)
18808       return -1;
18809   }
18810   {
18811     char fstype[] = "ext2";
18812     char device[] = "/dev/sda1";
18813     int r;
18814     suppress_error = 0;
18815     r = guestfs_mkfs (g, fstype, device);
18816     if (r == -1)
18817       return -1;
18818   }
18819   {
18820     char device[] = "/dev/sda1";
18821     char mountpoint[] = "/";
18822     int r;
18823     suppress_error = 0;
18824     r = guestfs_mount (g, device, mountpoint);
18825     if (r == -1)
18826       return -1;
18827   }
18828   /* TestOutputList for ls (0) */
18829   {
18830     char path[] = "/new";
18831     int r;
18832     suppress_error = 0;
18833     r = guestfs_touch (g, path);
18834     if (r == -1)
18835       return -1;
18836   }
18837   {
18838     char path[] = "/newer";
18839     int r;
18840     suppress_error = 0;
18841     r = guestfs_touch (g, path);
18842     if (r == -1)
18843       return -1;
18844   }
18845   {
18846     char path[] = "/newest";
18847     int r;
18848     suppress_error = 0;
18849     r = guestfs_touch (g, path);
18850     if (r == -1)
18851       return -1;
18852   }
18853   {
18854     char directory[] = "/";
18855     char **r;
18856     int i;
18857     suppress_error = 0;
18858     r = guestfs_ls (g, directory);
18859     if (r == NULL)
18860       return -1;
18861     if (!r[0]) {
18862       fprintf (stderr, "test_ls_0: short list returned from command\n");
18863       print_strings (r);
18864       return -1;
18865     }
18866     {
18867       char expected[] = "lost+found";
18868       if (strcmp (r[0], expected) != 0) {
18869         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18870         return -1;
18871       }
18872     }
18873     if (!r[1]) {
18874       fprintf (stderr, "test_ls_0: short list returned from command\n");
18875       print_strings (r);
18876       return -1;
18877     }
18878     {
18879       char expected[] = "new";
18880       if (strcmp (r[1], expected) != 0) {
18881         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18882         return -1;
18883       }
18884     }
18885     if (!r[2]) {
18886       fprintf (stderr, "test_ls_0: short list returned from command\n");
18887       print_strings (r);
18888       return -1;
18889     }
18890     {
18891       char expected[] = "newer";
18892       if (strcmp (r[2], expected) != 0) {
18893         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18894         return -1;
18895       }
18896     }
18897     if (!r[3]) {
18898       fprintf (stderr, "test_ls_0: short list returned from command\n");
18899       print_strings (r);
18900       return -1;
18901     }
18902     {
18903       char expected[] = "newest";
18904       if (strcmp (r[3], expected) != 0) {
18905         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18906         return -1;
18907       }
18908     }
18909     if (r[4] != NULL) {
18910       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18911       print_strings (r);
18912       return -1;
18913     }
18914     for (i = 0; r[i] != NULL; ++i)
18915       free (r[i]);
18916     free (r);
18917   }
18918   return 0;
18919 }
18920
18921 static int test_cat_0_skip (void)
18922 {
18923   const char *str;
18924
18925   str = getenv ("TEST_ONLY");
18926   if (str)
18927     return strstr (str, "cat") == NULL;
18928   str = getenv ("SKIP_TEST_CAT_0");
18929   if (str && strcmp (str, "1") == 0) return 1;
18930   str = getenv ("SKIP_TEST_CAT");
18931   if (str && strcmp (str, "1") == 0) return 1;
18932   return 0;
18933 }
18934
18935 static int test_cat_0 (void)
18936 {
18937   if (test_cat_0_skip ()) {
18938     printf ("        %s skipped (reason: environment variable set)\n", "test_cat_0");
18939     return 0;
18940   }
18941
18942   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18943   {
18944     char device[] = "/dev/sda";
18945     int r;
18946     suppress_error = 0;
18947     r = guestfs_blockdev_setrw (g, device);
18948     if (r == -1)
18949       return -1;
18950   }
18951   {
18952     int r;
18953     suppress_error = 0;
18954     r = guestfs_umount_all (g);
18955     if (r == -1)
18956       return -1;
18957   }
18958   {
18959     int r;
18960     suppress_error = 0;
18961     r = guestfs_lvm_remove_all (g);
18962     if (r == -1)
18963       return -1;
18964   }
18965   {
18966     char device[] = "/dev/sda";
18967     char lines_0[] = ",";
18968     char *lines[] = {
18969       lines_0,
18970       NULL
18971     };
18972     int r;
18973     suppress_error = 0;
18974     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18975     if (r == -1)
18976       return -1;
18977   }
18978   {
18979     char fstype[] = "ext2";
18980     char device[] = "/dev/sda1";
18981     int r;
18982     suppress_error = 0;
18983     r = guestfs_mkfs (g, fstype, device);
18984     if (r == -1)
18985       return -1;
18986   }
18987   {
18988     char device[] = "/dev/sda1";
18989     char mountpoint[] = "/";
18990     int r;
18991     suppress_error = 0;
18992     r = guestfs_mount (g, device, mountpoint);
18993     if (r == -1)
18994       return -1;
18995   }
18996   /* TestOutput for cat (0) */
18997   char expected[] = "new file contents";
18998   {
18999     char path[] = "/new";
19000     char content[] = "new file contents";
19001     int r;
19002     suppress_error = 0;
19003     r = guestfs_write_file (g, path, content, 0);
19004     if (r == -1)
19005       return -1;
19006   }
19007   {
19008     char path[] = "/new";
19009     char *r;
19010     suppress_error = 0;
19011     r = guestfs_cat (g, path);
19012     if (r == NULL)
19013       return -1;
19014     if (strcmp (r, expected) != 0) {
19015       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
19016       return -1;
19017     }
19018     free (r);
19019   }
19020   return 0;
19021 }
19022
19023 static int test_touch_0_skip (void)
19024 {
19025   const char *str;
19026
19027   str = getenv ("TEST_ONLY");
19028   if (str)
19029     return strstr (str, "touch") == NULL;
19030   str = getenv ("SKIP_TEST_TOUCH_0");
19031   if (str && strcmp (str, "1") == 0) return 1;
19032   str = getenv ("SKIP_TEST_TOUCH");
19033   if (str && strcmp (str, "1") == 0) return 1;
19034   return 0;
19035 }
19036
19037 static int test_touch_0 (void)
19038 {
19039   if (test_touch_0_skip ()) {
19040     printf ("        %s skipped (reason: environment variable set)\n", "test_touch_0");
19041     return 0;
19042   }
19043
19044   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
19045   {
19046     char device[] = "/dev/sda";
19047     int r;
19048     suppress_error = 0;
19049     r = guestfs_blockdev_setrw (g, device);
19050     if (r == -1)
19051       return -1;
19052   }
19053   {
19054     int r;
19055     suppress_error = 0;
19056     r = guestfs_umount_all (g);
19057     if (r == -1)
19058       return -1;
19059   }
19060   {
19061     int r;
19062     suppress_error = 0;
19063     r = guestfs_lvm_remove_all (g);
19064     if (r == -1)
19065       return -1;
19066   }
19067   {
19068     char device[] = "/dev/sda";
19069     char lines_0[] = ",";
19070     char *lines[] = {
19071       lines_0,
19072       NULL
19073     };
19074     int r;
19075     suppress_error = 0;
19076     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19077     if (r == -1)
19078       return -1;
19079   }
19080   {
19081     char fstype[] = "ext2";
19082     char device[] = "/dev/sda1";
19083     int r;
19084     suppress_error = 0;
19085     r = guestfs_mkfs (g, fstype, device);
19086     if (r == -1)
19087       return -1;
19088   }
19089   {
19090     char device[] = "/dev/sda1";
19091     char mountpoint[] = "/";
19092     int r;
19093     suppress_error = 0;
19094     r = guestfs_mount (g, device, mountpoint);
19095     if (r == -1)
19096       return -1;
19097   }
19098   /* TestOutputTrue for touch (0) */
19099   {
19100     char path[] = "/new";
19101     int r;
19102     suppress_error = 0;
19103     r = guestfs_touch (g, path);
19104     if (r == -1)
19105       return -1;
19106   }
19107   {
19108     char path[] = "/new";
19109     int r;
19110     suppress_error = 0;
19111     r = guestfs_exists (g, path);
19112     if (r == -1)
19113       return -1;
19114     if (!r) {
19115       fprintf (stderr, "test_touch_0: expected true, got false\n");
19116       return -1;
19117     }
19118   }
19119   return 0;
19120 }
19121
19122 static int test_sync_0_skip (void)
19123 {
19124   const char *str;
19125
19126   str = getenv ("TEST_ONLY");
19127   if (str)
19128     return strstr (str, "sync") == NULL;
19129   str = getenv ("SKIP_TEST_SYNC_0");
19130   if (str && strcmp (str, "1") == 0) return 1;
19131   str = getenv ("SKIP_TEST_SYNC");
19132   if (str && strcmp (str, "1") == 0) return 1;
19133   return 0;
19134 }
19135
19136 static int test_sync_0 (void)
19137 {
19138   if (test_sync_0_skip ()) {
19139     printf ("        %s skipped (reason: environment variable set)\n", "test_sync_0");
19140     return 0;
19141   }
19142
19143   /* InitNone|InitEmpty for test_sync_0 */
19144   {
19145     char device[] = "/dev/sda";
19146     int r;
19147     suppress_error = 0;
19148     r = guestfs_blockdev_setrw (g, device);
19149     if (r == -1)
19150       return -1;
19151   }
19152   {
19153     int r;
19154     suppress_error = 0;
19155     r = guestfs_umount_all (g);
19156     if (r == -1)
19157       return -1;
19158   }
19159   {
19160     int r;
19161     suppress_error = 0;
19162     r = guestfs_lvm_remove_all (g);
19163     if (r == -1)
19164       return -1;
19165   }
19166   /* TestRun for sync (0) */
19167   {
19168     int r;
19169     suppress_error = 0;
19170     r = guestfs_sync (g);
19171     if (r == -1)
19172       return -1;
19173   }
19174   return 0;
19175 }
19176
19177 static int test_mount_0_skip (void)
19178 {
19179   const char *str;
19180
19181   str = getenv ("TEST_ONLY");
19182   if (str)
19183     return strstr (str, "mount") == NULL;
19184   str = getenv ("SKIP_TEST_MOUNT_0");
19185   if (str && strcmp (str, "1") == 0) return 1;
19186   str = getenv ("SKIP_TEST_MOUNT");
19187   if (str && strcmp (str, "1") == 0) return 1;
19188   return 0;
19189 }
19190
19191 static int test_mount_0 (void)
19192 {
19193   if (test_mount_0_skip ()) {
19194     printf ("        %s skipped (reason: environment variable set)\n", "test_mount_0");
19195     return 0;
19196   }
19197
19198   /* InitNone|InitEmpty for test_mount_0 */
19199   {
19200     char device[] = "/dev/sda";
19201     int r;
19202     suppress_error = 0;
19203     r = guestfs_blockdev_setrw (g, device);
19204     if (r == -1)
19205       return -1;
19206   }
19207   {
19208     int r;
19209     suppress_error = 0;
19210     r = guestfs_umount_all (g);
19211     if (r == -1)
19212       return -1;
19213   }
19214   {
19215     int r;
19216     suppress_error = 0;
19217     r = guestfs_lvm_remove_all (g);
19218     if (r == -1)
19219       return -1;
19220   }
19221   /* TestOutput for mount (0) */
19222   char expected[] = "new file contents";
19223   {
19224     char device[] = "/dev/sda";
19225     char lines_0[] = ",";
19226     char *lines[] = {
19227       lines_0,
19228       NULL
19229     };
19230     int r;
19231     suppress_error = 0;
19232     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19233     if (r == -1)
19234       return -1;
19235   }
19236   {
19237     char fstype[] = "ext2";
19238     char device[] = "/dev/sda1";
19239     int r;
19240     suppress_error = 0;
19241     r = guestfs_mkfs (g, fstype, device);
19242     if (r == -1)
19243       return -1;
19244   }
19245   {
19246     char device[] = "/dev/sda1";
19247     char mountpoint[] = "/";
19248     int r;
19249     suppress_error = 0;
19250     r = guestfs_mount (g, device, mountpoint);
19251     if (r == -1)
19252       return -1;
19253   }
19254   {
19255     char path[] = "/new";
19256     char content[] = "new file contents";
19257     int r;
19258     suppress_error = 0;
19259     r = guestfs_write_file (g, path, content, 0);
19260     if (r == -1)
19261       return -1;
19262   }
19263   {
19264     char path[] = "/new";
19265     char *r;
19266     suppress_error = 0;
19267     r = guestfs_cat (g, path);
19268     if (r == NULL)
19269       return -1;
19270     if (strcmp (r, expected) != 0) {
19271       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
19272       return -1;
19273     }
19274     free (r);
19275   }
19276   return 0;
19277 }
19278
19279 int main (int argc, char *argv[])
19280 {
19281   char c = 0;
19282   int failed = 0;
19283   const char *filename;
19284   int fd;
19285   int nr_tests, test_num = 0;
19286
19287   setbuf (stdout, NULL);
19288
19289   no_test_warnings ();
19290
19291   g = guestfs_create ();
19292   if (g == NULL) {
19293     printf ("guestfs_create FAILED\n");
19294     exit (1);
19295   }
19296
19297   guestfs_set_error_handler (g, print_error, NULL);
19298
19299   guestfs_set_path (g, "../appliance");
19300
19301   filename = "test1.img";
19302   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19303   if (fd == -1) {
19304     perror (filename);
19305     exit (1);
19306   }
19307   if (lseek (fd, 524288000, SEEK_SET) == -1) {
19308     perror ("lseek");
19309     close (fd);
19310     unlink (filename);
19311     exit (1);
19312   }
19313   if (write (fd, &c, 1) == -1) {
19314     perror ("write");
19315     close (fd);
19316     unlink (filename);
19317     exit (1);
19318   }
19319   if (close (fd) == -1) {
19320     perror (filename);
19321     unlink (filename);
19322     exit (1);
19323   }
19324   if (guestfs_add_drive (g, filename) == -1) {
19325     printf ("guestfs_add_drive %s FAILED\n", filename);
19326     exit (1);
19327   }
19328
19329   filename = "test2.img";
19330   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19331   if (fd == -1) {
19332     perror (filename);
19333     exit (1);
19334   }
19335   if (lseek (fd, 52428800, SEEK_SET) == -1) {
19336     perror ("lseek");
19337     close (fd);
19338     unlink (filename);
19339     exit (1);
19340   }
19341   if (write (fd, &c, 1) == -1) {
19342     perror ("write");
19343     close (fd);
19344     unlink (filename);
19345     exit (1);
19346   }
19347   if (close (fd) == -1) {
19348     perror (filename);
19349     unlink (filename);
19350     exit (1);
19351   }
19352   if (guestfs_add_drive (g, filename) == -1) {
19353     printf ("guestfs_add_drive %s FAILED\n", filename);
19354     exit (1);
19355   }
19356
19357   filename = "test3.img";
19358   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19359   if (fd == -1) {
19360     perror (filename);
19361     exit (1);
19362   }
19363   if (lseek (fd, 10485760, SEEK_SET) == -1) {
19364     perror ("lseek");
19365     close (fd);
19366     unlink (filename);
19367     exit (1);
19368   }
19369   if (write (fd, &c, 1) == -1) {
19370     perror ("write");
19371     close (fd);
19372     unlink (filename);
19373     exit (1);
19374   }
19375   if (close (fd) == -1) {
19376     perror (filename);
19377     unlink (filename);
19378     exit (1);
19379   }
19380   if (guestfs_add_drive (g, filename) == -1) {
19381     printf ("guestfs_add_drive %s FAILED\n", filename);
19382     exit (1);
19383   }
19384
19385   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
19386     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
19387     exit (1);
19388   }
19389
19390   if (guestfs_launch (g) == -1) {
19391     printf ("guestfs_launch FAILED\n");
19392     exit (1);
19393   }
19394
19395   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
19396   alarm (600);
19397
19398   if (guestfs_wait_ready (g) == -1) {
19399     printf ("guestfs_wait_ready FAILED\n");
19400     exit (1);
19401   }
19402
19403   /* Cancel previous alarm. */
19404   alarm (0);
19405
19406   nr_tests = 174;
19407
19408   test_num++;
19409   printf ("%3d/%3d test_mknod_c_0\n", test_num, nr_tests);
19410   if (test_mknod_c_0 () == -1) {
19411     printf ("test_mknod_c_0 FAILED\n");
19412     failed++;
19413   }
19414   test_num++;
19415   printf ("%3d/%3d test_mknod_b_0\n", test_num, nr_tests);
19416   if (test_mknod_b_0 () == -1) {
19417     printf ("test_mknod_b_0 FAILED\n");
19418     failed++;
19419   }
19420   test_num++;
19421   printf ("%3d/%3d test_mkfifo_0\n", test_num, nr_tests);
19422   if (test_mkfifo_0 () == -1) {
19423     printf ("test_mkfifo_0 FAILED\n");
19424     failed++;
19425   }
19426   test_num++;
19427   printf ("%3d/%3d test_mknod_0\n", test_num, nr_tests);
19428   if (test_mknod_0 () == -1) {
19429     printf ("test_mknod_0 FAILED\n");
19430     failed++;
19431   }
19432   test_num++;
19433   printf ("%3d/%3d test_mknod_1\n", test_num, nr_tests);
19434   if (test_mknod_1 () == -1) {
19435     printf ("test_mknod_1 FAILED\n");
19436     failed++;
19437   }
19438   test_num++;
19439   printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests);
19440   if (test_mkswap_U_0 () == -1) {
19441     printf ("test_mkswap_U_0 FAILED\n");
19442     failed++;
19443   }
19444   test_num++;
19445   printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests);
19446   if (test_mkswap_L_0 () == -1) {
19447     printf ("test_mkswap_L_0 FAILED\n");
19448     failed++;
19449   }
19450   test_num++;
19451   printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests);
19452   if (test_mkswap_0 () == -1) {
19453     printf ("test_mkswap_0 FAILED\n");
19454     failed++;
19455   }
19456   test_num++;
19457   printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
19458   if (test_initrd_list_0 () == -1) {
19459     printf ("test_initrd_list_0 FAILED\n");
19460     failed++;
19461   }
19462   test_num++;
19463   printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
19464   if (test_du_0 () == -1) {
19465     printf ("test_du_0 FAILED\n");
19466     failed++;
19467   }
19468   test_num++;
19469   printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
19470   if (test_tail_n_0 () == -1) {
19471     printf ("test_tail_n_0 FAILED\n");
19472     failed++;
19473   }
19474   test_num++;
19475   printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
19476   if (test_tail_n_1 () == -1) {
19477     printf ("test_tail_n_1 FAILED\n");
19478     failed++;
19479   }
19480   test_num++;
19481   printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
19482   if (test_tail_n_2 () == -1) {
19483     printf ("test_tail_n_2 FAILED\n");
19484     failed++;
19485   }
19486   test_num++;
19487   printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
19488   if (test_tail_0 () == -1) {
19489     printf ("test_tail_0 FAILED\n");
19490     failed++;
19491   }
19492   test_num++;
19493   printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
19494   if (test_head_n_0 () == -1) {
19495     printf ("test_head_n_0 FAILED\n");
19496     failed++;
19497   }
19498   test_num++;
19499   printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
19500   if (test_head_n_1 () == -1) {
19501     printf ("test_head_n_1 FAILED\n");
19502     failed++;
19503   }
19504   test_num++;
19505   printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
19506   if (test_head_n_2 () == -1) {
19507     printf ("test_head_n_2 FAILED\n");
19508     failed++;
19509   }
19510   test_num++;
19511   printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
19512   if (test_head_0 () == -1) {
19513     printf ("test_head_0 FAILED\n");
19514     failed++;
19515   }
19516   test_num++;
19517   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
19518   if (test_wc_c_0 () == -1) {
19519     printf ("test_wc_c_0 FAILED\n");
19520     failed++;
19521   }
19522   test_num++;
19523   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
19524   if (test_wc_w_0 () == -1) {
19525     printf ("test_wc_w_0 FAILED\n");
19526     failed++;
19527   }
19528   test_num++;
19529   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
19530   if (test_wc_l_0 () == -1) {
19531     printf ("test_wc_l_0 FAILED\n");
19532     failed++;
19533   }
19534   test_num++;
19535   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
19536   if (test_mkdtemp_0 () == -1) {
19537     printf ("test_mkdtemp_0 FAILED\n");
19538     failed++;
19539   }
19540   test_num++;
19541   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
19542   if (test_scrub_file_0 () == -1) {
19543     printf ("test_scrub_file_0 FAILED\n");
19544     failed++;
19545   }
19546   test_num++;
19547   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
19548   if (test_scrub_device_0 () == -1) {
19549     printf ("test_scrub_device_0 FAILED\n");
19550     failed++;
19551   }
19552   test_num++;
19553   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
19554   if (test_glob_expand_0 () == -1) {
19555     printf ("test_glob_expand_0 FAILED\n");
19556     failed++;
19557   }
19558   test_num++;
19559   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
19560   if (test_glob_expand_1 () == -1) {
19561     printf ("test_glob_expand_1 FAILED\n");
19562     failed++;
19563   }
19564   test_num++;
19565   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
19566   if (test_glob_expand_2 () == -1) {
19567     printf ("test_glob_expand_2 FAILED\n");
19568     failed++;
19569   }
19570   test_num++;
19571   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
19572   if (test_ntfs_3g_probe_0 () == -1) {
19573     printf ("test_ntfs_3g_probe_0 FAILED\n");
19574     failed++;
19575   }
19576   test_num++;
19577   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
19578   if (test_ntfs_3g_probe_1 () == -1) {
19579     printf ("test_ntfs_3g_probe_1 FAILED\n");
19580     failed++;
19581   }
19582   test_num++;
19583   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
19584   if (test_sleep_0 () == -1) {
19585     printf ("test_sleep_0 FAILED\n");
19586     failed++;
19587   }
19588   test_num++;
19589   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
19590   if (test_find_0 () == -1) {
19591     printf ("test_find_0 FAILED\n");
19592     failed++;
19593   }
19594   test_num++;
19595   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
19596   if (test_find_1 () == -1) {
19597     printf ("test_find_1 FAILED\n");
19598     failed++;
19599   }
19600   test_num++;
19601   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
19602   if (test_find_2 () == -1) {
19603     printf ("test_find_2 FAILED\n");
19604     failed++;
19605   }
19606   test_num++;
19607   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
19608   if (test_lvresize_0 () == -1) {
19609     printf ("test_lvresize_0 FAILED\n");
19610     failed++;
19611   }
19612   test_num++;
19613   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
19614   if (test_zerofree_0 () == -1) {
19615     printf ("test_zerofree_0 FAILED\n");
19616     failed++;
19617   }
19618   test_num++;
19619   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
19620   if (test_hexdump_0 () == -1) {
19621     printf ("test_hexdump_0 FAILED\n");
19622     failed++;
19623   }
19624   test_num++;
19625   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
19626   if (test_hexdump_1 () == -1) {
19627     printf ("test_hexdump_1 FAILED\n");
19628     failed++;
19629   }
19630   test_num++;
19631   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
19632   if (test_strings_e_0 () == -1) {
19633     printf ("test_strings_e_0 FAILED\n");
19634     failed++;
19635   }
19636   test_num++;
19637   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
19638   if (test_strings_e_1 () == -1) {
19639     printf ("test_strings_e_1 FAILED\n");
19640     failed++;
19641   }
19642   test_num++;
19643   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
19644   if (test_strings_0 () == -1) {
19645     printf ("test_strings_0 FAILED\n");
19646     failed++;
19647   }
19648   test_num++;
19649   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
19650   if (test_strings_1 () == -1) {
19651     printf ("test_strings_1 FAILED\n");
19652     failed++;
19653   }
19654   test_num++;
19655   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
19656   if (test_equal_0 () == -1) {
19657     printf ("test_equal_0 FAILED\n");
19658     failed++;
19659   }
19660   test_num++;
19661   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
19662   if (test_equal_1 () == -1) {
19663     printf ("test_equal_1 FAILED\n");
19664     failed++;
19665   }
19666   test_num++;
19667   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
19668   if (test_equal_2 () == -1) {
19669     printf ("test_equal_2 FAILED\n");
19670     failed++;
19671   }
19672   test_num++;
19673   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
19674   if (test_ping_daemon_0 () == -1) {
19675     printf ("test_ping_daemon_0 FAILED\n");
19676     failed++;
19677   }
19678   test_num++;
19679   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
19680   if (test_dmesg_0 () == -1) {
19681     printf ("test_dmesg_0 FAILED\n");
19682     failed++;
19683   }
19684   test_num++;
19685   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
19686   if (test_drop_caches_0 () == -1) {
19687     printf ("test_drop_caches_0 FAILED\n");
19688     failed++;
19689   }
19690   test_num++;
19691   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19692   if (test_mv_0 () == -1) {
19693     printf ("test_mv_0 FAILED\n");
19694     failed++;
19695   }
19696   test_num++;
19697   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19698   if (test_mv_1 () == -1) {
19699     printf ("test_mv_1 FAILED\n");
19700     failed++;
19701   }
19702   test_num++;
19703   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19704   if (test_cp_a_0 () == -1) {
19705     printf ("test_cp_a_0 FAILED\n");
19706     failed++;
19707   }
19708   test_num++;
19709   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19710   if (test_cp_0 () == -1) {
19711     printf ("test_cp_0 FAILED\n");
19712     failed++;
19713   }
19714   test_num++;
19715   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19716   if (test_cp_1 () == -1) {
19717     printf ("test_cp_1 FAILED\n");
19718     failed++;
19719   }
19720   test_num++;
19721   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19722   if (test_cp_2 () == -1) {
19723     printf ("test_cp_2 FAILED\n");
19724     failed++;
19725   }
19726   test_num++;
19727   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19728   if (test_grub_install_0 () == -1) {
19729     printf ("test_grub_install_0 FAILED\n");
19730     failed++;
19731   }
19732   test_num++;
19733   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19734   if (test_zero_0 () == -1) {
19735     printf ("test_zero_0 FAILED\n");
19736     failed++;
19737   }
19738   test_num++;
19739   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19740   if (test_fsck_0 () == -1) {
19741     printf ("test_fsck_0 FAILED\n");
19742     failed++;
19743   }
19744   test_num++;
19745   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19746   if (test_fsck_1 () == -1) {
19747     printf ("test_fsck_1 FAILED\n");
19748     failed++;
19749   }
19750   test_num++;
19751   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19752   if (test_set_e2uuid_0 () == -1) {
19753     printf ("test_set_e2uuid_0 FAILED\n");
19754     failed++;
19755   }
19756   test_num++;
19757   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19758   if (test_set_e2uuid_1 () == -1) {
19759     printf ("test_set_e2uuid_1 FAILED\n");
19760     failed++;
19761   }
19762   test_num++;
19763   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19764   if (test_set_e2uuid_2 () == -1) {
19765     printf ("test_set_e2uuid_2 FAILED\n");
19766     failed++;
19767   }
19768   test_num++;
19769   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19770   if (test_set_e2uuid_3 () == -1) {
19771     printf ("test_set_e2uuid_3 FAILED\n");
19772     failed++;
19773   }
19774   test_num++;
19775   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19776   if (test_set_e2label_0 () == -1) {
19777     printf ("test_set_e2label_0 FAILED\n");
19778     failed++;
19779   }
19780   test_num++;
19781   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19782   if (test_pvremove_0 () == -1) {
19783     printf ("test_pvremove_0 FAILED\n");
19784     failed++;
19785   }
19786   test_num++;
19787   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19788   if (test_pvremove_1 () == -1) {
19789     printf ("test_pvremove_1 FAILED\n");
19790     failed++;
19791   }
19792   test_num++;
19793   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19794   if (test_pvremove_2 () == -1) {
19795     printf ("test_pvremove_2 FAILED\n");
19796     failed++;
19797   }
19798   test_num++;
19799   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19800   if (test_vgremove_0 () == -1) {
19801     printf ("test_vgremove_0 FAILED\n");
19802     failed++;
19803   }
19804   test_num++;
19805   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19806   if (test_vgremove_1 () == -1) {
19807     printf ("test_vgremove_1 FAILED\n");
19808     failed++;
19809   }
19810   test_num++;
19811   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19812   if (test_lvremove_0 () == -1) {
19813     printf ("test_lvremove_0 FAILED\n");
19814     failed++;
19815   }
19816   test_num++;
19817   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19818   if (test_lvremove_1 () == -1) {
19819     printf ("test_lvremove_1 FAILED\n");
19820     failed++;
19821   }
19822   test_num++;
19823   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19824   if (test_lvremove_2 () == -1) {
19825     printf ("test_lvremove_2 FAILED\n");
19826     failed++;
19827   }
19828   test_num++;
19829   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19830   if (test_mount_ro_0 () == -1) {
19831     printf ("test_mount_ro_0 FAILED\n");
19832     failed++;
19833   }
19834   test_num++;
19835   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19836   if (test_mount_ro_1 () == -1) {
19837     printf ("test_mount_ro_1 FAILED\n");
19838     failed++;
19839   }
19840   test_num++;
19841   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19842   if (test_tgz_in_0 () == -1) {
19843     printf ("test_tgz_in_0 FAILED\n");
19844     failed++;
19845   }
19846   test_num++;
19847   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19848   if (test_tar_in_0 () == -1) {
19849     printf ("test_tar_in_0 FAILED\n");
19850     failed++;
19851   }
19852   test_num++;
19853   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19854   if (test_checksum_0 () == -1) {
19855     printf ("test_checksum_0 FAILED\n");
19856     failed++;
19857   }
19858   test_num++;
19859   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19860   if (test_checksum_1 () == -1) {
19861     printf ("test_checksum_1 FAILED\n");
19862     failed++;
19863   }
19864   test_num++;
19865   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19866   if (test_checksum_2 () == -1) {
19867     printf ("test_checksum_2 FAILED\n");
19868     failed++;
19869   }
19870   test_num++;
19871   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19872   if (test_checksum_3 () == -1) {
19873     printf ("test_checksum_3 FAILED\n");
19874     failed++;
19875   }
19876   test_num++;
19877   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19878   if (test_checksum_4 () == -1) {
19879     printf ("test_checksum_4 FAILED\n");
19880     failed++;
19881   }
19882   test_num++;
19883   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19884   if (test_checksum_5 () == -1) {
19885     printf ("test_checksum_5 FAILED\n");
19886     failed++;
19887   }
19888   test_num++;
19889   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19890   if (test_checksum_6 () == -1) {
19891     printf ("test_checksum_6 FAILED\n");
19892     failed++;
19893   }
19894   test_num++;
19895   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19896   if (test_checksum_7 () == -1) {
19897     printf ("test_checksum_7 FAILED\n");
19898     failed++;
19899   }
19900   test_num++;
19901   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19902   if (test_checksum_8 () == -1) {
19903     printf ("test_checksum_8 FAILED\n");
19904     failed++;
19905   }
19906   test_num++;
19907   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19908   if (test_download_0 () == -1) {
19909     printf ("test_download_0 FAILED\n");
19910     failed++;
19911   }
19912   test_num++;
19913   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19914   if (test_upload_0 () == -1) {
19915     printf ("test_upload_0 FAILED\n");
19916     failed++;
19917   }
19918   test_num++;
19919   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19920   if (test_blockdev_rereadpt_0 () == -1) {
19921     printf ("test_blockdev_rereadpt_0 FAILED\n");
19922     failed++;
19923   }
19924   test_num++;
19925   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19926   if (test_blockdev_flushbufs_0 () == -1) {
19927     printf ("test_blockdev_flushbufs_0 FAILED\n");
19928     failed++;
19929   }
19930   test_num++;
19931   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19932   if (test_blockdev_getsize64_0 () == -1) {
19933     printf ("test_blockdev_getsize64_0 FAILED\n");
19934     failed++;
19935   }
19936   test_num++;
19937   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19938   if (test_blockdev_getsz_0 () == -1) {
19939     printf ("test_blockdev_getsz_0 FAILED\n");
19940     failed++;
19941   }
19942   test_num++;
19943   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19944   if (test_blockdev_getbsz_0 () == -1) {
19945     printf ("test_blockdev_getbsz_0 FAILED\n");
19946     failed++;
19947   }
19948   test_num++;
19949   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19950   if (test_blockdev_getss_0 () == -1) {
19951     printf ("test_blockdev_getss_0 FAILED\n");
19952     failed++;
19953   }
19954   test_num++;
19955   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19956   if (test_blockdev_getro_0 () == -1) {
19957     printf ("test_blockdev_getro_0 FAILED\n");
19958     failed++;
19959   }
19960   test_num++;
19961   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19962   if (test_blockdev_setrw_0 () == -1) {
19963     printf ("test_blockdev_setrw_0 FAILED\n");
19964     failed++;
19965   }
19966   test_num++;
19967   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19968   if (test_blockdev_setro_0 () == -1) {
19969     printf ("test_blockdev_setro_0 FAILED\n");
19970     failed++;
19971   }
19972   test_num++;
19973   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19974   if (test_statvfs_0 () == -1) {
19975     printf ("test_statvfs_0 FAILED\n");
19976     failed++;
19977   }
19978   test_num++;
19979   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19980   if (test_lstat_0 () == -1) {
19981     printf ("test_lstat_0 FAILED\n");
19982     failed++;
19983   }
19984   test_num++;
19985   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19986   if (test_stat_0 () == -1) {
19987     printf ("test_stat_0 FAILED\n");
19988     failed++;
19989   }
19990   test_num++;
19991   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19992   if (test_command_lines_0 () == -1) {
19993     printf ("test_command_lines_0 FAILED\n");
19994     failed++;
19995   }
19996   test_num++;
19997   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19998   if (test_command_lines_1 () == -1) {
19999     printf ("test_command_lines_1 FAILED\n");
20000     failed++;
20001   }
20002   test_num++;
20003   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
20004   if (test_command_lines_2 () == -1) {
20005     printf ("test_command_lines_2 FAILED\n");
20006     failed++;
20007   }
20008   test_num++;
20009   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
20010   if (test_command_lines_3 () == -1) {
20011     printf ("test_command_lines_3 FAILED\n");
20012     failed++;
20013   }
20014   test_num++;
20015   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
20016   if (test_command_lines_4 () == -1) {
20017     printf ("test_command_lines_4 FAILED\n");
20018     failed++;
20019   }
20020   test_num++;
20021   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
20022   if (test_command_lines_5 () == -1) {
20023     printf ("test_command_lines_5 FAILED\n");
20024     failed++;
20025   }
20026   test_num++;
20027   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
20028   if (test_command_lines_6 () == -1) {
20029     printf ("test_command_lines_6 FAILED\n");
20030     failed++;
20031   }
20032   test_num++;
20033   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
20034   if (test_command_lines_7 () == -1) {
20035     printf ("test_command_lines_7 FAILED\n");
20036     failed++;
20037   }
20038   test_num++;
20039   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
20040   if (test_command_lines_8 () == -1) {
20041     printf ("test_command_lines_8 FAILED\n");
20042     failed++;
20043   }
20044   test_num++;
20045   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
20046   if (test_command_lines_9 () == -1) {
20047     printf ("test_command_lines_9 FAILED\n");
20048     failed++;
20049   }
20050   test_num++;
20051   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
20052   if (test_command_lines_10 () == -1) {
20053     printf ("test_command_lines_10 FAILED\n");
20054     failed++;
20055   }
20056   test_num++;
20057   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
20058   if (test_command_0 () == -1) {
20059     printf ("test_command_0 FAILED\n");
20060     failed++;
20061   }
20062   test_num++;
20063   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
20064   if (test_command_1 () == -1) {
20065     printf ("test_command_1 FAILED\n");
20066     failed++;
20067   }
20068   test_num++;
20069   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
20070   if (test_command_2 () == -1) {
20071     printf ("test_command_2 FAILED\n");
20072     failed++;
20073   }
20074   test_num++;
20075   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
20076   if (test_command_3 () == -1) {
20077     printf ("test_command_3 FAILED\n");
20078     failed++;
20079   }
20080   test_num++;
20081   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
20082   if (test_command_4 () == -1) {
20083     printf ("test_command_4 FAILED\n");
20084     failed++;
20085   }
20086   test_num++;
20087   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
20088   if (test_command_5 () == -1) {
20089     printf ("test_command_5 FAILED\n");
20090     failed++;
20091   }
20092   test_num++;
20093   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
20094   if (test_command_6 () == -1) {
20095     printf ("test_command_6 FAILED\n");
20096     failed++;
20097   }
20098   test_num++;
20099   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
20100   if (test_command_7 () == -1) {
20101     printf ("test_command_7 FAILED\n");
20102     failed++;
20103   }
20104   test_num++;
20105   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
20106   if (test_command_8 () == -1) {
20107     printf ("test_command_8 FAILED\n");
20108     failed++;
20109   }
20110   test_num++;
20111   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
20112   if (test_command_9 () == -1) {
20113     printf ("test_command_9 FAILED\n");
20114     failed++;
20115   }
20116   test_num++;
20117   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
20118   if (test_command_10 () == -1) {
20119     printf ("test_command_10 FAILED\n");
20120     failed++;
20121   }
20122   test_num++;
20123   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
20124   if (test_command_11 () == -1) {
20125     printf ("test_command_11 FAILED\n");
20126     failed++;
20127   }
20128   test_num++;
20129   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
20130   if (test_file_0 () == -1) {
20131     printf ("test_file_0 FAILED\n");
20132     failed++;
20133   }
20134   test_num++;
20135   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
20136   if (test_file_1 () == -1) {
20137     printf ("test_file_1 FAILED\n");
20138     failed++;
20139   }
20140   test_num++;
20141   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
20142   if (test_file_2 () == -1) {
20143     printf ("test_file_2 FAILED\n");
20144     failed++;
20145   }
20146   test_num++;
20147   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
20148   if (test_umount_all_0 () == -1) {
20149     printf ("test_umount_all_0 FAILED\n");
20150     failed++;
20151   }
20152   test_num++;
20153   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
20154   if (test_umount_all_1 () == -1) {
20155     printf ("test_umount_all_1 FAILED\n");
20156     failed++;
20157   }
20158   test_num++;
20159   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
20160   if (test_mounts_0 () == -1) {
20161     printf ("test_mounts_0 FAILED\n");
20162     failed++;
20163   }
20164   test_num++;
20165   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
20166   if (test_umount_0 () == -1) {
20167     printf ("test_umount_0 FAILED\n");
20168     failed++;
20169   }
20170   test_num++;
20171   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
20172   if (test_umount_1 () == -1) {
20173     printf ("test_umount_1 FAILED\n");
20174     failed++;
20175   }
20176   test_num++;
20177   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
20178   if (test_write_file_0 () == -1) {
20179     printf ("test_write_file_0 FAILED\n");
20180     failed++;
20181   }
20182   test_num++;
20183   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
20184   if (test_write_file_1 () == -1) {
20185     printf ("test_write_file_1 FAILED\n");
20186     failed++;
20187   }
20188   test_num++;
20189   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
20190   if (test_write_file_2 () == -1) {
20191     printf ("test_write_file_2 FAILED\n");
20192     failed++;
20193   }
20194   test_num++;
20195   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
20196   if (test_write_file_3 () == -1) {
20197     printf ("test_write_file_3 FAILED\n");
20198     failed++;
20199   }
20200   test_num++;
20201   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
20202   if (test_write_file_4 () == -1) {
20203     printf ("test_write_file_4 FAILED\n");
20204     failed++;
20205   }
20206   test_num++;
20207   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
20208   if (test_write_file_5 () == -1) {
20209     printf ("test_write_file_5 FAILED\n");
20210     failed++;
20211   }
20212   test_num++;
20213   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
20214   if (test_mkfs_0 () == -1) {
20215     printf ("test_mkfs_0 FAILED\n");
20216     failed++;
20217   }
20218   test_num++;
20219   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
20220   if (test_lvcreate_0 () == -1) {
20221     printf ("test_lvcreate_0 FAILED\n");
20222     failed++;
20223   }
20224   test_num++;
20225   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
20226   if (test_vgcreate_0 () == -1) {
20227     printf ("test_vgcreate_0 FAILED\n");
20228     failed++;
20229   }
20230   test_num++;
20231   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
20232   if (test_pvcreate_0 () == -1) {
20233     printf ("test_pvcreate_0 FAILED\n");
20234     failed++;
20235   }
20236   test_num++;
20237   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
20238   if (test_is_dir_0 () == -1) {
20239     printf ("test_is_dir_0 FAILED\n");
20240     failed++;
20241   }
20242   test_num++;
20243   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
20244   if (test_is_dir_1 () == -1) {
20245     printf ("test_is_dir_1 FAILED\n");
20246     failed++;
20247   }
20248   test_num++;
20249   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
20250   if (test_is_file_0 () == -1) {
20251     printf ("test_is_file_0 FAILED\n");
20252     failed++;
20253   }
20254   test_num++;
20255   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
20256   if (test_is_file_1 () == -1) {
20257     printf ("test_is_file_1 FAILED\n");
20258     failed++;
20259   }
20260   test_num++;
20261   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
20262   if (test_exists_0 () == -1) {
20263     printf ("test_exists_0 FAILED\n");
20264     failed++;
20265   }
20266   test_num++;
20267   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
20268   if (test_exists_1 () == -1) {
20269     printf ("test_exists_1 FAILED\n");
20270     failed++;
20271   }
20272   test_num++;
20273   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
20274   if (test_mkdir_p_0 () == -1) {
20275     printf ("test_mkdir_p_0 FAILED\n");
20276     failed++;
20277   }
20278   test_num++;
20279   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
20280   if (test_mkdir_p_1 () == -1) {
20281     printf ("test_mkdir_p_1 FAILED\n");
20282     failed++;
20283   }
20284   test_num++;
20285   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
20286   if (test_mkdir_p_2 () == -1) {
20287     printf ("test_mkdir_p_2 FAILED\n");
20288     failed++;
20289   }
20290   test_num++;
20291   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
20292   if (test_mkdir_p_3 () == -1) {
20293     printf ("test_mkdir_p_3 FAILED\n");
20294     failed++;
20295   }
20296   test_num++;
20297   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
20298   if (test_mkdir_p_4 () == -1) {
20299     printf ("test_mkdir_p_4 FAILED\n");
20300     failed++;
20301   }
20302   test_num++;
20303   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
20304   if (test_mkdir_0 () == -1) {
20305     printf ("test_mkdir_0 FAILED\n");
20306     failed++;
20307   }
20308   test_num++;
20309   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
20310   if (test_mkdir_1 () == -1) {
20311     printf ("test_mkdir_1 FAILED\n");
20312     failed++;
20313   }
20314   test_num++;
20315   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
20316   if (test_rm_rf_0 () == -1) {
20317     printf ("test_rm_rf_0 FAILED\n");
20318     failed++;
20319   }
20320   test_num++;
20321   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
20322   if (test_rmdir_0 () == -1) {
20323     printf ("test_rmdir_0 FAILED\n");
20324     failed++;
20325   }
20326   test_num++;
20327   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
20328   if (test_rmdir_1 () == -1) {
20329     printf ("test_rmdir_1 FAILED\n");
20330     failed++;
20331   }
20332   test_num++;
20333   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
20334   if (test_rmdir_2 () == -1) {
20335     printf ("test_rmdir_2 FAILED\n");
20336     failed++;
20337   }
20338   test_num++;
20339   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
20340   if (test_rm_0 () == -1) {
20341     printf ("test_rm_0 FAILED\n");
20342     failed++;
20343   }
20344   test_num++;
20345   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
20346   if (test_rm_1 () == -1) {
20347     printf ("test_rm_1 FAILED\n");
20348     failed++;
20349   }
20350   test_num++;
20351   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
20352   if (test_rm_2 () == -1) {
20353     printf ("test_rm_2 FAILED\n");
20354     failed++;
20355   }
20356   test_num++;
20357   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
20358   if (test_read_lines_0 () == -1) {
20359     printf ("test_read_lines_0 FAILED\n");
20360     failed++;
20361   }
20362   test_num++;
20363   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
20364   if (test_read_lines_1 () == -1) {
20365     printf ("test_read_lines_1 FAILED\n");
20366     failed++;
20367   }
20368   test_num++;
20369   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
20370   if (test_lvs_0 () == -1) {
20371     printf ("test_lvs_0 FAILED\n");
20372     failed++;
20373   }
20374   test_num++;
20375   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
20376   if (test_lvs_1 () == -1) {
20377     printf ("test_lvs_1 FAILED\n");
20378     failed++;
20379   }
20380   test_num++;
20381   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
20382   if (test_vgs_0 () == -1) {
20383     printf ("test_vgs_0 FAILED\n");
20384     failed++;
20385   }
20386   test_num++;
20387   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
20388   if (test_vgs_1 () == -1) {
20389     printf ("test_vgs_1 FAILED\n");
20390     failed++;
20391   }
20392   test_num++;
20393   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
20394   if (test_pvs_0 () == -1) {
20395     printf ("test_pvs_0 FAILED\n");
20396     failed++;
20397   }
20398   test_num++;
20399   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
20400   if (test_pvs_1 () == -1) {
20401     printf ("test_pvs_1 FAILED\n");
20402     failed++;
20403   }
20404   test_num++;
20405   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
20406   if (test_list_partitions_0 () == -1) {
20407     printf ("test_list_partitions_0 FAILED\n");
20408     failed++;
20409   }
20410   test_num++;
20411   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
20412   if (test_list_partitions_1 () == -1) {
20413     printf ("test_list_partitions_1 FAILED\n");
20414     failed++;
20415   }
20416   test_num++;
20417   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
20418   if (test_list_devices_0 () == -1) {
20419     printf ("test_list_devices_0 FAILED\n");
20420     failed++;
20421   }
20422   test_num++;
20423   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
20424   if (test_ls_0 () == -1) {
20425     printf ("test_ls_0 FAILED\n");
20426     failed++;
20427   }
20428   test_num++;
20429   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
20430   if (test_cat_0 () == -1) {
20431     printf ("test_cat_0 FAILED\n");
20432     failed++;
20433   }
20434   test_num++;
20435   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
20436   if (test_touch_0 () == -1) {
20437     printf ("test_touch_0 FAILED\n");
20438     failed++;
20439   }
20440   test_num++;
20441   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
20442   if (test_sync_0 () == -1) {
20443     printf ("test_sync_0 FAILED\n");
20444     failed++;
20445   }
20446   test_num++;
20447   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
20448   if (test_mount_0 () == -1) {
20449     printf ("test_mount_0 FAILED\n");
20450     failed++;
20451   }
20452
20453   guestfs_close (g);
20454   unlink ("test1.img");
20455   unlink ("test2.img");
20456   unlink ("test3.img");
20457
20458   if (failed > 0) {
20459     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
20460     exit (1);
20461   }
20462
20463   exit (0);
20464 }