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_ll\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 151 }
 152
 153 static int test_ntfs_3g_probe_0_skip (void)
 154 {
 155   const char *str;
 156
 157   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
 158   if (str && strcmp (str, "1") == 0) return 1;
 159   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 160   if (str && strcmp (str, "1") == 0) return 1;
 161   return 0;
 162 }
 163
 164 static int test_ntfs_3g_probe_0 (void)
 165 {
 166   if (test_ntfs_3g_probe_0_skip ()) {
 167     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
 168     return 0;
 169   }
 170
 171   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
 172   {
 173     char device[] = "/dev/sda";
 174     int r;
 175     suppress_error = 0;
 176     r = guestfs_blockdev_setrw (g, device);
 177     if (r == -1)
 178       return -1;
 179   }
 180   {
 181     int r;
 182     suppress_error = 0;
 183     r = guestfs_umount_all (g);
 184     if (r == -1)
 185       return -1;
 186   }
 187   {
 188     int r;
 189     suppress_error = 0;
 190     r = guestfs_lvm_remove_all (g);
 191     if (r == -1)
 192       return -1;
 193   }
 194   /* TestOutputInt for ntfs_3g_probe (0) */
 195   {
 196     char device[] = "/dev/sda";
 197     char lines_0[] = ",";
 198     char *lines[] = {
 199       lines_0,
 200       NULL
 201     };
 202     int r;
 203     suppress_error = 0;
 204     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 205     if (r == -1)
 206       return -1;
 207   }
 208   {
 209     char fstype[] = "ntfs";
 210     char device[] = "/dev/sda1";
 211     int r;
 212     suppress_error = 0;
 213     r = guestfs_mkfs (g, fstype, device);
 214     if (r == -1)
 215       return -1;
 216   }
 217   {
 218     char device[] = "/dev/sda1";
 219     int r;
 220     suppress_error = 0;
 221     r = guestfs_ntfs_3g_probe (g, 1, device);
 222     if (r == -1)
 223       return -1;
 224     if (r != 0) {
 225       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
 226       return -1;
 227     }
 228   }
 229   return 0;
 230 }
 231
 232 static int test_ntfs_3g_probe_1_skip (void)
 233 {
 234   const char *str;
 235
 236   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
 237   if (str && strcmp (str, "1") == 0) return 1;
 238   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 239   if (str && strcmp (str, "1") == 0) return 1;
 240   return 0;
 241 }
 242
 243 static int test_ntfs_3g_probe_1 (void)
 244 {
 245   if (test_ntfs_3g_probe_1_skip ()) {
 246     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
 247     return 0;
 248   }
 249
 250   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
 251   {
 252     char device[] = "/dev/sda";
 253     int r;
 254     suppress_error = 0;
 255     r = guestfs_blockdev_setrw (g, device);
 256     if (r == -1)
 257       return -1;
 258   }
 259   {
 260     int r;
 261     suppress_error = 0;
 262     r = guestfs_umount_all (g);
 263     if (r == -1)
 264       return -1;
 265   }
 266   {
 267     int r;
 268     suppress_error = 0;
 269     r = guestfs_lvm_remove_all (g);
 270     if (r == -1)
 271       return -1;
 272   }
 273   /* TestOutputInt for ntfs_3g_probe (1) */
 274   {
 275     char device[] = "/dev/sda";
 276     char lines_0[] = ",";
 277     char *lines[] = {
 278       lines_0,
 279       NULL
 280     };
 281     int r;
 282     suppress_error = 0;
 283     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 284     if (r == -1)
 285       return -1;
 286   }
 287   {
 288     char fstype[] = "ext2";
 289     char device[] = "/dev/sda1";
 290     int r;
 291     suppress_error = 0;
 292     r = guestfs_mkfs (g, fstype, device);
 293     if (r == -1)
 294       return -1;
 295   }
 296   {
 297     char device[] = "/dev/sda1";
 298     int r;
 299     suppress_error = 0;
 300     r = guestfs_ntfs_3g_probe (g, 1, device);
 301     if (r == -1)
 302       return -1;
 303     if (r != 12) {
 304       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
 305       return -1;
 306     }
 307   }
 308   return 0;
 309 }
 310
 311 static int test_sleep_0_skip (void)
 312 {
 313   const char *str;
 314
 315   str = getenv ("SKIP_TEST_SLEEP_0");
 316   if (str && strcmp (str, "1") == 0) return 1;
 317   str = getenv ("SKIP_TEST_SLEEP");
 318   if (str && strcmp (str, "1") == 0) return 1;
 319   return 0;
 320 }
 321
 322 static int test_sleep_0 (void)
 323 {
 324   if (test_sleep_0_skip ()) {
 325     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
 326     return 0;
 327   }
 328
 329   /* InitNone|InitEmpty for test_sleep_0 */
 330   {
 331     char device[] = "/dev/sda";
 332     int r;
 333     suppress_error = 0;
 334     r = guestfs_blockdev_setrw (g, device);
 335     if (r == -1)
 336       return -1;
 337   }
 338   {
 339     int r;
 340     suppress_error = 0;
 341     r = guestfs_umount_all (g);
 342     if (r == -1)
 343       return -1;
 344   }
 345   {
 346     int r;
 347     suppress_error = 0;
 348     r = guestfs_lvm_remove_all (g);
 349     if (r == -1)
 350       return -1;
 351   }
 352   /* TestRun for sleep (0) */
 353   {
 354     int r;
 355     suppress_error = 0;
 356     r = guestfs_sleep (g, 1);
 357     if (r == -1)
 358       return -1;
 359   }
 360   return 0;
 361 }
 362
 363 static int test_find_0_skip (void)
 364 {
 365   const char *str;
 366
 367   str = getenv ("SKIP_TEST_FIND_0");
 368   if (str && strcmp (str, "1") == 0) return 1;
 369   str = getenv ("SKIP_TEST_FIND");
 370   if (str && strcmp (str, "1") == 0) return 1;
 371   return 0;
 372 }
 373
 374 static int test_find_0 (void)
 375 {
 376   if (test_find_0_skip ()) {
 377     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
 378     return 0;
 379   }
 380
 381   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 382   {
 383     char device[] = "/dev/sda";
 384     int r;
 385     suppress_error = 0;
 386     r = guestfs_blockdev_setrw (g, device);
 387     if (r == -1)
 388       return -1;
 389   }
 390   {
 391     int r;
 392     suppress_error = 0;
 393     r = guestfs_umount_all (g);
 394     if (r == -1)
 395       return -1;
 396   }
 397   {
 398     int r;
 399     suppress_error = 0;
 400     r = guestfs_lvm_remove_all (g);
 401     if (r == -1)
 402       return -1;
 403   }
 404   {
 405     char device[] = "/dev/sda";
 406     char lines_0[] = ",";
 407     char *lines[] = {
 408       lines_0,
 409       NULL
 410     };
 411     int r;
 412     suppress_error = 0;
 413     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 414     if (r == -1)
 415       return -1;
 416   }
 417   {
 418     char fstype[] = "ext2";
 419     char device[] = "/dev/sda1";
 420     int r;
 421     suppress_error = 0;
 422     r = guestfs_mkfs (g, fstype, device);
 423     if (r == -1)
 424       return -1;
 425   }
 426   {
 427     char device[] = "/dev/sda1";
 428     char mountpoint[] = "/";
 429     int r;
 430     suppress_error = 0;
 431     r = guestfs_mount (g, device, mountpoint);
 432     if (r == -1)
 433       return -1;
 434   }
 435   /* TestOutputList for find (0) */
 436   {
 437     char directory[] = "/";
 438     char **r;
 439     int i;
 440     suppress_error = 0;
 441     r = guestfs_find (g, directory);
 442     if (r == NULL)
 443       return -1;
 444     if (!r[0]) {
 445       fprintf (stderr, "test_find_0: short list returned from command\n");
 446       print_strings (r);
 447       return -1;
 448     }
 449     {
 450       char expected[] = "lost+found";
 451       if (strcmp (r[0], expected) != 0) {
 452         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 453         return -1;
 454       }
 455     }
 456     if (r[1] != NULL) {
 457       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 458       print_strings (r);
 459       return -1;
 460     }
 461     for (i = 0; r[i] != NULL; ++i)
 462       free (r[i]);
 463     free (r);
 464   }
 465   return 0;
 466 }
 467
 468 static int test_find_1_skip (void)
 469 {
 470   const char *str;
 471
 472   str = getenv ("SKIP_TEST_FIND_1");
 473   if (str && strcmp (str, "1") == 0) return 1;
 474   str = getenv ("SKIP_TEST_FIND");
 475   if (str && strcmp (str, "1") == 0) return 1;
 476   return 0;
 477 }
 478
 479 static int test_find_1 (void)
 480 {
 481   if (test_find_1_skip ()) {
 482     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
 483     return 0;
 484   }
 485
 486   /* InitBasicFS for test_find_1: 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   /* TestOutputList for find (1) */
 541   {
 542     char path[] = "/a";
 543     int r;
 544     suppress_error = 0;
 545     r = guestfs_touch (g, path);
 546     if (r == -1)
 547       return -1;
 548   }
 549   {
 550     char path[] = "/b";
 551     int r;
 552     suppress_error = 0;
 553     r = guestfs_mkdir (g, path);
 554     if (r == -1)
 555       return -1;
 556   }
 557   {
 558     char path[] = "/b/c";
 559     int r;
 560     suppress_error = 0;
 561     r = guestfs_touch (g, path);
 562     if (r == -1)
 563       return -1;
 564   }
 565   {
 566     char directory[] = "/";
 567     char **r;
 568     int i;
 569     suppress_error = 0;
 570     r = guestfs_find (g, directory);
 571     if (r == NULL)
 572       return -1;
 573     if (!r[0]) {
 574       fprintf (stderr, "test_find_1: short list returned from command\n");
 575       print_strings (r);
 576       return -1;
 577     }
 578     {
 579       char expected[] = "a";
 580       if (strcmp (r[0], expected) != 0) {
 581         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 582         return -1;
 583       }
 584     }
 585     if (!r[1]) {
 586       fprintf (stderr, "test_find_1: short list returned from command\n");
 587       print_strings (r);
 588       return -1;
 589     }
 590     {
 591       char expected[] = "b";
 592       if (strcmp (r[1], expected) != 0) {
 593         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 594         return -1;
 595       }
 596     }
 597     if (!r[2]) {
 598       fprintf (stderr, "test_find_1: short list returned from command\n");
 599       print_strings (r);
 600       return -1;
 601     }
 602     {
 603       char expected[] = "b/c";
 604       if (strcmp (r[2], expected) != 0) {
 605         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 606         return -1;
 607       }
 608     }
 609     if (!r[3]) {
 610       fprintf (stderr, "test_find_1: short list returned from command\n");
 611       print_strings (r);
 612       return -1;
 613     }
 614     {
 615       char expected[] = "lost+found";
 616       if (strcmp (r[3], expected) != 0) {
 617         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 618         return -1;
 619       }
 620     }
 621     if (r[4] != NULL) {
 622       fprintf (stderr, "test_find_1: extra elements returned from command\n");
 623       print_strings (r);
 624       return -1;
 625     }
 626     for (i = 0; r[i] != NULL; ++i)
 627       free (r[i]);
 628     free (r);
 629   }
 630   return 0;
 631 }
 632
 633 static int test_find_2_skip (void)
 634 {
 635   const char *str;
 636
 637   str = getenv ("SKIP_TEST_FIND_2");
 638   if (str && strcmp (str, "1") == 0) return 1;
 639   str = getenv ("SKIP_TEST_FIND");
 640   if (str && strcmp (str, "1") == 0) return 1;
 641   return 0;
 642 }
 643
 644 static int test_find_2 (void)
 645 {
 646   if (test_find_2_skip ()) {
 647     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
 648     return 0;
 649   }
 650
 651   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
 652   {
 653     char device[] = "/dev/sda";
 654     int r;
 655     suppress_error = 0;
 656     r = guestfs_blockdev_setrw (g, device);
 657     if (r == -1)
 658       return -1;
 659   }
 660   {
 661     int r;
 662     suppress_error = 0;
 663     r = guestfs_umount_all (g);
 664     if (r == -1)
 665       return -1;
 666   }
 667   {
 668     int r;
 669     suppress_error = 0;
 670     r = guestfs_lvm_remove_all (g);
 671     if (r == -1)
 672       return -1;
 673   }
 674   {
 675     char device[] = "/dev/sda";
 676     char lines_0[] = ",";
 677     char *lines[] = {
 678       lines_0,
 679       NULL
 680     };
 681     int r;
 682     suppress_error = 0;
 683     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 684     if (r == -1)
 685       return -1;
 686   }
 687   {
 688     char fstype[] = "ext2";
 689     char device[] = "/dev/sda1";
 690     int r;
 691     suppress_error = 0;
 692     r = guestfs_mkfs (g, fstype, device);
 693     if (r == -1)
 694       return -1;
 695   }
 696   {
 697     char device[] = "/dev/sda1";
 698     char mountpoint[] = "/";
 699     int r;
 700     suppress_error = 0;
 701     r = guestfs_mount (g, device, mountpoint);
 702     if (r == -1)
 703       return -1;
 704   }
 705   /* TestOutputList for find (2) */
 706   {
 707     char path[] = "/a/b/c";
 708     int r;
 709     suppress_error = 0;
 710     r = guestfs_mkdir_p (g, path);
 711     if (r == -1)
 712       return -1;
 713   }
 714   {
 715     char path[] = "/a/b/c/d";
 716     int r;
 717     suppress_error = 0;
 718     r = guestfs_touch (g, path);
 719     if (r == -1)
 720       return -1;
 721   }
 722   {
 723     char directory[] = "/a/b/";
 724     char **r;
 725     int i;
 726     suppress_error = 0;
 727     r = guestfs_find (g, directory);
 728     if (r == NULL)
 729       return -1;
 730     if (!r[0]) {
 731       fprintf (stderr, "test_find_2: short list returned from command\n");
 732       print_strings (r);
 733       return -1;
 734     }
 735     {
 736       char expected[] = "c";
 737       if (strcmp (r[0], expected) != 0) {
 738         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 739         return -1;
 740       }
 741     }
 742     if (!r[1]) {
 743       fprintf (stderr, "test_find_2: short list returned from command\n");
 744       print_strings (r);
 745       return -1;
 746     }
 747     {
 748       char expected[] = "c/d";
 749       if (strcmp (r[1], expected) != 0) {
 750         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 751         return -1;
 752       }
 753     }
 754     if (r[2] != NULL) {
 755       fprintf (stderr, "test_find_2: extra elements returned from command\n");
 756       print_strings (r);
 757       return -1;
 758     }
 759     for (i = 0; r[i] != NULL; ++i)
 760       free (r[i]);
 761     free (r);
 762   }
 763   return 0;
 764 }
 765
 766 static int test_lvresize_0_skip (void)
 767 {
 768   const char *str;
 769
 770   str = getenv ("SKIP_TEST_LVRESIZE_0");
 771   if (str && strcmp (str, "1") == 0) return 1;
 772   str = getenv ("SKIP_TEST_LVRESIZE");
 773   if (str && strcmp (str, "1") == 0) return 1;
 774   return 0;
 775 }
 776
 777 static int test_lvresize_0 (void)
 778 {
 779   if (test_lvresize_0_skip ()) {
 780     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
 781     return 0;
 782   }
 783
 784   /* InitNone|InitEmpty for test_lvresize_0 */
 785   {
 786     char device[] = "/dev/sda";
 787     int r;
 788     suppress_error = 0;
 789     r = guestfs_blockdev_setrw (g, device);
 790     if (r == -1)
 791       return -1;
 792   }
 793   {
 794     int r;
 795     suppress_error = 0;
 796     r = guestfs_umount_all (g);
 797     if (r == -1)
 798       return -1;
 799   }
 800   {
 801     int r;
 802     suppress_error = 0;
 803     r = guestfs_lvm_remove_all (g);
 804     if (r == -1)
 805       return -1;
 806   }
 807   /* TestOutput for lvresize (0) */
 808   char expected[] = "test content";
 809   {
 810     char device[] = "/dev/sda";
 811     char lines_0[] = ",";
 812     char *lines[] = {
 813       lines_0,
 814       NULL
 815     };
 816     int r;
 817     suppress_error = 0;
 818     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 819     if (r == -1)
 820       return -1;
 821   }
 822   {
 823     char device[] = "/dev/sda1";
 824     int r;
 825     suppress_error = 0;
 826     r = guestfs_pvcreate (g, device);
 827     if (r == -1)
 828       return -1;
 829   }
 830   {
 831     char volgroup[] = "VG";
 832     char physvols_0[] = "/dev/sda1";
 833     char *physvols[] = {
 834       physvols_0,
 835       NULL
 836     };
 837     int r;
 838     suppress_error = 0;
 839     r = guestfs_vgcreate (g, volgroup, physvols);
 840     if (r == -1)
 841       return -1;
 842   }
 843   {
 844     char logvol[] = "LV";
 845     char volgroup[] = "VG";
 846     int r;
 847     suppress_error = 0;
 848     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 849     if (r == -1)
 850       return -1;
 851   }
 852   {
 853     char fstype[] = "ext2";
 854     char device[] = "/dev/VG/LV";
 855     int r;
 856     suppress_error = 0;
 857     r = guestfs_mkfs (g, fstype, device);
 858     if (r == -1)
 859       return -1;
 860   }
 861   {
 862     char device[] = "/dev/VG/LV";
 863     char mountpoint[] = "/";
 864     int r;
 865     suppress_error = 0;
 866     r = guestfs_mount (g, device, mountpoint);
 867     if (r == -1)
 868       return -1;
 869   }
 870   {
 871     char path[] = "/new";
 872     char content[] = "test content";
 873     int r;
 874     suppress_error = 0;
 875     r = guestfs_write_file (g, path, content, 0);
 876     if (r == -1)
 877       return -1;
 878   }
 879   {
 880     char pathordevice[] = "/";
 881     int r;
 882     suppress_error = 0;
 883     r = guestfs_umount (g, pathordevice);
 884     if (r == -1)
 885       return -1;
 886   }
 887   {
 888     char device[] = "/dev/VG/LV";
 889     int r;
 890     suppress_error = 0;
 891     r = guestfs_lvresize (g, device, 20);
 892     if (r == -1)
 893       return -1;
 894   }
 895   {
 896     char device[] = "/dev/VG/LV";
 897     int r;
 898     suppress_error = 0;
 899     r = guestfs_e2fsck_f (g, device);
 900     if (r == -1)
 901       return -1;
 902   }
 903   {
 904     char device[] = "/dev/VG/LV";
 905     int r;
 906     suppress_error = 0;
 907     r = guestfs_resize2fs (g, device);
 908     if (r == -1)
 909       return -1;
 910   }
 911   {
 912     char device[] = "/dev/VG/LV";
 913     char mountpoint[] = "/";
 914     int r;
 915     suppress_error = 0;
 916     r = guestfs_mount (g, device, mountpoint);
 917     if (r == -1)
 918       return -1;
 919   }
 920   {
 921     char path[] = "/new";
 922     char *r;
 923     suppress_error = 0;
 924     r = guestfs_cat (g, path);
 925     if (r == NULL)
 926       return -1;
 927     if (strcmp (r, expected) != 0) {
 928       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 929       return -1;
 930     }
 931     free (r);
 932   }
 933   return 0;
 934 }
 935
 936 static int test_zerofree_0_skip (void)
 937 {
 938   const char *str;
 939
 940   str = getenv ("SKIP_TEST_ZEROFREE_0");
 941   if (str && strcmp (str, "1") == 0) return 1;
 942   str = getenv ("SKIP_TEST_ZEROFREE");
 943   if (str && strcmp (str, "1") == 0) return 1;
 944   return 0;
 945 }
 946
 947 static int test_zerofree_0 (void)
 948 {
 949   if (test_zerofree_0_skip ()) {
 950     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
 951     return 0;
 952   }
 953
 954   /* InitNone|InitEmpty for test_zerofree_0 */
 955   {
 956     char device[] = "/dev/sda";
 957     int r;
 958     suppress_error = 0;
 959     r = guestfs_blockdev_setrw (g, device);
 960     if (r == -1)
 961       return -1;
 962   }
 963   {
 964     int r;
 965     suppress_error = 0;
 966     r = guestfs_umount_all (g);
 967     if (r == -1)
 968       return -1;
 969   }
 970   {
 971     int r;
 972     suppress_error = 0;
 973     r = guestfs_lvm_remove_all (g);
 974     if (r == -1)
 975       return -1;
 976   }
 977   /* TestOutput for zerofree (0) */
 978   char expected[] = "test file";
 979   {
 980     char device[] = "/dev/sda";
 981     char lines_0[] = ",";
 982     char *lines[] = {
 983       lines_0,
 984       NULL
 985     };
 986     int r;
 987     suppress_error = 0;
 988     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 989     if (r == -1)
 990       return -1;
 991   }
 992   {
 993     char fstype[] = "ext3";
 994     char device[] = "/dev/sda1";
 995     int r;
 996     suppress_error = 0;
 997     r = guestfs_mkfs (g, fstype, device);
 998     if (r == -1)
 999       return -1;
1000   }
1001   {
1002     char device[] = "/dev/sda1";
1003     char mountpoint[] = "/";
1004     int r;
1005     suppress_error = 0;
1006     r = guestfs_mount (g, device, mountpoint);
1007     if (r == -1)
1008       return -1;
1009   }
1010   {
1011     char path[] = "/new";
1012     char content[] = "test file";
1013     int r;
1014     suppress_error = 0;
1015     r = guestfs_write_file (g, path, content, 0);
1016     if (r == -1)
1017       return -1;
1018   }
1019   {
1020     char pathordevice[] = "/dev/sda1";
1021     int r;
1022     suppress_error = 0;
1023     r = guestfs_umount (g, pathordevice);
1024     if (r == -1)
1025       return -1;
1026   }
1027   {
1028     char device[] = "/dev/sda1";
1029     int r;
1030     suppress_error = 0;
1031     r = guestfs_zerofree (g, device);
1032     if (r == -1)
1033       return -1;
1034   }
1035   {
1036     char device[] = "/dev/sda1";
1037     char mountpoint[] = "/";
1038     int r;
1039     suppress_error = 0;
1040     r = guestfs_mount (g, device, mountpoint);
1041     if (r == -1)
1042       return -1;
1043   }
1044   {
1045     char path[] = "/new";
1046     char *r;
1047     suppress_error = 0;
1048     r = guestfs_cat (g, path);
1049     if (r == NULL)
1050       return -1;
1051     if (strcmp (r, expected) != 0) {
1052       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1053       return -1;
1054     }
1055     free (r);
1056   }
1057   return 0;
1058 }
1059
1060 static int test_hexdump_0_skip (void)
1061 {
1062   const char *str;
1063
1064   str = getenv ("SKIP_TEST_HEXDUMP_0");
1065   if (str && strcmp (str, "1") == 0) return 1;
1066   str = getenv ("SKIP_TEST_HEXDUMP");
1067   if (str && strcmp (str, "1") == 0) return 1;
1068   return 0;
1069 }
1070
1071 static int test_hexdump_0 (void)
1072 {
1073   if (test_hexdump_0_skip ()) {
1074     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1075     return 0;
1076   }
1077
1078   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1079   {
1080     char device[] = "/dev/sda";
1081     int r;
1082     suppress_error = 0;
1083     r = guestfs_blockdev_setrw (g, device);
1084     if (r == -1)
1085       return -1;
1086   }
1087   {
1088     int r;
1089     suppress_error = 0;
1090     r = guestfs_umount_all (g);
1091     if (r == -1)
1092       return -1;
1093   }
1094   {
1095     int r;
1096     suppress_error = 0;
1097     r = guestfs_lvm_remove_all (g);
1098     if (r == -1)
1099       return -1;
1100   }
1101   {
1102     char device[] = "/dev/sda";
1103     char lines_0[] = ",";
1104     char *lines[] = {
1105       lines_0,
1106       NULL
1107     };
1108     int r;
1109     suppress_error = 0;
1110     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1111     if (r == -1)
1112       return -1;
1113   }
1114   {
1115     char fstype[] = "ext2";
1116     char device[] = "/dev/sda1";
1117     int r;
1118     suppress_error = 0;
1119     r = guestfs_mkfs (g, fstype, device);
1120     if (r == -1)
1121       return -1;
1122   }
1123   {
1124     char device[] = "/dev/sda1";
1125     char mountpoint[] = "/";
1126     int r;
1127     suppress_error = 0;
1128     r = guestfs_mount (g, device, mountpoint);
1129     if (r == -1)
1130       return -1;
1131   }
1132   /* TestOutput for hexdump (0) */
1133   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
1134   {
1135     char path[] = "/new";
1136     char content[] = "hello\nworld\n";
1137     int r;
1138     suppress_error = 0;
1139     r = guestfs_write_file (g, path, content, 12);
1140     if (r == -1)
1141       return -1;
1142   }
1143   {
1144     char path[] = "/new";
1145     char *r;
1146     suppress_error = 0;
1147     r = guestfs_hexdump (g, path);
1148     if (r == NULL)
1149       return -1;
1150     if (strcmp (r, expected) != 0) {
1151       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1152       return -1;
1153     }
1154     free (r);
1155   }
1156   return 0;
1157 }
1158
1159 static int test_strings_e_0_skip (void)
1160 {
1161   const char *str;
1162
1163   str = getenv ("SKIP_TEST_STRINGS_E_0");
1164   if (str && strcmp (str, "1") == 0) return 1;
1165   str = getenv ("SKIP_TEST_STRINGS_E");
1166   if (str && strcmp (str, "1") == 0) return 1;
1167   return 0;
1168 }
1169
1170 static int test_strings_e_0 (void)
1171 {
1172   if (test_strings_e_0_skip ()) {
1173     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1174     return 0;
1175   }
1176
1177   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1178   {
1179     char device[] = "/dev/sda";
1180     int r;
1181     suppress_error = 0;
1182     r = guestfs_blockdev_setrw (g, device);
1183     if (r == -1)
1184       return -1;
1185   }
1186   {
1187     int r;
1188     suppress_error = 0;
1189     r = guestfs_umount_all (g);
1190     if (r == -1)
1191       return -1;
1192   }
1193   {
1194     int r;
1195     suppress_error = 0;
1196     r = guestfs_lvm_remove_all (g);
1197     if (r == -1)
1198       return -1;
1199   }
1200   {
1201     char device[] = "/dev/sda";
1202     char lines_0[] = ",";
1203     char *lines[] = {
1204       lines_0,
1205       NULL
1206     };
1207     int r;
1208     suppress_error = 0;
1209     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1210     if (r == -1)
1211       return -1;
1212   }
1213   {
1214     char fstype[] = "ext2";
1215     char device[] = "/dev/sda1";
1216     int r;
1217     suppress_error = 0;
1218     r = guestfs_mkfs (g, fstype, device);
1219     if (r == -1)
1220       return -1;
1221   }
1222   {
1223     char device[] = "/dev/sda1";
1224     char mountpoint[] = "/";
1225     int r;
1226     suppress_error = 0;
1227     r = guestfs_mount (g, device, mountpoint);
1228     if (r == -1)
1229       return -1;
1230   }
1231   /* TestOutputList for strings_e (0) */
1232   {
1233     char path[] = "/new";
1234     char content[] = "hello\nworld\n";
1235     int r;
1236     suppress_error = 0;
1237     r = guestfs_write_file (g, path, content, 0);
1238     if (r == -1)
1239       return -1;
1240   }
1241   {
1242     char encoding[] = "b";
1243     char path[] = "/new";
1244     char **r;
1245     int i;
1246     suppress_error = 0;
1247     r = guestfs_strings_e (g, encoding, path);
1248     if (r == NULL)
1249       return -1;
1250     if (r[0] != NULL) {
1251       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1252       print_strings (r);
1253       return -1;
1254     }
1255     for (i = 0; r[i] != NULL; ++i)
1256       free (r[i]);
1257     free (r);
1258   }
1259   return 0;
1260 }
1261
1262 static int test_strings_e_1_skip (void)
1263 {
1264   const char *str;
1265
1266   str = getenv ("SKIP_TEST_STRINGS_E_1");
1267   if (str && strcmp (str, "1") == 0) return 1;
1268   str = getenv ("SKIP_TEST_STRINGS_E");
1269   if (str && strcmp (str, "1") == 0) return 1;
1270   return 0;
1271 }
1272
1273 static int test_strings_e_1 (void)
1274 {
1275   if (test_strings_e_1_skip ()) {
1276     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1277     return 0;
1278   }
1279
1280   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1281   return 0;
1282 }
1283
1284 static int test_strings_0_skip (void)
1285 {
1286   const char *str;
1287
1288   str = getenv ("SKIP_TEST_STRINGS_0");
1289   if (str && strcmp (str, "1") == 0) return 1;
1290   str = getenv ("SKIP_TEST_STRINGS");
1291   if (str && strcmp (str, "1") == 0) return 1;
1292   return 0;
1293 }
1294
1295 static int test_strings_0 (void)
1296 {
1297   if (test_strings_0_skip ()) {
1298     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1299     return 0;
1300   }
1301
1302   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1303   {
1304     char device[] = "/dev/sda";
1305     int r;
1306     suppress_error = 0;
1307     r = guestfs_blockdev_setrw (g, device);
1308     if (r == -1)
1309       return -1;
1310   }
1311   {
1312     int r;
1313     suppress_error = 0;
1314     r = guestfs_umount_all (g);
1315     if (r == -1)
1316       return -1;
1317   }
1318   {
1319     int r;
1320     suppress_error = 0;
1321     r = guestfs_lvm_remove_all (g);
1322     if (r == -1)
1323       return -1;
1324   }
1325   {
1326     char device[] = "/dev/sda";
1327     char lines_0[] = ",";
1328     char *lines[] = {
1329       lines_0,
1330       NULL
1331     };
1332     int r;
1333     suppress_error = 0;
1334     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1335     if (r == -1)
1336       return -1;
1337   }
1338   {
1339     char fstype[] = "ext2";
1340     char device[] = "/dev/sda1";
1341     int r;
1342     suppress_error = 0;
1343     r = guestfs_mkfs (g, fstype, device);
1344     if (r == -1)
1345       return -1;
1346   }
1347   {
1348     char device[] = "/dev/sda1";
1349     char mountpoint[] = "/";
1350     int r;
1351     suppress_error = 0;
1352     r = guestfs_mount (g, device, mountpoint);
1353     if (r == -1)
1354       return -1;
1355   }
1356   /* TestOutputList for strings (0) */
1357   {
1358     char path[] = "/new";
1359     char content[] = "hello\nworld\n";
1360     int r;
1361     suppress_error = 0;
1362     r = guestfs_write_file (g, path, content, 0);
1363     if (r == -1)
1364       return -1;
1365   }
1366   {
1367     char path[] = "/new";
1368     char **r;
1369     int i;
1370     suppress_error = 0;
1371     r = guestfs_strings (g, path);
1372     if (r == NULL)
1373       return -1;
1374     if (!r[0]) {
1375       fprintf (stderr, "test_strings_0: short list returned from command\n");
1376       print_strings (r);
1377       return -1;
1378     }
1379     {
1380       char expected[] = "hello";
1381       if (strcmp (r[0], expected) != 0) {
1382         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1383         return -1;
1384       }
1385     }
1386     if (!r[1]) {
1387       fprintf (stderr, "test_strings_0: short list returned from command\n");
1388       print_strings (r);
1389       return -1;
1390     }
1391     {
1392       char expected[] = "world";
1393       if (strcmp (r[1], expected) != 0) {
1394         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1395         return -1;
1396       }
1397     }
1398     if (r[2] != NULL) {
1399       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1400       print_strings (r);
1401       return -1;
1402     }
1403     for (i = 0; r[i] != NULL; ++i)
1404       free (r[i]);
1405     free (r);
1406   }
1407   return 0;
1408 }
1409
1410 static int test_strings_1_skip (void)
1411 {
1412   const char *str;
1413
1414   str = getenv ("SKIP_TEST_STRINGS_1");
1415   if (str && strcmp (str, "1") == 0) return 1;
1416   str = getenv ("SKIP_TEST_STRINGS");
1417   if (str && strcmp (str, "1") == 0) return 1;
1418   return 0;
1419 }
1420
1421 static int test_strings_1 (void)
1422 {
1423   if (test_strings_1_skip ()) {
1424     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1425     return 0;
1426   }
1427
1428   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1429   {
1430     char device[] = "/dev/sda";
1431     int r;
1432     suppress_error = 0;
1433     r = guestfs_blockdev_setrw (g, device);
1434     if (r == -1)
1435       return -1;
1436   }
1437   {
1438     int r;
1439     suppress_error = 0;
1440     r = guestfs_umount_all (g);
1441     if (r == -1)
1442       return -1;
1443   }
1444   {
1445     int r;
1446     suppress_error = 0;
1447     r = guestfs_lvm_remove_all (g);
1448     if (r == -1)
1449       return -1;
1450   }
1451   {
1452     char device[] = "/dev/sda";
1453     char lines_0[] = ",";
1454     char *lines[] = {
1455       lines_0,
1456       NULL
1457     };
1458     int r;
1459     suppress_error = 0;
1460     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1461     if (r == -1)
1462       return -1;
1463   }
1464   {
1465     char fstype[] = "ext2";
1466     char device[] = "/dev/sda1";
1467     int r;
1468     suppress_error = 0;
1469     r = guestfs_mkfs (g, fstype, device);
1470     if (r == -1)
1471       return -1;
1472   }
1473   {
1474     char device[] = "/dev/sda1";
1475     char mountpoint[] = "/";
1476     int r;
1477     suppress_error = 0;
1478     r = guestfs_mount (g, device, mountpoint);
1479     if (r == -1)
1480       return -1;
1481   }
1482   /* TestOutputList for strings (1) */
1483   {
1484     char path[] = "/new";
1485     int r;
1486     suppress_error = 0;
1487     r = guestfs_touch (g, path);
1488     if (r == -1)
1489       return -1;
1490   }
1491   {
1492     char path[] = "/new";
1493     char **r;
1494     int i;
1495     suppress_error = 0;
1496     r = guestfs_strings (g, path);
1497     if (r == NULL)
1498       return -1;
1499     if (r[0] != NULL) {
1500       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1501       print_strings (r);
1502       return -1;
1503     }
1504     for (i = 0; r[i] != NULL; ++i)
1505       free (r[i]);
1506     free (r);
1507   }
1508   return 0;
1509 }
1510
1511 static int test_equal_0_skip (void)
1512 {
1513   const char *str;
1514
1515   str = getenv ("SKIP_TEST_EQUAL_0");
1516   if (str && strcmp (str, "1") == 0) return 1;
1517   str = getenv ("SKIP_TEST_EQUAL");
1518   if (str && strcmp (str, "1") == 0) return 1;
1519   return 0;
1520 }
1521
1522 static int test_equal_0 (void)
1523 {
1524   if (test_equal_0_skip ()) {
1525     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1526     return 0;
1527   }
1528
1529   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1530   {
1531     char device[] = "/dev/sda";
1532     int r;
1533     suppress_error = 0;
1534     r = guestfs_blockdev_setrw (g, device);
1535     if (r == -1)
1536       return -1;
1537   }
1538   {
1539     int r;
1540     suppress_error = 0;
1541     r = guestfs_umount_all (g);
1542     if (r == -1)
1543       return -1;
1544   }
1545   {
1546     int r;
1547     suppress_error = 0;
1548     r = guestfs_lvm_remove_all (g);
1549     if (r == -1)
1550       return -1;
1551   }
1552   {
1553     char device[] = "/dev/sda";
1554     char lines_0[] = ",";
1555     char *lines[] = {
1556       lines_0,
1557       NULL
1558     };
1559     int r;
1560     suppress_error = 0;
1561     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1562     if (r == -1)
1563       return -1;
1564   }
1565   {
1566     char fstype[] = "ext2";
1567     char device[] = "/dev/sda1";
1568     int r;
1569     suppress_error = 0;
1570     r = guestfs_mkfs (g, fstype, device);
1571     if (r == -1)
1572       return -1;
1573   }
1574   {
1575     char device[] = "/dev/sda1";
1576     char mountpoint[] = "/";
1577     int r;
1578     suppress_error = 0;
1579     r = guestfs_mount (g, device, mountpoint);
1580     if (r == -1)
1581       return -1;
1582   }
1583   /* TestOutputTrue for equal (0) */
1584   {
1585     char path[] = "/file1";
1586     char content[] = "contents of a file";
1587     int r;
1588     suppress_error = 0;
1589     r = guestfs_write_file (g, path, content, 0);
1590     if (r == -1)
1591       return -1;
1592   }
1593   {
1594     char src[] = "/file1";
1595     char dest[] = "/file2";
1596     int r;
1597     suppress_error = 0;
1598     r = guestfs_cp (g, src, dest);
1599     if (r == -1)
1600       return -1;
1601   }
1602   {
1603     char file1[] = "/file1";
1604     char file2[] = "/file2";
1605     int r;
1606     suppress_error = 0;
1607     r = guestfs_equal (g, file1, file2);
1608     if (r == -1)
1609       return -1;
1610     if (!r) {
1611       fprintf (stderr, "test_equal_0: expected true, got false\n");
1612       return -1;
1613     }
1614   }
1615   return 0;
1616 }
1617
1618 static int test_equal_1_skip (void)
1619 {
1620   const char *str;
1621
1622   str = getenv ("SKIP_TEST_EQUAL_1");
1623   if (str && strcmp (str, "1") == 0) return 1;
1624   str = getenv ("SKIP_TEST_EQUAL");
1625   if (str && strcmp (str, "1") == 0) return 1;
1626   return 0;
1627 }
1628
1629 static int test_equal_1 (void)
1630 {
1631   if (test_equal_1_skip ()) {
1632     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1633     return 0;
1634   }
1635
1636   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1637   {
1638     char device[] = "/dev/sda";
1639     int r;
1640     suppress_error = 0;
1641     r = guestfs_blockdev_setrw (g, device);
1642     if (r == -1)
1643       return -1;
1644   }
1645   {
1646     int r;
1647     suppress_error = 0;
1648     r = guestfs_umount_all (g);
1649     if (r == -1)
1650       return -1;
1651   }
1652   {
1653     int r;
1654     suppress_error = 0;
1655     r = guestfs_lvm_remove_all (g);
1656     if (r == -1)
1657       return -1;
1658   }
1659   {
1660     char device[] = "/dev/sda";
1661     char lines_0[] = ",";
1662     char *lines[] = {
1663       lines_0,
1664       NULL
1665     };
1666     int r;
1667     suppress_error = 0;
1668     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1669     if (r == -1)
1670       return -1;
1671   }
1672   {
1673     char fstype[] = "ext2";
1674     char device[] = "/dev/sda1";
1675     int r;
1676     suppress_error = 0;
1677     r = guestfs_mkfs (g, fstype, device);
1678     if (r == -1)
1679       return -1;
1680   }
1681   {
1682     char device[] = "/dev/sda1";
1683     char mountpoint[] = "/";
1684     int r;
1685     suppress_error = 0;
1686     r = guestfs_mount (g, device, mountpoint);
1687     if (r == -1)
1688       return -1;
1689   }
1690   /* TestOutputFalse for equal (1) */
1691   {
1692     char path[] = "/file1";
1693     char content[] = "contents of a file";
1694     int r;
1695     suppress_error = 0;
1696     r = guestfs_write_file (g, path, content, 0);
1697     if (r == -1)
1698       return -1;
1699   }
1700   {
1701     char path[] = "/file2";
1702     char content[] = "contents of another file";
1703     int r;
1704     suppress_error = 0;
1705     r = guestfs_write_file (g, path, content, 0);
1706     if (r == -1)
1707       return -1;
1708   }
1709   {
1710     char file1[] = "/file1";
1711     char file2[] = "/file2";
1712     int r;
1713     suppress_error = 0;
1714     r = guestfs_equal (g, file1, file2);
1715     if (r == -1)
1716       return -1;
1717     if (r) {
1718       fprintf (stderr, "test_equal_1: expected false, got true\n");
1719       return -1;
1720     }
1721   }
1722   return 0;
1723 }
1724
1725 static int test_equal_2_skip (void)
1726 {
1727   const char *str;
1728
1729   str = getenv ("SKIP_TEST_EQUAL_2");
1730   if (str && strcmp (str, "1") == 0) return 1;
1731   str = getenv ("SKIP_TEST_EQUAL");
1732   if (str && strcmp (str, "1") == 0) return 1;
1733   return 0;
1734 }
1735
1736 static int test_equal_2 (void)
1737 {
1738   if (test_equal_2_skip ()) {
1739     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1740     return 0;
1741   }
1742
1743   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1744   {
1745     char device[] = "/dev/sda";
1746     int r;
1747     suppress_error = 0;
1748     r = guestfs_blockdev_setrw (g, device);
1749     if (r == -1)
1750       return -1;
1751   }
1752   {
1753     int r;
1754     suppress_error = 0;
1755     r = guestfs_umount_all (g);
1756     if (r == -1)
1757       return -1;
1758   }
1759   {
1760     int r;
1761     suppress_error = 0;
1762     r = guestfs_lvm_remove_all (g);
1763     if (r == -1)
1764       return -1;
1765   }
1766   {
1767     char device[] = "/dev/sda";
1768     char lines_0[] = ",";
1769     char *lines[] = {
1770       lines_0,
1771       NULL
1772     };
1773     int r;
1774     suppress_error = 0;
1775     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1776     if (r == -1)
1777       return -1;
1778   }
1779   {
1780     char fstype[] = "ext2";
1781     char device[] = "/dev/sda1";
1782     int r;
1783     suppress_error = 0;
1784     r = guestfs_mkfs (g, fstype, device);
1785     if (r == -1)
1786       return -1;
1787   }
1788   {
1789     char device[] = "/dev/sda1";
1790     char mountpoint[] = "/";
1791     int r;
1792     suppress_error = 0;
1793     r = guestfs_mount (g, device, mountpoint);
1794     if (r == -1)
1795       return -1;
1796   }
1797   /* TestLastFail for equal (2) */
1798   {
1799     char file1[] = "/file1";
1800     char file2[] = "/file2";
1801     int r;
1802     suppress_error = 1;
1803     r = guestfs_equal (g, file1, file2);
1804     if (r != -1)
1805       return -1;
1806   }
1807   return 0;
1808 }
1809
1810 static int test_ping_daemon_0_skip (void)
1811 {
1812   const char *str;
1813
1814   str = getenv ("SKIP_TEST_PING_DAEMON_0");
1815   if (str && strcmp (str, "1") == 0) return 1;
1816   str = getenv ("SKIP_TEST_PING_DAEMON");
1817   if (str && strcmp (str, "1") == 0) return 1;
1818   return 0;
1819 }
1820
1821 static int test_ping_daemon_0 (void)
1822 {
1823   if (test_ping_daemon_0_skip ()) {
1824     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1825     return 0;
1826   }
1827
1828   /* InitNone|InitEmpty for test_ping_daemon_0 */
1829   {
1830     char device[] = "/dev/sda";
1831     int r;
1832     suppress_error = 0;
1833     r = guestfs_blockdev_setrw (g, device);
1834     if (r == -1)
1835       return -1;
1836   }
1837   {
1838     int r;
1839     suppress_error = 0;
1840     r = guestfs_umount_all (g);
1841     if (r == -1)
1842       return -1;
1843   }
1844   {
1845     int r;
1846     suppress_error = 0;
1847     r = guestfs_lvm_remove_all (g);
1848     if (r == -1)
1849       return -1;
1850   }
1851   /* TestRun for ping_daemon (0) */
1852   {
1853     int r;
1854     suppress_error = 0;
1855     r = guestfs_ping_daemon (g);
1856     if (r == -1)
1857       return -1;
1858   }
1859   return 0;
1860 }
1861
1862 static int test_dmesg_0_skip (void)
1863 {
1864   const char *str;
1865
1866   str = getenv ("SKIP_TEST_DMESG_0");
1867   if (str && strcmp (str, "1") == 0) return 1;
1868   str = getenv ("SKIP_TEST_DMESG");
1869   if (str && strcmp (str, "1") == 0) return 1;
1870   return 0;
1871 }
1872
1873 static int test_dmesg_0 (void)
1874 {
1875   if (test_dmesg_0_skip ()) {
1876     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1877     return 0;
1878   }
1879
1880   /* InitNone|InitEmpty for test_dmesg_0 */
1881   {
1882     char device[] = "/dev/sda";
1883     int r;
1884     suppress_error = 0;
1885     r = guestfs_blockdev_setrw (g, device);
1886     if (r == -1)
1887       return -1;
1888   }
1889   {
1890     int r;
1891     suppress_error = 0;
1892     r = guestfs_umount_all (g);
1893     if (r == -1)
1894       return -1;
1895   }
1896   {
1897     int r;
1898     suppress_error = 0;
1899     r = guestfs_lvm_remove_all (g);
1900     if (r == -1)
1901       return -1;
1902   }
1903   /* TestRun for dmesg (0) */
1904   {
1905     char *r;
1906     suppress_error = 0;
1907     r = guestfs_dmesg (g);
1908     if (r == NULL)
1909       return -1;
1910     free (r);
1911   }
1912   return 0;
1913 }
1914
1915 static int test_drop_caches_0_skip (void)
1916 {
1917   const char *str;
1918
1919   str = getenv ("SKIP_TEST_DROP_CACHES_0");
1920   if (str && strcmp (str, "1") == 0) return 1;
1921   str = getenv ("SKIP_TEST_DROP_CACHES");
1922   if (str && strcmp (str, "1") == 0) return 1;
1923   return 0;
1924 }
1925
1926 static int test_drop_caches_0 (void)
1927 {
1928   if (test_drop_caches_0_skip ()) {
1929     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1930     return 0;
1931   }
1932
1933   /* InitNone|InitEmpty for test_drop_caches_0 */
1934   {
1935     char device[] = "/dev/sda";
1936     int r;
1937     suppress_error = 0;
1938     r = guestfs_blockdev_setrw (g, device);
1939     if (r == -1)
1940       return -1;
1941   }
1942   {
1943     int r;
1944     suppress_error = 0;
1945     r = guestfs_umount_all (g);
1946     if (r == -1)
1947       return -1;
1948   }
1949   {
1950     int r;
1951     suppress_error = 0;
1952     r = guestfs_lvm_remove_all (g);
1953     if (r == -1)
1954       return -1;
1955   }
1956   /* TestRun for drop_caches (0) */
1957   {
1958     int r;
1959     suppress_error = 0;
1960     r = guestfs_drop_caches (g, 3);
1961     if (r == -1)
1962       return -1;
1963   }
1964   return 0;
1965 }
1966
1967 static int test_mv_0_skip (void)
1968 {
1969   const char *str;
1970
1971   str = getenv ("SKIP_TEST_MV_0");
1972   if (str && strcmp (str, "1") == 0) return 1;
1973   str = getenv ("SKIP_TEST_MV");
1974   if (str && strcmp (str, "1") == 0) return 1;
1975   return 0;
1976 }
1977
1978 static int test_mv_0 (void)
1979 {
1980   if (test_mv_0_skip ()) {
1981     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
1982     return 0;
1983   }
1984
1985   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1986   {
1987     char device[] = "/dev/sda";
1988     int r;
1989     suppress_error = 0;
1990     r = guestfs_blockdev_setrw (g, device);
1991     if (r == -1)
1992       return -1;
1993   }
1994   {
1995     int r;
1996     suppress_error = 0;
1997     r = guestfs_umount_all (g);
1998     if (r == -1)
1999       return -1;
2000   }
2001   {
2002     int r;
2003     suppress_error = 0;
2004     r = guestfs_lvm_remove_all (g);
2005     if (r == -1)
2006       return -1;
2007   }
2008   {
2009     char device[] = "/dev/sda";
2010     char lines_0[] = ",";
2011     char *lines[] = {
2012       lines_0,
2013       NULL
2014     };
2015     int r;
2016     suppress_error = 0;
2017     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2018     if (r == -1)
2019       return -1;
2020   }
2021   {
2022     char fstype[] = "ext2";
2023     char device[] = "/dev/sda1";
2024     int r;
2025     suppress_error = 0;
2026     r = guestfs_mkfs (g, fstype, device);
2027     if (r == -1)
2028       return -1;
2029   }
2030   {
2031     char device[] = "/dev/sda1";
2032     char mountpoint[] = "/";
2033     int r;
2034     suppress_error = 0;
2035     r = guestfs_mount (g, device, mountpoint);
2036     if (r == -1)
2037       return -1;
2038   }
2039   /* TestOutput for mv (0) */
2040   char expected[] = "file content";
2041   {
2042     char path[] = "/old";
2043     char content[] = "file content";
2044     int r;
2045     suppress_error = 0;
2046     r = guestfs_write_file (g, path, content, 0);
2047     if (r == -1)
2048       return -1;
2049   }
2050   {
2051     char src[] = "/old";
2052     char dest[] = "/new";
2053     int r;
2054     suppress_error = 0;
2055     r = guestfs_mv (g, src, dest);
2056     if (r == -1)
2057       return -1;
2058   }
2059   {
2060     char path[] = "/new";
2061     char *r;
2062     suppress_error = 0;
2063     r = guestfs_cat (g, path);
2064     if (r == NULL)
2065       return -1;
2066     if (strcmp (r, expected) != 0) {
2067       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2068       return -1;
2069     }
2070     free (r);
2071   }
2072   return 0;
2073 }
2074
2075 static int test_mv_1_skip (void)
2076 {
2077   const char *str;
2078
2079   str = getenv ("SKIP_TEST_MV_1");
2080   if (str && strcmp (str, "1") == 0) return 1;
2081   str = getenv ("SKIP_TEST_MV");
2082   if (str && strcmp (str, "1") == 0) return 1;
2083   return 0;
2084 }
2085
2086 static int test_mv_1 (void)
2087 {
2088   if (test_mv_1_skip ()) {
2089     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2090     return 0;
2091   }
2092
2093   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2094   {
2095     char device[] = "/dev/sda";
2096     int r;
2097     suppress_error = 0;
2098     r = guestfs_blockdev_setrw (g, device);
2099     if (r == -1)
2100       return -1;
2101   }
2102   {
2103     int r;
2104     suppress_error = 0;
2105     r = guestfs_umount_all (g);
2106     if (r == -1)
2107       return -1;
2108   }
2109   {
2110     int r;
2111     suppress_error = 0;
2112     r = guestfs_lvm_remove_all (g);
2113     if (r == -1)
2114       return -1;
2115   }
2116   {
2117     char device[] = "/dev/sda";
2118     char lines_0[] = ",";
2119     char *lines[] = {
2120       lines_0,
2121       NULL
2122     };
2123     int r;
2124     suppress_error = 0;
2125     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2126     if (r == -1)
2127       return -1;
2128   }
2129   {
2130     char fstype[] = "ext2";
2131     char device[] = "/dev/sda1";
2132     int r;
2133     suppress_error = 0;
2134     r = guestfs_mkfs (g, fstype, device);
2135     if (r == -1)
2136       return -1;
2137   }
2138   {
2139     char device[] = "/dev/sda1";
2140     char mountpoint[] = "/";
2141     int r;
2142     suppress_error = 0;
2143     r = guestfs_mount (g, device, mountpoint);
2144     if (r == -1)
2145       return -1;
2146   }
2147   /* TestOutputFalse for mv (1) */
2148   {
2149     char path[] = "/old";
2150     char content[] = "file content";
2151     int r;
2152     suppress_error = 0;
2153     r = guestfs_write_file (g, path, content, 0);
2154     if (r == -1)
2155       return -1;
2156   }
2157   {
2158     char src[] = "/old";
2159     char dest[] = "/new";
2160     int r;
2161     suppress_error = 0;
2162     r = guestfs_mv (g, src, dest);
2163     if (r == -1)
2164       return -1;
2165   }
2166   {
2167     char path[] = "/old";
2168     int r;
2169     suppress_error = 0;
2170     r = guestfs_is_file (g, path);
2171     if (r == -1)
2172       return -1;
2173     if (r) {
2174       fprintf (stderr, "test_mv_1: expected false, got true\n");
2175       return -1;
2176     }
2177   }
2178   return 0;
2179 }
2180
2181 static int test_cp_a_0_skip (void)
2182 {
2183   const char *str;
2184
2185   str = getenv ("SKIP_TEST_CP_A_0");
2186   if (str && strcmp (str, "1") == 0) return 1;
2187   str = getenv ("SKIP_TEST_CP_A");
2188   if (str && strcmp (str, "1") == 0) return 1;
2189   return 0;
2190 }
2191
2192 static int test_cp_a_0 (void)
2193 {
2194   if (test_cp_a_0_skip ()) {
2195     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2196     return 0;
2197   }
2198
2199   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2200   {
2201     char device[] = "/dev/sda";
2202     int r;
2203     suppress_error = 0;
2204     r = guestfs_blockdev_setrw (g, device);
2205     if (r == -1)
2206       return -1;
2207   }
2208   {
2209     int r;
2210     suppress_error = 0;
2211     r = guestfs_umount_all (g);
2212     if (r == -1)
2213       return -1;
2214   }
2215   {
2216     int r;
2217     suppress_error = 0;
2218     r = guestfs_lvm_remove_all (g);
2219     if (r == -1)
2220       return -1;
2221   }
2222   {
2223     char device[] = "/dev/sda";
2224     char lines_0[] = ",";
2225     char *lines[] = {
2226       lines_0,
2227       NULL
2228     };
2229     int r;
2230     suppress_error = 0;
2231     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2232     if (r == -1)
2233       return -1;
2234   }
2235   {
2236     char fstype[] = "ext2";
2237     char device[] = "/dev/sda1";
2238     int r;
2239     suppress_error = 0;
2240     r = guestfs_mkfs (g, fstype, device);
2241     if (r == -1)
2242       return -1;
2243   }
2244   {
2245     char device[] = "/dev/sda1";
2246     char mountpoint[] = "/";
2247     int r;
2248     suppress_error = 0;
2249     r = guestfs_mount (g, device, mountpoint);
2250     if (r == -1)
2251       return -1;
2252   }
2253   /* TestOutput for cp_a (0) */
2254   char expected[] = "file content";
2255   {
2256     char path[] = "/olddir";
2257     int r;
2258     suppress_error = 0;
2259     r = guestfs_mkdir (g, path);
2260     if (r == -1)
2261       return -1;
2262   }
2263   {
2264     char path[] = "/newdir";
2265     int r;
2266     suppress_error = 0;
2267     r = guestfs_mkdir (g, path);
2268     if (r == -1)
2269       return -1;
2270   }
2271   {
2272     char path[] = "/olddir/file";
2273     char content[] = "file content";
2274     int r;
2275     suppress_error = 0;
2276     r = guestfs_write_file (g, path, content, 0);
2277     if (r == -1)
2278       return -1;
2279   }
2280   {
2281     char src[] = "/olddir";
2282     char dest[] = "/newdir";
2283     int r;
2284     suppress_error = 0;
2285     r = guestfs_cp_a (g, src, dest);
2286     if (r == -1)
2287       return -1;
2288   }
2289   {
2290     char path[] = "/newdir/olddir/file";
2291     char *r;
2292     suppress_error = 0;
2293     r = guestfs_cat (g, path);
2294     if (r == NULL)
2295       return -1;
2296     if (strcmp (r, expected) != 0) {
2297       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2298       return -1;
2299     }
2300     free (r);
2301   }
2302   return 0;
2303 }
2304
2305 static int test_cp_0_skip (void)
2306 {
2307   const char *str;
2308
2309   str = getenv ("SKIP_TEST_CP_0");
2310   if (str && strcmp (str, "1") == 0) return 1;
2311   str = getenv ("SKIP_TEST_CP");
2312   if (str && strcmp (str, "1") == 0) return 1;
2313   return 0;
2314 }
2315
2316 static int test_cp_0 (void)
2317 {
2318   if (test_cp_0_skip ()) {
2319     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2320     return 0;
2321   }
2322
2323   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2324   {
2325     char device[] = "/dev/sda";
2326     int r;
2327     suppress_error = 0;
2328     r = guestfs_blockdev_setrw (g, device);
2329     if (r == -1)
2330       return -1;
2331   }
2332   {
2333     int r;
2334     suppress_error = 0;
2335     r = guestfs_umount_all (g);
2336     if (r == -1)
2337       return -1;
2338   }
2339   {
2340     int r;
2341     suppress_error = 0;
2342     r = guestfs_lvm_remove_all (g);
2343     if (r == -1)
2344       return -1;
2345   }
2346   {
2347     char device[] = "/dev/sda";
2348     char lines_0[] = ",";
2349     char *lines[] = {
2350       lines_0,
2351       NULL
2352     };
2353     int r;
2354     suppress_error = 0;
2355     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2356     if (r == -1)
2357       return -1;
2358   }
2359   {
2360     char fstype[] = "ext2";
2361     char device[] = "/dev/sda1";
2362     int r;
2363     suppress_error = 0;
2364     r = guestfs_mkfs (g, fstype, device);
2365     if (r == -1)
2366       return -1;
2367   }
2368   {
2369     char device[] = "/dev/sda1";
2370     char mountpoint[] = "/";
2371     int r;
2372     suppress_error = 0;
2373     r = guestfs_mount (g, device, mountpoint);
2374     if (r == -1)
2375       return -1;
2376   }
2377   /* TestOutput for cp (0) */
2378   char expected[] = "file content";
2379   {
2380     char path[] = "/old";
2381     char content[] = "file content";
2382     int r;
2383     suppress_error = 0;
2384     r = guestfs_write_file (g, path, content, 0);
2385     if (r == -1)
2386       return -1;
2387   }
2388   {
2389     char src[] = "/old";
2390     char dest[] = "/new";
2391     int r;
2392     suppress_error = 0;
2393     r = guestfs_cp (g, src, dest);
2394     if (r == -1)
2395       return -1;
2396   }
2397   {
2398     char path[] = "/new";
2399     char *r;
2400     suppress_error = 0;
2401     r = guestfs_cat (g, path);
2402     if (r == NULL)
2403       return -1;
2404     if (strcmp (r, expected) != 0) {
2405       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2406       return -1;
2407     }
2408     free (r);
2409   }
2410   return 0;
2411 }
2412
2413 static int test_cp_1_skip (void)
2414 {
2415   const char *str;
2416
2417   str = getenv ("SKIP_TEST_CP_1");
2418   if (str && strcmp (str, "1") == 0) return 1;
2419   str = getenv ("SKIP_TEST_CP");
2420   if (str && strcmp (str, "1") == 0) return 1;
2421   return 0;
2422 }
2423
2424 static int test_cp_1 (void)
2425 {
2426   if (test_cp_1_skip ()) {
2427     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2428     return 0;
2429   }
2430
2431   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2432   {
2433     char device[] = "/dev/sda";
2434     int r;
2435     suppress_error = 0;
2436     r = guestfs_blockdev_setrw (g, device);
2437     if (r == -1)
2438       return -1;
2439   }
2440   {
2441     int r;
2442     suppress_error = 0;
2443     r = guestfs_umount_all (g);
2444     if (r == -1)
2445       return -1;
2446   }
2447   {
2448     int r;
2449     suppress_error = 0;
2450     r = guestfs_lvm_remove_all (g);
2451     if (r == -1)
2452       return -1;
2453   }
2454   {
2455     char device[] = "/dev/sda";
2456     char lines_0[] = ",";
2457     char *lines[] = {
2458       lines_0,
2459       NULL
2460     };
2461     int r;
2462     suppress_error = 0;
2463     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2464     if (r == -1)
2465       return -1;
2466   }
2467   {
2468     char fstype[] = "ext2";
2469     char device[] = "/dev/sda1";
2470     int r;
2471     suppress_error = 0;
2472     r = guestfs_mkfs (g, fstype, device);
2473     if (r == -1)
2474       return -1;
2475   }
2476   {
2477     char device[] = "/dev/sda1";
2478     char mountpoint[] = "/";
2479     int r;
2480     suppress_error = 0;
2481     r = guestfs_mount (g, device, mountpoint);
2482     if (r == -1)
2483       return -1;
2484   }
2485   /* TestOutputTrue for cp (1) */
2486   {
2487     char path[] = "/old";
2488     char content[] = "file content";
2489     int r;
2490     suppress_error = 0;
2491     r = guestfs_write_file (g, path, content, 0);
2492     if (r == -1)
2493       return -1;
2494   }
2495   {
2496     char src[] = "/old";
2497     char dest[] = "/new";
2498     int r;
2499     suppress_error = 0;
2500     r = guestfs_cp (g, src, dest);
2501     if (r == -1)
2502       return -1;
2503   }
2504   {
2505     char path[] = "/old";
2506     int r;
2507     suppress_error = 0;
2508     r = guestfs_is_file (g, path);
2509     if (r == -1)
2510       return -1;
2511     if (!r) {
2512       fprintf (stderr, "test_cp_1: expected true, got false\n");
2513       return -1;
2514     }
2515   }
2516   return 0;
2517 }
2518
2519 static int test_cp_2_skip (void)
2520 {
2521   const char *str;
2522
2523   str = getenv ("SKIP_TEST_CP_2");
2524   if (str && strcmp (str, "1") == 0) return 1;
2525   str = getenv ("SKIP_TEST_CP");
2526   if (str && strcmp (str, "1") == 0) return 1;
2527   return 0;
2528 }
2529
2530 static int test_cp_2 (void)
2531 {
2532   if (test_cp_2_skip ()) {
2533     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2534     return 0;
2535   }
2536
2537   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2538   {
2539     char device[] = "/dev/sda";
2540     int r;
2541     suppress_error = 0;
2542     r = guestfs_blockdev_setrw (g, device);
2543     if (r == -1)
2544       return -1;
2545   }
2546   {
2547     int r;
2548     suppress_error = 0;
2549     r = guestfs_umount_all (g);
2550     if (r == -1)
2551       return -1;
2552   }
2553   {
2554     int r;
2555     suppress_error = 0;
2556     r = guestfs_lvm_remove_all (g);
2557     if (r == -1)
2558       return -1;
2559   }
2560   {
2561     char device[] = "/dev/sda";
2562     char lines_0[] = ",";
2563     char *lines[] = {
2564       lines_0,
2565       NULL
2566     };
2567     int r;
2568     suppress_error = 0;
2569     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2570     if (r == -1)
2571       return -1;
2572   }
2573   {
2574     char fstype[] = "ext2";
2575     char device[] = "/dev/sda1";
2576     int r;
2577     suppress_error = 0;
2578     r = guestfs_mkfs (g, fstype, device);
2579     if (r == -1)
2580       return -1;
2581   }
2582   {
2583     char device[] = "/dev/sda1";
2584     char mountpoint[] = "/";
2585     int r;
2586     suppress_error = 0;
2587     r = guestfs_mount (g, device, mountpoint);
2588     if (r == -1)
2589       return -1;
2590   }
2591   /* TestOutput for cp (2) */
2592   char expected[] = "file content";
2593   {
2594     char path[] = "/old";
2595     char content[] = "file content";
2596     int r;
2597     suppress_error = 0;
2598     r = guestfs_write_file (g, path, content, 0);
2599     if (r == -1)
2600       return -1;
2601   }
2602   {
2603     char path[] = "/dir";
2604     int r;
2605     suppress_error = 0;
2606     r = guestfs_mkdir (g, path);
2607     if (r == -1)
2608       return -1;
2609   }
2610   {
2611     char src[] = "/old";
2612     char dest[] = "/dir/new";
2613     int r;
2614     suppress_error = 0;
2615     r = guestfs_cp (g, src, dest);
2616     if (r == -1)
2617       return -1;
2618   }
2619   {
2620     char path[] = "/dir/new";
2621     char *r;
2622     suppress_error = 0;
2623     r = guestfs_cat (g, path);
2624     if (r == NULL)
2625       return -1;
2626     if (strcmp (r, expected) != 0) {
2627       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2628       return -1;
2629     }
2630     free (r);
2631   }
2632   return 0;
2633 }
2634
2635 static int test_grub_install_0_skip (void)
2636 {
2637   const char *str;
2638
2639   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2640   if (str && strcmp (str, "1") == 0) return 1;
2641   str = getenv ("SKIP_TEST_GRUB_INSTALL");
2642   if (str && strcmp (str, "1") == 0) return 1;
2643   return 0;
2644 }
2645
2646 static int test_grub_install_0 (void)
2647 {
2648   if (test_grub_install_0_skip ()) {
2649     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2650     return 0;
2651   }
2652
2653   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2654   {
2655     char device[] = "/dev/sda";
2656     int r;
2657     suppress_error = 0;
2658     r = guestfs_blockdev_setrw (g, device);
2659     if (r == -1)
2660       return -1;
2661   }
2662   {
2663     int r;
2664     suppress_error = 0;
2665     r = guestfs_umount_all (g);
2666     if (r == -1)
2667       return -1;
2668   }
2669   {
2670     int r;
2671     suppress_error = 0;
2672     r = guestfs_lvm_remove_all (g);
2673     if (r == -1)
2674       return -1;
2675   }
2676   {
2677     char device[] = "/dev/sda";
2678     char lines_0[] = ",";
2679     char *lines[] = {
2680       lines_0,
2681       NULL
2682     };
2683     int r;
2684     suppress_error = 0;
2685     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2686     if (r == -1)
2687       return -1;
2688   }
2689   {
2690     char fstype[] = "ext2";
2691     char device[] = "/dev/sda1";
2692     int r;
2693     suppress_error = 0;
2694     r = guestfs_mkfs (g, fstype, device);
2695     if (r == -1)
2696       return -1;
2697   }
2698   {
2699     char device[] = "/dev/sda1";
2700     char mountpoint[] = "/";
2701     int r;
2702     suppress_error = 0;
2703     r = guestfs_mount (g, device, mountpoint);
2704     if (r == -1)
2705       return -1;
2706   }
2707   /* TestOutputTrue for grub_install (0) */
2708   {
2709     char root[] = "/";
2710     char device[] = "/dev/sda1";
2711     int r;
2712     suppress_error = 0;
2713     r = guestfs_grub_install (g, root, device);
2714     if (r == -1)
2715       return -1;
2716   }
2717   {
2718     char path[] = "/boot";
2719     int r;
2720     suppress_error = 0;
2721     r = guestfs_is_dir (g, path);
2722     if (r == -1)
2723       return -1;
2724     if (!r) {
2725       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2726       return -1;
2727     }
2728   }
2729   return 0;
2730 }
2731
2732 static int test_zero_0_skip (void)
2733 {
2734   const char *str;
2735
2736   str = getenv ("SKIP_TEST_ZERO_0");
2737   if (str && strcmp (str, "1") == 0) return 1;
2738   str = getenv ("SKIP_TEST_ZERO");
2739   if (str && strcmp (str, "1") == 0) return 1;
2740   return 0;
2741 }
2742
2743 static int test_zero_0 (void)
2744 {
2745   if (test_zero_0_skip ()) {
2746     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2747     return 0;
2748   }
2749
2750   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2751   {
2752     char device[] = "/dev/sda";
2753     int r;
2754     suppress_error = 0;
2755     r = guestfs_blockdev_setrw (g, device);
2756     if (r == -1)
2757       return -1;
2758   }
2759   {
2760     int r;
2761     suppress_error = 0;
2762     r = guestfs_umount_all (g);
2763     if (r == -1)
2764       return -1;
2765   }
2766   {
2767     int r;
2768     suppress_error = 0;
2769     r = guestfs_lvm_remove_all (g);
2770     if (r == -1)
2771       return -1;
2772   }
2773   {
2774     char device[] = "/dev/sda";
2775     char lines_0[] = ",";
2776     char *lines[] = {
2777       lines_0,
2778       NULL
2779     };
2780     int r;
2781     suppress_error = 0;
2782     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2783     if (r == -1)
2784       return -1;
2785   }
2786   {
2787     char fstype[] = "ext2";
2788     char device[] = "/dev/sda1";
2789     int r;
2790     suppress_error = 0;
2791     r = guestfs_mkfs (g, fstype, device);
2792     if (r == -1)
2793       return -1;
2794   }
2795   {
2796     char device[] = "/dev/sda1";
2797     char mountpoint[] = "/";
2798     int r;
2799     suppress_error = 0;
2800     r = guestfs_mount (g, device, mountpoint);
2801     if (r == -1)
2802       return -1;
2803   }
2804   /* TestOutput for zero (0) */
2805   char expected[] = "data";
2806   {
2807     char pathordevice[] = "/dev/sda1";
2808     int r;
2809     suppress_error = 0;
2810     r = guestfs_umount (g, pathordevice);
2811     if (r == -1)
2812       return -1;
2813   }
2814   {
2815     char device[] = "/dev/sda1";
2816     int r;
2817     suppress_error = 0;
2818     r = guestfs_zero (g, device);
2819     if (r == -1)
2820       return -1;
2821   }
2822   {
2823     char path[] = "/dev/sda1";
2824     char *r;
2825     suppress_error = 0;
2826     r = guestfs_file (g, path);
2827     if (r == NULL)
2828       return -1;
2829     if (strcmp (r, expected) != 0) {
2830       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2831       return -1;
2832     }
2833     free (r);
2834   }
2835   return 0;
2836 }
2837
2838 static int test_fsck_0_skip (void)
2839 {
2840   const char *str;
2841
2842   str = getenv ("SKIP_TEST_FSCK_0");
2843   if (str && strcmp (str, "1") == 0) return 1;
2844   str = getenv ("SKIP_TEST_FSCK");
2845   if (str && strcmp (str, "1") == 0) return 1;
2846   return 0;
2847 }
2848
2849 static int test_fsck_0 (void)
2850 {
2851   if (test_fsck_0_skip ()) {
2852     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2853     return 0;
2854   }
2855
2856   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2857   {
2858     char device[] = "/dev/sda";
2859     int r;
2860     suppress_error = 0;
2861     r = guestfs_blockdev_setrw (g, device);
2862     if (r == -1)
2863       return -1;
2864   }
2865   {
2866     int r;
2867     suppress_error = 0;
2868     r = guestfs_umount_all (g);
2869     if (r == -1)
2870       return -1;
2871   }
2872   {
2873     int r;
2874     suppress_error = 0;
2875     r = guestfs_lvm_remove_all (g);
2876     if (r == -1)
2877       return -1;
2878   }
2879   {
2880     char device[] = "/dev/sda";
2881     char lines_0[] = ",";
2882     char *lines[] = {
2883       lines_0,
2884       NULL
2885     };
2886     int r;
2887     suppress_error = 0;
2888     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2889     if (r == -1)
2890       return -1;
2891   }
2892   {
2893     char fstype[] = "ext2";
2894     char device[] = "/dev/sda1";
2895     int r;
2896     suppress_error = 0;
2897     r = guestfs_mkfs (g, fstype, device);
2898     if (r == -1)
2899       return -1;
2900   }
2901   {
2902     char device[] = "/dev/sda1";
2903     char mountpoint[] = "/";
2904     int r;
2905     suppress_error = 0;
2906     r = guestfs_mount (g, device, mountpoint);
2907     if (r == -1)
2908       return -1;
2909   }
2910   /* TestOutputInt for fsck (0) */
2911   {
2912     char pathordevice[] = "/dev/sda1";
2913     int r;
2914     suppress_error = 0;
2915     r = guestfs_umount (g, pathordevice);
2916     if (r == -1)
2917       return -1;
2918   }
2919   {
2920     char fstype[] = "ext2";
2921     char device[] = "/dev/sda1";
2922     int r;
2923     suppress_error = 0;
2924     r = guestfs_fsck (g, fstype, device);
2925     if (r == -1)
2926       return -1;
2927     if (r != 0) {
2928       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
2929       return -1;
2930     }
2931   }
2932   return 0;
2933 }
2934
2935 static int test_fsck_1_skip (void)
2936 {
2937   const char *str;
2938
2939   str = getenv ("SKIP_TEST_FSCK_1");
2940   if (str && strcmp (str, "1") == 0) return 1;
2941   str = getenv ("SKIP_TEST_FSCK");
2942   if (str && strcmp (str, "1") == 0) return 1;
2943   return 0;
2944 }
2945
2946 static int test_fsck_1 (void)
2947 {
2948   if (test_fsck_1_skip ()) {
2949     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
2950     return 0;
2951   }
2952
2953   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2954   {
2955     char device[] = "/dev/sda";
2956     int r;
2957     suppress_error = 0;
2958     r = guestfs_blockdev_setrw (g, device);
2959     if (r == -1)
2960       return -1;
2961   }
2962   {
2963     int r;
2964     suppress_error = 0;
2965     r = guestfs_umount_all (g);
2966     if (r == -1)
2967       return -1;
2968   }
2969   {
2970     int r;
2971     suppress_error = 0;
2972     r = guestfs_lvm_remove_all (g);
2973     if (r == -1)
2974       return -1;
2975   }
2976   {
2977     char device[] = "/dev/sda";
2978     char lines_0[] = ",";
2979     char *lines[] = {
2980       lines_0,
2981       NULL
2982     };
2983     int r;
2984     suppress_error = 0;
2985     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2986     if (r == -1)
2987       return -1;
2988   }
2989   {
2990     char fstype[] = "ext2";
2991     char device[] = "/dev/sda1";
2992     int r;
2993     suppress_error = 0;
2994     r = guestfs_mkfs (g, fstype, device);
2995     if (r == -1)
2996       return -1;
2997   }
2998   {
2999     char device[] = "/dev/sda1";
3000     char mountpoint[] = "/";
3001     int r;
3002     suppress_error = 0;
3003     r = guestfs_mount (g, device, mountpoint);
3004     if (r == -1)
3005       return -1;
3006   }
3007   /* TestOutputInt for fsck (1) */
3008   {
3009     char pathordevice[] = "/dev/sda1";
3010     int r;
3011     suppress_error = 0;
3012     r = guestfs_umount (g, pathordevice);
3013     if (r == -1)
3014       return -1;
3015   }
3016   {
3017     char device[] = "/dev/sda1";
3018     int r;
3019     suppress_error = 0;
3020     r = guestfs_zero (g, device);
3021     if (r == -1)
3022       return -1;
3023   }
3024   {
3025     char fstype[] = "ext2";
3026     char device[] = "/dev/sda1";
3027     int r;
3028     suppress_error = 0;
3029     r = guestfs_fsck (g, fstype, device);
3030     if (r == -1)
3031       return -1;
3032     if (r != 8) {
3033       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
3034       return -1;
3035     }
3036   }
3037   return 0;
3038 }
3039
3040 static int test_set_e2uuid_0_skip (void)
3041 {
3042   const char *str;
3043
3044   str = getenv ("SKIP_TEST_SET_E2UUID_0");
3045   if (str && strcmp (str, "1") == 0) return 1;
3046   str = getenv ("SKIP_TEST_SET_E2UUID");
3047   if (str && strcmp (str, "1") == 0) return 1;
3048   return 0;
3049 }
3050
3051 static int test_set_e2uuid_0 (void)
3052 {
3053   if (test_set_e2uuid_0_skip ()) {
3054     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3055     return 0;
3056   }
3057
3058   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3059   {
3060     char device[] = "/dev/sda";
3061     int r;
3062     suppress_error = 0;
3063     r = guestfs_blockdev_setrw (g, device);
3064     if (r == -1)
3065       return -1;
3066   }
3067   {
3068     int r;
3069     suppress_error = 0;
3070     r = guestfs_umount_all (g);
3071     if (r == -1)
3072       return -1;
3073   }
3074   {
3075     int r;
3076     suppress_error = 0;
3077     r = guestfs_lvm_remove_all (g);
3078     if (r == -1)
3079       return -1;
3080   }
3081   {
3082     char device[] = "/dev/sda";
3083     char lines_0[] = ",";
3084     char *lines[] = {
3085       lines_0,
3086       NULL
3087     };
3088     int r;
3089     suppress_error = 0;
3090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3091     if (r == -1)
3092       return -1;
3093   }
3094   {
3095     char fstype[] = "ext2";
3096     char device[] = "/dev/sda1";
3097     int r;
3098     suppress_error = 0;
3099     r = guestfs_mkfs (g, fstype, device);
3100     if (r == -1)
3101       return -1;
3102   }
3103   {
3104     char device[] = "/dev/sda1";
3105     char mountpoint[] = "/";
3106     int r;
3107     suppress_error = 0;
3108     r = guestfs_mount (g, device, mountpoint);
3109     if (r == -1)
3110       return -1;
3111   }
3112   /* TestOutput for set_e2uuid (0) */
3113   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3114   {
3115     char device[] = "/dev/sda1";
3116     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3117     int r;
3118     suppress_error = 0;
3119     r = guestfs_set_e2uuid (g, device, uuid);
3120     if (r == -1)
3121       return -1;
3122   }
3123   {
3124     char device[] = "/dev/sda1";
3125     char *r;
3126     suppress_error = 0;
3127     r = guestfs_get_e2uuid (g, device);
3128     if (r == NULL)
3129       return -1;
3130     if (strcmp (r, expected) != 0) {
3131       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3132       return -1;
3133     }
3134     free (r);
3135   }
3136   return 0;
3137 }
3138
3139 static int test_set_e2uuid_1_skip (void)
3140 {
3141   const char *str;
3142
3143   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3144   if (str && strcmp (str, "1") == 0) return 1;
3145   str = getenv ("SKIP_TEST_SET_E2UUID");
3146   if (str && strcmp (str, "1") == 0) return 1;
3147   return 0;
3148 }
3149
3150 static int test_set_e2uuid_1 (void)
3151 {
3152   if (test_set_e2uuid_1_skip ()) {
3153     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3154     return 0;
3155   }
3156
3157   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3158   {
3159     char device[] = "/dev/sda";
3160     int r;
3161     suppress_error = 0;
3162     r = guestfs_blockdev_setrw (g, device);
3163     if (r == -1)
3164       return -1;
3165   }
3166   {
3167     int r;
3168     suppress_error = 0;
3169     r = guestfs_umount_all (g);
3170     if (r == -1)
3171       return -1;
3172   }
3173   {
3174     int r;
3175     suppress_error = 0;
3176     r = guestfs_lvm_remove_all (g);
3177     if (r == -1)
3178       return -1;
3179   }
3180   {
3181     char device[] = "/dev/sda";
3182     char lines_0[] = ",";
3183     char *lines[] = {
3184       lines_0,
3185       NULL
3186     };
3187     int r;
3188     suppress_error = 0;
3189     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3190     if (r == -1)
3191       return -1;
3192   }
3193   {
3194     char fstype[] = "ext2";
3195     char device[] = "/dev/sda1";
3196     int r;
3197     suppress_error = 0;
3198     r = guestfs_mkfs (g, fstype, device);
3199     if (r == -1)
3200       return -1;
3201   }
3202   {
3203     char device[] = "/dev/sda1";
3204     char mountpoint[] = "/";
3205     int r;
3206     suppress_error = 0;
3207     r = guestfs_mount (g, device, mountpoint);
3208     if (r == -1)
3209       return -1;
3210   }
3211   /* TestOutput for set_e2uuid (1) */
3212   char expected[] = "";
3213   {
3214     char device[] = "/dev/sda1";
3215     char uuid[] = "clear";
3216     int r;
3217     suppress_error = 0;
3218     r = guestfs_set_e2uuid (g, device, uuid);
3219     if (r == -1)
3220       return -1;
3221   }
3222   {
3223     char device[] = "/dev/sda1";
3224     char *r;
3225     suppress_error = 0;
3226     r = guestfs_get_e2uuid (g, device);
3227     if (r == NULL)
3228       return -1;
3229     if (strcmp (r, expected) != 0) {
3230       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3231       return -1;
3232     }
3233     free (r);
3234   }
3235   return 0;
3236 }
3237
3238 static int test_set_e2uuid_2_skip (void)
3239 {
3240   const char *str;
3241
3242   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3243   if (str && strcmp (str, "1") == 0) return 1;
3244   str = getenv ("SKIP_TEST_SET_E2UUID");
3245   if (str && strcmp (str, "1") == 0) return 1;
3246   return 0;
3247 }
3248
3249 static int test_set_e2uuid_2 (void)
3250 {
3251   if (test_set_e2uuid_2_skip ()) {
3252     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3253     return 0;
3254   }
3255
3256   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3257   {
3258     char device[] = "/dev/sda";
3259     int r;
3260     suppress_error = 0;
3261     r = guestfs_blockdev_setrw (g, device);
3262     if (r == -1)
3263       return -1;
3264   }
3265   {
3266     int r;
3267     suppress_error = 0;
3268     r = guestfs_umount_all (g);
3269     if (r == -1)
3270       return -1;
3271   }
3272   {
3273     int r;
3274     suppress_error = 0;
3275     r = guestfs_lvm_remove_all (g);
3276     if (r == -1)
3277       return -1;
3278   }
3279   {
3280     char device[] = "/dev/sda";
3281     char lines_0[] = ",";
3282     char *lines[] = {
3283       lines_0,
3284       NULL
3285     };
3286     int r;
3287     suppress_error = 0;
3288     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3289     if (r == -1)
3290       return -1;
3291   }
3292   {
3293     char fstype[] = "ext2";
3294     char device[] = "/dev/sda1";
3295     int r;
3296     suppress_error = 0;
3297     r = guestfs_mkfs (g, fstype, device);
3298     if (r == -1)
3299       return -1;
3300   }
3301   {
3302     char device[] = "/dev/sda1";
3303     char mountpoint[] = "/";
3304     int r;
3305     suppress_error = 0;
3306     r = guestfs_mount (g, device, mountpoint);
3307     if (r == -1)
3308       return -1;
3309   }
3310   /* TestRun for set_e2uuid (2) */
3311   {
3312     char device[] = "/dev/sda1";
3313     char uuid[] = "random";
3314     int r;
3315     suppress_error = 0;
3316     r = guestfs_set_e2uuid (g, device, uuid);
3317     if (r == -1)
3318       return -1;
3319   }
3320   return 0;
3321 }
3322
3323 static int test_set_e2uuid_3_skip (void)
3324 {
3325   const char *str;
3326
3327   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3328   if (str && strcmp (str, "1") == 0) return 1;
3329   str = getenv ("SKIP_TEST_SET_E2UUID");
3330   if (str && strcmp (str, "1") == 0) return 1;
3331   return 0;
3332 }
3333
3334 static int test_set_e2uuid_3 (void)
3335 {
3336   if (test_set_e2uuid_3_skip ()) {
3337     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3338     return 0;
3339   }
3340
3341   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3342   {
3343     char device[] = "/dev/sda";
3344     int r;
3345     suppress_error = 0;
3346     r = guestfs_blockdev_setrw (g, device);
3347     if (r == -1)
3348       return -1;
3349   }
3350   {
3351     int r;
3352     suppress_error = 0;
3353     r = guestfs_umount_all (g);
3354     if (r == -1)
3355       return -1;
3356   }
3357   {
3358     int r;
3359     suppress_error = 0;
3360     r = guestfs_lvm_remove_all (g);
3361     if (r == -1)
3362       return -1;
3363   }
3364   {
3365     char device[] = "/dev/sda";
3366     char lines_0[] = ",";
3367     char *lines[] = {
3368       lines_0,
3369       NULL
3370     };
3371     int r;
3372     suppress_error = 0;
3373     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3374     if (r == -1)
3375       return -1;
3376   }
3377   {
3378     char fstype[] = "ext2";
3379     char device[] = "/dev/sda1";
3380     int r;
3381     suppress_error = 0;
3382     r = guestfs_mkfs (g, fstype, device);
3383     if (r == -1)
3384       return -1;
3385   }
3386   {
3387     char device[] = "/dev/sda1";
3388     char mountpoint[] = "/";
3389     int r;
3390     suppress_error = 0;
3391     r = guestfs_mount (g, device, mountpoint);
3392     if (r == -1)
3393       return -1;
3394   }
3395   /* TestRun for set_e2uuid (3) */
3396   {
3397     char device[] = "/dev/sda1";
3398     char uuid[] = "time";
3399     int r;
3400     suppress_error = 0;
3401     r = guestfs_set_e2uuid (g, device, uuid);
3402     if (r == -1)
3403       return -1;
3404   }
3405   return 0;
3406 }
3407
3408 static int test_set_e2label_0_skip (void)
3409 {
3410   const char *str;
3411
3412   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3413   if (str && strcmp (str, "1") == 0) return 1;
3414   str = getenv ("SKIP_TEST_SET_E2LABEL");
3415   if (str && strcmp (str, "1") == 0) return 1;
3416   return 0;
3417 }
3418
3419 static int test_set_e2label_0 (void)
3420 {
3421   if (test_set_e2label_0_skip ()) {
3422     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3423     return 0;
3424   }
3425
3426   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3427   {
3428     char device[] = "/dev/sda";
3429     int r;
3430     suppress_error = 0;
3431     r = guestfs_blockdev_setrw (g, device);
3432     if (r == -1)
3433       return -1;
3434   }
3435   {
3436     int r;
3437     suppress_error = 0;
3438     r = guestfs_umount_all (g);
3439     if (r == -1)
3440       return -1;
3441   }
3442   {
3443     int r;
3444     suppress_error = 0;
3445     r = guestfs_lvm_remove_all (g);
3446     if (r == -1)
3447       return -1;
3448   }
3449   {
3450     char device[] = "/dev/sda";
3451     char lines_0[] = ",";
3452     char *lines[] = {
3453       lines_0,
3454       NULL
3455     };
3456     int r;
3457     suppress_error = 0;
3458     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3459     if (r == -1)
3460       return -1;
3461   }
3462   {
3463     char fstype[] = "ext2";
3464     char device[] = "/dev/sda1";
3465     int r;
3466     suppress_error = 0;
3467     r = guestfs_mkfs (g, fstype, device);
3468     if (r == -1)
3469       return -1;
3470   }
3471   {
3472     char device[] = "/dev/sda1";
3473     char mountpoint[] = "/";
3474     int r;
3475     suppress_error = 0;
3476     r = guestfs_mount (g, device, mountpoint);
3477     if (r == -1)
3478       return -1;
3479   }
3480   /* TestOutput for set_e2label (0) */
3481   char expected[] = "testlabel";
3482   {
3483     char device[] = "/dev/sda1";
3484     char label[] = "testlabel";
3485     int r;
3486     suppress_error = 0;
3487     r = guestfs_set_e2label (g, device, label);
3488     if (r == -1)
3489       return -1;
3490   }
3491   {
3492     char device[] = "/dev/sda1";
3493     char *r;
3494     suppress_error = 0;
3495     r = guestfs_get_e2label (g, device);
3496     if (r == NULL)
3497       return -1;
3498     if (strcmp (r, expected) != 0) {
3499       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3500       return -1;
3501     }
3502     free (r);
3503   }
3504   return 0;
3505 }
3506
3507 static int test_pvremove_0_skip (void)
3508 {
3509   const char *str;
3510
3511   str = getenv ("SKIP_TEST_PVREMOVE_0");
3512   if (str && strcmp (str, "1") == 0) return 1;
3513   str = getenv ("SKIP_TEST_PVREMOVE");
3514   if (str && strcmp (str, "1") == 0) return 1;
3515   return 0;
3516 }
3517
3518 static int test_pvremove_0 (void)
3519 {
3520   if (test_pvremove_0_skip ()) {
3521     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3522     return 0;
3523   }
3524
3525   /* InitNone|InitEmpty for test_pvremove_0 */
3526   {
3527     char device[] = "/dev/sda";
3528     int r;
3529     suppress_error = 0;
3530     r = guestfs_blockdev_setrw (g, device);
3531     if (r == -1)
3532       return -1;
3533   }
3534   {
3535     int r;
3536     suppress_error = 0;
3537     r = guestfs_umount_all (g);
3538     if (r == -1)
3539       return -1;
3540   }
3541   {
3542     int r;
3543     suppress_error = 0;
3544     r = guestfs_lvm_remove_all (g);
3545     if (r == -1)
3546       return -1;
3547   }
3548   /* TestOutputListOfDevices for pvremove (0) */
3549   {
3550     char device[] = "/dev/sda";
3551     char lines_0[] = ",";
3552     char *lines[] = {
3553       lines_0,
3554       NULL
3555     };
3556     int r;
3557     suppress_error = 0;
3558     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3559     if (r == -1)
3560       return -1;
3561   }
3562   {
3563     char device[] = "/dev/sda1";
3564     int r;
3565     suppress_error = 0;
3566     r = guestfs_pvcreate (g, device);
3567     if (r == -1)
3568       return -1;
3569   }
3570   {
3571     char volgroup[] = "VG";
3572     char physvols_0[] = "/dev/sda1";
3573     char *physvols[] = {
3574       physvols_0,
3575       NULL
3576     };
3577     int r;
3578     suppress_error = 0;
3579     r = guestfs_vgcreate (g, volgroup, physvols);
3580     if (r == -1)
3581       return -1;
3582   }
3583   {
3584     char logvol[] = "LV1";
3585     char volgroup[] = "VG";
3586     int r;
3587     suppress_error = 0;
3588     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3589     if (r == -1)
3590       return -1;
3591   }
3592   {
3593     char logvol[] = "LV2";
3594     char volgroup[] = "VG";
3595     int r;
3596     suppress_error = 0;
3597     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3598     if (r == -1)
3599       return -1;
3600   }
3601   {
3602     char vgname[] = "VG";
3603     int r;
3604     suppress_error = 0;
3605     r = guestfs_vgremove (g, vgname);
3606     if (r == -1)
3607       return -1;
3608   }
3609   {
3610     char device[] = "/dev/sda1";
3611     int r;
3612     suppress_error = 0;
3613     r = guestfs_pvremove (g, device);
3614     if (r == -1)
3615       return -1;
3616   }
3617   {
3618     char **r;
3619     int i;
3620     suppress_error = 0;
3621     r = guestfs_lvs (g);
3622     if (r == NULL)
3623       return -1;
3624     if (r[0] != NULL) {
3625       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3626       print_strings (r);
3627       return -1;
3628     }
3629     for (i = 0; r[i] != NULL; ++i)
3630       free (r[i]);
3631     free (r);
3632   }
3633   return 0;
3634 }
3635
3636 static int test_pvremove_1_skip (void)
3637 {
3638   const char *str;
3639
3640   str = getenv ("SKIP_TEST_PVREMOVE_1");
3641   if (str && strcmp (str, "1") == 0) return 1;
3642   str = getenv ("SKIP_TEST_PVREMOVE");
3643   if (str && strcmp (str, "1") == 0) return 1;
3644   return 0;
3645 }
3646
3647 static int test_pvremove_1 (void)
3648 {
3649   if (test_pvremove_1_skip ()) {
3650     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3651     return 0;
3652   }
3653
3654   /* InitNone|InitEmpty for test_pvremove_1 */
3655   {
3656     char device[] = "/dev/sda";
3657     int r;
3658     suppress_error = 0;
3659     r = guestfs_blockdev_setrw (g, device);
3660     if (r == -1)
3661       return -1;
3662   }
3663   {
3664     int r;
3665     suppress_error = 0;
3666     r = guestfs_umount_all (g);
3667     if (r == -1)
3668       return -1;
3669   }
3670   {
3671     int r;
3672     suppress_error = 0;
3673     r = guestfs_lvm_remove_all (g);
3674     if (r == -1)
3675       return -1;
3676   }
3677   /* TestOutputListOfDevices for pvremove (1) */
3678   {
3679     char device[] = "/dev/sda";
3680     char lines_0[] = ",";
3681     char *lines[] = {
3682       lines_0,
3683       NULL
3684     };
3685     int r;
3686     suppress_error = 0;
3687     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3688     if (r == -1)
3689       return -1;
3690   }
3691   {
3692     char device[] = "/dev/sda1";
3693     int r;
3694     suppress_error = 0;
3695     r = guestfs_pvcreate (g, device);
3696     if (r == -1)
3697       return -1;
3698   }
3699   {
3700     char volgroup[] = "VG";
3701     char physvols_0[] = "/dev/sda1";
3702     char *physvols[] = {
3703       physvols_0,
3704       NULL
3705     };
3706     int r;
3707     suppress_error = 0;
3708     r = guestfs_vgcreate (g, volgroup, physvols);
3709     if (r == -1)
3710       return -1;
3711   }
3712   {
3713     char logvol[] = "LV1";
3714     char volgroup[] = "VG";
3715     int r;
3716     suppress_error = 0;
3717     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3718     if (r == -1)
3719       return -1;
3720   }
3721   {
3722     char logvol[] = "LV2";
3723     char volgroup[] = "VG";
3724     int r;
3725     suppress_error = 0;
3726     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3727     if (r == -1)
3728       return -1;
3729   }
3730   {
3731     char vgname[] = "VG";
3732     int r;
3733     suppress_error = 0;
3734     r = guestfs_vgremove (g, vgname);
3735     if (r == -1)
3736       return -1;
3737   }
3738   {
3739     char device[] = "/dev/sda1";
3740     int r;
3741     suppress_error = 0;
3742     r = guestfs_pvremove (g, device);
3743     if (r == -1)
3744       return -1;
3745   }
3746   {
3747     char **r;
3748     int i;
3749     suppress_error = 0;
3750     r = guestfs_vgs (g);
3751     if (r == NULL)
3752       return -1;
3753     if (r[0] != NULL) {
3754       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3755       print_strings (r);
3756       return -1;
3757     }
3758     for (i = 0; r[i] != NULL; ++i)
3759       free (r[i]);
3760     free (r);
3761   }
3762   return 0;
3763 }
3764
3765 static int test_pvremove_2_skip (void)
3766 {
3767   const char *str;
3768
3769   str = getenv ("SKIP_TEST_PVREMOVE_2");
3770   if (str && strcmp (str, "1") == 0) return 1;
3771   str = getenv ("SKIP_TEST_PVREMOVE");
3772   if (str && strcmp (str, "1") == 0) return 1;
3773   return 0;
3774 }
3775
3776 static int test_pvremove_2 (void)
3777 {
3778   if (test_pvremove_2_skip ()) {
3779     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3780     return 0;
3781   }
3782
3783   /* InitNone|InitEmpty for test_pvremove_2 */
3784   {
3785     char device[] = "/dev/sda";
3786     int r;
3787     suppress_error = 0;
3788     r = guestfs_blockdev_setrw (g, device);
3789     if (r == -1)
3790       return -1;
3791   }
3792   {
3793     int r;
3794     suppress_error = 0;
3795     r = guestfs_umount_all (g);
3796     if (r == -1)
3797       return -1;
3798   }
3799   {
3800     int r;
3801     suppress_error = 0;
3802     r = guestfs_lvm_remove_all (g);
3803     if (r == -1)
3804       return -1;
3805   }
3806   /* TestOutputListOfDevices for pvremove (2) */
3807   {
3808     char device[] = "/dev/sda";
3809     char lines_0[] = ",";
3810     char *lines[] = {
3811       lines_0,
3812       NULL
3813     };
3814     int r;
3815     suppress_error = 0;
3816     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3817     if (r == -1)
3818       return -1;
3819   }
3820   {
3821     char device[] = "/dev/sda1";
3822     int r;
3823     suppress_error = 0;
3824     r = guestfs_pvcreate (g, device);
3825     if (r == -1)
3826       return -1;
3827   }
3828   {
3829     char volgroup[] = "VG";
3830     char physvols_0[] = "/dev/sda1";
3831     char *physvols[] = {
3832       physvols_0,
3833       NULL
3834     };
3835     int r;
3836     suppress_error = 0;
3837     r = guestfs_vgcreate (g, volgroup, physvols);
3838     if (r == -1)
3839       return -1;
3840   }
3841   {
3842     char logvol[] = "LV1";
3843     char volgroup[] = "VG";
3844     int r;
3845     suppress_error = 0;
3846     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3847     if (r == -1)
3848       return -1;
3849   }
3850   {
3851     char logvol[] = "LV2";
3852     char volgroup[] = "VG";
3853     int r;
3854     suppress_error = 0;
3855     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3856     if (r == -1)
3857       return -1;
3858   }
3859   {
3860     char vgname[] = "VG";
3861     int r;
3862     suppress_error = 0;
3863     r = guestfs_vgremove (g, vgname);
3864     if (r == -1)
3865       return -1;
3866   }
3867   {
3868     char device[] = "/dev/sda1";
3869     int r;
3870     suppress_error = 0;
3871     r = guestfs_pvremove (g, device);
3872     if (r == -1)
3873       return -1;
3874   }
3875   {
3876     char **r;
3877     int i;
3878     suppress_error = 0;
3879     r = guestfs_pvs (g);
3880     if (r == NULL)
3881       return -1;
3882     if (r[0] != NULL) {
3883       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3884       print_strings (r);
3885       return -1;
3886     }
3887     for (i = 0; r[i] != NULL; ++i)
3888       free (r[i]);
3889     free (r);
3890   }
3891   return 0;
3892 }
3893
3894 static int test_vgremove_0_skip (void)
3895 {
3896   const char *str;
3897
3898   str = getenv ("SKIP_TEST_VGREMOVE_0");
3899   if (str && strcmp (str, "1") == 0) return 1;
3900   str = getenv ("SKIP_TEST_VGREMOVE");
3901   if (str && strcmp (str, "1") == 0) return 1;
3902   return 0;
3903 }
3904
3905 static int test_vgremove_0 (void)
3906 {
3907   if (test_vgremove_0_skip ()) {
3908     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
3909     return 0;
3910   }
3911
3912   /* InitNone|InitEmpty for test_vgremove_0 */
3913   {
3914     char device[] = "/dev/sda";
3915     int r;
3916     suppress_error = 0;
3917     r = guestfs_blockdev_setrw (g, device);
3918     if (r == -1)
3919       return -1;
3920   }
3921   {
3922     int r;
3923     suppress_error = 0;
3924     r = guestfs_umount_all (g);
3925     if (r == -1)
3926       return -1;
3927   }
3928   {
3929     int r;
3930     suppress_error = 0;
3931     r = guestfs_lvm_remove_all (g);
3932     if (r == -1)
3933       return -1;
3934   }
3935   /* TestOutputList for vgremove (0) */
3936   {
3937     char device[] = "/dev/sda";
3938     char lines_0[] = ",";
3939     char *lines[] = {
3940       lines_0,
3941       NULL
3942     };
3943     int r;
3944     suppress_error = 0;
3945     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3946     if (r == -1)
3947       return -1;
3948   }
3949   {
3950     char device[] = "/dev/sda1";
3951     int r;
3952     suppress_error = 0;
3953     r = guestfs_pvcreate (g, device);
3954     if (r == -1)
3955       return -1;
3956   }
3957   {
3958     char volgroup[] = "VG";
3959     char physvols_0[] = "/dev/sda1";
3960     char *physvols[] = {
3961       physvols_0,
3962       NULL
3963     };
3964     int r;
3965     suppress_error = 0;
3966     r = guestfs_vgcreate (g, volgroup, physvols);
3967     if (r == -1)
3968       return -1;
3969   }
3970   {
3971     char logvol[] = "LV1";
3972     char volgroup[] = "VG";
3973     int r;
3974     suppress_error = 0;
3975     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3976     if (r == -1)
3977       return -1;
3978   }
3979   {
3980     char logvol[] = "LV2";
3981     char volgroup[] = "VG";
3982     int r;
3983     suppress_error = 0;
3984     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3985     if (r == -1)
3986       return -1;
3987   }
3988   {
3989     char vgname[] = "VG";
3990     int r;
3991     suppress_error = 0;
3992     r = guestfs_vgremove (g, vgname);
3993     if (r == -1)
3994       return -1;
3995   }
3996   {
3997     char **r;
3998     int i;
3999     suppress_error = 0;
4000     r = guestfs_lvs (g);
4001     if (r == NULL)
4002       return -1;
4003     if (r[0] != NULL) {
4004       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4005       print_strings (r);
4006       return -1;
4007     }
4008     for (i = 0; r[i] != NULL; ++i)
4009       free (r[i]);
4010     free (r);
4011   }
4012   return 0;
4013 }
4014
4015 static int test_vgremove_1_skip (void)
4016 {
4017   const char *str;
4018
4019   str = getenv ("SKIP_TEST_VGREMOVE_1");
4020   if (str && strcmp (str, "1") == 0) return 1;
4021   str = getenv ("SKIP_TEST_VGREMOVE");
4022   if (str && strcmp (str, "1") == 0) return 1;
4023   return 0;
4024 }
4025
4026 static int test_vgremove_1 (void)
4027 {
4028   if (test_vgremove_1_skip ()) {
4029     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4030     return 0;
4031   }
4032
4033   /* InitNone|InitEmpty for test_vgremove_1 */
4034   {
4035     char device[] = "/dev/sda";
4036     int r;
4037     suppress_error = 0;
4038     r = guestfs_blockdev_setrw (g, device);
4039     if (r == -1)
4040       return -1;
4041   }
4042   {
4043     int r;
4044     suppress_error = 0;
4045     r = guestfs_umount_all (g);
4046     if (r == -1)
4047       return -1;
4048   }
4049   {
4050     int r;
4051     suppress_error = 0;
4052     r = guestfs_lvm_remove_all (g);
4053     if (r == -1)
4054       return -1;
4055   }
4056   /* TestOutputList for vgremove (1) */
4057   {
4058     char device[] = "/dev/sda";
4059     char lines_0[] = ",";
4060     char *lines[] = {
4061       lines_0,
4062       NULL
4063     };
4064     int r;
4065     suppress_error = 0;
4066     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4067     if (r == -1)
4068       return -1;
4069   }
4070   {
4071     char device[] = "/dev/sda1";
4072     int r;
4073     suppress_error = 0;
4074     r = guestfs_pvcreate (g, device);
4075     if (r == -1)
4076       return -1;
4077   }
4078   {
4079     char volgroup[] = "VG";
4080     char physvols_0[] = "/dev/sda1";
4081     char *physvols[] = {
4082       physvols_0,
4083       NULL
4084     };
4085     int r;
4086     suppress_error = 0;
4087     r = guestfs_vgcreate (g, volgroup, physvols);
4088     if (r == -1)
4089       return -1;
4090   }
4091   {
4092     char logvol[] = "LV1";
4093     char volgroup[] = "VG";
4094     int r;
4095     suppress_error = 0;
4096     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4097     if (r == -1)
4098       return -1;
4099   }
4100   {
4101     char logvol[] = "LV2";
4102     char volgroup[] = "VG";
4103     int r;
4104     suppress_error = 0;
4105     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4106     if (r == -1)
4107       return -1;
4108   }
4109   {
4110     char vgname[] = "VG";
4111     int r;
4112     suppress_error = 0;
4113     r = guestfs_vgremove (g, vgname);
4114     if (r == -1)
4115       return -1;
4116   }
4117   {
4118     char **r;
4119     int i;
4120     suppress_error = 0;
4121     r = guestfs_vgs (g);
4122     if (r == NULL)
4123       return -1;
4124     if (r[0] != NULL) {
4125       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4126       print_strings (r);
4127       return -1;
4128     }
4129     for (i = 0; r[i] != NULL; ++i)
4130       free (r[i]);
4131     free (r);
4132   }
4133   return 0;
4134 }
4135
4136 static int test_lvremove_0_skip (void)
4137 {
4138   const char *str;
4139
4140   str = getenv ("SKIP_TEST_LVREMOVE_0");
4141   if (str && strcmp (str, "1") == 0) return 1;
4142   str = getenv ("SKIP_TEST_LVREMOVE");
4143   if (str && strcmp (str, "1") == 0) return 1;
4144   return 0;
4145 }
4146
4147 static int test_lvremove_0 (void)
4148 {
4149   if (test_lvremove_0_skip ()) {
4150     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4151     return 0;
4152   }
4153
4154   /* InitNone|InitEmpty for test_lvremove_0 */
4155   {
4156     char device[] = "/dev/sda";
4157     int r;
4158     suppress_error = 0;
4159     r = guestfs_blockdev_setrw (g, device);
4160     if (r == -1)
4161       return -1;
4162   }
4163   {
4164     int r;
4165     suppress_error = 0;
4166     r = guestfs_umount_all (g);
4167     if (r == -1)
4168       return -1;
4169   }
4170   {
4171     int r;
4172     suppress_error = 0;
4173     r = guestfs_lvm_remove_all (g);
4174     if (r == -1)
4175       return -1;
4176   }
4177   /* TestOutputList for lvremove (0) */
4178   {
4179     char device[] = "/dev/sda";
4180     char lines_0[] = ",";
4181     char *lines[] = {
4182       lines_0,
4183       NULL
4184     };
4185     int r;
4186     suppress_error = 0;
4187     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4188     if (r == -1)
4189       return -1;
4190   }
4191   {
4192     char device[] = "/dev/sda1";
4193     int r;
4194     suppress_error = 0;
4195     r = guestfs_pvcreate (g, device);
4196     if (r == -1)
4197       return -1;
4198   }
4199   {
4200     char volgroup[] = "VG";
4201     char physvols_0[] = "/dev/sda1";
4202     char *physvols[] = {
4203       physvols_0,
4204       NULL
4205     };
4206     int r;
4207     suppress_error = 0;
4208     r = guestfs_vgcreate (g, volgroup, physvols);
4209     if (r == -1)
4210       return -1;
4211   }
4212   {
4213     char logvol[] = "LV1";
4214     char volgroup[] = "VG";
4215     int r;
4216     suppress_error = 0;
4217     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4218     if (r == -1)
4219       return -1;
4220   }
4221   {
4222     char logvol[] = "LV2";
4223     char volgroup[] = "VG";
4224     int r;
4225     suppress_error = 0;
4226     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4227     if (r == -1)
4228       return -1;
4229   }
4230   {
4231     char device[] = "/dev/VG/LV1";
4232     int r;
4233     suppress_error = 0;
4234     r = guestfs_lvremove (g, device);
4235     if (r == -1)
4236       return -1;
4237   }
4238   {
4239     char **r;
4240     int i;
4241     suppress_error = 0;
4242     r = guestfs_lvs (g);
4243     if (r == NULL)
4244       return -1;
4245     if (!r[0]) {
4246       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4247       print_strings (r);
4248       return -1;
4249     }
4250     {
4251       char expected[] = "/dev/VG/LV2";
4252       if (strcmp (r[0], expected) != 0) {
4253         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4254         return -1;
4255       }
4256     }
4257     if (r[1] != NULL) {
4258       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4259       print_strings (r);
4260       return -1;
4261     }
4262     for (i = 0; r[i] != NULL; ++i)
4263       free (r[i]);
4264     free (r);
4265   }
4266   return 0;
4267 }
4268
4269 static int test_lvremove_1_skip (void)
4270 {
4271   const char *str;
4272
4273   str = getenv ("SKIP_TEST_LVREMOVE_1");
4274   if (str && strcmp (str, "1") == 0) return 1;
4275   str = getenv ("SKIP_TEST_LVREMOVE");
4276   if (str && strcmp (str, "1") == 0) return 1;
4277   return 0;
4278 }
4279
4280 static int test_lvremove_1 (void)
4281 {
4282   if (test_lvremove_1_skip ()) {
4283     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4284     return 0;
4285   }
4286
4287   /* InitNone|InitEmpty for test_lvremove_1 */
4288   {
4289     char device[] = "/dev/sda";
4290     int r;
4291     suppress_error = 0;
4292     r = guestfs_blockdev_setrw (g, device);
4293     if (r == -1)
4294       return -1;
4295   }
4296   {
4297     int r;
4298     suppress_error = 0;
4299     r = guestfs_umount_all (g);
4300     if (r == -1)
4301       return -1;
4302   }
4303   {
4304     int r;
4305     suppress_error = 0;
4306     r = guestfs_lvm_remove_all (g);
4307     if (r == -1)
4308       return -1;
4309   }
4310   /* TestOutputList for lvremove (1) */
4311   {
4312     char device[] = "/dev/sda";
4313     char lines_0[] = ",";
4314     char *lines[] = {
4315       lines_0,
4316       NULL
4317     };
4318     int r;
4319     suppress_error = 0;
4320     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4321     if (r == -1)
4322       return -1;
4323   }
4324   {
4325     char device[] = "/dev/sda1";
4326     int r;
4327     suppress_error = 0;
4328     r = guestfs_pvcreate (g, device);
4329     if (r == -1)
4330       return -1;
4331   }
4332   {
4333     char volgroup[] = "VG";
4334     char physvols_0[] = "/dev/sda1";
4335     char *physvols[] = {
4336       physvols_0,
4337       NULL
4338     };
4339     int r;
4340     suppress_error = 0;
4341     r = guestfs_vgcreate (g, volgroup, physvols);
4342     if (r == -1)
4343       return -1;
4344   }
4345   {
4346     char logvol[] = "LV1";
4347     char volgroup[] = "VG";
4348     int r;
4349     suppress_error = 0;
4350     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4351     if (r == -1)
4352       return -1;
4353   }
4354   {
4355     char logvol[] = "LV2";
4356     char volgroup[] = "VG";
4357     int r;
4358     suppress_error = 0;
4359     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4360     if (r == -1)
4361       return -1;
4362   }
4363   {
4364     char device[] = "/dev/VG";
4365     int r;
4366     suppress_error = 0;
4367     r = guestfs_lvremove (g, device);
4368     if (r == -1)
4369       return -1;
4370   }
4371   {
4372     char **r;
4373     int i;
4374     suppress_error = 0;
4375     r = guestfs_lvs (g);
4376     if (r == NULL)
4377       return -1;
4378     if (r[0] != NULL) {
4379       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4380       print_strings (r);
4381       return -1;
4382     }
4383     for (i = 0; r[i] != NULL; ++i)
4384       free (r[i]);
4385     free (r);
4386   }
4387   return 0;
4388 }
4389
4390 static int test_lvremove_2_skip (void)
4391 {
4392   const char *str;
4393
4394   str = getenv ("SKIP_TEST_LVREMOVE_2");
4395   if (str && strcmp (str, "1") == 0) return 1;
4396   str = getenv ("SKIP_TEST_LVREMOVE");
4397   if (str && strcmp (str, "1") == 0) return 1;
4398   return 0;
4399 }
4400
4401 static int test_lvremove_2 (void)
4402 {
4403   if (test_lvremove_2_skip ()) {
4404     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4405     return 0;
4406   }
4407
4408   /* InitNone|InitEmpty for test_lvremove_2 */
4409   {
4410     char device[] = "/dev/sda";
4411     int r;
4412     suppress_error = 0;
4413     r = guestfs_blockdev_setrw (g, device);
4414     if (r == -1)
4415       return -1;
4416   }
4417   {
4418     int r;
4419     suppress_error = 0;
4420     r = guestfs_umount_all (g);
4421     if (r == -1)
4422       return -1;
4423   }
4424   {
4425     int r;
4426     suppress_error = 0;
4427     r = guestfs_lvm_remove_all (g);
4428     if (r == -1)
4429       return -1;
4430   }
4431   /* TestOutputList for lvremove (2) */
4432   {
4433     char device[] = "/dev/sda";
4434     char lines_0[] = ",";
4435     char *lines[] = {
4436       lines_0,
4437       NULL
4438     };
4439     int r;
4440     suppress_error = 0;
4441     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4442     if (r == -1)
4443       return -1;
4444   }
4445   {
4446     char device[] = "/dev/sda1";
4447     int r;
4448     suppress_error = 0;
4449     r = guestfs_pvcreate (g, device);
4450     if (r == -1)
4451       return -1;
4452   }
4453   {
4454     char volgroup[] = "VG";
4455     char physvols_0[] = "/dev/sda1";
4456     char *physvols[] = {
4457       physvols_0,
4458       NULL
4459     };
4460     int r;
4461     suppress_error = 0;
4462     r = guestfs_vgcreate (g, volgroup, physvols);
4463     if (r == -1)
4464       return -1;
4465   }
4466   {
4467     char logvol[] = "LV1";
4468     char volgroup[] = "VG";
4469     int r;
4470     suppress_error = 0;
4471     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4472     if (r == -1)
4473       return -1;
4474   }
4475   {
4476     char logvol[] = "LV2";
4477     char volgroup[] = "VG";
4478     int r;
4479     suppress_error = 0;
4480     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4481     if (r == -1)
4482       return -1;
4483   }
4484   {
4485     char device[] = "/dev/VG";
4486     int r;
4487     suppress_error = 0;
4488     r = guestfs_lvremove (g, device);
4489     if (r == -1)
4490       return -1;
4491   }
4492   {
4493     char **r;
4494     int i;
4495     suppress_error = 0;
4496     r = guestfs_vgs (g);
4497     if (r == NULL)
4498       return -1;
4499     if (!r[0]) {
4500       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4501       print_strings (r);
4502       return -1;
4503     }
4504     {
4505       char expected[] = "VG";
4506       if (strcmp (r[0], expected) != 0) {
4507         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4508         return -1;
4509       }
4510     }
4511     if (r[1] != NULL) {
4512       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4513       print_strings (r);
4514       return -1;
4515     }
4516     for (i = 0; r[i] != NULL; ++i)
4517       free (r[i]);
4518     free (r);
4519   }
4520   return 0;
4521 }
4522
4523 static int test_mount_ro_0_skip (void)
4524 {
4525   const char *str;
4526
4527   str = getenv ("SKIP_TEST_MOUNT_RO_0");
4528   if (str && strcmp (str, "1") == 0) return 1;
4529   str = getenv ("SKIP_TEST_MOUNT_RO");
4530   if (str && strcmp (str, "1") == 0) return 1;
4531   return 0;
4532 }
4533
4534 static int test_mount_ro_0 (void)
4535 {
4536   if (test_mount_ro_0_skip ()) {
4537     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4538     return 0;
4539   }
4540
4541   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4542   {
4543     char device[] = "/dev/sda";
4544     int r;
4545     suppress_error = 0;
4546     r = guestfs_blockdev_setrw (g, device);
4547     if (r == -1)
4548       return -1;
4549   }
4550   {
4551     int r;
4552     suppress_error = 0;
4553     r = guestfs_umount_all (g);
4554     if (r == -1)
4555       return -1;
4556   }
4557   {
4558     int r;
4559     suppress_error = 0;
4560     r = guestfs_lvm_remove_all (g);
4561     if (r == -1)
4562       return -1;
4563   }
4564   {
4565     char device[] = "/dev/sda";
4566     char lines_0[] = ",";
4567     char *lines[] = {
4568       lines_0,
4569       NULL
4570     };
4571     int r;
4572     suppress_error = 0;
4573     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4574     if (r == -1)
4575       return -1;
4576   }
4577   {
4578     char fstype[] = "ext2";
4579     char device[] = "/dev/sda1";
4580     int r;
4581     suppress_error = 0;
4582     r = guestfs_mkfs (g, fstype, device);
4583     if (r == -1)
4584       return -1;
4585   }
4586   {
4587     char device[] = "/dev/sda1";
4588     char mountpoint[] = "/";
4589     int r;
4590     suppress_error = 0;
4591     r = guestfs_mount (g, device, mountpoint);
4592     if (r == -1)
4593       return -1;
4594   }
4595   /* TestLastFail for mount_ro (0) */
4596   {
4597     char pathordevice[] = "/";
4598     int r;
4599     suppress_error = 0;
4600     r = guestfs_umount (g, pathordevice);
4601     if (r == -1)
4602       return -1;
4603   }
4604   {
4605     char device[] = "/dev/sda1";
4606     char mountpoint[] = "/";
4607     int r;
4608     suppress_error = 0;
4609     r = guestfs_mount_ro (g, device, mountpoint);
4610     if (r == -1)
4611       return -1;
4612   }
4613   {
4614     char path[] = "/new";
4615     int r;
4616     suppress_error = 1;
4617     r = guestfs_touch (g, path);
4618     if (r != -1)
4619       return -1;
4620   }
4621   return 0;
4622 }
4623
4624 static int test_mount_ro_1_skip (void)
4625 {
4626   const char *str;
4627
4628   str = getenv ("SKIP_TEST_MOUNT_RO_1");
4629   if (str && strcmp (str, "1") == 0) return 1;
4630   str = getenv ("SKIP_TEST_MOUNT_RO");
4631   if (str && strcmp (str, "1") == 0) return 1;
4632   return 0;
4633 }
4634
4635 static int test_mount_ro_1 (void)
4636 {
4637   if (test_mount_ro_1_skip ()) {
4638     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4639     return 0;
4640   }
4641
4642   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4643   {
4644     char device[] = "/dev/sda";
4645     int r;
4646     suppress_error = 0;
4647     r = guestfs_blockdev_setrw (g, device);
4648     if (r == -1)
4649       return -1;
4650   }
4651   {
4652     int r;
4653     suppress_error = 0;
4654     r = guestfs_umount_all (g);
4655     if (r == -1)
4656       return -1;
4657   }
4658   {
4659     int r;
4660     suppress_error = 0;
4661     r = guestfs_lvm_remove_all (g);
4662     if (r == -1)
4663       return -1;
4664   }
4665   {
4666     char device[] = "/dev/sda";
4667     char lines_0[] = ",";
4668     char *lines[] = {
4669       lines_0,
4670       NULL
4671     };
4672     int r;
4673     suppress_error = 0;
4674     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4675     if (r == -1)
4676       return -1;
4677   }
4678   {
4679     char fstype[] = "ext2";
4680     char device[] = "/dev/sda1";
4681     int r;
4682     suppress_error = 0;
4683     r = guestfs_mkfs (g, fstype, device);
4684     if (r == -1)
4685       return -1;
4686   }
4687   {
4688     char device[] = "/dev/sda1";
4689     char mountpoint[] = "/";
4690     int r;
4691     suppress_error = 0;
4692     r = guestfs_mount (g, device, mountpoint);
4693     if (r == -1)
4694       return -1;
4695   }
4696   /* TestOutput for mount_ro (1) */
4697   char expected[] = "data";
4698   {
4699     char path[] = "/new";
4700     char content[] = "data";
4701     int r;
4702     suppress_error = 0;
4703     r = guestfs_write_file (g, path, content, 0);
4704     if (r == -1)
4705       return -1;
4706   }
4707   {
4708     char pathordevice[] = "/";
4709     int r;
4710     suppress_error = 0;
4711     r = guestfs_umount (g, pathordevice);
4712     if (r == -1)
4713       return -1;
4714   }
4715   {
4716     char device[] = "/dev/sda1";
4717     char mountpoint[] = "/";
4718     int r;
4719     suppress_error = 0;
4720     r = guestfs_mount_ro (g, device, mountpoint);
4721     if (r == -1)
4722       return -1;
4723   }
4724   {
4725     char path[] = "/new";
4726     char *r;
4727     suppress_error = 0;
4728     r = guestfs_cat (g, path);
4729     if (r == NULL)
4730       return -1;
4731     if (strcmp (r, expected) != 0) {
4732       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4733       return -1;
4734     }
4735     free (r);
4736   }
4737   return 0;
4738 }
4739
4740 static int test_tgz_in_0_skip (void)
4741 {
4742   const char *str;
4743
4744   str = getenv ("SKIP_TEST_TGZ_IN_0");
4745   if (str && strcmp (str, "1") == 0) return 1;
4746   str = getenv ("SKIP_TEST_TGZ_IN");
4747   if (str && strcmp (str, "1") == 0) return 1;
4748   return 0;
4749 }
4750
4751 static int test_tgz_in_0 (void)
4752 {
4753   if (test_tgz_in_0_skip ()) {
4754     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4755     return 0;
4756   }
4757
4758   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4759   {
4760     char device[] = "/dev/sda";
4761     int r;
4762     suppress_error = 0;
4763     r = guestfs_blockdev_setrw (g, device);
4764     if (r == -1)
4765       return -1;
4766   }
4767   {
4768     int r;
4769     suppress_error = 0;
4770     r = guestfs_umount_all (g);
4771     if (r == -1)
4772       return -1;
4773   }
4774   {
4775     int r;
4776     suppress_error = 0;
4777     r = guestfs_lvm_remove_all (g);
4778     if (r == -1)
4779       return -1;
4780   }
4781   {
4782     char device[] = "/dev/sda";
4783     char lines_0[] = ",";
4784     char *lines[] = {
4785       lines_0,
4786       NULL
4787     };
4788     int r;
4789     suppress_error = 0;
4790     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4791     if (r == -1)
4792       return -1;
4793   }
4794   {
4795     char fstype[] = "ext2";
4796     char device[] = "/dev/sda1";
4797     int r;
4798     suppress_error = 0;
4799     r = guestfs_mkfs (g, fstype, device);
4800     if (r == -1)
4801       return -1;
4802   }
4803   {
4804     char device[] = "/dev/sda1";
4805     char mountpoint[] = "/";
4806     int r;
4807     suppress_error = 0;
4808     r = guestfs_mount (g, device, mountpoint);
4809     if (r == -1)
4810       return -1;
4811   }
4812   /* TestOutput for tgz_in (0) */
4813   char expected[] = "hello\n";
4814   {
4815     char directory[] = "/";
4816     int r;
4817     suppress_error = 0;
4818     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
4819     if (r == -1)
4820       return -1;
4821   }
4822   {
4823     char path[] = "/hello";
4824     char *r;
4825     suppress_error = 0;
4826     r = guestfs_cat (g, path);
4827     if (r == NULL)
4828       return -1;
4829     if (strcmp (r, expected) != 0) {
4830       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4831       return -1;
4832     }
4833     free (r);
4834   }
4835   return 0;
4836 }
4837
4838 static int test_tar_in_0_skip (void)
4839 {
4840   const char *str;
4841
4842   str = getenv ("SKIP_TEST_TAR_IN_0");
4843   if (str && strcmp (str, "1") == 0) return 1;
4844   str = getenv ("SKIP_TEST_TAR_IN");
4845   if (str && strcmp (str, "1") == 0) return 1;
4846   return 0;
4847 }
4848
4849 static int test_tar_in_0 (void)
4850 {
4851   if (test_tar_in_0_skip ()) {
4852     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
4853     return 0;
4854   }
4855
4856   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4857   {
4858     char device[] = "/dev/sda";
4859     int r;
4860     suppress_error = 0;
4861     r = guestfs_blockdev_setrw (g, device);
4862     if (r == -1)
4863       return -1;
4864   }
4865   {
4866     int r;
4867     suppress_error = 0;
4868     r = guestfs_umount_all (g);
4869     if (r == -1)
4870       return -1;
4871   }
4872   {
4873     int r;
4874     suppress_error = 0;
4875     r = guestfs_lvm_remove_all (g);
4876     if (r == -1)
4877       return -1;
4878   }
4879   {
4880     char device[] = "/dev/sda";
4881     char lines_0[] = ",";
4882     char *lines[] = {
4883       lines_0,
4884       NULL
4885     };
4886     int r;
4887     suppress_error = 0;
4888     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4889     if (r == -1)
4890       return -1;
4891   }
4892   {
4893     char fstype[] = "ext2";
4894     char device[] = "/dev/sda1";
4895     int r;
4896     suppress_error = 0;
4897     r = guestfs_mkfs (g, fstype, device);
4898     if (r == -1)
4899       return -1;
4900   }
4901   {
4902     char device[] = "/dev/sda1";
4903     char mountpoint[] = "/";
4904     int r;
4905     suppress_error = 0;
4906     r = guestfs_mount (g, device, mountpoint);
4907     if (r == -1)
4908       return -1;
4909   }
4910   /* TestOutput for tar_in (0) */
4911   char expected[] = "hello\n";
4912   {
4913     char directory[] = "/";
4914     int r;
4915     suppress_error = 0;
4916     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
4917     if (r == -1)
4918       return -1;
4919   }
4920   {
4921     char path[] = "/hello";
4922     char *r;
4923     suppress_error = 0;
4924     r = guestfs_cat (g, path);
4925     if (r == NULL)
4926       return -1;
4927     if (strcmp (r, expected) != 0) {
4928       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4929       return -1;
4930     }
4931     free (r);
4932   }
4933   return 0;
4934 }
4935
4936 static int test_checksum_0_skip (void)
4937 {
4938   const char *str;
4939
4940   str = getenv ("SKIP_TEST_CHECKSUM_0");
4941   if (str && strcmp (str, "1") == 0) return 1;
4942   str = getenv ("SKIP_TEST_CHECKSUM");
4943   if (str && strcmp (str, "1") == 0) return 1;
4944   return 0;
4945 }
4946
4947 static int test_checksum_0 (void)
4948 {
4949   if (test_checksum_0_skip ()) {
4950     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
4951     return 0;
4952   }
4953
4954   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4955   {
4956     char device[] = "/dev/sda";
4957     int r;
4958     suppress_error = 0;
4959     r = guestfs_blockdev_setrw (g, device);
4960     if (r == -1)
4961       return -1;
4962   }
4963   {
4964     int r;
4965     suppress_error = 0;
4966     r = guestfs_umount_all (g);
4967     if (r == -1)
4968       return -1;
4969   }
4970   {
4971     int r;
4972     suppress_error = 0;
4973     r = guestfs_lvm_remove_all (g);
4974     if (r == -1)
4975       return -1;
4976   }
4977   {
4978     char device[] = "/dev/sda";
4979     char lines_0[] = ",";
4980     char *lines[] = {
4981       lines_0,
4982       NULL
4983     };
4984     int r;
4985     suppress_error = 0;
4986     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4987     if (r == -1)
4988       return -1;
4989   }
4990   {
4991     char fstype[] = "ext2";
4992     char device[] = "/dev/sda1";
4993     int r;
4994     suppress_error = 0;
4995     r = guestfs_mkfs (g, fstype, device);
4996     if (r == -1)
4997       return -1;
4998   }
4999   {
5000     char device[] = "/dev/sda1";
5001     char mountpoint[] = "/";
5002     int r;
5003     suppress_error = 0;
5004     r = guestfs_mount (g, device, mountpoint);
5005     if (r == -1)
5006       return -1;
5007   }
5008   /* TestOutput for checksum (0) */
5009   char expected[] = "935282863";
5010   {
5011     char path[] = "/new";
5012     char content[] = "test\n";
5013     int r;
5014     suppress_error = 0;
5015     r = guestfs_write_file (g, path, content, 0);
5016     if (r == -1)
5017       return -1;
5018   }
5019   {
5020     char csumtype[] = "crc";
5021     char path[] = "/new";
5022     char *r;
5023     suppress_error = 0;
5024     r = guestfs_checksum (g, csumtype, path);
5025     if (r == NULL)
5026       return -1;
5027     if (strcmp (r, expected) != 0) {
5028       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5029       return -1;
5030     }
5031     free (r);
5032   }
5033   return 0;
5034 }
5035
5036 static int test_checksum_1_skip (void)
5037 {
5038   const char *str;
5039
5040   str = getenv ("SKIP_TEST_CHECKSUM_1");
5041   if (str && strcmp (str, "1") == 0) return 1;
5042   str = getenv ("SKIP_TEST_CHECKSUM");
5043   if (str && strcmp (str, "1") == 0) return 1;
5044   return 0;
5045 }
5046
5047 static int test_checksum_1 (void)
5048 {
5049   if (test_checksum_1_skip ()) {
5050     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5051     return 0;
5052   }
5053
5054   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5055   {
5056     char device[] = "/dev/sda";
5057     int r;
5058     suppress_error = 0;
5059     r = guestfs_blockdev_setrw (g, device);
5060     if (r == -1)
5061       return -1;
5062   }
5063   {
5064     int r;
5065     suppress_error = 0;
5066     r = guestfs_umount_all (g);
5067     if (r == -1)
5068       return -1;
5069   }
5070   {
5071     int r;
5072     suppress_error = 0;
5073     r = guestfs_lvm_remove_all (g);
5074     if (r == -1)
5075       return -1;
5076   }
5077   {
5078     char device[] = "/dev/sda";
5079     char lines_0[] = ",";
5080     char *lines[] = {
5081       lines_0,
5082       NULL
5083     };
5084     int r;
5085     suppress_error = 0;
5086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5087     if (r == -1)
5088       return -1;
5089   }
5090   {
5091     char fstype[] = "ext2";
5092     char device[] = "/dev/sda1";
5093     int r;
5094     suppress_error = 0;
5095     r = guestfs_mkfs (g, fstype, device);
5096     if (r == -1)
5097       return -1;
5098   }
5099   {
5100     char device[] = "/dev/sda1";
5101     char mountpoint[] = "/";
5102     int r;
5103     suppress_error = 0;
5104     r = guestfs_mount (g, device, mountpoint);
5105     if (r == -1)
5106       return -1;
5107   }
5108   /* TestLastFail for checksum (1) */
5109   {
5110     char csumtype[] = "crc";
5111     char path[] = "/new";
5112     char *r;
5113     suppress_error = 1;
5114     r = guestfs_checksum (g, csumtype, path);
5115     if (r != NULL)
5116       return -1;
5117     free (r);
5118   }
5119   return 0;
5120 }
5121
5122 static int test_checksum_2_skip (void)
5123 {
5124   const char *str;
5125
5126   str = getenv ("SKIP_TEST_CHECKSUM_2");
5127   if (str && strcmp (str, "1") == 0) return 1;
5128   str = getenv ("SKIP_TEST_CHECKSUM");
5129   if (str && strcmp (str, "1") == 0) return 1;
5130   return 0;
5131 }
5132
5133 static int test_checksum_2 (void)
5134 {
5135   if (test_checksum_2_skip ()) {
5136     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5137     return 0;
5138   }
5139
5140   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5141   {
5142     char device[] = "/dev/sda";
5143     int r;
5144     suppress_error = 0;
5145     r = guestfs_blockdev_setrw (g, device);
5146     if (r == -1)
5147       return -1;
5148   }
5149   {
5150     int r;
5151     suppress_error = 0;
5152     r = guestfs_umount_all (g);
5153     if (r == -1)
5154       return -1;
5155   }
5156   {
5157     int r;
5158     suppress_error = 0;
5159     r = guestfs_lvm_remove_all (g);
5160     if (r == -1)
5161       return -1;
5162   }
5163   {
5164     char device[] = "/dev/sda";
5165     char lines_0[] = ",";
5166     char *lines[] = {
5167       lines_0,
5168       NULL
5169     };
5170     int r;
5171     suppress_error = 0;
5172     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5173     if (r == -1)
5174       return -1;
5175   }
5176   {
5177     char fstype[] = "ext2";
5178     char device[] = "/dev/sda1";
5179     int r;
5180     suppress_error = 0;
5181     r = guestfs_mkfs (g, fstype, device);
5182     if (r == -1)
5183       return -1;
5184   }
5185   {
5186     char device[] = "/dev/sda1";
5187     char mountpoint[] = "/";
5188     int r;
5189     suppress_error = 0;
5190     r = guestfs_mount (g, device, mountpoint);
5191     if (r == -1)
5192       return -1;
5193   }
5194   /* TestOutput for checksum (2) */
5195   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5196   {
5197     char path[] = "/new";
5198     char content[] = "test\n";
5199     int r;
5200     suppress_error = 0;
5201     r = guestfs_write_file (g, path, content, 0);
5202     if (r == -1)
5203       return -1;
5204   }
5205   {
5206     char csumtype[] = "md5";
5207     char path[] = "/new";
5208     char *r;
5209     suppress_error = 0;
5210     r = guestfs_checksum (g, csumtype, path);
5211     if (r == NULL)
5212       return -1;
5213     if (strcmp (r, expected) != 0) {
5214       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5215       return -1;
5216     }
5217     free (r);
5218   }
5219   return 0;
5220 }
5221
5222 static int test_checksum_3_skip (void)
5223 {
5224   const char *str;
5225
5226   str = getenv ("SKIP_TEST_CHECKSUM_3");
5227   if (str && strcmp (str, "1") == 0) return 1;
5228   str = getenv ("SKIP_TEST_CHECKSUM");
5229   if (str && strcmp (str, "1") == 0) return 1;
5230   return 0;
5231 }
5232
5233 static int test_checksum_3 (void)
5234 {
5235   if (test_checksum_3_skip ()) {
5236     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5237     return 0;
5238   }
5239
5240   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5241   {
5242     char device[] = "/dev/sda";
5243     int r;
5244     suppress_error = 0;
5245     r = guestfs_blockdev_setrw (g, device);
5246     if (r == -1)
5247       return -1;
5248   }
5249   {
5250     int r;
5251     suppress_error = 0;
5252     r = guestfs_umount_all (g);
5253     if (r == -1)
5254       return -1;
5255   }
5256   {
5257     int r;
5258     suppress_error = 0;
5259     r = guestfs_lvm_remove_all (g);
5260     if (r == -1)
5261       return -1;
5262   }
5263   {
5264     char device[] = "/dev/sda";
5265     char lines_0[] = ",";
5266     char *lines[] = {
5267       lines_0,
5268       NULL
5269     };
5270     int r;
5271     suppress_error = 0;
5272     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5273     if (r == -1)
5274       return -1;
5275   }
5276   {
5277     char fstype[] = "ext2";
5278     char device[] = "/dev/sda1";
5279     int r;
5280     suppress_error = 0;
5281     r = guestfs_mkfs (g, fstype, device);
5282     if (r == -1)
5283       return -1;
5284   }
5285   {
5286     char device[] = "/dev/sda1";
5287     char mountpoint[] = "/";
5288     int r;
5289     suppress_error = 0;
5290     r = guestfs_mount (g, device, mountpoint);
5291     if (r == -1)
5292       return -1;
5293   }
5294   /* TestOutput for checksum (3) */
5295   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5296   {
5297     char path[] = "/new";
5298     char content[] = "test\n";
5299     int r;
5300     suppress_error = 0;
5301     r = guestfs_write_file (g, path, content, 0);
5302     if (r == -1)
5303       return -1;
5304   }
5305   {
5306     char csumtype[] = "sha1";
5307     char path[] = "/new";
5308     char *r;
5309     suppress_error = 0;
5310     r = guestfs_checksum (g, csumtype, path);
5311     if (r == NULL)
5312       return -1;
5313     if (strcmp (r, expected) != 0) {
5314       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5315       return -1;
5316     }
5317     free (r);
5318   }
5319   return 0;
5320 }
5321
5322 static int test_checksum_4_skip (void)
5323 {
5324   const char *str;
5325
5326   str = getenv ("SKIP_TEST_CHECKSUM_4");
5327   if (str && strcmp (str, "1") == 0) return 1;
5328   str = getenv ("SKIP_TEST_CHECKSUM");
5329   if (str && strcmp (str, "1") == 0) return 1;
5330   return 0;
5331 }
5332
5333 static int test_checksum_4 (void)
5334 {
5335   if (test_checksum_4_skip ()) {
5336     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5337     return 0;
5338   }
5339
5340   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5341   {
5342     char device[] = "/dev/sda";
5343     int r;
5344     suppress_error = 0;
5345     r = guestfs_blockdev_setrw (g, device);
5346     if (r == -1)
5347       return -1;
5348   }
5349   {
5350     int r;
5351     suppress_error = 0;
5352     r = guestfs_umount_all (g);
5353     if (r == -1)
5354       return -1;
5355   }
5356   {
5357     int r;
5358     suppress_error = 0;
5359     r = guestfs_lvm_remove_all (g);
5360     if (r == -1)
5361       return -1;
5362   }
5363   {
5364     char device[] = "/dev/sda";
5365     char lines_0[] = ",";
5366     char *lines[] = {
5367       lines_0,
5368       NULL
5369     };
5370     int r;
5371     suppress_error = 0;
5372     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5373     if (r == -1)
5374       return -1;
5375   }
5376   {
5377     char fstype[] = "ext2";
5378     char device[] = "/dev/sda1";
5379     int r;
5380     suppress_error = 0;
5381     r = guestfs_mkfs (g, fstype, device);
5382     if (r == -1)
5383       return -1;
5384   }
5385   {
5386     char device[] = "/dev/sda1";
5387     char mountpoint[] = "/";
5388     int r;
5389     suppress_error = 0;
5390     r = guestfs_mount (g, device, mountpoint);
5391     if (r == -1)
5392       return -1;
5393   }
5394   /* TestOutput for checksum (4) */
5395   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5396   {
5397     char path[] = "/new";
5398     char content[] = "test\n";
5399     int r;
5400     suppress_error = 0;
5401     r = guestfs_write_file (g, path, content, 0);
5402     if (r == -1)
5403       return -1;
5404   }
5405   {
5406     char csumtype[] = "sha224";
5407     char path[] = "/new";
5408     char *r;
5409     suppress_error = 0;
5410     r = guestfs_checksum (g, csumtype, path);
5411     if (r == NULL)
5412       return -1;
5413     if (strcmp (r, expected) != 0) {
5414       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5415       return -1;
5416     }
5417     free (r);
5418   }
5419   return 0;
5420 }
5421
5422 static int test_checksum_5_skip (void)
5423 {
5424   const char *str;
5425
5426   str = getenv ("SKIP_TEST_CHECKSUM_5");
5427   if (str && strcmp (str, "1") == 0) return 1;
5428   str = getenv ("SKIP_TEST_CHECKSUM");
5429   if (str && strcmp (str, "1") == 0) return 1;
5430   return 0;
5431 }
5432
5433 static int test_checksum_5 (void)
5434 {
5435   if (test_checksum_5_skip ()) {
5436     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5437     return 0;
5438   }
5439
5440   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5441   {
5442     char device[] = "/dev/sda";
5443     int r;
5444     suppress_error = 0;
5445     r = guestfs_blockdev_setrw (g, device);
5446     if (r == -1)
5447       return -1;
5448   }
5449   {
5450     int r;
5451     suppress_error = 0;
5452     r = guestfs_umount_all (g);
5453     if (r == -1)
5454       return -1;
5455   }
5456   {
5457     int r;
5458     suppress_error = 0;
5459     r = guestfs_lvm_remove_all (g);
5460     if (r == -1)
5461       return -1;
5462   }
5463   {
5464     char device[] = "/dev/sda";
5465     char lines_0[] = ",";
5466     char *lines[] = {
5467       lines_0,
5468       NULL
5469     };
5470     int r;
5471     suppress_error = 0;
5472     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5473     if (r == -1)
5474       return -1;
5475   }
5476   {
5477     char fstype[] = "ext2";
5478     char device[] = "/dev/sda1";
5479     int r;
5480     suppress_error = 0;
5481     r = guestfs_mkfs (g, fstype, device);
5482     if (r == -1)
5483       return -1;
5484   }
5485   {
5486     char device[] = "/dev/sda1";
5487     char mountpoint[] = "/";
5488     int r;
5489     suppress_error = 0;
5490     r = guestfs_mount (g, device, mountpoint);
5491     if (r == -1)
5492       return -1;
5493   }
5494   /* TestOutput for checksum (5) */
5495   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5496   {
5497     char path[] = "/new";
5498     char content[] = "test\n";
5499     int r;
5500     suppress_error = 0;
5501     r = guestfs_write_file (g, path, content, 0);
5502     if (r == -1)
5503       return -1;
5504   }
5505   {
5506     char csumtype[] = "sha256";
5507     char path[] = "/new";
5508     char *r;
5509     suppress_error = 0;
5510     r = guestfs_checksum (g, csumtype, path);
5511     if (r == NULL)
5512       return -1;
5513     if (strcmp (r, expected) != 0) {
5514       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5515       return -1;
5516     }
5517     free (r);
5518   }
5519   return 0;
5520 }
5521
5522 static int test_checksum_6_skip (void)
5523 {
5524   const char *str;
5525
5526   str = getenv ("SKIP_TEST_CHECKSUM_6");
5527   if (str && strcmp (str, "1") == 0) return 1;
5528   str = getenv ("SKIP_TEST_CHECKSUM");
5529   if (str && strcmp (str, "1") == 0) return 1;
5530   return 0;
5531 }
5532
5533 static int test_checksum_6 (void)
5534 {
5535   if (test_checksum_6_skip ()) {
5536     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5537     return 0;
5538   }
5539
5540   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5541   {
5542     char device[] = "/dev/sda";
5543     int r;
5544     suppress_error = 0;
5545     r = guestfs_blockdev_setrw (g, device);
5546     if (r == -1)
5547       return -1;
5548   }
5549   {
5550     int r;
5551     suppress_error = 0;
5552     r = guestfs_umount_all (g);
5553     if (r == -1)
5554       return -1;
5555   }
5556   {
5557     int r;
5558     suppress_error = 0;
5559     r = guestfs_lvm_remove_all (g);
5560     if (r == -1)
5561       return -1;
5562   }
5563   {
5564     char device[] = "/dev/sda";
5565     char lines_0[] = ",";
5566     char *lines[] = {
5567       lines_0,
5568       NULL
5569     };
5570     int r;
5571     suppress_error = 0;
5572     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5573     if (r == -1)
5574       return -1;
5575   }
5576   {
5577     char fstype[] = "ext2";
5578     char device[] = "/dev/sda1";
5579     int r;
5580     suppress_error = 0;
5581     r = guestfs_mkfs (g, fstype, device);
5582     if (r == -1)
5583       return -1;
5584   }
5585   {
5586     char device[] = "/dev/sda1";
5587     char mountpoint[] = "/";
5588     int r;
5589     suppress_error = 0;
5590     r = guestfs_mount (g, device, mountpoint);
5591     if (r == -1)
5592       return -1;
5593   }
5594   /* TestOutput for checksum (6) */
5595   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5596   {
5597     char path[] = "/new";
5598     char content[] = "test\n";
5599     int r;
5600     suppress_error = 0;
5601     r = guestfs_write_file (g, path, content, 0);
5602     if (r == -1)
5603       return -1;
5604   }
5605   {
5606     char csumtype[] = "sha384";
5607     char path[] = "/new";
5608     char *r;
5609     suppress_error = 0;
5610     r = guestfs_checksum (g, csumtype, path);
5611     if (r == NULL)
5612       return -1;
5613     if (strcmp (r, expected) != 0) {
5614       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5615       return -1;
5616     }
5617     free (r);
5618   }
5619   return 0;
5620 }
5621
5622 static int test_checksum_7_skip (void)
5623 {
5624   const char *str;
5625
5626   str = getenv ("SKIP_TEST_CHECKSUM_7");
5627   if (str && strcmp (str, "1") == 0) return 1;
5628   str = getenv ("SKIP_TEST_CHECKSUM");
5629   if (str && strcmp (str, "1") == 0) return 1;
5630   return 0;
5631 }
5632
5633 static int test_checksum_7 (void)
5634 {
5635   if (test_checksum_7_skip ()) {
5636     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5637     return 0;
5638   }
5639
5640   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5641   {
5642     char device[] = "/dev/sda";
5643     int r;
5644     suppress_error = 0;
5645     r = guestfs_blockdev_setrw (g, device);
5646     if (r == -1)
5647       return -1;
5648   }
5649   {
5650     int r;
5651     suppress_error = 0;
5652     r = guestfs_umount_all (g);
5653     if (r == -1)
5654       return -1;
5655   }
5656   {
5657     int r;
5658     suppress_error = 0;
5659     r = guestfs_lvm_remove_all (g);
5660     if (r == -1)
5661       return -1;
5662   }
5663   {
5664     char device[] = "/dev/sda";
5665     char lines_0[] = ",";
5666     char *lines[] = {
5667       lines_0,
5668       NULL
5669     };
5670     int r;
5671     suppress_error = 0;
5672     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5673     if (r == -1)
5674       return -1;
5675   }
5676   {
5677     char fstype[] = "ext2";
5678     char device[] = "/dev/sda1";
5679     int r;
5680     suppress_error = 0;
5681     r = guestfs_mkfs (g, fstype, device);
5682     if (r == -1)
5683       return -1;
5684   }
5685   {
5686     char device[] = "/dev/sda1";
5687     char mountpoint[] = "/";
5688     int r;
5689     suppress_error = 0;
5690     r = guestfs_mount (g, device, mountpoint);
5691     if (r == -1)
5692       return -1;
5693   }
5694   /* TestOutput for checksum (7) */
5695   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5696   {
5697     char path[] = "/new";
5698     char content[] = "test\n";
5699     int r;
5700     suppress_error = 0;
5701     r = guestfs_write_file (g, path, content, 0);
5702     if (r == -1)
5703       return -1;
5704   }
5705   {
5706     char csumtype[] = "sha512";
5707     char path[] = "/new";
5708     char *r;
5709     suppress_error = 0;
5710     r = guestfs_checksum (g, csumtype, path);
5711     if (r == NULL)
5712       return -1;
5713     if (strcmp (r, expected) != 0) {
5714       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5715       return -1;
5716     }
5717     free (r);
5718   }
5719   return 0;
5720 }
5721
5722 static int test_checksum_8_skip (void)
5723 {
5724   const char *str;
5725
5726   str = getenv ("SKIP_TEST_CHECKSUM_8");
5727   if (str && strcmp (str, "1") == 0) return 1;
5728   str = getenv ("SKIP_TEST_CHECKSUM");
5729   if (str && strcmp (str, "1") == 0) return 1;
5730   return 0;
5731 }
5732
5733 static int test_checksum_8 (void)
5734 {
5735   if (test_checksum_8_skip ()) {
5736     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
5737     return 0;
5738   }
5739
5740   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
5741   {
5742     char device[] = "/dev/sda";
5743     int r;
5744     suppress_error = 0;
5745     r = guestfs_blockdev_setrw (g, device);
5746     if (r == -1)
5747       return -1;
5748   }
5749   {
5750     int r;
5751     suppress_error = 0;
5752     r = guestfs_umount_all (g);
5753     if (r == -1)
5754       return -1;
5755   }
5756   {
5757     int r;
5758     suppress_error = 0;
5759     r = guestfs_lvm_remove_all (g);
5760     if (r == -1)
5761       return -1;
5762   }
5763   {
5764     char device[] = "/dev/sda";
5765     char lines_0[] = ",";
5766     char *lines[] = {
5767       lines_0,
5768       NULL
5769     };
5770     int r;
5771     suppress_error = 0;
5772     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5773     if (r == -1)
5774       return -1;
5775   }
5776   {
5777     char fstype[] = "ext2";
5778     char device[] = "/dev/sda1";
5779     int r;
5780     suppress_error = 0;
5781     r = guestfs_mkfs (g, fstype, device);
5782     if (r == -1)
5783       return -1;
5784   }
5785   {
5786     char device[] = "/dev/sda1";
5787     char mountpoint[] = "/";
5788     int r;
5789     suppress_error = 0;
5790     r = guestfs_mount (g, device, mountpoint);
5791     if (r == -1)
5792       return -1;
5793   }
5794   /* TestOutput for checksum (8) */
5795   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
5796   {
5797     char device[] = "/dev/sdd";
5798     char mountpoint[] = "/";
5799     int r;
5800     suppress_error = 0;
5801     r = guestfs_mount (g, device, mountpoint);
5802     if (r == -1)
5803       return -1;
5804   }
5805   {
5806     char csumtype[] = "md5";
5807     char path[] = "/known-3";
5808     char *r;
5809     suppress_error = 0;
5810     r = guestfs_checksum (g, csumtype, path);
5811     if (r == NULL)
5812       return -1;
5813     if (strcmp (r, expected) != 0) {
5814       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
5815       return -1;
5816     }
5817     free (r);
5818   }
5819   return 0;
5820 }
5821
5822 static int test_download_0_skip (void)
5823 {
5824   const char *str;
5825
5826   str = getenv ("SKIP_TEST_DOWNLOAD_0");
5827   if (str && strcmp (str, "1") == 0) return 1;
5828   str = getenv ("SKIP_TEST_DOWNLOAD");
5829   if (str && strcmp (str, "1") == 0) return 1;
5830   return 0;
5831 }
5832
5833 static int test_download_0 (void)
5834 {
5835   if (test_download_0_skip ()) {
5836     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5837     return 0;
5838   }
5839
5840   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5841   {
5842     char device[] = "/dev/sda";
5843     int r;
5844     suppress_error = 0;
5845     r = guestfs_blockdev_setrw (g, device);
5846     if (r == -1)
5847       return -1;
5848   }
5849   {
5850     int r;
5851     suppress_error = 0;
5852     r = guestfs_umount_all (g);
5853     if (r == -1)
5854       return -1;
5855   }
5856   {
5857     int r;
5858     suppress_error = 0;
5859     r = guestfs_lvm_remove_all (g);
5860     if (r == -1)
5861       return -1;
5862   }
5863   {
5864     char device[] = "/dev/sda";
5865     char lines_0[] = ",";
5866     char *lines[] = {
5867       lines_0,
5868       NULL
5869     };
5870     int r;
5871     suppress_error = 0;
5872     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5873     if (r == -1)
5874       return -1;
5875   }
5876   {
5877     char fstype[] = "ext2";
5878     char device[] = "/dev/sda1";
5879     int r;
5880     suppress_error = 0;
5881     r = guestfs_mkfs (g, fstype, device);
5882     if (r == -1)
5883       return -1;
5884   }
5885   {
5886     char device[] = "/dev/sda1";
5887     char mountpoint[] = "/";
5888     int r;
5889     suppress_error = 0;
5890     r = guestfs_mount (g, device, mountpoint);
5891     if (r == -1)
5892       return -1;
5893   }
5894   /* TestOutput for download (0) */
5895   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5896   {
5897     char remotefilename[] = "/COPYING.LIB";
5898     int r;
5899     suppress_error = 0;
5900     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5901     if (r == -1)
5902       return -1;
5903   }
5904   {
5905     char remotefilename[] = "/COPYING.LIB";
5906     int r;
5907     suppress_error = 0;
5908     r = guestfs_download (g, remotefilename, "testdownload.tmp");
5909     if (r == -1)
5910       return -1;
5911   }
5912   {
5913     char remotefilename[] = "/upload";
5914     int r;
5915     suppress_error = 0;
5916     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5917     if (r == -1)
5918       return -1;
5919   }
5920   {
5921     char csumtype[] = "md5";
5922     char path[] = "/upload";
5923     char *r;
5924     suppress_error = 0;
5925     r = guestfs_checksum (g, csumtype, path);
5926     if (r == NULL)
5927       return -1;
5928     if (strcmp (r, expected) != 0) {
5929       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5930       return -1;
5931     }
5932     free (r);
5933   }
5934   return 0;
5935 }
5936
5937 static int test_upload_0_skip (void)
5938 {
5939   const char *str;
5940
5941   str = getenv ("SKIP_TEST_UPLOAD_0");
5942   if (str && strcmp (str, "1") == 0) return 1;
5943   str = getenv ("SKIP_TEST_UPLOAD");
5944   if (str && strcmp (str, "1") == 0) return 1;
5945   return 0;
5946 }
5947
5948 static int test_upload_0 (void)
5949 {
5950   if (test_upload_0_skip ()) {
5951     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5952     return 0;
5953   }
5954
5955   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5956   {
5957     char device[] = "/dev/sda";
5958     int r;
5959     suppress_error = 0;
5960     r = guestfs_blockdev_setrw (g, device);
5961     if (r == -1)
5962       return -1;
5963   }
5964   {
5965     int r;
5966     suppress_error = 0;
5967     r = guestfs_umount_all (g);
5968     if (r == -1)
5969       return -1;
5970   }
5971   {
5972     int r;
5973     suppress_error = 0;
5974     r = guestfs_lvm_remove_all (g);
5975     if (r == -1)
5976       return -1;
5977   }
5978   {
5979     char device[] = "/dev/sda";
5980     char lines_0[] = ",";
5981     char *lines[] = {
5982       lines_0,
5983       NULL
5984     };
5985     int r;
5986     suppress_error = 0;
5987     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5988     if (r == -1)
5989       return -1;
5990   }
5991   {
5992     char fstype[] = "ext2";
5993     char device[] = "/dev/sda1";
5994     int r;
5995     suppress_error = 0;
5996     r = guestfs_mkfs (g, fstype, device);
5997     if (r == -1)
5998       return -1;
5999   }
6000   {
6001     char device[] = "/dev/sda1";
6002     char mountpoint[] = "/";
6003     int r;
6004     suppress_error = 0;
6005     r = guestfs_mount (g, device, mountpoint);
6006     if (r == -1)
6007       return -1;
6008   }
6009   /* TestOutput for upload (0) */
6010   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6011   {
6012     char remotefilename[] = "/COPYING.LIB";
6013     int r;
6014     suppress_error = 0;
6015     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6016     if (r == -1)
6017       return -1;
6018   }
6019   {
6020     char csumtype[] = "md5";
6021     char path[] = "/COPYING.LIB";
6022     char *r;
6023     suppress_error = 0;
6024     r = guestfs_checksum (g, csumtype, path);
6025     if (r == NULL)
6026       return -1;
6027     if (strcmp (r, expected) != 0) {
6028       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6029       return -1;
6030     }
6031     free (r);
6032   }
6033   return 0;
6034 }
6035
6036 static int test_blockdev_rereadpt_0_skip (void)
6037 {
6038   const char *str;
6039
6040   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6041   if (str && strcmp (str, "1") == 0) return 1;
6042   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6043   if (str && strcmp (str, "1") == 0) return 1;
6044   return 0;
6045 }
6046
6047 static int test_blockdev_rereadpt_0 (void)
6048 {
6049   if (test_blockdev_rereadpt_0_skip ()) {
6050     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6051     return 0;
6052   }
6053
6054   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6055   {
6056     char device[] = "/dev/sda";
6057     int r;
6058     suppress_error = 0;
6059     r = guestfs_blockdev_setrw (g, device);
6060     if (r == -1)
6061       return -1;
6062   }
6063   {
6064     int r;
6065     suppress_error = 0;
6066     r = guestfs_umount_all (g);
6067     if (r == -1)
6068       return -1;
6069   }
6070   {
6071     int r;
6072     suppress_error = 0;
6073     r = guestfs_lvm_remove_all (g);
6074     if (r == -1)
6075       return -1;
6076   }
6077   /* TestRun for blockdev_rereadpt (0) */
6078   {
6079     char device[] = "/dev/sda";
6080     int r;
6081     suppress_error = 0;
6082     r = guestfs_blockdev_rereadpt (g, device);
6083     if (r == -1)
6084       return -1;
6085   }
6086   return 0;
6087 }
6088
6089 static int test_blockdev_flushbufs_0_skip (void)
6090 {
6091   const char *str;
6092
6093   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6094   if (str && strcmp (str, "1") == 0) return 1;
6095   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6096   if (str && strcmp (str, "1") == 0) return 1;
6097   return 0;
6098 }
6099
6100 static int test_blockdev_flushbufs_0 (void)
6101 {
6102   if (test_blockdev_flushbufs_0_skip ()) {
6103     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6104     return 0;
6105   }
6106
6107   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6108   {
6109     char device[] = "/dev/sda";
6110     int r;
6111     suppress_error = 0;
6112     r = guestfs_blockdev_setrw (g, device);
6113     if (r == -1)
6114       return -1;
6115   }
6116   {
6117     int r;
6118     suppress_error = 0;
6119     r = guestfs_umount_all (g);
6120     if (r == -1)
6121       return -1;
6122   }
6123   {
6124     int r;
6125     suppress_error = 0;
6126     r = guestfs_lvm_remove_all (g);
6127     if (r == -1)
6128       return -1;
6129   }
6130   /* TestRun for blockdev_flushbufs (0) */
6131   {
6132     char device[] = "/dev/sda";
6133     int r;
6134     suppress_error = 0;
6135     r = guestfs_blockdev_flushbufs (g, device);
6136     if (r == -1)
6137       return -1;
6138   }
6139   return 0;
6140 }
6141
6142 static int test_blockdev_getsize64_0_skip (void)
6143 {
6144   const char *str;
6145
6146   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6147   if (str && strcmp (str, "1") == 0) return 1;
6148   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6149   if (str && strcmp (str, "1") == 0) return 1;
6150   return 0;
6151 }
6152
6153 static int test_blockdev_getsize64_0 (void)
6154 {
6155   if (test_blockdev_getsize64_0_skip ()) {
6156     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6157     return 0;
6158   }
6159
6160   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6161   {
6162     char device[] = "/dev/sda";
6163     int r;
6164     suppress_error = 0;
6165     r = guestfs_blockdev_setrw (g, device);
6166     if (r == -1)
6167       return -1;
6168   }
6169   {
6170     int r;
6171     suppress_error = 0;
6172     r = guestfs_umount_all (g);
6173     if (r == -1)
6174       return -1;
6175   }
6176   {
6177     int r;
6178     suppress_error = 0;
6179     r = guestfs_lvm_remove_all (g);
6180     if (r == -1)
6181       return -1;
6182   }
6183   /* TestOutputInt for blockdev_getsize64 (0) */
6184   {
6185     char device[] = "/dev/sda";
6186     int64_t r;
6187     suppress_error = 0;
6188     r = guestfs_blockdev_getsize64 (g, device);
6189     if (r == -1)
6190       return -1;
6191     if (r != 524288000) {
6192       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6193       return -1;
6194     }
6195   }
6196   return 0;
6197 }
6198
6199 static int test_blockdev_getsz_0_skip (void)
6200 {
6201   const char *str;
6202
6203   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6204   if (str && strcmp (str, "1") == 0) return 1;
6205   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6206   if (str && strcmp (str, "1") == 0) return 1;
6207   return 0;
6208 }
6209
6210 static int test_blockdev_getsz_0 (void)
6211 {
6212   if (test_blockdev_getsz_0_skip ()) {
6213     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6214     return 0;
6215   }
6216
6217   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6218   {
6219     char device[] = "/dev/sda";
6220     int r;
6221     suppress_error = 0;
6222     r = guestfs_blockdev_setrw (g, device);
6223     if (r == -1)
6224       return -1;
6225   }
6226   {
6227     int r;
6228     suppress_error = 0;
6229     r = guestfs_umount_all (g);
6230     if (r == -1)
6231       return -1;
6232   }
6233   {
6234     int r;
6235     suppress_error = 0;
6236     r = guestfs_lvm_remove_all (g);
6237     if (r == -1)
6238       return -1;
6239   }
6240   /* TestOutputInt for blockdev_getsz (0) */
6241   {
6242     char device[] = "/dev/sda";
6243     int64_t r;
6244     suppress_error = 0;
6245     r = guestfs_blockdev_getsz (g, device);
6246     if (r == -1)
6247       return -1;
6248     if (r != 1024000) {
6249       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6250       return -1;
6251     }
6252   }
6253   return 0;
6254 }
6255
6256 static int test_blockdev_getbsz_0_skip (void)
6257 {
6258   const char *str;
6259
6260   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6261   if (str && strcmp (str, "1") == 0) return 1;
6262   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6263   if (str && strcmp (str, "1") == 0) return 1;
6264   return 0;
6265 }
6266
6267 static int test_blockdev_getbsz_0 (void)
6268 {
6269   if (test_blockdev_getbsz_0_skip ()) {
6270     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6271     return 0;
6272   }
6273
6274   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6275   {
6276     char device[] = "/dev/sda";
6277     int r;
6278     suppress_error = 0;
6279     r = guestfs_blockdev_setrw (g, device);
6280     if (r == -1)
6281       return -1;
6282   }
6283   {
6284     int r;
6285     suppress_error = 0;
6286     r = guestfs_umount_all (g);
6287     if (r == -1)
6288       return -1;
6289   }
6290   {
6291     int r;
6292     suppress_error = 0;
6293     r = guestfs_lvm_remove_all (g);
6294     if (r == -1)
6295       return -1;
6296   }
6297   /* TestOutputInt for blockdev_getbsz (0) */
6298   {
6299     char device[] = "/dev/sda";
6300     int r;
6301     suppress_error = 0;
6302     r = guestfs_blockdev_getbsz (g, device);
6303     if (r == -1)
6304       return -1;
6305     if (r != 4096) {
6306       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6307       return -1;
6308     }
6309   }
6310   return 0;
6311 }
6312
6313 static int test_blockdev_getss_0_skip (void)
6314 {
6315   const char *str;
6316
6317   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6318   if (str && strcmp (str, "1") == 0) return 1;
6319   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6320   if (str && strcmp (str, "1") == 0) return 1;
6321   return 0;
6322 }
6323
6324 static int test_blockdev_getss_0 (void)
6325 {
6326   if (test_blockdev_getss_0_skip ()) {
6327     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6328     return 0;
6329   }
6330
6331   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6332   {
6333     char device[] = "/dev/sda";
6334     int r;
6335     suppress_error = 0;
6336     r = guestfs_blockdev_setrw (g, device);
6337     if (r == -1)
6338       return -1;
6339   }
6340   {
6341     int r;
6342     suppress_error = 0;
6343     r = guestfs_umount_all (g);
6344     if (r == -1)
6345       return -1;
6346   }
6347   {
6348     int r;
6349     suppress_error = 0;
6350     r = guestfs_lvm_remove_all (g);
6351     if (r == -1)
6352       return -1;
6353   }
6354   /* TestOutputInt for blockdev_getss (0) */
6355   {
6356     char device[] = "/dev/sda";
6357     int r;
6358     suppress_error = 0;
6359     r = guestfs_blockdev_getss (g, device);
6360     if (r == -1)
6361       return -1;
6362     if (r != 512) {
6363       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6364       return -1;
6365     }
6366   }
6367   return 0;
6368 }
6369
6370 static int test_blockdev_getro_0_skip (void)
6371 {
6372   const char *str;
6373
6374   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6375   if (str && strcmp (str, "1") == 0) return 1;
6376   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6377   if (str && strcmp (str, "1") == 0) return 1;
6378   return 0;
6379 }
6380
6381 static int test_blockdev_getro_0 (void)
6382 {
6383   if (test_blockdev_getro_0_skip ()) {
6384     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6385     return 0;
6386   }
6387
6388   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6389   {
6390     char device[] = "/dev/sda";
6391     int r;
6392     suppress_error = 0;
6393     r = guestfs_blockdev_setrw (g, device);
6394     if (r == -1)
6395       return -1;
6396   }
6397   {
6398     int r;
6399     suppress_error = 0;
6400     r = guestfs_umount_all (g);
6401     if (r == -1)
6402       return -1;
6403   }
6404   {
6405     int r;
6406     suppress_error = 0;
6407     r = guestfs_lvm_remove_all (g);
6408     if (r == -1)
6409       return -1;
6410   }
6411   /* TestOutputTrue for blockdev_getro (0) */
6412   {
6413     char device[] = "/dev/sda";
6414     int r;
6415     suppress_error = 0;
6416     r = guestfs_blockdev_setro (g, device);
6417     if (r == -1)
6418       return -1;
6419   }
6420   {
6421     char device[] = "/dev/sda";
6422     int r;
6423     suppress_error = 0;
6424     r = guestfs_blockdev_getro (g, device);
6425     if (r == -1)
6426       return -1;
6427     if (!r) {
6428       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6429       return -1;
6430     }
6431   }
6432   return 0;
6433 }
6434
6435 static int test_blockdev_setrw_0_skip (void)
6436 {
6437   const char *str;
6438
6439   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6440   if (str && strcmp (str, "1") == 0) return 1;
6441   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6442   if (str && strcmp (str, "1") == 0) return 1;
6443   return 0;
6444 }
6445
6446 static int test_blockdev_setrw_0 (void)
6447 {
6448   if (test_blockdev_setrw_0_skip ()) {
6449     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6450     return 0;
6451   }
6452
6453   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
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   /* TestOutputFalse for blockdev_setrw (0) */
6477   {
6478     char device[] = "/dev/sda";
6479     int r;
6480     suppress_error = 0;
6481     r = guestfs_blockdev_setrw (g, device);
6482     if (r == -1)
6483       return -1;
6484   }
6485   {
6486     char device[] = "/dev/sda";
6487     int r;
6488     suppress_error = 0;
6489     r = guestfs_blockdev_getro (g, device);
6490     if (r == -1)
6491       return -1;
6492     if (r) {
6493       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6494       return -1;
6495     }
6496   }
6497   return 0;
6498 }
6499
6500 static int test_blockdev_setro_0_skip (void)
6501 {
6502   const char *str;
6503
6504   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6505   if (str && strcmp (str, "1") == 0) return 1;
6506   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6507   if (str && strcmp (str, "1") == 0) return 1;
6508   return 0;
6509 }
6510
6511 static int test_blockdev_setro_0 (void)
6512 {
6513   if (test_blockdev_setro_0_skip ()) {
6514     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6515     return 0;
6516   }
6517
6518   /* InitNone|InitEmpty for test_blockdev_setro_0 */
6519   {
6520     char device[] = "/dev/sda";
6521     int r;
6522     suppress_error = 0;
6523     r = guestfs_blockdev_setrw (g, device);
6524     if (r == -1)
6525       return -1;
6526   }
6527   {
6528     int r;
6529     suppress_error = 0;
6530     r = guestfs_umount_all (g);
6531     if (r == -1)
6532       return -1;
6533   }
6534   {
6535     int r;
6536     suppress_error = 0;
6537     r = guestfs_lvm_remove_all (g);
6538     if (r == -1)
6539       return -1;
6540   }
6541   /* TestOutputTrue for blockdev_setro (0) */
6542   {
6543     char device[] = "/dev/sda";
6544     int r;
6545     suppress_error = 0;
6546     r = guestfs_blockdev_setro (g, device);
6547     if (r == -1)
6548       return -1;
6549   }
6550   {
6551     char device[] = "/dev/sda";
6552     int r;
6553     suppress_error = 0;
6554     r = guestfs_blockdev_getro (g, device);
6555     if (r == -1)
6556       return -1;
6557     if (!r) {
6558       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6559       return -1;
6560     }
6561   }
6562   return 0;
6563 }
6564
6565 static int test_statvfs_0_skip (void)
6566 {
6567   const char *str;
6568
6569   str = getenv ("SKIP_TEST_STATVFS_0");
6570   if (str && strcmp (str, "1") == 0) return 1;
6571   str = getenv ("SKIP_TEST_STATVFS");
6572   if (str && strcmp (str, "1") == 0) return 1;
6573   return 0;
6574 }
6575
6576 static int test_statvfs_0 (void)
6577 {
6578   if (test_statvfs_0_skip ()) {
6579     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6580     return 0;
6581   }
6582
6583   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6584   {
6585     char device[] = "/dev/sda";
6586     int r;
6587     suppress_error = 0;
6588     r = guestfs_blockdev_setrw (g, device);
6589     if (r == -1)
6590       return -1;
6591   }
6592   {
6593     int r;
6594     suppress_error = 0;
6595     r = guestfs_umount_all (g);
6596     if (r == -1)
6597       return -1;
6598   }
6599   {
6600     int r;
6601     suppress_error = 0;
6602     r = guestfs_lvm_remove_all (g);
6603     if (r == -1)
6604       return -1;
6605   }
6606   {
6607     char device[] = "/dev/sda";
6608     char lines_0[] = ",";
6609     char *lines[] = {
6610       lines_0,
6611       NULL
6612     };
6613     int r;
6614     suppress_error = 0;
6615     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6616     if (r == -1)
6617       return -1;
6618   }
6619   {
6620     char fstype[] = "ext2";
6621     char device[] = "/dev/sda1";
6622     int r;
6623     suppress_error = 0;
6624     r = guestfs_mkfs (g, fstype, device);
6625     if (r == -1)
6626       return -1;
6627   }
6628   {
6629     char device[] = "/dev/sda1";
6630     char mountpoint[] = "/";
6631     int r;
6632     suppress_error = 0;
6633     r = guestfs_mount (g, device, mountpoint);
6634     if (r == -1)
6635       return -1;
6636   }
6637   /* TestOutputStruct for statvfs (0) */
6638   {
6639     char path[] = "/";
6640     struct guestfs_statvfs *r;
6641     suppress_error = 0;
6642     r = guestfs_statvfs (g, path);
6643     if (r == NULL)
6644       return -1;
6645     if (r->bfree != 487702) {
6646       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6647                (int) r->bfree);
6648       return -1;
6649     }
6650     if (r->blocks != 490020) {
6651       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6652                (int) r->blocks);
6653       return -1;
6654     }
6655     if (r->bsize != 1024) {
6656       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6657                (int) r->bsize);
6658       return -1;
6659     }
6660     free (r);
6661   }
6662   return 0;
6663 }
6664
6665 static int test_lstat_0_skip (void)
6666 {
6667   const char *str;
6668
6669   str = getenv ("SKIP_TEST_LSTAT_0");
6670   if (str && strcmp (str, "1") == 0) return 1;
6671   str = getenv ("SKIP_TEST_LSTAT");
6672   if (str && strcmp (str, "1") == 0) return 1;
6673   return 0;
6674 }
6675
6676 static int test_lstat_0 (void)
6677 {
6678   if (test_lstat_0_skip ()) {
6679     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6680     return 0;
6681   }
6682
6683   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6684   {
6685     char device[] = "/dev/sda";
6686     int r;
6687     suppress_error = 0;
6688     r = guestfs_blockdev_setrw (g, device);
6689     if (r == -1)
6690       return -1;
6691   }
6692   {
6693     int r;
6694     suppress_error = 0;
6695     r = guestfs_umount_all (g);
6696     if (r == -1)
6697       return -1;
6698   }
6699   {
6700     int r;
6701     suppress_error = 0;
6702     r = guestfs_lvm_remove_all (g);
6703     if (r == -1)
6704       return -1;
6705   }
6706   {
6707     char device[] = "/dev/sda";
6708     char lines_0[] = ",";
6709     char *lines[] = {
6710       lines_0,
6711       NULL
6712     };
6713     int r;
6714     suppress_error = 0;
6715     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6716     if (r == -1)
6717       return -1;
6718   }
6719   {
6720     char fstype[] = "ext2";
6721     char device[] = "/dev/sda1";
6722     int r;
6723     suppress_error = 0;
6724     r = guestfs_mkfs (g, fstype, device);
6725     if (r == -1)
6726       return -1;
6727   }
6728   {
6729     char device[] = "/dev/sda1";
6730     char mountpoint[] = "/";
6731     int r;
6732     suppress_error = 0;
6733     r = guestfs_mount (g, device, mountpoint);
6734     if (r == -1)
6735       return -1;
6736   }
6737   /* TestOutputStruct for lstat (0) */
6738   {
6739     char path[] = "/new";
6740     int r;
6741     suppress_error = 0;
6742     r = guestfs_touch (g, path);
6743     if (r == -1)
6744       return -1;
6745   }
6746   {
6747     char path[] = "/new";
6748     struct guestfs_stat *r;
6749     suppress_error = 0;
6750     r = guestfs_lstat (g, path);
6751     if (r == NULL)
6752       return -1;
6753     if (r->size != 0) {
6754       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6755                (int) r->size);
6756       return -1;
6757     }
6758     free (r);
6759   }
6760   return 0;
6761 }
6762
6763 static int test_stat_0_skip (void)
6764 {
6765   const char *str;
6766
6767   str = getenv ("SKIP_TEST_STAT_0");
6768   if (str && strcmp (str, "1") == 0) return 1;
6769   str = getenv ("SKIP_TEST_STAT");
6770   if (str && strcmp (str, "1") == 0) return 1;
6771   return 0;
6772 }
6773
6774 static int test_stat_0 (void)
6775 {
6776   if (test_stat_0_skip ()) {
6777     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6778     return 0;
6779   }
6780
6781   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6782   {
6783     char device[] = "/dev/sda";
6784     int r;
6785     suppress_error = 0;
6786     r = guestfs_blockdev_setrw (g, device);
6787     if (r == -1)
6788       return -1;
6789   }
6790   {
6791     int r;
6792     suppress_error = 0;
6793     r = guestfs_umount_all (g);
6794     if (r == -1)
6795       return -1;
6796   }
6797   {
6798     int r;
6799     suppress_error = 0;
6800     r = guestfs_lvm_remove_all (g);
6801     if (r == -1)
6802       return -1;
6803   }
6804   {
6805     char device[] = "/dev/sda";
6806     char lines_0[] = ",";
6807     char *lines[] = {
6808       lines_0,
6809       NULL
6810     };
6811     int r;
6812     suppress_error = 0;
6813     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6814     if (r == -1)
6815       return -1;
6816   }
6817   {
6818     char fstype[] = "ext2";
6819     char device[] = "/dev/sda1";
6820     int r;
6821     suppress_error = 0;
6822     r = guestfs_mkfs (g, fstype, device);
6823     if (r == -1)
6824       return -1;
6825   }
6826   {
6827     char device[] = "/dev/sda1";
6828     char mountpoint[] = "/";
6829     int r;
6830     suppress_error = 0;
6831     r = guestfs_mount (g, device, mountpoint);
6832     if (r == -1)
6833       return -1;
6834   }
6835   /* TestOutputStruct for stat (0) */
6836   {
6837     char path[] = "/new";
6838     int r;
6839     suppress_error = 0;
6840     r = guestfs_touch (g, path);
6841     if (r == -1)
6842       return -1;
6843   }
6844   {
6845     char path[] = "/new";
6846     struct guestfs_stat *r;
6847     suppress_error = 0;
6848     r = guestfs_stat (g, path);
6849     if (r == NULL)
6850       return -1;
6851     if (r->size != 0) {
6852       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6853                (int) r->size);
6854       return -1;
6855     }
6856     free (r);
6857   }
6858   return 0;
6859 }
6860
6861 static int test_command_lines_0_skip (void)
6862 {
6863   const char *str;
6864
6865   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6866   if (str && strcmp (str, "1") == 0) return 1;
6867   str = getenv ("SKIP_TEST_COMMAND_LINES");
6868   if (str && strcmp (str, "1") == 0) return 1;
6869   return 0;
6870 }
6871
6872 static int test_command_lines_0 (void)
6873 {
6874   if (test_command_lines_0_skip ()) {
6875     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6876     return 0;
6877   }
6878
6879   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6880   {
6881     char device[] = "/dev/sda";
6882     int r;
6883     suppress_error = 0;
6884     r = guestfs_blockdev_setrw (g, device);
6885     if (r == -1)
6886       return -1;
6887   }
6888   {
6889     int r;
6890     suppress_error = 0;
6891     r = guestfs_umount_all (g);
6892     if (r == -1)
6893       return -1;
6894   }
6895   {
6896     int r;
6897     suppress_error = 0;
6898     r = guestfs_lvm_remove_all (g);
6899     if (r == -1)
6900       return -1;
6901   }
6902   {
6903     char device[] = "/dev/sda";
6904     char lines_0[] = ",";
6905     char *lines[] = {
6906       lines_0,
6907       NULL
6908     };
6909     int r;
6910     suppress_error = 0;
6911     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6912     if (r == -1)
6913       return -1;
6914   }
6915   {
6916     char fstype[] = "ext2";
6917     char device[] = "/dev/sda1";
6918     int r;
6919     suppress_error = 0;
6920     r = guestfs_mkfs (g, fstype, device);
6921     if (r == -1)
6922       return -1;
6923   }
6924   {
6925     char device[] = "/dev/sda1";
6926     char mountpoint[] = "/";
6927     int r;
6928     suppress_error = 0;
6929     r = guestfs_mount (g, device, mountpoint);
6930     if (r == -1)
6931       return -1;
6932   }
6933   /* TestOutputList for command_lines (0) */
6934   {
6935     char remotefilename[] = "/test-command";
6936     int r;
6937     suppress_error = 0;
6938     r = guestfs_upload (g, "test-command", remotefilename);
6939     if (r == -1)
6940       return -1;
6941   }
6942   {
6943     char path[] = "/test-command";
6944     int r;
6945     suppress_error = 0;
6946     r = guestfs_chmod (g, 493, path);
6947     if (r == -1)
6948       return -1;
6949   }
6950   {
6951     char arguments_0[] = "/test-command";
6952     char arguments_1[] = "1";
6953     char *arguments[] = {
6954       arguments_0,
6955       arguments_1,
6956       NULL
6957     };
6958     char **r;
6959     int i;
6960     suppress_error = 0;
6961     r = guestfs_command_lines (g, arguments);
6962     if (r == NULL)
6963       return -1;
6964     if (!r[0]) {
6965       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
6966       print_strings (r);
6967       return -1;
6968     }
6969     {
6970       char expected[] = "Result1";
6971       if (strcmp (r[0], expected) != 0) {
6972         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6973         return -1;
6974       }
6975     }
6976     if (r[1] != NULL) {
6977       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
6978       print_strings (r);
6979       return -1;
6980     }
6981     for (i = 0; r[i] != NULL; ++i)
6982       free (r[i]);
6983     free (r);
6984   }
6985   return 0;
6986 }
6987
6988 static int test_command_lines_1_skip (void)
6989 {
6990   const char *str;
6991
6992   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
6993   if (str && strcmp (str, "1") == 0) return 1;
6994   str = getenv ("SKIP_TEST_COMMAND_LINES");
6995   if (str && strcmp (str, "1") == 0) return 1;
6996   return 0;
6997 }
6998
6999 static int test_command_lines_1 (void)
7000 {
7001   if (test_command_lines_1_skip ()) {
7002     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7003     return 0;
7004   }
7005
7006   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7007   {
7008     char device[] = "/dev/sda";
7009     int r;
7010     suppress_error = 0;
7011     r = guestfs_blockdev_setrw (g, device);
7012     if (r == -1)
7013       return -1;
7014   }
7015   {
7016     int r;
7017     suppress_error = 0;
7018     r = guestfs_umount_all (g);
7019     if (r == -1)
7020       return -1;
7021   }
7022   {
7023     int r;
7024     suppress_error = 0;
7025     r = guestfs_lvm_remove_all (g);
7026     if (r == -1)
7027       return -1;
7028   }
7029   {
7030     char device[] = "/dev/sda";
7031     char lines_0[] = ",";
7032     char *lines[] = {
7033       lines_0,
7034       NULL
7035     };
7036     int r;
7037     suppress_error = 0;
7038     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7039     if (r == -1)
7040       return -1;
7041   }
7042   {
7043     char fstype[] = "ext2";
7044     char device[] = "/dev/sda1";
7045     int r;
7046     suppress_error = 0;
7047     r = guestfs_mkfs (g, fstype, device);
7048     if (r == -1)
7049       return -1;
7050   }
7051   {
7052     char device[] = "/dev/sda1";
7053     char mountpoint[] = "/";
7054     int r;
7055     suppress_error = 0;
7056     r = guestfs_mount (g, device, mountpoint);
7057     if (r == -1)
7058       return -1;
7059   }
7060   /* TestOutputList for command_lines (1) */
7061   {
7062     char remotefilename[] = "/test-command";
7063     int r;
7064     suppress_error = 0;
7065     r = guestfs_upload (g, "test-command", remotefilename);
7066     if (r == -1)
7067       return -1;
7068   }
7069   {
7070     char path[] = "/test-command";
7071     int r;
7072     suppress_error = 0;
7073     r = guestfs_chmod (g, 493, path);
7074     if (r == -1)
7075       return -1;
7076   }
7077   {
7078     char arguments_0[] = "/test-command";
7079     char arguments_1[] = "2";
7080     char *arguments[] = {
7081       arguments_0,
7082       arguments_1,
7083       NULL
7084     };
7085     char **r;
7086     int i;
7087     suppress_error = 0;
7088     r = guestfs_command_lines (g, arguments);
7089     if (r == NULL)
7090       return -1;
7091     if (!r[0]) {
7092       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7093       print_strings (r);
7094       return -1;
7095     }
7096     {
7097       char expected[] = "Result2";
7098       if (strcmp (r[0], expected) != 0) {
7099         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7100         return -1;
7101       }
7102     }
7103     if (r[1] != NULL) {
7104       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7105       print_strings (r);
7106       return -1;
7107     }
7108     for (i = 0; r[i] != NULL; ++i)
7109       free (r[i]);
7110     free (r);
7111   }
7112   return 0;
7113 }
7114
7115 static int test_command_lines_2_skip (void)
7116 {
7117   const char *str;
7118
7119   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7120   if (str && strcmp (str, "1") == 0) return 1;
7121   str = getenv ("SKIP_TEST_COMMAND_LINES");
7122   if (str && strcmp (str, "1") == 0) return 1;
7123   return 0;
7124 }
7125
7126 static int test_command_lines_2 (void)
7127 {
7128   if (test_command_lines_2_skip ()) {
7129     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7130     return 0;
7131   }
7132
7133   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7134   {
7135     char device[] = "/dev/sda";
7136     int r;
7137     suppress_error = 0;
7138     r = guestfs_blockdev_setrw (g, device);
7139     if (r == -1)
7140       return -1;
7141   }
7142   {
7143     int r;
7144     suppress_error = 0;
7145     r = guestfs_umount_all (g);
7146     if (r == -1)
7147       return -1;
7148   }
7149   {
7150     int r;
7151     suppress_error = 0;
7152     r = guestfs_lvm_remove_all (g);
7153     if (r == -1)
7154       return -1;
7155   }
7156   {
7157     char device[] = "/dev/sda";
7158     char lines_0[] = ",";
7159     char *lines[] = {
7160       lines_0,
7161       NULL
7162     };
7163     int r;
7164     suppress_error = 0;
7165     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7166     if (r == -1)
7167       return -1;
7168   }
7169   {
7170     char fstype[] = "ext2";
7171     char device[] = "/dev/sda1";
7172     int r;
7173     suppress_error = 0;
7174     r = guestfs_mkfs (g, fstype, device);
7175     if (r == -1)
7176       return -1;
7177   }
7178   {
7179     char device[] = "/dev/sda1";
7180     char mountpoint[] = "/";
7181     int r;
7182     suppress_error = 0;
7183     r = guestfs_mount (g, device, mountpoint);
7184     if (r == -1)
7185       return -1;
7186   }
7187   /* TestOutputList for command_lines (2) */
7188   {
7189     char remotefilename[] = "/test-command";
7190     int r;
7191     suppress_error = 0;
7192     r = guestfs_upload (g, "test-command", remotefilename);
7193     if (r == -1)
7194       return -1;
7195   }
7196   {
7197     char path[] = "/test-command";
7198     int r;
7199     suppress_error = 0;
7200     r = guestfs_chmod (g, 493, path);
7201     if (r == -1)
7202       return -1;
7203   }
7204   {
7205     char arguments_0[] = "/test-command";
7206     char arguments_1[] = "3";
7207     char *arguments[] = {
7208       arguments_0,
7209       arguments_1,
7210       NULL
7211     };
7212     char **r;
7213     int i;
7214     suppress_error = 0;
7215     r = guestfs_command_lines (g, arguments);
7216     if (r == NULL)
7217       return -1;
7218     if (!r[0]) {
7219       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7220       print_strings (r);
7221       return -1;
7222     }
7223     {
7224       char expected[] = "";
7225       if (strcmp (r[0], expected) != 0) {
7226         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7227         return -1;
7228       }
7229     }
7230     if (!r[1]) {
7231       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7232       print_strings (r);
7233       return -1;
7234     }
7235     {
7236       char expected[] = "Result3";
7237       if (strcmp (r[1], expected) != 0) {
7238         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7239         return -1;
7240       }
7241     }
7242     if (r[2] != NULL) {
7243       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7244       print_strings (r);
7245       return -1;
7246     }
7247     for (i = 0; r[i] != NULL; ++i)
7248       free (r[i]);
7249     free (r);
7250   }
7251   return 0;
7252 }
7253
7254 static int test_command_lines_3_skip (void)
7255 {
7256   const char *str;
7257
7258   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7259   if (str && strcmp (str, "1") == 0) return 1;
7260   str = getenv ("SKIP_TEST_COMMAND_LINES");
7261   if (str && strcmp (str, "1") == 0) return 1;
7262   return 0;
7263 }
7264
7265 static int test_command_lines_3 (void)
7266 {
7267   if (test_command_lines_3_skip ()) {
7268     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7269     return 0;
7270   }
7271
7272   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7273   {
7274     char device[] = "/dev/sda";
7275     int r;
7276     suppress_error = 0;
7277     r = guestfs_blockdev_setrw (g, device);
7278     if (r == -1)
7279       return -1;
7280   }
7281   {
7282     int r;
7283     suppress_error = 0;
7284     r = guestfs_umount_all (g);
7285     if (r == -1)
7286       return -1;
7287   }
7288   {
7289     int r;
7290     suppress_error = 0;
7291     r = guestfs_lvm_remove_all (g);
7292     if (r == -1)
7293       return -1;
7294   }
7295   {
7296     char device[] = "/dev/sda";
7297     char lines_0[] = ",";
7298     char *lines[] = {
7299       lines_0,
7300       NULL
7301     };
7302     int r;
7303     suppress_error = 0;
7304     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7305     if (r == -1)
7306       return -1;
7307   }
7308   {
7309     char fstype[] = "ext2";
7310     char device[] = "/dev/sda1";
7311     int r;
7312     suppress_error = 0;
7313     r = guestfs_mkfs (g, fstype, device);
7314     if (r == -1)
7315       return -1;
7316   }
7317   {
7318     char device[] = "/dev/sda1";
7319     char mountpoint[] = "/";
7320     int r;
7321     suppress_error = 0;
7322     r = guestfs_mount (g, device, mountpoint);
7323     if (r == -1)
7324       return -1;
7325   }
7326   /* TestOutputList for command_lines (3) */
7327   {
7328     char remotefilename[] = "/test-command";
7329     int r;
7330     suppress_error = 0;
7331     r = guestfs_upload (g, "test-command", remotefilename);
7332     if (r == -1)
7333       return -1;
7334   }
7335   {
7336     char path[] = "/test-command";
7337     int r;
7338     suppress_error = 0;
7339     r = guestfs_chmod (g, 493, path);
7340     if (r == -1)
7341       return -1;
7342   }
7343   {
7344     char arguments_0[] = "/test-command";
7345     char arguments_1[] = "4";
7346     char *arguments[] = {
7347       arguments_0,
7348       arguments_1,
7349       NULL
7350     };
7351     char **r;
7352     int i;
7353     suppress_error = 0;
7354     r = guestfs_command_lines (g, arguments);
7355     if (r == NULL)
7356       return -1;
7357     if (!r[0]) {
7358       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7359       print_strings (r);
7360       return -1;
7361     }
7362     {
7363       char expected[] = "";
7364       if (strcmp (r[0], expected) != 0) {
7365         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7366         return -1;
7367       }
7368     }
7369     if (!r[1]) {
7370       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7371       print_strings (r);
7372       return -1;
7373     }
7374     {
7375       char expected[] = "Result4";
7376       if (strcmp (r[1], expected) != 0) {
7377         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7378         return -1;
7379       }
7380     }
7381     if (r[2] != NULL) {
7382       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7383       print_strings (r);
7384       return -1;
7385     }
7386     for (i = 0; r[i] != NULL; ++i)
7387       free (r[i]);
7388     free (r);
7389   }
7390   return 0;
7391 }
7392
7393 static int test_command_lines_4_skip (void)
7394 {
7395   const char *str;
7396
7397   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7398   if (str && strcmp (str, "1") == 0) return 1;
7399   str = getenv ("SKIP_TEST_COMMAND_LINES");
7400   if (str && strcmp (str, "1") == 0) return 1;
7401   return 0;
7402 }
7403
7404 static int test_command_lines_4 (void)
7405 {
7406   if (test_command_lines_4_skip ()) {
7407     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7408     return 0;
7409   }
7410
7411   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7412   {
7413     char device[] = "/dev/sda";
7414     int r;
7415     suppress_error = 0;
7416     r = guestfs_blockdev_setrw (g, device);
7417     if (r == -1)
7418       return -1;
7419   }
7420   {
7421     int r;
7422     suppress_error = 0;
7423     r = guestfs_umount_all (g);
7424     if (r == -1)
7425       return -1;
7426   }
7427   {
7428     int r;
7429     suppress_error = 0;
7430     r = guestfs_lvm_remove_all (g);
7431     if (r == -1)
7432       return -1;
7433   }
7434   {
7435     char device[] = "/dev/sda";
7436     char lines_0[] = ",";
7437     char *lines[] = {
7438       lines_0,
7439       NULL
7440     };
7441     int r;
7442     suppress_error = 0;
7443     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7444     if (r == -1)
7445       return -1;
7446   }
7447   {
7448     char fstype[] = "ext2";
7449     char device[] = "/dev/sda1";
7450     int r;
7451     suppress_error = 0;
7452     r = guestfs_mkfs (g, fstype, device);
7453     if (r == -1)
7454       return -1;
7455   }
7456   {
7457     char device[] = "/dev/sda1";
7458     char mountpoint[] = "/";
7459     int r;
7460     suppress_error = 0;
7461     r = guestfs_mount (g, device, mountpoint);
7462     if (r == -1)
7463       return -1;
7464   }
7465   /* TestOutputList for command_lines (4) */
7466   {
7467     char remotefilename[] = "/test-command";
7468     int r;
7469     suppress_error = 0;
7470     r = guestfs_upload (g, "test-command", remotefilename);
7471     if (r == -1)
7472       return -1;
7473   }
7474   {
7475     char path[] = "/test-command";
7476     int r;
7477     suppress_error = 0;
7478     r = guestfs_chmod (g, 493, path);
7479     if (r == -1)
7480       return -1;
7481   }
7482   {
7483     char arguments_0[] = "/test-command";
7484     char arguments_1[] = "5";
7485     char *arguments[] = {
7486       arguments_0,
7487       arguments_1,
7488       NULL
7489     };
7490     char **r;
7491     int i;
7492     suppress_error = 0;
7493     r = guestfs_command_lines (g, arguments);
7494     if (r == NULL)
7495       return -1;
7496     if (!r[0]) {
7497       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7498       print_strings (r);
7499       return -1;
7500     }
7501     {
7502       char expected[] = "";
7503       if (strcmp (r[0], expected) != 0) {
7504         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7505         return -1;
7506       }
7507     }
7508     if (!r[1]) {
7509       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7510       print_strings (r);
7511       return -1;
7512     }
7513     {
7514       char expected[] = "Result5";
7515       if (strcmp (r[1], expected) != 0) {
7516         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7517         return -1;
7518       }
7519     }
7520     if (!r[2]) {
7521       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7522       print_strings (r);
7523       return -1;
7524     }
7525     {
7526       char expected[] = "";
7527       if (strcmp (r[2], expected) != 0) {
7528         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7529         return -1;
7530       }
7531     }
7532     if (r[3] != NULL) {
7533       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7534       print_strings (r);
7535       return -1;
7536     }
7537     for (i = 0; r[i] != NULL; ++i)
7538       free (r[i]);
7539     free (r);
7540   }
7541   return 0;
7542 }
7543
7544 static int test_command_lines_5_skip (void)
7545 {
7546   const char *str;
7547
7548   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7549   if (str && strcmp (str, "1") == 0) return 1;
7550   str = getenv ("SKIP_TEST_COMMAND_LINES");
7551   if (str && strcmp (str, "1") == 0) return 1;
7552   return 0;
7553 }
7554
7555 static int test_command_lines_5 (void)
7556 {
7557   if (test_command_lines_5_skip ()) {
7558     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7559     return 0;
7560   }
7561
7562   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7563   {
7564     char device[] = "/dev/sda";
7565     int r;
7566     suppress_error = 0;
7567     r = guestfs_blockdev_setrw (g, device);
7568     if (r == -1)
7569       return -1;
7570   }
7571   {
7572     int r;
7573     suppress_error = 0;
7574     r = guestfs_umount_all (g);
7575     if (r == -1)
7576       return -1;
7577   }
7578   {
7579     int r;
7580     suppress_error = 0;
7581     r = guestfs_lvm_remove_all (g);
7582     if (r == -1)
7583       return -1;
7584   }
7585   {
7586     char device[] = "/dev/sda";
7587     char lines_0[] = ",";
7588     char *lines[] = {
7589       lines_0,
7590       NULL
7591     };
7592     int r;
7593     suppress_error = 0;
7594     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7595     if (r == -1)
7596       return -1;
7597   }
7598   {
7599     char fstype[] = "ext2";
7600     char device[] = "/dev/sda1";
7601     int r;
7602     suppress_error = 0;
7603     r = guestfs_mkfs (g, fstype, device);
7604     if (r == -1)
7605       return -1;
7606   }
7607   {
7608     char device[] = "/dev/sda1";
7609     char mountpoint[] = "/";
7610     int r;
7611     suppress_error = 0;
7612     r = guestfs_mount (g, device, mountpoint);
7613     if (r == -1)
7614       return -1;
7615   }
7616   /* TestOutputList for command_lines (5) */
7617   {
7618     char remotefilename[] = "/test-command";
7619     int r;
7620     suppress_error = 0;
7621     r = guestfs_upload (g, "test-command", remotefilename);
7622     if (r == -1)
7623       return -1;
7624   }
7625   {
7626     char path[] = "/test-command";
7627     int r;
7628     suppress_error = 0;
7629     r = guestfs_chmod (g, 493, path);
7630     if (r == -1)
7631       return -1;
7632   }
7633   {
7634     char arguments_0[] = "/test-command";
7635     char arguments_1[] = "6";
7636     char *arguments[] = {
7637       arguments_0,
7638       arguments_1,
7639       NULL
7640     };
7641     char **r;
7642     int i;
7643     suppress_error = 0;
7644     r = guestfs_command_lines (g, arguments);
7645     if (r == NULL)
7646       return -1;
7647     if (!r[0]) {
7648       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7649       print_strings (r);
7650       return -1;
7651     }
7652     {
7653       char expected[] = "";
7654       if (strcmp (r[0], expected) != 0) {
7655         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7656         return -1;
7657       }
7658     }
7659     if (!r[1]) {
7660       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7661       print_strings (r);
7662       return -1;
7663     }
7664     {
7665       char expected[] = "";
7666       if (strcmp (r[1], expected) != 0) {
7667         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7668         return -1;
7669       }
7670     }
7671     if (!r[2]) {
7672       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7673       print_strings (r);
7674       return -1;
7675     }
7676     {
7677       char expected[] = "Result6";
7678       if (strcmp (r[2], expected) != 0) {
7679         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7680         return -1;
7681       }
7682     }
7683     if (!r[3]) {
7684       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7685       print_strings (r);
7686       return -1;
7687     }
7688     {
7689       char expected[] = "";
7690       if (strcmp (r[3], expected) != 0) {
7691         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7692         return -1;
7693       }
7694     }
7695     if (r[4] != NULL) {
7696       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7697       print_strings (r);
7698       return -1;
7699     }
7700     for (i = 0; r[i] != NULL; ++i)
7701       free (r[i]);
7702     free (r);
7703   }
7704   return 0;
7705 }
7706
7707 static int test_command_lines_6_skip (void)
7708 {
7709   const char *str;
7710
7711   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7712   if (str && strcmp (str, "1") == 0) return 1;
7713   str = getenv ("SKIP_TEST_COMMAND_LINES");
7714   if (str && strcmp (str, "1") == 0) return 1;
7715   return 0;
7716 }
7717
7718 static int test_command_lines_6 (void)
7719 {
7720   if (test_command_lines_6_skip ()) {
7721     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7722     return 0;
7723   }
7724
7725   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7726   {
7727     char device[] = "/dev/sda";
7728     int r;
7729     suppress_error = 0;
7730     r = guestfs_blockdev_setrw (g, device);
7731     if (r == -1)
7732       return -1;
7733   }
7734   {
7735     int r;
7736     suppress_error = 0;
7737     r = guestfs_umount_all (g);
7738     if (r == -1)
7739       return -1;
7740   }
7741   {
7742     int r;
7743     suppress_error = 0;
7744     r = guestfs_lvm_remove_all (g);
7745     if (r == -1)
7746       return -1;
7747   }
7748   {
7749     char device[] = "/dev/sda";
7750     char lines_0[] = ",";
7751     char *lines[] = {
7752       lines_0,
7753       NULL
7754     };
7755     int r;
7756     suppress_error = 0;
7757     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7758     if (r == -1)
7759       return -1;
7760   }
7761   {
7762     char fstype[] = "ext2";
7763     char device[] = "/dev/sda1";
7764     int r;
7765     suppress_error = 0;
7766     r = guestfs_mkfs (g, fstype, device);
7767     if (r == -1)
7768       return -1;
7769   }
7770   {
7771     char device[] = "/dev/sda1";
7772     char mountpoint[] = "/";
7773     int r;
7774     suppress_error = 0;
7775     r = guestfs_mount (g, device, mountpoint);
7776     if (r == -1)
7777       return -1;
7778   }
7779   /* TestOutputList for command_lines (6) */
7780   {
7781     char remotefilename[] = "/test-command";
7782     int r;
7783     suppress_error = 0;
7784     r = guestfs_upload (g, "test-command", remotefilename);
7785     if (r == -1)
7786       return -1;
7787   }
7788   {
7789     char path[] = "/test-command";
7790     int r;
7791     suppress_error = 0;
7792     r = guestfs_chmod (g, 493, path);
7793     if (r == -1)
7794       return -1;
7795   }
7796   {
7797     char arguments_0[] = "/test-command";
7798     char arguments_1[] = "7";
7799     char *arguments[] = {
7800       arguments_0,
7801       arguments_1,
7802       NULL
7803     };
7804     char **r;
7805     int i;
7806     suppress_error = 0;
7807     r = guestfs_command_lines (g, arguments);
7808     if (r == NULL)
7809       return -1;
7810     if (r[0] != NULL) {
7811       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7812       print_strings (r);
7813       return -1;
7814     }
7815     for (i = 0; r[i] != NULL; ++i)
7816       free (r[i]);
7817     free (r);
7818   }
7819   return 0;
7820 }
7821
7822 static int test_command_lines_7_skip (void)
7823 {
7824   const char *str;
7825
7826   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7827   if (str && strcmp (str, "1") == 0) return 1;
7828   str = getenv ("SKIP_TEST_COMMAND_LINES");
7829   if (str && strcmp (str, "1") == 0) return 1;
7830   return 0;
7831 }
7832
7833 static int test_command_lines_7 (void)
7834 {
7835   if (test_command_lines_7_skip ()) {
7836     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7837     return 0;
7838   }
7839
7840   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7841   {
7842     char device[] = "/dev/sda";
7843     int r;
7844     suppress_error = 0;
7845     r = guestfs_blockdev_setrw (g, device);
7846     if (r == -1)
7847       return -1;
7848   }
7849   {
7850     int r;
7851     suppress_error = 0;
7852     r = guestfs_umount_all (g);
7853     if (r == -1)
7854       return -1;
7855   }
7856   {
7857     int r;
7858     suppress_error = 0;
7859     r = guestfs_lvm_remove_all (g);
7860     if (r == -1)
7861       return -1;
7862   }
7863   {
7864     char device[] = "/dev/sda";
7865     char lines_0[] = ",";
7866     char *lines[] = {
7867       lines_0,
7868       NULL
7869     };
7870     int r;
7871     suppress_error = 0;
7872     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7873     if (r == -1)
7874       return -1;
7875   }
7876   {
7877     char fstype[] = "ext2";
7878     char device[] = "/dev/sda1";
7879     int r;
7880     suppress_error = 0;
7881     r = guestfs_mkfs (g, fstype, device);
7882     if (r == -1)
7883       return -1;
7884   }
7885   {
7886     char device[] = "/dev/sda1";
7887     char mountpoint[] = "/";
7888     int r;
7889     suppress_error = 0;
7890     r = guestfs_mount (g, device, mountpoint);
7891     if (r == -1)
7892       return -1;
7893   }
7894   /* TestOutputList for command_lines (7) */
7895   {
7896     char remotefilename[] = "/test-command";
7897     int r;
7898     suppress_error = 0;
7899     r = guestfs_upload (g, "test-command", remotefilename);
7900     if (r == -1)
7901       return -1;
7902   }
7903   {
7904     char path[] = "/test-command";
7905     int r;
7906     suppress_error = 0;
7907     r = guestfs_chmod (g, 493, path);
7908     if (r == -1)
7909       return -1;
7910   }
7911   {
7912     char arguments_0[] = "/test-command";
7913     char arguments_1[] = "8";
7914     char *arguments[] = {
7915       arguments_0,
7916       arguments_1,
7917       NULL
7918     };
7919     char **r;
7920     int i;
7921     suppress_error = 0;
7922     r = guestfs_command_lines (g, arguments);
7923     if (r == NULL)
7924       return -1;
7925     if (!r[0]) {
7926       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
7927       print_strings (r);
7928       return -1;
7929     }
7930     {
7931       char expected[] = "";
7932       if (strcmp (r[0], expected) != 0) {
7933         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7934         return -1;
7935       }
7936     }
7937     if (r[1] != NULL) {
7938       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
7939       print_strings (r);
7940       return -1;
7941     }
7942     for (i = 0; r[i] != NULL; ++i)
7943       free (r[i]);
7944     free (r);
7945   }
7946   return 0;
7947 }
7948
7949 static int test_command_lines_8_skip (void)
7950 {
7951   const char *str;
7952
7953   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
7954   if (str && strcmp (str, "1") == 0) return 1;
7955   str = getenv ("SKIP_TEST_COMMAND_LINES");
7956   if (str && strcmp (str, "1") == 0) return 1;
7957   return 0;
7958 }
7959
7960 static int test_command_lines_8 (void)
7961 {
7962   if (test_command_lines_8_skip ()) {
7963     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
7964     return 0;
7965   }
7966
7967   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
7968   {
7969     char device[] = "/dev/sda";
7970     int r;
7971     suppress_error = 0;
7972     r = guestfs_blockdev_setrw (g, device);
7973     if (r == -1)
7974       return -1;
7975   }
7976   {
7977     int r;
7978     suppress_error = 0;
7979     r = guestfs_umount_all (g);
7980     if (r == -1)
7981       return -1;
7982   }
7983   {
7984     int r;
7985     suppress_error = 0;
7986     r = guestfs_lvm_remove_all (g);
7987     if (r == -1)
7988       return -1;
7989   }
7990   {
7991     char device[] = "/dev/sda";
7992     char lines_0[] = ",";
7993     char *lines[] = {
7994       lines_0,
7995       NULL
7996     };
7997     int r;
7998     suppress_error = 0;
7999     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8000     if (r == -1)
8001       return -1;
8002   }
8003   {
8004     char fstype[] = "ext2";
8005     char device[] = "/dev/sda1";
8006     int r;
8007     suppress_error = 0;
8008     r = guestfs_mkfs (g, fstype, device);
8009     if (r == -1)
8010       return -1;
8011   }
8012   {
8013     char device[] = "/dev/sda1";
8014     char mountpoint[] = "/";
8015     int r;
8016     suppress_error = 0;
8017     r = guestfs_mount (g, device, mountpoint);
8018     if (r == -1)
8019       return -1;
8020   }
8021   /* TestOutputList for command_lines (8) */
8022   {
8023     char remotefilename[] = "/test-command";
8024     int r;
8025     suppress_error = 0;
8026     r = guestfs_upload (g, "test-command", remotefilename);
8027     if (r == -1)
8028       return -1;
8029   }
8030   {
8031     char path[] = "/test-command";
8032     int r;
8033     suppress_error = 0;
8034     r = guestfs_chmod (g, 493, path);
8035     if (r == -1)
8036       return -1;
8037   }
8038   {
8039     char arguments_0[] = "/test-command";
8040     char arguments_1[] = "9";
8041     char *arguments[] = {
8042       arguments_0,
8043       arguments_1,
8044       NULL
8045     };
8046     char **r;
8047     int i;
8048     suppress_error = 0;
8049     r = guestfs_command_lines (g, arguments);
8050     if (r == NULL)
8051       return -1;
8052     if (!r[0]) {
8053       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8054       print_strings (r);
8055       return -1;
8056     }
8057     {
8058       char expected[] = "";
8059       if (strcmp (r[0], expected) != 0) {
8060         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8061         return -1;
8062       }
8063     }
8064     if (!r[1]) {
8065       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8066       print_strings (r);
8067       return -1;
8068     }
8069     {
8070       char expected[] = "";
8071       if (strcmp (r[1], expected) != 0) {
8072         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8073         return -1;
8074       }
8075     }
8076     if (r[2] != NULL) {
8077       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8078       print_strings (r);
8079       return -1;
8080     }
8081     for (i = 0; r[i] != NULL; ++i)
8082       free (r[i]);
8083     free (r);
8084   }
8085   return 0;
8086 }
8087
8088 static int test_command_lines_9_skip (void)
8089 {
8090   const char *str;
8091
8092   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8093   if (str && strcmp (str, "1") == 0) return 1;
8094   str = getenv ("SKIP_TEST_COMMAND_LINES");
8095   if (str && strcmp (str, "1") == 0) return 1;
8096   return 0;
8097 }
8098
8099 static int test_command_lines_9 (void)
8100 {
8101   if (test_command_lines_9_skip ()) {
8102     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8103     return 0;
8104   }
8105
8106   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8107   {
8108     char device[] = "/dev/sda";
8109     int r;
8110     suppress_error = 0;
8111     r = guestfs_blockdev_setrw (g, device);
8112     if (r == -1)
8113       return -1;
8114   }
8115   {
8116     int r;
8117     suppress_error = 0;
8118     r = guestfs_umount_all (g);
8119     if (r == -1)
8120       return -1;
8121   }
8122   {
8123     int r;
8124     suppress_error = 0;
8125     r = guestfs_lvm_remove_all (g);
8126     if (r == -1)
8127       return -1;
8128   }
8129   {
8130     char device[] = "/dev/sda";
8131     char lines_0[] = ",";
8132     char *lines[] = {
8133       lines_0,
8134       NULL
8135     };
8136     int r;
8137     suppress_error = 0;
8138     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8139     if (r == -1)
8140       return -1;
8141   }
8142   {
8143     char fstype[] = "ext2";
8144     char device[] = "/dev/sda1";
8145     int r;
8146     suppress_error = 0;
8147     r = guestfs_mkfs (g, fstype, device);
8148     if (r == -1)
8149       return -1;
8150   }
8151   {
8152     char device[] = "/dev/sda1";
8153     char mountpoint[] = "/";
8154     int r;
8155     suppress_error = 0;
8156     r = guestfs_mount (g, device, mountpoint);
8157     if (r == -1)
8158       return -1;
8159   }
8160   /* TestOutputList for command_lines (9) */
8161   {
8162     char remotefilename[] = "/test-command";
8163     int r;
8164     suppress_error = 0;
8165     r = guestfs_upload (g, "test-command", remotefilename);
8166     if (r == -1)
8167       return -1;
8168   }
8169   {
8170     char path[] = "/test-command";
8171     int r;
8172     suppress_error = 0;
8173     r = guestfs_chmod (g, 493, path);
8174     if (r == -1)
8175       return -1;
8176   }
8177   {
8178     char arguments_0[] = "/test-command";
8179     char arguments_1[] = "10";
8180     char *arguments[] = {
8181       arguments_0,
8182       arguments_1,
8183       NULL
8184     };
8185     char **r;
8186     int i;
8187     suppress_error = 0;
8188     r = guestfs_command_lines (g, arguments);
8189     if (r == NULL)
8190       return -1;
8191     if (!r[0]) {
8192       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8193       print_strings (r);
8194       return -1;
8195     }
8196     {
8197       char expected[] = "Result10-1";
8198       if (strcmp (r[0], expected) != 0) {
8199         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8200         return -1;
8201       }
8202     }
8203     if (!r[1]) {
8204       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8205       print_strings (r);
8206       return -1;
8207     }
8208     {
8209       char expected[] = "Result10-2";
8210       if (strcmp (r[1], expected) != 0) {
8211         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8212         return -1;
8213       }
8214     }
8215     if (r[2] != NULL) {
8216       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8217       print_strings (r);
8218       return -1;
8219     }
8220     for (i = 0; r[i] != NULL; ++i)
8221       free (r[i]);
8222     free (r);
8223   }
8224   return 0;
8225 }
8226
8227 static int test_command_lines_10_skip (void)
8228 {
8229   const char *str;
8230
8231   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8232   if (str && strcmp (str, "1") == 0) return 1;
8233   str = getenv ("SKIP_TEST_COMMAND_LINES");
8234   if (str && strcmp (str, "1") == 0) return 1;
8235   return 0;
8236 }
8237
8238 static int test_command_lines_10 (void)
8239 {
8240   if (test_command_lines_10_skip ()) {
8241     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8242     return 0;
8243   }
8244
8245   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8246   {
8247     char device[] = "/dev/sda";
8248     int r;
8249     suppress_error = 0;
8250     r = guestfs_blockdev_setrw (g, device);
8251     if (r == -1)
8252       return -1;
8253   }
8254   {
8255     int r;
8256     suppress_error = 0;
8257     r = guestfs_umount_all (g);
8258     if (r == -1)
8259       return -1;
8260   }
8261   {
8262     int r;
8263     suppress_error = 0;
8264     r = guestfs_lvm_remove_all (g);
8265     if (r == -1)
8266       return -1;
8267   }
8268   {
8269     char device[] = "/dev/sda";
8270     char lines_0[] = ",";
8271     char *lines[] = {
8272       lines_0,
8273       NULL
8274     };
8275     int r;
8276     suppress_error = 0;
8277     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8278     if (r == -1)
8279       return -1;
8280   }
8281   {
8282     char fstype[] = "ext2";
8283     char device[] = "/dev/sda1";
8284     int r;
8285     suppress_error = 0;
8286     r = guestfs_mkfs (g, fstype, device);
8287     if (r == -1)
8288       return -1;
8289   }
8290   {
8291     char device[] = "/dev/sda1";
8292     char mountpoint[] = "/";
8293     int r;
8294     suppress_error = 0;
8295     r = guestfs_mount (g, device, mountpoint);
8296     if (r == -1)
8297       return -1;
8298   }
8299   /* TestOutputList for command_lines (10) */
8300   {
8301     char remotefilename[] = "/test-command";
8302     int r;
8303     suppress_error = 0;
8304     r = guestfs_upload (g, "test-command", remotefilename);
8305     if (r == -1)
8306       return -1;
8307   }
8308   {
8309     char path[] = "/test-command";
8310     int r;
8311     suppress_error = 0;
8312     r = guestfs_chmod (g, 493, path);
8313     if (r == -1)
8314       return -1;
8315   }
8316   {
8317     char arguments_0[] = "/test-command";
8318     char arguments_1[] = "11";
8319     char *arguments[] = {
8320       arguments_0,
8321       arguments_1,
8322       NULL
8323     };
8324     char **r;
8325     int i;
8326     suppress_error = 0;
8327     r = guestfs_command_lines (g, arguments);
8328     if (r == NULL)
8329       return -1;
8330     if (!r[0]) {
8331       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8332       print_strings (r);
8333       return -1;
8334     }
8335     {
8336       char expected[] = "Result11-1";
8337       if (strcmp (r[0], expected) != 0) {
8338         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8339         return -1;
8340       }
8341     }
8342     if (!r[1]) {
8343       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8344       print_strings (r);
8345       return -1;
8346     }
8347     {
8348       char expected[] = "Result11-2";
8349       if (strcmp (r[1], expected) != 0) {
8350         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8351         return -1;
8352       }
8353     }
8354     if (r[2] != NULL) {
8355       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8356       print_strings (r);
8357       return -1;
8358     }
8359     for (i = 0; r[i] != NULL; ++i)
8360       free (r[i]);
8361     free (r);
8362   }
8363   return 0;
8364 }
8365
8366 static int test_command_0_skip (void)
8367 {
8368   const char *str;
8369
8370   str = getenv ("SKIP_TEST_COMMAND_0");
8371   if (str && strcmp (str, "1") == 0) return 1;
8372   str = getenv ("SKIP_TEST_COMMAND");
8373   if (str && strcmp (str, "1") == 0) return 1;
8374   return 0;
8375 }
8376
8377 static int test_command_0 (void)
8378 {
8379   if (test_command_0_skip ()) {
8380     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8381     return 0;
8382   }
8383
8384   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8385   {
8386     char device[] = "/dev/sda";
8387     int r;
8388     suppress_error = 0;
8389     r = guestfs_blockdev_setrw (g, device);
8390     if (r == -1)
8391       return -1;
8392   }
8393   {
8394     int r;
8395     suppress_error = 0;
8396     r = guestfs_umount_all (g);
8397     if (r == -1)
8398       return -1;
8399   }
8400   {
8401     int r;
8402     suppress_error = 0;
8403     r = guestfs_lvm_remove_all (g);
8404     if (r == -1)
8405       return -1;
8406   }
8407   {
8408     char device[] = "/dev/sda";
8409     char lines_0[] = ",";
8410     char *lines[] = {
8411       lines_0,
8412       NULL
8413     };
8414     int r;
8415     suppress_error = 0;
8416     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8417     if (r == -1)
8418       return -1;
8419   }
8420   {
8421     char fstype[] = "ext2";
8422     char device[] = "/dev/sda1";
8423     int r;
8424     suppress_error = 0;
8425     r = guestfs_mkfs (g, fstype, device);
8426     if (r == -1)
8427       return -1;
8428   }
8429   {
8430     char device[] = "/dev/sda1";
8431     char mountpoint[] = "/";
8432     int r;
8433     suppress_error = 0;
8434     r = guestfs_mount (g, device, mountpoint);
8435     if (r == -1)
8436       return -1;
8437   }
8438   /* TestOutput for command (0) */
8439   char expected[] = "Result1";
8440   {
8441     char remotefilename[] = "/test-command";
8442     int r;
8443     suppress_error = 0;
8444     r = guestfs_upload (g, "test-command", remotefilename);
8445     if (r == -1)
8446       return -1;
8447   }
8448   {
8449     char path[] = "/test-command";
8450     int r;
8451     suppress_error = 0;
8452     r = guestfs_chmod (g, 493, path);
8453     if (r == -1)
8454       return -1;
8455   }
8456   {
8457     char arguments_0[] = "/test-command";
8458     char arguments_1[] = "1";
8459     char *arguments[] = {
8460       arguments_0,
8461       arguments_1,
8462       NULL
8463     };
8464     char *r;
8465     suppress_error = 0;
8466     r = guestfs_command (g, arguments);
8467     if (r == NULL)
8468       return -1;
8469     if (strcmp (r, expected) != 0) {
8470       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8471       return -1;
8472     }
8473     free (r);
8474   }
8475   return 0;
8476 }
8477
8478 static int test_command_1_skip (void)
8479 {
8480   const char *str;
8481
8482   str = getenv ("SKIP_TEST_COMMAND_1");
8483   if (str && strcmp (str, "1") == 0) return 1;
8484   str = getenv ("SKIP_TEST_COMMAND");
8485   if (str && strcmp (str, "1") == 0) return 1;
8486   return 0;
8487 }
8488
8489 static int test_command_1 (void)
8490 {
8491   if (test_command_1_skip ()) {
8492     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8493     return 0;
8494   }
8495
8496   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8497   {
8498     char device[] = "/dev/sda";
8499     int r;
8500     suppress_error = 0;
8501     r = guestfs_blockdev_setrw (g, device);
8502     if (r == -1)
8503       return -1;
8504   }
8505   {
8506     int r;
8507     suppress_error = 0;
8508     r = guestfs_umount_all (g);
8509     if (r == -1)
8510       return -1;
8511   }
8512   {
8513     int r;
8514     suppress_error = 0;
8515     r = guestfs_lvm_remove_all (g);
8516     if (r == -1)
8517       return -1;
8518   }
8519   {
8520     char device[] = "/dev/sda";
8521     char lines_0[] = ",";
8522     char *lines[] = {
8523       lines_0,
8524       NULL
8525     };
8526     int r;
8527     suppress_error = 0;
8528     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8529     if (r == -1)
8530       return -1;
8531   }
8532   {
8533     char fstype[] = "ext2";
8534     char device[] = "/dev/sda1";
8535     int r;
8536     suppress_error = 0;
8537     r = guestfs_mkfs (g, fstype, device);
8538     if (r == -1)
8539       return -1;
8540   }
8541   {
8542     char device[] = "/dev/sda1";
8543     char mountpoint[] = "/";
8544     int r;
8545     suppress_error = 0;
8546     r = guestfs_mount (g, device, mountpoint);
8547     if (r == -1)
8548       return -1;
8549   }
8550   /* TestOutput for command (1) */
8551   char expected[] = "Result2\n";
8552   {
8553     char remotefilename[] = "/test-command";
8554     int r;
8555     suppress_error = 0;
8556     r = guestfs_upload (g, "test-command", remotefilename);
8557     if (r == -1)
8558       return -1;
8559   }
8560   {
8561     char path[] = "/test-command";
8562     int r;
8563     suppress_error = 0;
8564     r = guestfs_chmod (g, 493, path);
8565     if (r == -1)
8566       return -1;
8567   }
8568   {
8569     char arguments_0[] = "/test-command";
8570     char arguments_1[] = "2";
8571     char *arguments[] = {
8572       arguments_0,
8573       arguments_1,
8574       NULL
8575     };
8576     char *r;
8577     suppress_error = 0;
8578     r = guestfs_command (g, arguments);
8579     if (r == NULL)
8580       return -1;
8581     if (strcmp (r, expected) != 0) {
8582       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8583       return -1;
8584     }
8585     free (r);
8586   }
8587   return 0;
8588 }
8589
8590 static int test_command_2_skip (void)
8591 {
8592   const char *str;
8593
8594   str = getenv ("SKIP_TEST_COMMAND_2");
8595   if (str && strcmp (str, "1") == 0) return 1;
8596   str = getenv ("SKIP_TEST_COMMAND");
8597   if (str && strcmp (str, "1") == 0) return 1;
8598   return 0;
8599 }
8600
8601 static int test_command_2 (void)
8602 {
8603   if (test_command_2_skip ()) {
8604     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8605     return 0;
8606   }
8607
8608   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8609   {
8610     char device[] = "/dev/sda";
8611     int r;
8612     suppress_error = 0;
8613     r = guestfs_blockdev_setrw (g, device);
8614     if (r == -1)
8615       return -1;
8616   }
8617   {
8618     int r;
8619     suppress_error = 0;
8620     r = guestfs_umount_all (g);
8621     if (r == -1)
8622       return -1;
8623   }
8624   {
8625     int r;
8626     suppress_error = 0;
8627     r = guestfs_lvm_remove_all (g);
8628     if (r == -1)
8629       return -1;
8630   }
8631   {
8632     char device[] = "/dev/sda";
8633     char lines_0[] = ",";
8634     char *lines[] = {
8635       lines_0,
8636       NULL
8637     };
8638     int r;
8639     suppress_error = 0;
8640     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8641     if (r == -1)
8642       return -1;
8643   }
8644   {
8645     char fstype[] = "ext2";
8646     char device[] = "/dev/sda1";
8647     int r;
8648     suppress_error = 0;
8649     r = guestfs_mkfs (g, fstype, device);
8650     if (r == -1)
8651       return -1;
8652   }
8653   {
8654     char device[] = "/dev/sda1";
8655     char mountpoint[] = "/";
8656     int r;
8657     suppress_error = 0;
8658     r = guestfs_mount (g, device, mountpoint);
8659     if (r == -1)
8660       return -1;
8661   }
8662   /* TestOutput for command (2) */
8663   char expected[] = "\nResult3";
8664   {
8665     char remotefilename[] = "/test-command";
8666     int r;
8667     suppress_error = 0;
8668     r = guestfs_upload (g, "test-command", remotefilename);
8669     if (r == -1)
8670       return -1;
8671   }
8672   {
8673     char path[] = "/test-command";
8674     int r;
8675     suppress_error = 0;
8676     r = guestfs_chmod (g, 493, path);
8677     if (r == -1)
8678       return -1;
8679   }
8680   {
8681     char arguments_0[] = "/test-command";
8682     char arguments_1[] = "3";
8683     char *arguments[] = {
8684       arguments_0,
8685       arguments_1,
8686       NULL
8687     };
8688     char *r;
8689     suppress_error = 0;
8690     r = guestfs_command (g, arguments);
8691     if (r == NULL)
8692       return -1;
8693     if (strcmp (r, expected) != 0) {
8694       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8695       return -1;
8696     }
8697     free (r);
8698   }
8699   return 0;
8700 }
8701
8702 static int test_command_3_skip (void)
8703 {
8704   const char *str;
8705
8706   str = getenv ("SKIP_TEST_COMMAND_3");
8707   if (str && strcmp (str, "1") == 0) return 1;
8708   str = getenv ("SKIP_TEST_COMMAND");
8709   if (str && strcmp (str, "1") == 0) return 1;
8710   return 0;
8711 }
8712
8713 static int test_command_3 (void)
8714 {
8715   if (test_command_3_skip ()) {
8716     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8717     return 0;
8718   }
8719
8720   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8721   {
8722     char device[] = "/dev/sda";
8723     int r;
8724     suppress_error = 0;
8725     r = guestfs_blockdev_setrw (g, device);
8726     if (r == -1)
8727       return -1;
8728   }
8729   {
8730     int r;
8731     suppress_error = 0;
8732     r = guestfs_umount_all (g);
8733     if (r == -1)
8734       return -1;
8735   }
8736   {
8737     int r;
8738     suppress_error = 0;
8739     r = guestfs_lvm_remove_all (g);
8740     if (r == -1)
8741       return -1;
8742   }
8743   {
8744     char device[] = "/dev/sda";
8745     char lines_0[] = ",";
8746     char *lines[] = {
8747       lines_0,
8748       NULL
8749     };
8750     int r;
8751     suppress_error = 0;
8752     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8753     if (r == -1)
8754       return -1;
8755   }
8756   {
8757     char fstype[] = "ext2";
8758     char device[] = "/dev/sda1";
8759     int r;
8760     suppress_error = 0;
8761     r = guestfs_mkfs (g, fstype, device);
8762     if (r == -1)
8763       return -1;
8764   }
8765   {
8766     char device[] = "/dev/sda1";
8767     char mountpoint[] = "/";
8768     int r;
8769     suppress_error = 0;
8770     r = guestfs_mount (g, device, mountpoint);
8771     if (r == -1)
8772       return -1;
8773   }
8774   /* TestOutput for command (3) */
8775   char expected[] = "\nResult4\n";
8776   {
8777     char remotefilename[] = "/test-command";
8778     int r;
8779     suppress_error = 0;
8780     r = guestfs_upload (g, "test-command", remotefilename);
8781     if (r == -1)
8782       return -1;
8783   }
8784   {
8785     char path[] = "/test-command";
8786     int r;
8787     suppress_error = 0;
8788     r = guestfs_chmod (g, 493, path);
8789     if (r == -1)
8790       return -1;
8791   }
8792   {
8793     char arguments_0[] = "/test-command";
8794     char arguments_1[] = "4";
8795     char *arguments[] = {
8796       arguments_0,
8797       arguments_1,
8798       NULL
8799     };
8800     char *r;
8801     suppress_error = 0;
8802     r = guestfs_command (g, arguments);
8803     if (r == NULL)
8804       return -1;
8805     if (strcmp (r, expected) != 0) {
8806       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8807       return -1;
8808     }
8809     free (r);
8810   }
8811   return 0;
8812 }
8813
8814 static int test_command_4_skip (void)
8815 {
8816   const char *str;
8817
8818   str = getenv ("SKIP_TEST_COMMAND_4");
8819   if (str && strcmp (str, "1") == 0) return 1;
8820   str = getenv ("SKIP_TEST_COMMAND");
8821   if (str && strcmp (str, "1") == 0) return 1;
8822   return 0;
8823 }
8824
8825 static int test_command_4 (void)
8826 {
8827   if (test_command_4_skip ()) {
8828     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8829     return 0;
8830   }
8831
8832   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8833   {
8834     char device[] = "/dev/sda";
8835     int r;
8836     suppress_error = 0;
8837     r = guestfs_blockdev_setrw (g, device);
8838     if (r == -1)
8839       return -1;
8840   }
8841   {
8842     int r;
8843     suppress_error = 0;
8844     r = guestfs_umount_all (g);
8845     if (r == -1)
8846       return -1;
8847   }
8848   {
8849     int r;
8850     suppress_error = 0;
8851     r = guestfs_lvm_remove_all (g);
8852     if (r == -1)
8853       return -1;
8854   }
8855   {
8856     char device[] = "/dev/sda";
8857     char lines_0[] = ",";
8858     char *lines[] = {
8859       lines_0,
8860       NULL
8861     };
8862     int r;
8863     suppress_error = 0;
8864     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8865     if (r == -1)
8866       return -1;
8867   }
8868   {
8869     char fstype[] = "ext2";
8870     char device[] = "/dev/sda1";
8871     int r;
8872     suppress_error = 0;
8873     r = guestfs_mkfs (g, fstype, device);
8874     if (r == -1)
8875       return -1;
8876   }
8877   {
8878     char device[] = "/dev/sda1";
8879     char mountpoint[] = "/";
8880     int r;
8881     suppress_error = 0;
8882     r = guestfs_mount (g, device, mountpoint);
8883     if (r == -1)
8884       return -1;
8885   }
8886   /* TestOutput for command (4) */
8887   char expected[] = "\nResult5\n\n";
8888   {
8889     char remotefilename[] = "/test-command";
8890     int r;
8891     suppress_error = 0;
8892     r = guestfs_upload (g, "test-command", remotefilename);
8893     if (r == -1)
8894       return -1;
8895   }
8896   {
8897     char path[] = "/test-command";
8898     int r;
8899     suppress_error = 0;
8900     r = guestfs_chmod (g, 493, path);
8901     if (r == -1)
8902       return -1;
8903   }
8904   {
8905     char arguments_0[] = "/test-command";
8906     char arguments_1[] = "5";
8907     char *arguments[] = {
8908       arguments_0,
8909       arguments_1,
8910       NULL
8911     };
8912     char *r;
8913     suppress_error = 0;
8914     r = guestfs_command (g, arguments);
8915     if (r == NULL)
8916       return -1;
8917     if (strcmp (r, expected) != 0) {
8918       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
8919       return -1;
8920     }
8921     free (r);
8922   }
8923   return 0;
8924 }
8925
8926 static int test_command_5_skip (void)
8927 {
8928   const char *str;
8929
8930   str = getenv ("SKIP_TEST_COMMAND_5");
8931   if (str && strcmp (str, "1") == 0) return 1;
8932   str = getenv ("SKIP_TEST_COMMAND");
8933   if (str && strcmp (str, "1") == 0) return 1;
8934   return 0;
8935 }
8936
8937 static int test_command_5 (void)
8938 {
8939   if (test_command_5_skip ()) {
8940     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
8941     return 0;
8942   }
8943
8944   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
8945   {
8946     char device[] = "/dev/sda";
8947     int r;
8948     suppress_error = 0;
8949     r = guestfs_blockdev_setrw (g, device);
8950     if (r == -1)
8951       return -1;
8952   }
8953   {
8954     int r;
8955     suppress_error = 0;
8956     r = guestfs_umount_all (g);
8957     if (r == -1)
8958       return -1;
8959   }
8960   {
8961     int r;
8962     suppress_error = 0;
8963     r = guestfs_lvm_remove_all (g);
8964     if (r == -1)
8965       return -1;
8966   }
8967   {
8968     char device[] = "/dev/sda";
8969     char lines_0[] = ",";
8970     char *lines[] = {
8971       lines_0,
8972       NULL
8973     };
8974     int r;
8975     suppress_error = 0;
8976     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8977     if (r == -1)
8978       return -1;
8979   }
8980   {
8981     char fstype[] = "ext2";
8982     char device[] = "/dev/sda1";
8983     int r;
8984     suppress_error = 0;
8985     r = guestfs_mkfs (g, fstype, device);
8986     if (r == -1)
8987       return -1;
8988   }
8989   {
8990     char device[] = "/dev/sda1";
8991     char mountpoint[] = "/";
8992     int r;
8993     suppress_error = 0;
8994     r = guestfs_mount (g, device, mountpoint);
8995     if (r == -1)
8996       return -1;
8997   }
8998   /* TestOutput for command (5) */
8999   char expected[] = "\n\nResult6\n\n";
9000   {
9001     char remotefilename[] = "/test-command";
9002     int r;
9003     suppress_error = 0;
9004     r = guestfs_upload (g, "test-command", remotefilename);
9005     if (r == -1)
9006       return -1;
9007   }
9008   {
9009     char path[] = "/test-command";
9010     int r;
9011     suppress_error = 0;
9012     r = guestfs_chmod (g, 493, path);
9013     if (r == -1)
9014       return -1;
9015   }
9016   {
9017     char arguments_0[] = "/test-command";
9018     char arguments_1[] = "6";
9019     char *arguments[] = {
9020       arguments_0,
9021       arguments_1,
9022       NULL
9023     };
9024     char *r;
9025     suppress_error = 0;
9026     r = guestfs_command (g, arguments);
9027     if (r == NULL)
9028       return -1;
9029     if (strcmp (r, expected) != 0) {
9030       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9031       return -1;
9032     }
9033     free (r);
9034   }
9035   return 0;
9036 }
9037
9038 static int test_command_6_skip (void)
9039 {
9040   const char *str;
9041
9042   str = getenv ("SKIP_TEST_COMMAND_6");
9043   if (str && strcmp (str, "1") == 0) return 1;
9044   str = getenv ("SKIP_TEST_COMMAND");
9045   if (str && strcmp (str, "1") == 0) return 1;
9046   return 0;
9047 }
9048
9049 static int test_command_6 (void)
9050 {
9051   if (test_command_6_skip ()) {
9052     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9053     return 0;
9054   }
9055
9056   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9057   {
9058     char device[] = "/dev/sda";
9059     int r;
9060     suppress_error = 0;
9061     r = guestfs_blockdev_setrw (g, device);
9062     if (r == -1)
9063       return -1;
9064   }
9065   {
9066     int r;
9067     suppress_error = 0;
9068     r = guestfs_umount_all (g);
9069     if (r == -1)
9070       return -1;
9071   }
9072   {
9073     int r;
9074     suppress_error = 0;
9075     r = guestfs_lvm_remove_all (g);
9076     if (r == -1)
9077       return -1;
9078   }
9079   {
9080     char device[] = "/dev/sda";
9081     char lines_0[] = ",";
9082     char *lines[] = {
9083       lines_0,
9084       NULL
9085     };
9086     int r;
9087     suppress_error = 0;
9088     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9089     if (r == -1)
9090       return -1;
9091   }
9092   {
9093     char fstype[] = "ext2";
9094     char device[] = "/dev/sda1";
9095     int r;
9096     suppress_error = 0;
9097     r = guestfs_mkfs (g, fstype, device);
9098     if (r == -1)
9099       return -1;
9100   }
9101   {
9102     char device[] = "/dev/sda1";
9103     char mountpoint[] = "/";
9104     int r;
9105     suppress_error = 0;
9106     r = guestfs_mount (g, device, mountpoint);
9107     if (r == -1)
9108       return -1;
9109   }
9110   /* TestOutput for command (6) */
9111   char expected[] = "";
9112   {
9113     char remotefilename[] = "/test-command";
9114     int r;
9115     suppress_error = 0;
9116     r = guestfs_upload (g, "test-command", remotefilename);
9117     if (r == -1)
9118       return -1;
9119   }
9120   {
9121     char path[] = "/test-command";
9122     int r;
9123     suppress_error = 0;
9124     r = guestfs_chmod (g, 493, path);
9125     if (r == -1)
9126       return -1;
9127   }
9128   {
9129     char arguments_0[] = "/test-command";
9130     char arguments_1[] = "7";
9131     char *arguments[] = {
9132       arguments_0,
9133       arguments_1,
9134       NULL
9135     };
9136     char *r;
9137     suppress_error = 0;
9138     r = guestfs_command (g, arguments);
9139     if (r == NULL)
9140       return -1;
9141     if (strcmp (r, expected) != 0) {
9142       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9143       return -1;
9144     }
9145     free (r);
9146   }
9147   return 0;
9148 }
9149
9150 static int test_command_7_skip (void)
9151 {
9152   const char *str;
9153
9154   str = getenv ("SKIP_TEST_COMMAND_7");
9155   if (str && strcmp (str, "1") == 0) return 1;
9156   str = getenv ("SKIP_TEST_COMMAND");
9157   if (str && strcmp (str, "1") == 0) return 1;
9158   return 0;
9159 }
9160
9161 static int test_command_7 (void)
9162 {
9163   if (test_command_7_skip ()) {
9164     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9165     return 0;
9166   }
9167
9168   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9169   {
9170     char device[] = "/dev/sda";
9171     int r;
9172     suppress_error = 0;
9173     r = guestfs_blockdev_setrw (g, device);
9174     if (r == -1)
9175       return -1;
9176   }
9177   {
9178     int r;
9179     suppress_error = 0;
9180     r = guestfs_umount_all (g);
9181     if (r == -1)
9182       return -1;
9183   }
9184   {
9185     int r;
9186     suppress_error = 0;
9187     r = guestfs_lvm_remove_all (g);
9188     if (r == -1)
9189       return -1;
9190   }
9191   {
9192     char device[] = "/dev/sda";
9193     char lines_0[] = ",";
9194     char *lines[] = {
9195       lines_0,
9196       NULL
9197     };
9198     int r;
9199     suppress_error = 0;
9200     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9201     if (r == -1)
9202       return -1;
9203   }
9204   {
9205     char fstype[] = "ext2";
9206     char device[] = "/dev/sda1";
9207     int r;
9208     suppress_error = 0;
9209     r = guestfs_mkfs (g, fstype, device);
9210     if (r == -1)
9211       return -1;
9212   }
9213   {
9214     char device[] = "/dev/sda1";
9215     char mountpoint[] = "/";
9216     int r;
9217     suppress_error = 0;
9218     r = guestfs_mount (g, device, mountpoint);
9219     if (r == -1)
9220       return -1;
9221   }
9222   /* TestOutput for command (7) */
9223   char expected[] = "\n";
9224   {
9225     char remotefilename[] = "/test-command";
9226     int r;
9227     suppress_error = 0;
9228     r = guestfs_upload (g, "test-command", remotefilename);
9229     if (r == -1)
9230       return -1;
9231   }
9232   {
9233     char path[] = "/test-command";
9234     int r;
9235     suppress_error = 0;
9236     r = guestfs_chmod (g, 493, path);
9237     if (r == -1)
9238       return -1;
9239   }
9240   {
9241     char arguments_0[] = "/test-command";
9242     char arguments_1[] = "8";
9243     char *arguments[] = {
9244       arguments_0,
9245       arguments_1,
9246       NULL
9247     };
9248     char *r;
9249     suppress_error = 0;
9250     r = guestfs_command (g, arguments);
9251     if (r == NULL)
9252       return -1;
9253     if (strcmp (r, expected) != 0) {
9254       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9255       return -1;
9256     }
9257     free (r);
9258   }
9259   return 0;
9260 }
9261
9262 static int test_command_8_skip (void)
9263 {
9264   const char *str;
9265
9266   str = getenv ("SKIP_TEST_COMMAND_8");
9267   if (str && strcmp (str, "1") == 0) return 1;
9268   str = getenv ("SKIP_TEST_COMMAND");
9269   if (str && strcmp (str, "1") == 0) return 1;
9270   return 0;
9271 }
9272
9273 static int test_command_8 (void)
9274 {
9275   if (test_command_8_skip ()) {
9276     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9277     return 0;
9278   }
9279
9280   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9281   {
9282     char device[] = "/dev/sda";
9283     int r;
9284     suppress_error = 0;
9285     r = guestfs_blockdev_setrw (g, device);
9286     if (r == -1)
9287       return -1;
9288   }
9289   {
9290     int r;
9291     suppress_error = 0;
9292     r = guestfs_umount_all (g);
9293     if (r == -1)
9294       return -1;
9295   }
9296   {
9297     int r;
9298     suppress_error = 0;
9299     r = guestfs_lvm_remove_all (g);
9300     if (r == -1)
9301       return -1;
9302   }
9303   {
9304     char device[] = "/dev/sda";
9305     char lines_0[] = ",";
9306     char *lines[] = {
9307       lines_0,
9308       NULL
9309     };
9310     int r;
9311     suppress_error = 0;
9312     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9313     if (r == -1)
9314       return -1;
9315   }
9316   {
9317     char fstype[] = "ext2";
9318     char device[] = "/dev/sda1";
9319     int r;
9320     suppress_error = 0;
9321     r = guestfs_mkfs (g, fstype, device);
9322     if (r == -1)
9323       return -1;
9324   }
9325   {
9326     char device[] = "/dev/sda1";
9327     char mountpoint[] = "/";
9328     int r;
9329     suppress_error = 0;
9330     r = guestfs_mount (g, device, mountpoint);
9331     if (r == -1)
9332       return -1;
9333   }
9334   /* TestOutput for command (8) */
9335   char expected[] = "\n\n";
9336   {
9337     char remotefilename[] = "/test-command";
9338     int r;
9339     suppress_error = 0;
9340     r = guestfs_upload (g, "test-command", remotefilename);
9341     if (r == -1)
9342       return -1;
9343   }
9344   {
9345     char path[] = "/test-command";
9346     int r;
9347     suppress_error = 0;
9348     r = guestfs_chmod (g, 493, path);
9349     if (r == -1)
9350       return -1;
9351   }
9352   {
9353     char arguments_0[] = "/test-command";
9354     char arguments_1[] = "9";
9355     char *arguments[] = {
9356       arguments_0,
9357       arguments_1,
9358       NULL
9359     };
9360     char *r;
9361     suppress_error = 0;
9362     r = guestfs_command (g, arguments);
9363     if (r == NULL)
9364       return -1;
9365     if (strcmp (r, expected) != 0) {
9366       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9367       return -1;
9368     }
9369     free (r);
9370   }
9371   return 0;
9372 }
9373
9374 static int test_command_9_skip (void)
9375 {
9376   const char *str;
9377
9378   str = getenv ("SKIP_TEST_COMMAND_9");
9379   if (str && strcmp (str, "1") == 0) return 1;
9380   str = getenv ("SKIP_TEST_COMMAND");
9381   if (str && strcmp (str, "1") == 0) return 1;
9382   return 0;
9383 }
9384
9385 static int test_command_9 (void)
9386 {
9387   if (test_command_9_skip ()) {
9388     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9389     return 0;
9390   }
9391
9392   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9393   {
9394     char device[] = "/dev/sda";
9395     int r;
9396     suppress_error = 0;
9397     r = guestfs_blockdev_setrw (g, device);
9398     if (r == -1)
9399       return -1;
9400   }
9401   {
9402     int r;
9403     suppress_error = 0;
9404     r = guestfs_umount_all (g);
9405     if (r == -1)
9406       return -1;
9407   }
9408   {
9409     int r;
9410     suppress_error = 0;
9411     r = guestfs_lvm_remove_all (g);
9412     if (r == -1)
9413       return -1;
9414   }
9415   {
9416     char device[] = "/dev/sda";
9417     char lines_0[] = ",";
9418     char *lines[] = {
9419       lines_0,
9420       NULL
9421     };
9422     int r;
9423     suppress_error = 0;
9424     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9425     if (r == -1)
9426       return -1;
9427   }
9428   {
9429     char fstype[] = "ext2";
9430     char device[] = "/dev/sda1";
9431     int r;
9432     suppress_error = 0;
9433     r = guestfs_mkfs (g, fstype, device);
9434     if (r == -1)
9435       return -1;
9436   }
9437   {
9438     char device[] = "/dev/sda1";
9439     char mountpoint[] = "/";
9440     int r;
9441     suppress_error = 0;
9442     r = guestfs_mount (g, device, mountpoint);
9443     if (r == -1)
9444       return -1;
9445   }
9446   /* TestOutput for command (9) */
9447   char expected[] = "Result10-1\nResult10-2\n";
9448   {
9449     char remotefilename[] = "/test-command";
9450     int r;
9451     suppress_error = 0;
9452     r = guestfs_upload (g, "test-command", remotefilename);
9453     if (r == -1)
9454       return -1;
9455   }
9456   {
9457     char path[] = "/test-command";
9458     int r;
9459     suppress_error = 0;
9460     r = guestfs_chmod (g, 493, path);
9461     if (r == -1)
9462       return -1;
9463   }
9464   {
9465     char arguments_0[] = "/test-command";
9466     char arguments_1[] = "10";
9467     char *arguments[] = {
9468       arguments_0,
9469       arguments_1,
9470       NULL
9471     };
9472     char *r;
9473     suppress_error = 0;
9474     r = guestfs_command (g, arguments);
9475     if (r == NULL)
9476       return -1;
9477     if (strcmp (r, expected) != 0) {
9478       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9479       return -1;
9480     }
9481     free (r);
9482   }
9483   return 0;
9484 }
9485
9486 static int test_command_10_skip (void)
9487 {
9488   const char *str;
9489
9490   str = getenv ("SKIP_TEST_COMMAND_10");
9491   if (str && strcmp (str, "1") == 0) return 1;
9492   str = getenv ("SKIP_TEST_COMMAND");
9493   if (str && strcmp (str, "1") == 0) return 1;
9494   return 0;
9495 }
9496
9497 static int test_command_10 (void)
9498 {
9499   if (test_command_10_skip ()) {
9500     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9501     return 0;
9502   }
9503
9504   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9505   {
9506     char device[] = "/dev/sda";
9507     int r;
9508     suppress_error = 0;
9509     r = guestfs_blockdev_setrw (g, device);
9510     if (r == -1)
9511       return -1;
9512   }
9513   {
9514     int r;
9515     suppress_error = 0;
9516     r = guestfs_umount_all (g);
9517     if (r == -1)
9518       return -1;
9519   }
9520   {
9521     int r;
9522     suppress_error = 0;
9523     r = guestfs_lvm_remove_all (g);
9524     if (r == -1)
9525       return -1;
9526   }
9527   {
9528     char device[] = "/dev/sda";
9529     char lines_0[] = ",";
9530     char *lines[] = {
9531       lines_0,
9532       NULL
9533     };
9534     int r;
9535     suppress_error = 0;
9536     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9537     if (r == -1)
9538       return -1;
9539   }
9540   {
9541     char fstype[] = "ext2";
9542     char device[] = "/dev/sda1";
9543     int r;
9544     suppress_error = 0;
9545     r = guestfs_mkfs (g, fstype, device);
9546     if (r == -1)
9547       return -1;
9548   }
9549   {
9550     char device[] = "/dev/sda1";
9551     char mountpoint[] = "/";
9552     int r;
9553     suppress_error = 0;
9554     r = guestfs_mount (g, device, mountpoint);
9555     if (r == -1)
9556       return -1;
9557   }
9558   /* TestOutput for command (10) */
9559   char expected[] = "Result11-1\nResult11-2";
9560   {
9561     char remotefilename[] = "/test-command";
9562     int r;
9563     suppress_error = 0;
9564     r = guestfs_upload (g, "test-command", remotefilename);
9565     if (r == -1)
9566       return -1;
9567   }
9568   {
9569     char path[] = "/test-command";
9570     int r;
9571     suppress_error = 0;
9572     r = guestfs_chmod (g, 493, path);
9573     if (r == -1)
9574       return -1;
9575   }
9576   {
9577     char arguments_0[] = "/test-command";
9578     char arguments_1[] = "11";
9579     char *arguments[] = {
9580       arguments_0,
9581       arguments_1,
9582       NULL
9583     };
9584     char *r;
9585     suppress_error = 0;
9586     r = guestfs_command (g, arguments);
9587     if (r == NULL)
9588       return -1;
9589     if (strcmp (r, expected) != 0) {
9590       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9591       return -1;
9592     }
9593     free (r);
9594   }
9595   return 0;
9596 }
9597
9598 static int test_command_11_skip (void)
9599 {
9600   const char *str;
9601
9602   str = getenv ("SKIP_TEST_COMMAND_11");
9603   if (str && strcmp (str, "1") == 0) return 1;
9604   str = getenv ("SKIP_TEST_COMMAND");
9605   if (str && strcmp (str, "1") == 0) return 1;
9606   return 0;
9607 }
9608
9609 static int test_command_11 (void)
9610 {
9611   if (test_command_11_skip ()) {
9612     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9613     return 0;
9614   }
9615
9616   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9617   {
9618     char device[] = "/dev/sda";
9619     int r;
9620     suppress_error = 0;
9621     r = guestfs_blockdev_setrw (g, device);
9622     if (r == -1)
9623       return -1;
9624   }
9625   {
9626     int r;
9627     suppress_error = 0;
9628     r = guestfs_umount_all (g);
9629     if (r == -1)
9630       return -1;
9631   }
9632   {
9633     int r;
9634     suppress_error = 0;
9635     r = guestfs_lvm_remove_all (g);
9636     if (r == -1)
9637       return -1;
9638   }
9639   {
9640     char device[] = "/dev/sda";
9641     char lines_0[] = ",";
9642     char *lines[] = {
9643       lines_0,
9644       NULL
9645     };
9646     int r;
9647     suppress_error = 0;
9648     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9649     if (r == -1)
9650       return -1;
9651   }
9652   {
9653     char fstype[] = "ext2";
9654     char device[] = "/dev/sda1";
9655     int r;
9656     suppress_error = 0;
9657     r = guestfs_mkfs (g, fstype, device);
9658     if (r == -1)
9659       return -1;
9660   }
9661   {
9662     char device[] = "/dev/sda1";
9663     char mountpoint[] = "/";
9664     int r;
9665     suppress_error = 0;
9666     r = guestfs_mount (g, device, mountpoint);
9667     if (r == -1)
9668       return -1;
9669   }
9670   /* TestLastFail for command (11) */
9671   {
9672     char remotefilename[] = "/test-command";
9673     int r;
9674     suppress_error = 0;
9675     r = guestfs_upload (g, "test-command", remotefilename);
9676     if (r == -1)
9677       return -1;
9678   }
9679   {
9680     char path[] = "/test-command";
9681     int r;
9682     suppress_error = 0;
9683     r = guestfs_chmod (g, 493, path);
9684     if (r == -1)
9685       return -1;
9686   }
9687   {
9688     char arguments_0[] = "/test-command";
9689     char *arguments[] = {
9690       arguments_0,
9691       NULL
9692     };
9693     char *r;
9694     suppress_error = 1;
9695     r = guestfs_command (g, arguments);
9696     if (r != NULL)
9697       return -1;
9698     free (r);
9699   }
9700   return 0;
9701 }
9702
9703 static int test_file_0_skip (void)
9704 {
9705   const char *str;
9706
9707   str = getenv ("SKIP_TEST_FILE_0");
9708   if (str && strcmp (str, "1") == 0) return 1;
9709   str = getenv ("SKIP_TEST_FILE");
9710   if (str && strcmp (str, "1") == 0) return 1;
9711   return 0;
9712 }
9713
9714 static int test_file_0 (void)
9715 {
9716   if (test_file_0_skip ()) {
9717     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9718     return 0;
9719   }
9720
9721   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9722   {
9723     char device[] = "/dev/sda";
9724     int r;
9725     suppress_error = 0;
9726     r = guestfs_blockdev_setrw (g, device);
9727     if (r == -1)
9728       return -1;
9729   }
9730   {
9731     int r;
9732     suppress_error = 0;
9733     r = guestfs_umount_all (g);
9734     if (r == -1)
9735       return -1;
9736   }
9737   {
9738     int r;
9739     suppress_error = 0;
9740     r = guestfs_lvm_remove_all (g);
9741     if (r == -1)
9742       return -1;
9743   }
9744   {
9745     char device[] = "/dev/sda";
9746     char lines_0[] = ",";
9747     char *lines[] = {
9748       lines_0,
9749       NULL
9750     };
9751     int r;
9752     suppress_error = 0;
9753     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9754     if (r == -1)
9755       return -1;
9756   }
9757   {
9758     char fstype[] = "ext2";
9759     char device[] = "/dev/sda1";
9760     int r;
9761     suppress_error = 0;
9762     r = guestfs_mkfs (g, fstype, device);
9763     if (r == -1)
9764       return -1;
9765   }
9766   {
9767     char device[] = "/dev/sda1";
9768     char mountpoint[] = "/";
9769     int r;
9770     suppress_error = 0;
9771     r = guestfs_mount (g, device, mountpoint);
9772     if (r == -1)
9773       return -1;
9774   }
9775   /* TestOutput for file (0) */
9776   char expected[] = "empty";
9777   {
9778     char path[] = "/new";
9779     int r;
9780     suppress_error = 0;
9781     r = guestfs_touch (g, path);
9782     if (r == -1)
9783       return -1;
9784   }
9785   {
9786     char path[] = "/new";
9787     char *r;
9788     suppress_error = 0;
9789     r = guestfs_file (g, path);
9790     if (r == NULL)
9791       return -1;
9792     if (strcmp (r, expected) != 0) {
9793       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9794       return -1;
9795     }
9796     free (r);
9797   }
9798   return 0;
9799 }
9800
9801 static int test_file_1_skip (void)
9802 {
9803   const char *str;
9804
9805   str = getenv ("SKIP_TEST_FILE_1");
9806   if (str && strcmp (str, "1") == 0) return 1;
9807   str = getenv ("SKIP_TEST_FILE");
9808   if (str && strcmp (str, "1") == 0) return 1;
9809   return 0;
9810 }
9811
9812 static int test_file_1 (void)
9813 {
9814   if (test_file_1_skip ()) {
9815     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9816     return 0;
9817   }
9818
9819   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9820   {
9821     char device[] = "/dev/sda";
9822     int r;
9823     suppress_error = 0;
9824     r = guestfs_blockdev_setrw (g, device);
9825     if (r == -1)
9826       return -1;
9827   }
9828   {
9829     int r;
9830     suppress_error = 0;
9831     r = guestfs_umount_all (g);
9832     if (r == -1)
9833       return -1;
9834   }
9835   {
9836     int r;
9837     suppress_error = 0;
9838     r = guestfs_lvm_remove_all (g);
9839     if (r == -1)
9840       return -1;
9841   }
9842   {
9843     char device[] = "/dev/sda";
9844     char lines_0[] = ",";
9845     char *lines[] = {
9846       lines_0,
9847       NULL
9848     };
9849     int r;
9850     suppress_error = 0;
9851     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9852     if (r == -1)
9853       return -1;
9854   }
9855   {
9856     char fstype[] = "ext2";
9857     char device[] = "/dev/sda1";
9858     int r;
9859     suppress_error = 0;
9860     r = guestfs_mkfs (g, fstype, device);
9861     if (r == -1)
9862       return -1;
9863   }
9864   {
9865     char device[] = "/dev/sda1";
9866     char mountpoint[] = "/";
9867     int r;
9868     suppress_error = 0;
9869     r = guestfs_mount (g, device, mountpoint);
9870     if (r == -1)
9871       return -1;
9872   }
9873   /* TestOutput for file (1) */
9874   char expected[] = "ASCII text";
9875   {
9876     char path[] = "/new";
9877     char content[] = "some content\n";
9878     int r;
9879     suppress_error = 0;
9880     r = guestfs_write_file (g, path, content, 0);
9881     if (r == -1)
9882       return -1;
9883   }
9884   {
9885     char path[] = "/new";
9886     char *r;
9887     suppress_error = 0;
9888     r = guestfs_file (g, path);
9889     if (r == NULL)
9890       return -1;
9891     if (strcmp (r, expected) != 0) {
9892       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9893       return -1;
9894     }
9895     free (r);
9896   }
9897   return 0;
9898 }
9899
9900 static int test_file_2_skip (void)
9901 {
9902   const char *str;
9903
9904   str = getenv ("SKIP_TEST_FILE_2");
9905   if (str && strcmp (str, "1") == 0) return 1;
9906   str = getenv ("SKIP_TEST_FILE");
9907   if (str && strcmp (str, "1") == 0) return 1;
9908   return 0;
9909 }
9910
9911 static int test_file_2 (void)
9912 {
9913   if (test_file_2_skip ()) {
9914     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
9915     return 0;
9916   }
9917
9918   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
9919   {
9920     char device[] = "/dev/sda";
9921     int r;
9922     suppress_error = 0;
9923     r = guestfs_blockdev_setrw (g, device);
9924     if (r == -1)
9925       return -1;
9926   }
9927   {
9928     int r;
9929     suppress_error = 0;
9930     r = guestfs_umount_all (g);
9931     if (r == -1)
9932       return -1;
9933   }
9934   {
9935     int r;
9936     suppress_error = 0;
9937     r = guestfs_lvm_remove_all (g);
9938     if (r == -1)
9939       return -1;
9940   }
9941   {
9942     char device[] = "/dev/sda";
9943     char lines_0[] = ",";
9944     char *lines[] = {
9945       lines_0,
9946       NULL
9947     };
9948     int r;
9949     suppress_error = 0;
9950     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9951     if (r == -1)
9952       return -1;
9953   }
9954   {
9955     char fstype[] = "ext2";
9956     char device[] = "/dev/sda1";
9957     int r;
9958     suppress_error = 0;
9959     r = guestfs_mkfs (g, fstype, device);
9960     if (r == -1)
9961       return -1;
9962   }
9963   {
9964     char device[] = "/dev/sda1";
9965     char mountpoint[] = "/";
9966     int r;
9967     suppress_error = 0;
9968     r = guestfs_mount (g, device, mountpoint);
9969     if (r == -1)
9970       return -1;
9971   }
9972   /* TestLastFail for file (2) */
9973   {
9974     char path[] = "/nofile";
9975     char *r;
9976     suppress_error = 1;
9977     r = guestfs_file (g, path);
9978     if (r != NULL)
9979       return -1;
9980     free (r);
9981   }
9982   return 0;
9983 }
9984
9985 static int test_umount_all_0_skip (void)
9986 {
9987   const char *str;
9988
9989   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
9990   if (str && strcmp (str, "1") == 0) return 1;
9991   str = getenv ("SKIP_TEST_UMOUNT_ALL");
9992   if (str && strcmp (str, "1") == 0) return 1;
9993   return 0;
9994 }
9995
9996 static int test_umount_all_0 (void)
9997 {
9998   if (test_umount_all_0_skip ()) {
9999     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10000     return 0;
10001   }
10002
10003   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10004   {
10005     char device[] = "/dev/sda";
10006     int r;
10007     suppress_error = 0;
10008     r = guestfs_blockdev_setrw (g, device);
10009     if (r == -1)
10010       return -1;
10011   }
10012   {
10013     int r;
10014     suppress_error = 0;
10015     r = guestfs_umount_all (g);
10016     if (r == -1)
10017       return -1;
10018   }
10019   {
10020     int r;
10021     suppress_error = 0;
10022     r = guestfs_lvm_remove_all (g);
10023     if (r == -1)
10024       return -1;
10025   }
10026   {
10027     char device[] = "/dev/sda";
10028     char lines_0[] = ",";
10029     char *lines[] = {
10030       lines_0,
10031       NULL
10032     };
10033     int r;
10034     suppress_error = 0;
10035     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10036     if (r == -1)
10037       return -1;
10038   }
10039   {
10040     char fstype[] = "ext2";
10041     char device[] = "/dev/sda1";
10042     int r;
10043     suppress_error = 0;
10044     r = guestfs_mkfs (g, fstype, device);
10045     if (r == -1)
10046       return -1;
10047   }
10048   {
10049     char device[] = "/dev/sda1";
10050     char mountpoint[] = "/";
10051     int r;
10052     suppress_error = 0;
10053     r = guestfs_mount (g, device, mountpoint);
10054     if (r == -1)
10055       return -1;
10056   }
10057   /* TestOutputList for umount_all (0) */
10058   {
10059     int r;
10060     suppress_error = 0;
10061     r = guestfs_umount_all (g);
10062     if (r == -1)
10063       return -1;
10064   }
10065   {
10066     char **r;
10067     int i;
10068     suppress_error = 0;
10069     r = guestfs_mounts (g);
10070     if (r == NULL)
10071       return -1;
10072     if (r[0] != NULL) {
10073       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10074       print_strings (r);
10075       return -1;
10076     }
10077     for (i = 0; r[i] != NULL; ++i)
10078       free (r[i]);
10079     free (r);
10080   }
10081   return 0;
10082 }
10083
10084 static int test_umount_all_1_skip (void)
10085 {
10086   const char *str;
10087
10088   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10089   if (str && strcmp (str, "1") == 0) return 1;
10090   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10091   if (str && strcmp (str, "1") == 0) return 1;
10092   return 0;
10093 }
10094
10095 static int test_umount_all_1 (void)
10096 {
10097   if (test_umount_all_1_skip ()) {
10098     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10099     return 0;
10100   }
10101
10102   /* InitNone|InitEmpty for test_umount_all_1 */
10103   {
10104     char device[] = "/dev/sda";
10105     int r;
10106     suppress_error = 0;
10107     r = guestfs_blockdev_setrw (g, device);
10108     if (r == -1)
10109       return -1;
10110   }
10111   {
10112     int r;
10113     suppress_error = 0;
10114     r = guestfs_umount_all (g);
10115     if (r == -1)
10116       return -1;
10117   }
10118   {
10119     int r;
10120     suppress_error = 0;
10121     r = guestfs_lvm_remove_all (g);
10122     if (r == -1)
10123       return -1;
10124   }
10125   /* TestOutputList for umount_all (1) */
10126   {
10127     char device[] = "/dev/sda";
10128     char lines_0[] = ",10";
10129     char lines_1[] = ",20";
10130     char lines_2[] = ",";
10131     char *lines[] = {
10132       lines_0,
10133       lines_1,
10134       lines_2,
10135       NULL
10136     };
10137     int r;
10138     suppress_error = 0;
10139     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10140     if (r == -1)
10141       return -1;
10142   }
10143   {
10144     char fstype[] = "ext2";
10145     char device[] = "/dev/sda1";
10146     int r;
10147     suppress_error = 0;
10148     r = guestfs_mkfs (g, fstype, device);
10149     if (r == -1)
10150       return -1;
10151   }
10152   {
10153     char fstype[] = "ext2";
10154     char device[] = "/dev/sda2";
10155     int r;
10156     suppress_error = 0;
10157     r = guestfs_mkfs (g, fstype, device);
10158     if (r == -1)
10159       return -1;
10160   }
10161   {
10162     char fstype[] = "ext2";
10163     char device[] = "/dev/sda3";
10164     int r;
10165     suppress_error = 0;
10166     r = guestfs_mkfs (g, fstype, device);
10167     if (r == -1)
10168       return -1;
10169   }
10170   {
10171     char device[] = "/dev/sda1";
10172     char mountpoint[] = "/";
10173     int r;
10174     suppress_error = 0;
10175     r = guestfs_mount (g, device, mountpoint);
10176     if (r == -1)
10177       return -1;
10178   }
10179   {
10180     char path[] = "/mp1";
10181     int r;
10182     suppress_error = 0;
10183     r = guestfs_mkdir (g, path);
10184     if (r == -1)
10185       return -1;
10186   }
10187   {
10188     char device[] = "/dev/sda2";
10189     char mountpoint[] = "/mp1";
10190     int r;
10191     suppress_error = 0;
10192     r = guestfs_mount (g, device, mountpoint);
10193     if (r == -1)
10194       return -1;
10195   }
10196   {
10197     char path[] = "/mp1/mp2";
10198     int r;
10199     suppress_error = 0;
10200     r = guestfs_mkdir (g, path);
10201     if (r == -1)
10202       return -1;
10203   }
10204   {
10205     char device[] = "/dev/sda3";
10206     char mountpoint[] = "/mp1/mp2";
10207     int r;
10208     suppress_error = 0;
10209     r = guestfs_mount (g, device, mountpoint);
10210     if (r == -1)
10211       return -1;
10212   }
10213   {
10214     char path[] = "/mp1/mp2/mp3";
10215     int r;
10216     suppress_error = 0;
10217     r = guestfs_mkdir (g, path);
10218     if (r == -1)
10219       return -1;
10220   }
10221   {
10222     int r;
10223     suppress_error = 0;
10224     r = guestfs_umount_all (g);
10225     if (r == -1)
10226       return -1;
10227   }
10228   {
10229     char **r;
10230     int i;
10231     suppress_error = 0;
10232     r = guestfs_mounts (g);
10233     if (r == NULL)
10234       return -1;
10235     if (r[0] != NULL) {
10236       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10237       print_strings (r);
10238       return -1;
10239     }
10240     for (i = 0; r[i] != NULL; ++i)
10241       free (r[i]);
10242     free (r);
10243   }
10244   return 0;
10245 }
10246
10247 static int test_mounts_0_skip (void)
10248 {
10249   const char *str;
10250
10251   str = getenv ("SKIP_TEST_MOUNTS_0");
10252   if (str && strcmp (str, "1") == 0) return 1;
10253   str = getenv ("SKIP_TEST_MOUNTS");
10254   if (str && strcmp (str, "1") == 0) return 1;
10255   return 0;
10256 }
10257
10258 static int test_mounts_0 (void)
10259 {
10260   if (test_mounts_0_skip ()) {
10261     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10262     return 0;
10263   }
10264
10265   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10266   {
10267     char device[] = "/dev/sda";
10268     int r;
10269     suppress_error = 0;
10270     r = guestfs_blockdev_setrw (g, device);
10271     if (r == -1)
10272       return -1;
10273   }
10274   {
10275     int r;
10276     suppress_error = 0;
10277     r = guestfs_umount_all (g);
10278     if (r == -1)
10279       return -1;
10280   }
10281   {
10282     int r;
10283     suppress_error = 0;
10284     r = guestfs_lvm_remove_all (g);
10285     if (r == -1)
10286       return -1;
10287   }
10288   {
10289     char device[] = "/dev/sda";
10290     char lines_0[] = ",";
10291     char *lines[] = {
10292       lines_0,
10293       NULL
10294     };
10295     int r;
10296     suppress_error = 0;
10297     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10298     if (r == -1)
10299       return -1;
10300   }
10301   {
10302     char fstype[] = "ext2";
10303     char device[] = "/dev/sda1";
10304     int r;
10305     suppress_error = 0;
10306     r = guestfs_mkfs (g, fstype, device);
10307     if (r == -1)
10308       return -1;
10309   }
10310   {
10311     char device[] = "/dev/sda1";
10312     char mountpoint[] = "/";
10313     int r;
10314     suppress_error = 0;
10315     r = guestfs_mount (g, device, mountpoint);
10316     if (r == -1)
10317       return -1;
10318   }
10319   /* TestOutputListOfDevices for mounts (0) */
10320   {
10321     char **r;
10322     int i;
10323     suppress_error = 0;
10324     r = guestfs_mounts (g);
10325     if (r == NULL)
10326       return -1;
10327     if (!r[0]) {
10328       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10329       print_strings (r);
10330       return -1;
10331     }
10332     {
10333       char expected[] = "/dev/sda1";
10334       r[0][5] = 's';
10335       if (strcmp (r[0], expected) != 0) {
10336         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10337         return -1;
10338       }
10339     }
10340     if (r[1] != NULL) {
10341       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10342       print_strings (r);
10343       return -1;
10344     }
10345     for (i = 0; r[i] != NULL; ++i)
10346       free (r[i]);
10347     free (r);
10348   }
10349   return 0;
10350 }
10351
10352 static int test_umount_0_skip (void)
10353 {
10354   const char *str;
10355
10356   str = getenv ("SKIP_TEST_UMOUNT_0");
10357   if (str && strcmp (str, "1") == 0) return 1;
10358   str = getenv ("SKIP_TEST_UMOUNT");
10359   if (str && strcmp (str, "1") == 0) return 1;
10360   return 0;
10361 }
10362
10363 static int test_umount_0 (void)
10364 {
10365   if (test_umount_0_skip ()) {
10366     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10367     return 0;
10368   }
10369
10370   /* InitNone|InitEmpty for test_umount_0 */
10371   {
10372     char device[] = "/dev/sda";
10373     int r;
10374     suppress_error = 0;
10375     r = guestfs_blockdev_setrw (g, device);
10376     if (r == -1)
10377       return -1;
10378   }
10379   {
10380     int r;
10381     suppress_error = 0;
10382     r = guestfs_umount_all (g);
10383     if (r == -1)
10384       return -1;
10385   }
10386   {
10387     int r;
10388     suppress_error = 0;
10389     r = guestfs_lvm_remove_all (g);
10390     if (r == -1)
10391       return -1;
10392   }
10393   /* TestOutputListOfDevices for umount (0) */
10394   {
10395     char device[] = "/dev/sda";
10396     char lines_0[] = ",";
10397     char *lines[] = {
10398       lines_0,
10399       NULL
10400     };
10401     int r;
10402     suppress_error = 0;
10403     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10404     if (r == -1)
10405       return -1;
10406   }
10407   {
10408     char fstype[] = "ext2";
10409     char device[] = "/dev/sda1";
10410     int r;
10411     suppress_error = 0;
10412     r = guestfs_mkfs (g, fstype, device);
10413     if (r == -1)
10414       return -1;
10415   }
10416   {
10417     char device[] = "/dev/sda1";
10418     char mountpoint[] = "/";
10419     int r;
10420     suppress_error = 0;
10421     r = guestfs_mount (g, device, mountpoint);
10422     if (r == -1)
10423       return -1;
10424   }
10425   {
10426     char **r;
10427     int i;
10428     suppress_error = 0;
10429     r = guestfs_mounts (g);
10430     if (r == NULL)
10431       return -1;
10432     if (!r[0]) {
10433       fprintf (stderr, "test_umount_0: short list returned from command\n");
10434       print_strings (r);
10435       return -1;
10436     }
10437     {
10438       char expected[] = "/dev/sda1";
10439       r[0][5] = 's';
10440       if (strcmp (r[0], expected) != 0) {
10441         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10442         return -1;
10443       }
10444     }
10445     if (r[1] != NULL) {
10446       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10447       print_strings (r);
10448       return -1;
10449     }
10450     for (i = 0; r[i] != NULL; ++i)
10451       free (r[i]);
10452     free (r);
10453   }
10454   return 0;
10455 }
10456
10457 static int test_umount_1_skip (void)
10458 {
10459   const char *str;
10460
10461   str = getenv ("SKIP_TEST_UMOUNT_1");
10462   if (str && strcmp (str, "1") == 0) return 1;
10463   str = getenv ("SKIP_TEST_UMOUNT");
10464   if (str && strcmp (str, "1") == 0) return 1;
10465   return 0;
10466 }
10467
10468 static int test_umount_1 (void)
10469 {
10470   if (test_umount_1_skip ()) {
10471     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10472     return 0;
10473   }
10474
10475   /* InitNone|InitEmpty for test_umount_1 */
10476   {
10477     char device[] = "/dev/sda";
10478     int r;
10479     suppress_error = 0;
10480     r = guestfs_blockdev_setrw (g, device);
10481     if (r == -1)
10482       return -1;
10483   }
10484   {
10485     int r;
10486     suppress_error = 0;
10487     r = guestfs_umount_all (g);
10488     if (r == -1)
10489       return -1;
10490   }
10491   {
10492     int r;
10493     suppress_error = 0;
10494     r = guestfs_lvm_remove_all (g);
10495     if (r == -1)
10496       return -1;
10497   }
10498   /* TestOutputList for umount (1) */
10499   {
10500     char device[] = "/dev/sda";
10501     char lines_0[] = ",";
10502     char *lines[] = {
10503       lines_0,
10504       NULL
10505     };
10506     int r;
10507     suppress_error = 0;
10508     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10509     if (r == -1)
10510       return -1;
10511   }
10512   {
10513     char fstype[] = "ext2";
10514     char device[] = "/dev/sda1";
10515     int r;
10516     suppress_error = 0;
10517     r = guestfs_mkfs (g, fstype, device);
10518     if (r == -1)
10519       return -1;
10520   }
10521   {
10522     char device[] = "/dev/sda1";
10523     char mountpoint[] = "/";
10524     int r;
10525     suppress_error = 0;
10526     r = guestfs_mount (g, device, mountpoint);
10527     if (r == -1)
10528       return -1;
10529   }
10530   {
10531     char pathordevice[] = "/";
10532     int r;
10533     suppress_error = 0;
10534     r = guestfs_umount (g, pathordevice);
10535     if (r == -1)
10536       return -1;
10537   }
10538   {
10539     char **r;
10540     int i;
10541     suppress_error = 0;
10542     r = guestfs_mounts (g);
10543     if (r == NULL)
10544       return -1;
10545     if (r[0] != NULL) {
10546       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10547       print_strings (r);
10548       return -1;
10549     }
10550     for (i = 0; r[i] != NULL; ++i)
10551       free (r[i]);
10552     free (r);
10553   }
10554   return 0;
10555 }
10556
10557 static int test_write_file_0_skip (void)
10558 {
10559   const char *str;
10560
10561   str = getenv ("SKIP_TEST_WRITE_FILE_0");
10562   if (str && strcmp (str, "1") == 0) return 1;
10563   str = getenv ("SKIP_TEST_WRITE_FILE");
10564   if (str && strcmp (str, "1") == 0) return 1;
10565   return 0;
10566 }
10567
10568 static int test_write_file_0 (void)
10569 {
10570   if (test_write_file_0_skip ()) {
10571     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10572     return 0;
10573   }
10574
10575   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10576   {
10577     char device[] = "/dev/sda";
10578     int r;
10579     suppress_error = 0;
10580     r = guestfs_blockdev_setrw (g, device);
10581     if (r == -1)
10582       return -1;
10583   }
10584   {
10585     int r;
10586     suppress_error = 0;
10587     r = guestfs_umount_all (g);
10588     if (r == -1)
10589       return -1;
10590   }
10591   {
10592     int r;
10593     suppress_error = 0;
10594     r = guestfs_lvm_remove_all (g);
10595     if (r == -1)
10596       return -1;
10597   }
10598   {
10599     char device[] = "/dev/sda";
10600     char lines_0[] = ",";
10601     char *lines[] = {
10602       lines_0,
10603       NULL
10604     };
10605     int r;
10606     suppress_error = 0;
10607     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10608     if (r == -1)
10609       return -1;
10610   }
10611   {
10612     char fstype[] = "ext2";
10613     char device[] = "/dev/sda1";
10614     int r;
10615     suppress_error = 0;
10616     r = guestfs_mkfs (g, fstype, device);
10617     if (r == -1)
10618       return -1;
10619   }
10620   {
10621     char device[] = "/dev/sda1";
10622     char mountpoint[] = "/";
10623     int r;
10624     suppress_error = 0;
10625     r = guestfs_mount (g, device, mountpoint);
10626     if (r == -1)
10627       return -1;
10628   }
10629   /* TestOutput for write_file (0) */
10630   char expected[] = "new file contents";
10631   {
10632     char path[] = "/new";
10633     char content[] = "new file contents";
10634     int r;
10635     suppress_error = 0;
10636     r = guestfs_write_file (g, path, content, 0);
10637     if (r == -1)
10638       return -1;
10639   }
10640   {
10641     char path[] = "/new";
10642     char *r;
10643     suppress_error = 0;
10644     r = guestfs_cat (g, path);
10645     if (r == NULL)
10646       return -1;
10647     if (strcmp (r, expected) != 0) {
10648       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10649       return -1;
10650     }
10651     free (r);
10652   }
10653   return 0;
10654 }
10655
10656 static int test_write_file_1_skip (void)
10657 {
10658   const char *str;
10659
10660   str = getenv ("SKIP_TEST_WRITE_FILE_1");
10661   if (str && strcmp (str, "1") == 0) return 1;
10662   str = getenv ("SKIP_TEST_WRITE_FILE");
10663   if (str && strcmp (str, "1") == 0) return 1;
10664   return 0;
10665 }
10666
10667 static int test_write_file_1 (void)
10668 {
10669   if (test_write_file_1_skip ()) {
10670     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10671     return 0;
10672   }
10673
10674   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10675   {
10676     char device[] = "/dev/sda";
10677     int r;
10678     suppress_error = 0;
10679     r = guestfs_blockdev_setrw (g, device);
10680     if (r == -1)
10681       return -1;
10682   }
10683   {
10684     int r;
10685     suppress_error = 0;
10686     r = guestfs_umount_all (g);
10687     if (r == -1)
10688       return -1;
10689   }
10690   {
10691     int r;
10692     suppress_error = 0;
10693     r = guestfs_lvm_remove_all (g);
10694     if (r == -1)
10695       return -1;
10696   }
10697   {
10698     char device[] = "/dev/sda";
10699     char lines_0[] = ",";
10700     char *lines[] = {
10701       lines_0,
10702       NULL
10703     };
10704     int r;
10705     suppress_error = 0;
10706     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10707     if (r == -1)
10708       return -1;
10709   }
10710   {
10711     char fstype[] = "ext2";
10712     char device[] = "/dev/sda1";
10713     int r;
10714     suppress_error = 0;
10715     r = guestfs_mkfs (g, fstype, device);
10716     if (r == -1)
10717       return -1;
10718   }
10719   {
10720     char device[] = "/dev/sda1";
10721     char mountpoint[] = "/";
10722     int r;
10723     suppress_error = 0;
10724     r = guestfs_mount (g, device, mountpoint);
10725     if (r == -1)
10726       return -1;
10727   }
10728   /* TestOutput for write_file (1) */
10729   char expected[] = "\nnew file contents\n";
10730   {
10731     char path[] = "/new";
10732     char content[] = "\nnew file contents\n";
10733     int r;
10734     suppress_error = 0;
10735     r = guestfs_write_file (g, path, content, 0);
10736     if (r == -1)
10737       return -1;
10738   }
10739   {
10740     char path[] = "/new";
10741     char *r;
10742     suppress_error = 0;
10743     r = guestfs_cat (g, path);
10744     if (r == NULL)
10745       return -1;
10746     if (strcmp (r, expected) != 0) {
10747       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10748       return -1;
10749     }
10750     free (r);
10751   }
10752   return 0;
10753 }
10754
10755 static int test_write_file_2_skip (void)
10756 {
10757   const char *str;
10758
10759   str = getenv ("SKIP_TEST_WRITE_FILE_2");
10760   if (str && strcmp (str, "1") == 0) return 1;
10761   str = getenv ("SKIP_TEST_WRITE_FILE");
10762   if (str && strcmp (str, "1") == 0) return 1;
10763   return 0;
10764 }
10765
10766 static int test_write_file_2 (void)
10767 {
10768   if (test_write_file_2_skip ()) {
10769     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10770     return 0;
10771   }
10772
10773   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10774   {
10775     char device[] = "/dev/sda";
10776     int r;
10777     suppress_error = 0;
10778     r = guestfs_blockdev_setrw (g, device);
10779     if (r == -1)
10780       return -1;
10781   }
10782   {
10783     int r;
10784     suppress_error = 0;
10785     r = guestfs_umount_all (g);
10786     if (r == -1)
10787       return -1;
10788   }
10789   {
10790     int r;
10791     suppress_error = 0;
10792     r = guestfs_lvm_remove_all (g);
10793     if (r == -1)
10794       return -1;
10795   }
10796   {
10797     char device[] = "/dev/sda";
10798     char lines_0[] = ",";
10799     char *lines[] = {
10800       lines_0,
10801       NULL
10802     };
10803     int r;
10804     suppress_error = 0;
10805     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10806     if (r == -1)
10807       return -1;
10808   }
10809   {
10810     char fstype[] = "ext2";
10811     char device[] = "/dev/sda1";
10812     int r;
10813     suppress_error = 0;
10814     r = guestfs_mkfs (g, fstype, device);
10815     if (r == -1)
10816       return -1;
10817   }
10818   {
10819     char device[] = "/dev/sda1";
10820     char mountpoint[] = "/";
10821     int r;
10822     suppress_error = 0;
10823     r = guestfs_mount (g, device, mountpoint);
10824     if (r == -1)
10825       return -1;
10826   }
10827   /* TestOutput for write_file (2) */
10828   char expected[] = "\n\n";
10829   {
10830     char path[] = "/new";
10831     char content[] = "\n\n";
10832     int r;
10833     suppress_error = 0;
10834     r = guestfs_write_file (g, path, content, 0);
10835     if (r == -1)
10836       return -1;
10837   }
10838   {
10839     char path[] = "/new";
10840     char *r;
10841     suppress_error = 0;
10842     r = guestfs_cat (g, path);
10843     if (r == NULL)
10844       return -1;
10845     if (strcmp (r, expected) != 0) {
10846       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
10847       return -1;
10848     }
10849     free (r);
10850   }
10851   return 0;
10852 }
10853
10854 static int test_write_file_3_skip (void)
10855 {
10856   const char *str;
10857
10858   str = getenv ("SKIP_TEST_WRITE_FILE_3");
10859   if (str && strcmp (str, "1") == 0) return 1;
10860   str = getenv ("SKIP_TEST_WRITE_FILE");
10861   if (str && strcmp (str, "1") == 0) return 1;
10862   return 0;
10863 }
10864
10865 static int test_write_file_3 (void)
10866 {
10867   if (test_write_file_3_skip ()) {
10868     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
10869     return 0;
10870   }
10871
10872   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
10873   {
10874     char device[] = "/dev/sda";
10875     int r;
10876     suppress_error = 0;
10877     r = guestfs_blockdev_setrw (g, device);
10878     if (r == -1)
10879       return -1;
10880   }
10881   {
10882     int r;
10883     suppress_error = 0;
10884     r = guestfs_umount_all (g);
10885     if (r == -1)
10886       return -1;
10887   }
10888   {
10889     int r;
10890     suppress_error = 0;
10891     r = guestfs_lvm_remove_all (g);
10892     if (r == -1)
10893       return -1;
10894   }
10895   {
10896     char device[] = "/dev/sda";
10897     char lines_0[] = ",";
10898     char *lines[] = {
10899       lines_0,
10900       NULL
10901     };
10902     int r;
10903     suppress_error = 0;
10904     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10905     if (r == -1)
10906       return -1;
10907   }
10908   {
10909     char fstype[] = "ext2";
10910     char device[] = "/dev/sda1";
10911     int r;
10912     suppress_error = 0;
10913     r = guestfs_mkfs (g, fstype, device);
10914     if (r == -1)
10915       return -1;
10916   }
10917   {
10918     char device[] = "/dev/sda1";
10919     char mountpoint[] = "/";
10920     int r;
10921     suppress_error = 0;
10922     r = guestfs_mount (g, device, mountpoint);
10923     if (r == -1)
10924       return -1;
10925   }
10926   /* TestOutput for write_file (3) */
10927   char expected[] = "";
10928   {
10929     char path[] = "/new";
10930     char content[] = "";
10931     int r;
10932     suppress_error = 0;
10933     r = guestfs_write_file (g, path, content, 0);
10934     if (r == -1)
10935       return -1;
10936   }
10937   {
10938     char path[] = "/new";
10939     char *r;
10940     suppress_error = 0;
10941     r = guestfs_cat (g, path);
10942     if (r == NULL)
10943       return -1;
10944     if (strcmp (r, expected) != 0) {
10945       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
10946       return -1;
10947     }
10948     free (r);
10949   }
10950   return 0;
10951 }
10952
10953 static int test_write_file_4_skip (void)
10954 {
10955   const char *str;
10956
10957   str = getenv ("SKIP_TEST_WRITE_FILE_4");
10958   if (str && strcmp (str, "1") == 0) return 1;
10959   str = getenv ("SKIP_TEST_WRITE_FILE");
10960   if (str && strcmp (str, "1") == 0) return 1;
10961   return 0;
10962 }
10963
10964 static int test_write_file_4 (void)
10965 {
10966   if (test_write_file_4_skip ()) {
10967     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
10968     return 0;
10969   }
10970
10971   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
10972   {
10973     char device[] = "/dev/sda";
10974     int r;
10975     suppress_error = 0;
10976     r = guestfs_blockdev_setrw (g, device);
10977     if (r == -1)
10978       return -1;
10979   }
10980   {
10981     int r;
10982     suppress_error = 0;
10983     r = guestfs_umount_all (g);
10984     if (r == -1)
10985       return -1;
10986   }
10987   {
10988     int r;
10989     suppress_error = 0;
10990     r = guestfs_lvm_remove_all (g);
10991     if (r == -1)
10992       return -1;
10993   }
10994   {
10995     char device[] = "/dev/sda";
10996     char lines_0[] = ",";
10997     char *lines[] = {
10998       lines_0,
10999       NULL
11000     };
11001     int r;
11002     suppress_error = 0;
11003     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11004     if (r == -1)
11005       return -1;
11006   }
11007   {
11008     char fstype[] = "ext2";
11009     char device[] = "/dev/sda1";
11010     int r;
11011     suppress_error = 0;
11012     r = guestfs_mkfs (g, fstype, device);
11013     if (r == -1)
11014       return -1;
11015   }
11016   {
11017     char device[] = "/dev/sda1";
11018     char mountpoint[] = "/";
11019     int r;
11020     suppress_error = 0;
11021     r = guestfs_mount (g, device, mountpoint);
11022     if (r == -1)
11023       return -1;
11024   }
11025   /* TestOutput for write_file (4) */
11026   char expected[] = "\n\n\n";
11027   {
11028     char path[] = "/new";
11029     char content[] = "\n\n\n";
11030     int r;
11031     suppress_error = 0;
11032     r = guestfs_write_file (g, path, content, 0);
11033     if (r == -1)
11034       return -1;
11035   }
11036   {
11037     char path[] = "/new";
11038     char *r;
11039     suppress_error = 0;
11040     r = guestfs_cat (g, path);
11041     if (r == NULL)
11042       return -1;
11043     if (strcmp (r, expected) != 0) {
11044       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11045       return -1;
11046     }
11047     free (r);
11048   }
11049   return 0;
11050 }
11051
11052 static int test_write_file_5_skip (void)
11053 {
11054   const char *str;
11055
11056   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11057   if (str && strcmp (str, "1") == 0) return 1;
11058   str = getenv ("SKIP_TEST_WRITE_FILE");
11059   if (str && strcmp (str, "1") == 0) return 1;
11060   return 0;
11061 }
11062
11063 static int test_write_file_5 (void)
11064 {
11065   if (test_write_file_5_skip ()) {
11066     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11067     return 0;
11068   }
11069
11070   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11071   {
11072     char device[] = "/dev/sda";
11073     int r;
11074     suppress_error = 0;
11075     r = guestfs_blockdev_setrw (g, device);
11076     if (r == -1)
11077       return -1;
11078   }
11079   {
11080     int r;
11081     suppress_error = 0;
11082     r = guestfs_umount_all (g);
11083     if (r == -1)
11084       return -1;
11085   }
11086   {
11087     int r;
11088     suppress_error = 0;
11089     r = guestfs_lvm_remove_all (g);
11090     if (r == -1)
11091       return -1;
11092   }
11093   {
11094     char device[] = "/dev/sda";
11095     char lines_0[] = ",";
11096     char *lines[] = {
11097       lines_0,
11098       NULL
11099     };
11100     int r;
11101     suppress_error = 0;
11102     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11103     if (r == -1)
11104       return -1;
11105   }
11106   {
11107     char fstype[] = "ext2";
11108     char device[] = "/dev/sda1";
11109     int r;
11110     suppress_error = 0;
11111     r = guestfs_mkfs (g, fstype, device);
11112     if (r == -1)
11113       return -1;
11114   }
11115   {
11116     char device[] = "/dev/sda1";
11117     char mountpoint[] = "/";
11118     int r;
11119     suppress_error = 0;
11120     r = guestfs_mount (g, device, mountpoint);
11121     if (r == -1)
11122       return -1;
11123   }
11124   /* TestOutput for write_file (5) */
11125   char expected[] = "\n";
11126   {
11127     char path[] = "/new";
11128     char content[] = "\n";
11129     int r;
11130     suppress_error = 0;
11131     r = guestfs_write_file (g, path, content, 0);
11132     if (r == -1)
11133       return -1;
11134   }
11135   {
11136     char path[] = "/new";
11137     char *r;
11138     suppress_error = 0;
11139     r = guestfs_cat (g, path);
11140     if (r == NULL)
11141       return -1;
11142     if (strcmp (r, expected) != 0) {
11143       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11144       return -1;
11145     }
11146     free (r);
11147   }
11148   return 0;
11149 }
11150
11151 static int test_mkfs_0_skip (void)
11152 {
11153   const char *str;
11154
11155   str = getenv ("SKIP_TEST_MKFS_0");
11156   if (str && strcmp (str, "1") == 0) return 1;
11157   str = getenv ("SKIP_TEST_MKFS");
11158   if (str && strcmp (str, "1") == 0) return 1;
11159   return 0;
11160 }
11161
11162 static int test_mkfs_0 (void)
11163 {
11164   if (test_mkfs_0_skip ()) {
11165     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11166     return 0;
11167   }
11168
11169   /* InitNone|InitEmpty for test_mkfs_0 */
11170   {
11171     char device[] = "/dev/sda";
11172     int r;
11173     suppress_error = 0;
11174     r = guestfs_blockdev_setrw (g, device);
11175     if (r == -1)
11176       return -1;
11177   }
11178   {
11179     int r;
11180     suppress_error = 0;
11181     r = guestfs_umount_all (g);
11182     if (r == -1)
11183       return -1;
11184   }
11185   {
11186     int r;
11187     suppress_error = 0;
11188     r = guestfs_lvm_remove_all (g);
11189     if (r == -1)
11190       return -1;
11191   }
11192   /* TestOutput for mkfs (0) */
11193   char expected[] = "new file contents";
11194   {
11195     char device[] = "/dev/sda";
11196     char lines_0[] = ",";
11197     char *lines[] = {
11198       lines_0,
11199       NULL
11200     };
11201     int r;
11202     suppress_error = 0;
11203     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11204     if (r == -1)
11205       return -1;
11206   }
11207   {
11208     char fstype[] = "ext2";
11209     char device[] = "/dev/sda1";
11210     int r;
11211     suppress_error = 0;
11212     r = guestfs_mkfs (g, fstype, device);
11213     if (r == -1)
11214       return -1;
11215   }
11216   {
11217     char device[] = "/dev/sda1";
11218     char mountpoint[] = "/";
11219     int r;
11220     suppress_error = 0;
11221     r = guestfs_mount (g, device, mountpoint);
11222     if (r == -1)
11223       return -1;
11224   }
11225   {
11226     char path[] = "/new";
11227     char content[] = "new file contents";
11228     int r;
11229     suppress_error = 0;
11230     r = guestfs_write_file (g, path, content, 0);
11231     if (r == -1)
11232       return -1;
11233   }
11234   {
11235     char path[] = "/new";
11236     char *r;
11237     suppress_error = 0;
11238     r = guestfs_cat (g, path);
11239     if (r == NULL)
11240       return -1;
11241     if (strcmp (r, expected) != 0) {
11242       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11243       return -1;
11244     }
11245     free (r);
11246   }
11247   return 0;
11248 }
11249
11250 static int test_lvcreate_0_skip (void)
11251 {
11252   const char *str;
11253
11254   str = getenv ("SKIP_TEST_LVCREATE_0");
11255   if (str && strcmp (str, "1") == 0) return 1;
11256   str = getenv ("SKIP_TEST_LVCREATE");
11257   if (str && strcmp (str, "1") == 0) return 1;
11258   return 0;
11259 }
11260
11261 static int test_lvcreate_0 (void)
11262 {
11263   if (test_lvcreate_0_skip ()) {
11264     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11265     return 0;
11266   }
11267
11268   /* InitNone|InitEmpty for test_lvcreate_0 */
11269   {
11270     char device[] = "/dev/sda";
11271     int r;
11272     suppress_error = 0;
11273     r = guestfs_blockdev_setrw (g, device);
11274     if (r == -1)
11275       return -1;
11276   }
11277   {
11278     int r;
11279     suppress_error = 0;
11280     r = guestfs_umount_all (g);
11281     if (r == -1)
11282       return -1;
11283   }
11284   {
11285     int r;
11286     suppress_error = 0;
11287     r = guestfs_lvm_remove_all (g);
11288     if (r == -1)
11289       return -1;
11290   }
11291   /* TestOutputList for lvcreate (0) */
11292   {
11293     char device[] = "/dev/sda";
11294     char lines_0[] = ",10";
11295     char lines_1[] = ",20";
11296     char lines_2[] = ",";
11297     char *lines[] = {
11298       lines_0,
11299       lines_1,
11300       lines_2,
11301       NULL
11302     };
11303     int r;
11304     suppress_error = 0;
11305     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11306     if (r == -1)
11307       return -1;
11308   }
11309   {
11310     char device[] = "/dev/sda1";
11311     int r;
11312     suppress_error = 0;
11313     r = guestfs_pvcreate (g, device);
11314     if (r == -1)
11315       return -1;
11316   }
11317   {
11318     char device[] = "/dev/sda2";
11319     int r;
11320     suppress_error = 0;
11321     r = guestfs_pvcreate (g, device);
11322     if (r == -1)
11323       return -1;
11324   }
11325   {
11326     char device[] = "/dev/sda3";
11327     int r;
11328     suppress_error = 0;
11329     r = guestfs_pvcreate (g, device);
11330     if (r == -1)
11331       return -1;
11332   }
11333   {
11334     char volgroup[] = "VG1";
11335     char physvols_0[] = "/dev/sda1";
11336     char physvols_1[] = "/dev/sda2";
11337     char *physvols[] = {
11338       physvols_0,
11339       physvols_1,
11340       NULL
11341     };
11342     int r;
11343     suppress_error = 0;
11344     r = guestfs_vgcreate (g, volgroup, physvols);
11345     if (r == -1)
11346       return -1;
11347   }
11348   {
11349     char volgroup[] = "VG2";
11350     char physvols_0[] = "/dev/sda3";
11351     char *physvols[] = {
11352       physvols_0,
11353       NULL
11354     };
11355     int r;
11356     suppress_error = 0;
11357     r = guestfs_vgcreate (g, volgroup, physvols);
11358     if (r == -1)
11359       return -1;
11360   }
11361   {
11362     char logvol[] = "LV1";
11363     char volgroup[] = "VG1";
11364     int r;
11365     suppress_error = 0;
11366     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11367     if (r == -1)
11368       return -1;
11369   }
11370   {
11371     char logvol[] = "LV2";
11372     char volgroup[] = "VG1";
11373     int r;
11374     suppress_error = 0;
11375     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11376     if (r == -1)
11377       return -1;
11378   }
11379   {
11380     char logvol[] = "LV3";
11381     char volgroup[] = "VG2";
11382     int r;
11383     suppress_error = 0;
11384     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11385     if (r == -1)
11386       return -1;
11387   }
11388   {
11389     char logvol[] = "LV4";
11390     char volgroup[] = "VG2";
11391     int r;
11392     suppress_error = 0;
11393     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11394     if (r == -1)
11395       return -1;
11396   }
11397   {
11398     char logvol[] = "LV5";
11399     char volgroup[] = "VG2";
11400     int r;
11401     suppress_error = 0;
11402     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11403     if (r == -1)
11404       return -1;
11405   }
11406   {
11407     char **r;
11408     int i;
11409     suppress_error = 0;
11410     r = guestfs_lvs (g);
11411     if (r == NULL)
11412       return -1;
11413     if (!r[0]) {
11414       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11415       print_strings (r);
11416       return -1;
11417     }
11418     {
11419       char expected[] = "/dev/VG1/LV1";
11420       if (strcmp (r[0], expected) != 0) {
11421         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11422         return -1;
11423       }
11424     }
11425     if (!r[1]) {
11426       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11427       print_strings (r);
11428       return -1;
11429     }
11430     {
11431       char expected[] = "/dev/VG1/LV2";
11432       if (strcmp (r[1], expected) != 0) {
11433         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11434         return -1;
11435       }
11436     }
11437     if (!r[2]) {
11438       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11439       print_strings (r);
11440       return -1;
11441     }
11442     {
11443       char expected[] = "/dev/VG2/LV3";
11444       if (strcmp (r[2], expected) != 0) {
11445         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11446         return -1;
11447       }
11448     }
11449     if (!r[3]) {
11450       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11451       print_strings (r);
11452       return -1;
11453     }
11454     {
11455       char expected[] = "/dev/VG2/LV4";
11456       if (strcmp (r[3], expected) != 0) {
11457         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11458         return -1;
11459       }
11460     }
11461     if (!r[4]) {
11462       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11463       print_strings (r);
11464       return -1;
11465     }
11466     {
11467       char expected[] = "/dev/VG2/LV5";
11468       if (strcmp (r[4], expected) != 0) {
11469         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11470         return -1;
11471       }
11472     }
11473     if (r[5] != NULL) {
11474       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11475       print_strings (r);
11476       return -1;
11477     }
11478     for (i = 0; r[i] != NULL; ++i)
11479       free (r[i]);
11480     free (r);
11481   }
11482   return 0;
11483 }
11484
11485 static int test_vgcreate_0_skip (void)
11486 {
11487   const char *str;
11488
11489   str = getenv ("SKIP_TEST_VGCREATE_0");
11490   if (str && strcmp (str, "1") == 0) return 1;
11491   str = getenv ("SKIP_TEST_VGCREATE");
11492   if (str && strcmp (str, "1") == 0) return 1;
11493   return 0;
11494 }
11495
11496 static int test_vgcreate_0 (void)
11497 {
11498   if (test_vgcreate_0_skip ()) {
11499     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11500     return 0;
11501   }
11502
11503   /* InitNone|InitEmpty for test_vgcreate_0 */
11504   {
11505     char device[] = "/dev/sda";
11506     int r;
11507     suppress_error = 0;
11508     r = guestfs_blockdev_setrw (g, device);
11509     if (r == -1)
11510       return -1;
11511   }
11512   {
11513     int r;
11514     suppress_error = 0;
11515     r = guestfs_umount_all (g);
11516     if (r == -1)
11517       return -1;
11518   }
11519   {
11520     int r;
11521     suppress_error = 0;
11522     r = guestfs_lvm_remove_all (g);
11523     if (r == -1)
11524       return -1;
11525   }
11526   /* TestOutputList for vgcreate (0) */
11527   {
11528     char device[] = "/dev/sda";
11529     char lines_0[] = ",10";
11530     char lines_1[] = ",20";
11531     char lines_2[] = ",";
11532     char *lines[] = {
11533       lines_0,
11534       lines_1,
11535       lines_2,
11536       NULL
11537     };
11538     int r;
11539     suppress_error = 0;
11540     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11541     if (r == -1)
11542       return -1;
11543   }
11544   {
11545     char device[] = "/dev/sda1";
11546     int r;
11547     suppress_error = 0;
11548     r = guestfs_pvcreate (g, device);
11549     if (r == -1)
11550       return -1;
11551   }
11552   {
11553     char device[] = "/dev/sda2";
11554     int r;
11555     suppress_error = 0;
11556     r = guestfs_pvcreate (g, device);
11557     if (r == -1)
11558       return -1;
11559   }
11560   {
11561     char device[] = "/dev/sda3";
11562     int r;
11563     suppress_error = 0;
11564     r = guestfs_pvcreate (g, device);
11565     if (r == -1)
11566       return -1;
11567   }
11568   {
11569     char volgroup[] = "VG1";
11570     char physvols_0[] = "/dev/sda1";
11571     char physvols_1[] = "/dev/sda2";
11572     char *physvols[] = {
11573       physvols_0,
11574       physvols_1,
11575       NULL
11576     };
11577     int r;
11578     suppress_error = 0;
11579     r = guestfs_vgcreate (g, volgroup, physvols);
11580     if (r == -1)
11581       return -1;
11582   }
11583   {
11584     char volgroup[] = "VG2";
11585     char physvols_0[] = "/dev/sda3";
11586     char *physvols[] = {
11587       physvols_0,
11588       NULL
11589     };
11590     int r;
11591     suppress_error = 0;
11592     r = guestfs_vgcreate (g, volgroup, physvols);
11593     if (r == -1)
11594       return -1;
11595   }
11596   {
11597     char **r;
11598     int i;
11599     suppress_error = 0;
11600     r = guestfs_vgs (g);
11601     if (r == NULL)
11602       return -1;
11603     if (!r[0]) {
11604       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11605       print_strings (r);
11606       return -1;
11607     }
11608     {
11609       char expected[] = "VG1";
11610       if (strcmp (r[0], expected) != 0) {
11611         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11612         return -1;
11613       }
11614     }
11615     if (!r[1]) {
11616       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11617       print_strings (r);
11618       return -1;
11619     }
11620     {
11621       char expected[] = "VG2";
11622       if (strcmp (r[1], expected) != 0) {
11623         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11624         return -1;
11625       }
11626     }
11627     if (r[2] != NULL) {
11628       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11629       print_strings (r);
11630       return -1;
11631     }
11632     for (i = 0; r[i] != NULL; ++i)
11633       free (r[i]);
11634     free (r);
11635   }
11636   return 0;
11637 }
11638
11639 static int test_pvcreate_0_skip (void)
11640 {
11641   const char *str;
11642
11643   str = getenv ("SKIP_TEST_PVCREATE_0");
11644   if (str && strcmp (str, "1") == 0) return 1;
11645   str = getenv ("SKIP_TEST_PVCREATE");
11646   if (str && strcmp (str, "1") == 0) return 1;
11647   return 0;
11648 }
11649
11650 static int test_pvcreate_0 (void)
11651 {
11652   if (test_pvcreate_0_skip ()) {
11653     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11654     return 0;
11655   }
11656
11657   /* InitNone|InitEmpty for test_pvcreate_0 */
11658   {
11659     char device[] = "/dev/sda";
11660     int r;
11661     suppress_error = 0;
11662     r = guestfs_blockdev_setrw (g, device);
11663     if (r == -1)
11664       return -1;
11665   }
11666   {
11667     int r;
11668     suppress_error = 0;
11669     r = guestfs_umount_all (g);
11670     if (r == -1)
11671       return -1;
11672   }
11673   {
11674     int r;
11675     suppress_error = 0;
11676     r = guestfs_lvm_remove_all (g);
11677     if (r == -1)
11678       return -1;
11679   }
11680   /* TestOutputListOfDevices for pvcreate (0) */
11681   {
11682     char device[] = "/dev/sda";
11683     char lines_0[] = ",10";
11684     char lines_1[] = ",20";
11685     char lines_2[] = ",";
11686     char *lines[] = {
11687       lines_0,
11688       lines_1,
11689       lines_2,
11690       NULL
11691     };
11692     int r;
11693     suppress_error = 0;
11694     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11695     if (r == -1)
11696       return -1;
11697   }
11698   {
11699     char device[] = "/dev/sda1";
11700     int r;
11701     suppress_error = 0;
11702     r = guestfs_pvcreate (g, device);
11703     if (r == -1)
11704       return -1;
11705   }
11706   {
11707     char device[] = "/dev/sda2";
11708     int r;
11709     suppress_error = 0;
11710     r = guestfs_pvcreate (g, device);
11711     if (r == -1)
11712       return -1;
11713   }
11714   {
11715     char device[] = "/dev/sda3";
11716     int r;
11717     suppress_error = 0;
11718     r = guestfs_pvcreate (g, device);
11719     if (r == -1)
11720       return -1;
11721   }
11722   {
11723     char **r;
11724     int i;
11725     suppress_error = 0;
11726     r = guestfs_pvs (g);
11727     if (r == NULL)
11728       return -1;
11729     if (!r[0]) {
11730       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11731       print_strings (r);
11732       return -1;
11733     }
11734     {
11735       char expected[] = "/dev/sda1";
11736       r[0][5] = 's';
11737       if (strcmp (r[0], expected) != 0) {
11738         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11739         return -1;
11740       }
11741     }
11742     if (!r[1]) {
11743       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11744       print_strings (r);
11745       return -1;
11746     }
11747     {
11748       char expected[] = "/dev/sda2";
11749       r[1][5] = 's';
11750       if (strcmp (r[1], expected) != 0) {
11751         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11752         return -1;
11753       }
11754     }
11755     if (!r[2]) {
11756       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11757       print_strings (r);
11758       return -1;
11759     }
11760     {
11761       char expected[] = "/dev/sda3";
11762       r[2][5] = 's';
11763       if (strcmp (r[2], expected) != 0) {
11764         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11765         return -1;
11766       }
11767     }
11768     if (r[3] != NULL) {
11769       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
11770       print_strings (r);
11771       return -1;
11772     }
11773     for (i = 0; r[i] != NULL; ++i)
11774       free (r[i]);
11775     free (r);
11776   }
11777   return 0;
11778 }
11779
11780 static int test_is_dir_0_skip (void)
11781 {
11782   const char *str;
11783
11784   str = getenv ("SKIP_TEST_IS_DIR_0");
11785   if (str && strcmp (str, "1") == 0) return 1;
11786   str = getenv ("SKIP_TEST_IS_DIR");
11787   if (str && strcmp (str, "1") == 0) return 1;
11788   return 0;
11789 }
11790
11791 static int test_is_dir_0 (void)
11792 {
11793   if (test_is_dir_0_skip ()) {
11794     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
11795     return 0;
11796   }
11797
11798   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
11799   {
11800     char device[] = "/dev/sda";
11801     int r;
11802     suppress_error = 0;
11803     r = guestfs_blockdev_setrw (g, device);
11804     if (r == -1)
11805       return -1;
11806   }
11807   {
11808     int r;
11809     suppress_error = 0;
11810     r = guestfs_umount_all (g);
11811     if (r == -1)
11812       return -1;
11813   }
11814   {
11815     int r;
11816     suppress_error = 0;
11817     r = guestfs_lvm_remove_all (g);
11818     if (r == -1)
11819       return -1;
11820   }
11821   {
11822     char device[] = "/dev/sda";
11823     char lines_0[] = ",";
11824     char *lines[] = {
11825       lines_0,
11826       NULL
11827     };
11828     int r;
11829     suppress_error = 0;
11830     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11831     if (r == -1)
11832       return -1;
11833   }
11834   {
11835     char fstype[] = "ext2";
11836     char device[] = "/dev/sda1";
11837     int r;
11838     suppress_error = 0;
11839     r = guestfs_mkfs (g, fstype, device);
11840     if (r == -1)
11841       return -1;
11842   }
11843   {
11844     char device[] = "/dev/sda1";
11845     char mountpoint[] = "/";
11846     int r;
11847     suppress_error = 0;
11848     r = guestfs_mount (g, device, mountpoint);
11849     if (r == -1)
11850       return -1;
11851   }
11852   /* TestOutputFalse for is_dir (0) */
11853   {
11854     char path[] = "/new";
11855     int r;
11856     suppress_error = 0;
11857     r = guestfs_touch (g, path);
11858     if (r == -1)
11859       return -1;
11860   }
11861   {
11862     char path[] = "/new";
11863     int r;
11864     suppress_error = 0;
11865     r = guestfs_is_dir (g, path);
11866     if (r == -1)
11867       return -1;
11868     if (r) {
11869       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
11870       return -1;
11871     }
11872   }
11873   return 0;
11874 }
11875
11876 static int test_is_dir_1_skip (void)
11877 {
11878   const char *str;
11879
11880   str = getenv ("SKIP_TEST_IS_DIR_1");
11881   if (str && strcmp (str, "1") == 0) return 1;
11882   str = getenv ("SKIP_TEST_IS_DIR");
11883   if (str && strcmp (str, "1") == 0) return 1;
11884   return 0;
11885 }
11886
11887 static int test_is_dir_1 (void)
11888 {
11889   if (test_is_dir_1_skip ()) {
11890     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
11891     return 0;
11892   }
11893
11894   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
11895   {
11896     char device[] = "/dev/sda";
11897     int r;
11898     suppress_error = 0;
11899     r = guestfs_blockdev_setrw (g, device);
11900     if (r == -1)
11901       return -1;
11902   }
11903   {
11904     int r;
11905     suppress_error = 0;
11906     r = guestfs_umount_all (g);
11907     if (r == -1)
11908       return -1;
11909   }
11910   {
11911     int r;
11912     suppress_error = 0;
11913     r = guestfs_lvm_remove_all (g);
11914     if (r == -1)
11915       return -1;
11916   }
11917   {
11918     char device[] = "/dev/sda";
11919     char lines_0[] = ",";
11920     char *lines[] = {
11921       lines_0,
11922       NULL
11923     };
11924     int r;
11925     suppress_error = 0;
11926     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11927     if (r == -1)
11928       return -1;
11929   }
11930   {
11931     char fstype[] = "ext2";
11932     char device[] = "/dev/sda1";
11933     int r;
11934     suppress_error = 0;
11935     r = guestfs_mkfs (g, fstype, device);
11936     if (r == -1)
11937       return -1;
11938   }
11939   {
11940     char device[] = "/dev/sda1";
11941     char mountpoint[] = "/";
11942     int r;
11943     suppress_error = 0;
11944     r = guestfs_mount (g, device, mountpoint);
11945     if (r == -1)
11946       return -1;
11947   }
11948   /* TestOutputTrue for is_dir (1) */
11949   {
11950     char path[] = "/new";
11951     int r;
11952     suppress_error = 0;
11953     r = guestfs_mkdir (g, path);
11954     if (r == -1)
11955       return -1;
11956   }
11957   {
11958     char path[] = "/new";
11959     int r;
11960     suppress_error = 0;
11961     r = guestfs_is_dir (g, path);
11962     if (r == -1)
11963       return -1;
11964     if (!r) {
11965       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
11966       return -1;
11967     }
11968   }
11969   return 0;
11970 }
11971
11972 static int test_is_file_0_skip (void)
11973 {
11974   const char *str;
11975
11976   str = getenv ("SKIP_TEST_IS_FILE_0");
11977   if (str && strcmp (str, "1") == 0) return 1;
11978   str = getenv ("SKIP_TEST_IS_FILE");
11979   if (str && strcmp (str, "1") == 0) return 1;
11980   return 0;
11981 }
11982
11983 static int test_is_file_0 (void)
11984 {
11985   if (test_is_file_0_skip ()) {
11986     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
11987     return 0;
11988   }
11989
11990   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
11991   {
11992     char device[] = "/dev/sda";
11993     int r;
11994     suppress_error = 0;
11995     r = guestfs_blockdev_setrw (g, device);
11996     if (r == -1)
11997       return -1;
11998   }
11999   {
12000     int r;
12001     suppress_error = 0;
12002     r = guestfs_umount_all (g);
12003     if (r == -1)
12004       return -1;
12005   }
12006   {
12007     int r;
12008     suppress_error = 0;
12009     r = guestfs_lvm_remove_all (g);
12010     if (r == -1)
12011       return -1;
12012   }
12013   {
12014     char device[] = "/dev/sda";
12015     char lines_0[] = ",";
12016     char *lines[] = {
12017       lines_0,
12018       NULL
12019     };
12020     int r;
12021     suppress_error = 0;
12022     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12023     if (r == -1)
12024       return -1;
12025   }
12026   {
12027     char fstype[] = "ext2";
12028     char device[] = "/dev/sda1";
12029     int r;
12030     suppress_error = 0;
12031     r = guestfs_mkfs (g, fstype, device);
12032     if (r == -1)
12033       return -1;
12034   }
12035   {
12036     char device[] = "/dev/sda1";
12037     char mountpoint[] = "/";
12038     int r;
12039     suppress_error = 0;
12040     r = guestfs_mount (g, device, mountpoint);
12041     if (r == -1)
12042       return -1;
12043   }
12044   /* TestOutputTrue for is_file (0) */
12045   {
12046     char path[] = "/new";
12047     int r;
12048     suppress_error = 0;
12049     r = guestfs_touch (g, path);
12050     if (r == -1)
12051       return -1;
12052   }
12053   {
12054     char path[] = "/new";
12055     int r;
12056     suppress_error = 0;
12057     r = guestfs_is_file (g, path);
12058     if (r == -1)
12059       return -1;
12060     if (!r) {
12061       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12062       return -1;
12063     }
12064   }
12065   return 0;
12066 }
12067
12068 static int test_is_file_1_skip (void)
12069 {
12070   const char *str;
12071
12072   str = getenv ("SKIP_TEST_IS_FILE_1");
12073   if (str && strcmp (str, "1") == 0) return 1;
12074   str = getenv ("SKIP_TEST_IS_FILE");
12075   if (str && strcmp (str, "1") == 0) return 1;
12076   return 0;
12077 }
12078
12079 static int test_is_file_1 (void)
12080 {
12081   if (test_is_file_1_skip ()) {
12082     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12083     return 0;
12084   }
12085
12086   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12087   {
12088     char device[] = "/dev/sda";
12089     int r;
12090     suppress_error = 0;
12091     r = guestfs_blockdev_setrw (g, device);
12092     if (r == -1)
12093       return -1;
12094   }
12095   {
12096     int r;
12097     suppress_error = 0;
12098     r = guestfs_umount_all (g);
12099     if (r == -1)
12100       return -1;
12101   }
12102   {
12103     int r;
12104     suppress_error = 0;
12105     r = guestfs_lvm_remove_all (g);
12106     if (r == -1)
12107       return -1;
12108   }
12109   {
12110     char device[] = "/dev/sda";
12111     char lines_0[] = ",";
12112     char *lines[] = {
12113       lines_0,
12114       NULL
12115     };
12116     int r;
12117     suppress_error = 0;
12118     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12119     if (r == -1)
12120       return -1;
12121   }
12122   {
12123     char fstype[] = "ext2";
12124     char device[] = "/dev/sda1";
12125     int r;
12126     suppress_error = 0;
12127     r = guestfs_mkfs (g, fstype, device);
12128     if (r == -1)
12129       return -1;
12130   }
12131   {
12132     char device[] = "/dev/sda1";
12133     char mountpoint[] = "/";
12134     int r;
12135     suppress_error = 0;
12136     r = guestfs_mount (g, device, mountpoint);
12137     if (r == -1)
12138       return -1;
12139   }
12140   /* TestOutputFalse for is_file (1) */
12141   {
12142     char path[] = "/new";
12143     int r;
12144     suppress_error = 0;
12145     r = guestfs_mkdir (g, path);
12146     if (r == -1)
12147       return -1;
12148   }
12149   {
12150     char path[] = "/new";
12151     int r;
12152     suppress_error = 0;
12153     r = guestfs_is_file (g, path);
12154     if (r == -1)
12155       return -1;
12156     if (r) {
12157       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12158       return -1;
12159     }
12160   }
12161   return 0;
12162 }
12163
12164 static int test_exists_0_skip (void)
12165 {
12166   const char *str;
12167
12168   str = getenv ("SKIP_TEST_EXISTS_0");
12169   if (str && strcmp (str, "1") == 0) return 1;
12170   str = getenv ("SKIP_TEST_EXISTS");
12171   if (str && strcmp (str, "1") == 0) return 1;
12172   return 0;
12173 }
12174
12175 static int test_exists_0 (void)
12176 {
12177   if (test_exists_0_skip ()) {
12178     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12179     return 0;
12180   }
12181
12182   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12183   {
12184     char device[] = "/dev/sda";
12185     int r;
12186     suppress_error = 0;
12187     r = guestfs_blockdev_setrw (g, device);
12188     if (r == -1)
12189       return -1;
12190   }
12191   {
12192     int r;
12193     suppress_error = 0;
12194     r = guestfs_umount_all (g);
12195     if (r == -1)
12196       return -1;
12197   }
12198   {
12199     int r;
12200     suppress_error = 0;
12201     r = guestfs_lvm_remove_all (g);
12202     if (r == -1)
12203       return -1;
12204   }
12205   {
12206     char device[] = "/dev/sda";
12207     char lines_0[] = ",";
12208     char *lines[] = {
12209       lines_0,
12210       NULL
12211     };
12212     int r;
12213     suppress_error = 0;
12214     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12215     if (r == -1)
12216       return -1;
12217   }
12218   {
12219     char fstype[] = "ext2";
12220     char device[] = "/dev/sda1";
12221     int r;
12222     suppress_error = 0;
12223     r = guestfs_mkfs (g, fstype, device);
12224     if (r == -1)
12225       return -1;
12226   }
12227   {
12228     char device[] = "/dev/sda1";
12229     char mountpoint[] = "/";
12230     int r;
12231     suppress_error = 0;
12232     r = guestfs_mount (g, device, mountpoint);
12233     if (r == -1)
12234       return -1;
12235   }
12236   /* TestOutputTrue for exists (0) */
12237   {
12238     char path[] = "/new";
12239     int r;
12240     suppress_error = 0;
12241     r = guestfs_touch (g, path);
12242     if (r == -1)
12243       return -1;
12244   }
12245   {
12246     char path[] = "/new";
12247     int r;
12248     suppress_error = 0;
12249     r = guestfs_exists (g, path);
12250     if (r == -1)
12251       return -1;
12252     if (!r) {
12253       fprintf (stderr, "test_exists_0: expected true, got false\n");
12254       return -1;
12255     }
12256   }
12257   return 0;
12258 }
12259
12260 static int test_exists_1_skip (void)
12261 {
12262   const char *str;
12263
12264   str = getenv ("SKIP_TEST_EXISTS_1");
12265   if (str && strcmp (str, "1") == 0) return 1;
12266   str = getenv ("SKIP_TEST_EXISTS");
12267   if (str && strcmp (str, "1") == 0) return 1;
12268   return 0;
12269 }
12270
12271 static int test_exists_1 (void)
12272 {
12273   if (test_exists_1_skip ()) {
12274     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12275     return 0;
12276   }
12277
12278   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12279   {
12280     char device[] = "/dev/sda";
12281     int r;
12282     suppress_error = 0;
12283     r = guestfs_blockdev_setrw (g, device);
12284     if (r == -1)
12285       return -1;
12286   }
12287   {
12288     int r;
12289     suppress_error = 0;
12290     r = guestfs_umount_all (g);
12291     if (r == -1)
12292       return -1;
12293   }
12294   {
12295     int r;
12296     suppress_error = 0;
12297     r = guestfs_lvm_remove_all (g);
12298     if (r == -1)
12299       return -1;
12300   }
12301   {
12302     char device[] = "/dev/sda";
12303     char lines_0[] = ",";
12304     char *lines[] = {
12305       lines_0,
12306       NULL
12307     };
12308     int r;
12309     suppress_error = 0;
12310     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12311     if (r == -1)
12312       return -1;
12313   }
12314   {
12315     char fstype[] = "ext2";
12316     char device[] = "/dev/sda1";
12317     int r;
12318     suppress_error = 0;
12319     r = guestfs_mkfs (g, fstype, device);
12320     if (r == -1)
12321       return -1;
12322   }
12323   {
12324     char device[] = "/dev/sda1";
12325     char mountpoint[] = "/";
12326     int r;
12327     suppress_error = 0;
12328     r = guestfs_mount (g, device, mountpoint);
12329     if (r == -1)
12330       return -1;
12331   }
12332   /* TestOutputTrue for exists (1) */
12333   {
12334     char path[] = "/new";
12335     int r;
12336     suppress_error = 0;
12337     r = guestfs_mkdir (g, path);
12338     if (r == -1)
12339       return -1;
12340   }
12341   {
12342     char path[] = "/new";
12343     int r;
12344     suppress_error = 0;
12345     r = guestfs_exists (g, path);
12346     if (r == -1)
12347       return -1;
12348     if (!r) {
12349       fprintf (stderr, "test_exists_1: expected true, got false\n");
12350       return -1;
12351     }
12352   }
12353   return 0;
12354 }
12355
12356 static int test_mkdir_p_0_skip (void)
12357 {
12358   const char *str;
12359
12360   str = getenv ("SKIP_TEST_MKDIR_P_0");
12361   if (str && strcmp (str, "1") == 0) return 1;
12362   str = getenv ("SKIP_TEST_MKDIR_P");
12363   if (str && strcmp (str, "1") == 0) return 1;
12364   return 0;
12365 }
12366
12367 static int test_mkdir_p_0 (void)
12368 {
12369   if (test_mkdir_p_0_skip ()) {
12370     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12371     return 0;
12372   }
12373
12374   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12375   {
12376     char device[] = "/dev/sda";
12377     int r;
12378     suppress_error = 0;
12379     r = guestfs_blockdev_setrw (g, device);
12380     if (r == -1)
12381       return -1;
12382   }
12383   {
12384     int r;
12385     suppress_error = 0;
12386     r = guestfs_umount_all (g);
12387     if (r == -1)
12388       return -1;
12389   }
12390   {
12391     int r;
12392     suppress_error = 0;
12393     r = guestfs_lvm_remove_all (g);
12394     if (r == -1)
12395       return -1;
12396   }
12397   {
12398     char device[] = "/dev/sda";
12399     char lines_0[] = ",";
12400     char *lines[] = {
12401       lines_0,
12402       NULL
12403     };
12404     int r;
12405     suppress_error = 0;
12406     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12407     if (r == -1)
12408       return -1;
12409   }
12410   {
12411     char fstype[] = "ext2";
12412     char device[] = "/dev/sda1";
12413     int r;
12414     suppress_error = 0;
12415     r = guestfs_mkfs (g, fstype, device);
12416     if (r == -1)
12417       return -1;
12418   }
12419   {
12420     char device[] = "/dev/sda1";
12421     char mountpoint[] = "/";
12422     int r;
12423     suppress_error = 0;
12424     r = guestfs_mount (g, device, mountpoint);
12425     if (r == -1)
12426       return -1;
12427   }
12428   /* TestOutputTrue for mkdir_p (0) */
12429   {
12430     char path[] = "/new/foo/bar";
12431     int r;
12432     suppress_error = 0;
12433     r = guestfs_mkdir_p (g, path);
12434     if (r == -1)
12435       return -1;
12436   }
12437   {
12438     char path[] = "/new/foo/bar";
12439     int r;
12440     suppress_error = 0;
12441     r = guestfs_is_dir (g, path);
12442     if (r == -1)
12443       return -1;
12444     if (!r) {
12445       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12446       return -1;
12447     }
12448   }
12449   return 0;
12450 }
12451
12452 static int test_mkdir_p_1_skip (void)
12453 {
12454   const char *str;
12455
12456   str = getenv ("SKIP_TEST_MKDIR_P_1");
12457   if (str && strcmp (str, "1") == 0) return 1;
12458   str = getenv ("SKIP_TEST_MKDIR_P");
12459   if (str && strcmp (str, "1") == 0) return 1;
12460   return 0;
12461 }
12462
12463 static int test_mkdir_p_1 (void)
12464 {
12465   if (test_mkdir_p_1_skip ()) {
12466     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12467     return 0;
12468   }
12469
12470   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12471   {
12472     char device[] = "/dev/sda";
12473     int r;
12474     suppress_error = 0;
12475     r = guestfs_blockdev_setrw (g, device);
12476     if (r == -1)
12477       return -1;
12478   }
12479   {
12480     int r;
12481     suppress_error = 0;
12482     r = guestfs_umount_all (g);
12483     if (r == -1)
12484       return -1;
12485   }
12486   {
12487     int r;
12488     suppress_error = 0;
12489     r = guestfs_lvm_remove_all (g);
12490     if (r == -1)
12491       return -1;
12492   }
12493   {
12494     char device[] = "/dev/sda";
12495     char lines_0[] = ",";
12496     char *lines[] = {
12497       lines_0,
12498       NULL
12499     };
12500     int r;
12501     suppress_error = 0;
12502     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12503     if (r == -1)
12504       return -1;
12505   }
12506   {
12507     char fstype[] = "ext2";
12508     char device[] = "/dev/sda1";
12509     int r;
12510     suppress_error = 0;
12511     r = guestfs_mkfs (g, fstype, device);
12512     if (r == -1)
12513       return -1;
12514   }
12515   {
12516     char device[] = "/dev/sda1";
12517     char mountpoint[] = "/";
12518     int r;
12519     suppress_error = 0;
12520     r = guestfs_mount (g, device, mountpoint);
12521     if (r == -1)
12522       return -1;
12523   }
12524   /* TestOutputTrue for mkdir_p (1) */
12525   {
12526     char path[] = "/new/foo/bar";
12527     int r;
12528     suppress_error = 0;
12529     r = guestfs_mkdir_p (g, path);
12530     if (r == -1)
12531       return -1;
12532   }
12533   {
12534     char path[] = "/new/foo";
12535     int r;
12536     suppress_error = 0;
12537     r = guestfs_is_dir (g, path);
12538     if (r == -1)
12539       return -1;
12540     if (!r) {
12541       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12542       return -1;
12543     }
12544   }
12545   return 0;
12546 }
12547
12548 static int test_mkdir_p_2_skip (void)
12549 {
12550   const char *str;
12551
12552   str = getenv ("SKIP_TEST_MKDIR_P_2");
12553   if (str && strcmp (str, "1") == 0) return 1;
12554   str = getenv ("SKIP_TEST_MKDIR_P");
12555   if (str && strcmp (str, "1") == 0) return 1;
12556   return 0;
12557 }
12558
12559 static int test_mkdir_p_2 (void)
12560 {
12561   if (test_mkdir_p_2_skip ()) {
12562     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12563     return 0;
12564   }
12565
12566   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12567   {
12568     char device[] = "/dev/sda";
12569     int r;
12570     suppress_error = 0;
12571     r = guestfs_blockdev_setrw (g, device);
12572     if (r == -1)
12573       return -1;
12574   }
12575   {
12576     int r;
12577     suppress_error = 0;
12578     r = guestfs_umount_all (g);
12579     if (r == -1)
12580       return -1;
12581   }
12582   {
12583     int r;
12584     suppress_error = 0;
12585     r = guestfs_lvm_remove_all (g);
12586     if (r == -1)
12587       return -1;
12588   }
12589   {
12590     char device[] = "/dev/sda";
12591     char lines_0[] = ",";
12592     char *lines[] = {
12593       lines_0,
12594       NULL
12595     };
12596     int r;
12597     suppress_error = 0;
12598     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12599     if (r == -1)
12600       return -1;
12601   }
12602   {
12603     char fstype[] = "ext2";
12604     char device[] = "/dev/sda1";
12605     int r;
12606     suppress_error = 0;
12607     r = guestfs_mkfs (g, fstype, device);
12608     if (r == -1)
12609       return -1;
12610   }
12611   {
12612     char device[] = "/dev/sda1";
12613     char mountpoint[] = "/";
12614     int r;
12615     suppress_error = 0;
12616     r = guestfs_mount (g, device, mountpoint);
12617     if (r == -1)
12618       return -1;
12619   }
12620   /* TestOutputTrue for mkdir_p (2) */
12621   {
12622     char path[] = "/new/foo/bar";
12623     int r;
12624     suppress_error = 0;
12625     r = guestfs_mkdir_p (g, path);
12626     if (r == -1)
12627       return -1;
12628   }
12629   {
12630     char path[] = "/new";
12631     int r;
12632     suppress_error = 0;
12633     r = guestfs_is_dir (g, path);
12634     if (r == -1)
12635       return -1;
12636     if (!r) {
12637       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12638       return -1;
12639     }
12640   }
12641   return 0;
12642 }
12643
12644 static int test_mkdir_p_3_skip (void)
12645 {
12646   const char *str;
12647
12648   str = getenv ("SKIP_TEST_MKDIR_P_3");
12649   if (str && strcmp (str, "1") == 0) return 1;
12650   str = getenv ("SKIP_TEST_MKDIR_P");
12651   if (str && strcmp (str, "1") == 0) return 1;
12652   return 0;
12653 }
12654
12655 static int test_mkdir_p_3 (void)
12656 {
12657   if (test_mkdir_p_3_skip ()) {
12658     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12659     return 0;
12660   }
12661
12662   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12663   {
12664     char device[] = "/dev/sda";
12665     int r;
12666     suppress_error = 0;
12667     r = guestfs_blockdev_setrw (g, device);
12668     if (r == -1)
12669       return -1;
12670   }
12671   {
12672     int r;
12673     suppress_error = 0;
12674     r = guestfs_umount_all (g);
12675     if (r == -1)
12676       return -1;
12677   }
12678   {
12679     int r;
12680     suppress_error = 0;
12681     r = guestfs_lvm_remove_all (g);
12682     if (r == -1)
12683       return -1;
12684   }
12685   {
12686     char device[] = "/dev/sda";
12687     char lines_0[] = ",";
12688     char *lines[] = {
12689       lines_0,
12690       NULL
12691     };
12692     int r;
12693     suppress_error = 0;
12694     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12695     if (r == -1)
12696       return -1;
12697   }
12698   {
12699     char fstype[] = "ext2";
12700     char device[] = "/dev/sda1";
12701     int r;
12702     suppress_error = 0;
12703     r = guestfs_mkfs (g, fstype, device);
12704     if (r == -1)
12705       return -1;
12706   }
12707   {
12708     char device[] = "/dev/sda1";
12709     char mountpoint[] = "/";
12710     int r;
12711     suppress_error = 0;
12712     r = guestfs_mount (g, device, mountpoint);
12713     if (r == -1)
12714       return -1;
12715   }
12716   /* TestRun for mkdir_p (3) */
12717   {
12718     char path[] = "/new";
12719     int r;
12720     suppress_error = 0;
12721     r = guestfs_mkdir (g, path);
12722     if (r == -1)
12723       return -1;
12724   }
12725   {
12726     char path[] = "/new";
12727     int r;
12728     suppress_error = 0;
12729     r = guestfs_mkdir_p (g, path);
12730     if (r == -1)
12731       return -1;
12732   }
12733   return 0;
12734 }
12735
12736 static int test_mkdir_p_4_skip (void)
12737 {
12738   const char *str;
12739
12740   str = getenv ("SKIP_TEST_MKDIR_P_4");
12741   if (str && strcmp (str, "1") == 0) return 1;
12742   str = getenv ("SKIP_TEST_MKDIR_P");
12743   if (str && strcmp (str, "1") == 0) return 1;
12744   return 0;
12745 }
12746
12747 static int test_mkdir_p_4 (void)
12748 {
12749   if (test_mkdir_p_4_skip ()) {
12750     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
12751     return 0;
12752   }
12753
12754   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
12755   {
12756     char device[] = "/dev/sda";
12757     int r;
12758     suppress_error = 0;
12759     r = guestfs_blockdev_setrw (g, device);
12760     if (r == -1)
12761       return -1;
12762   }
12763   {
12764     int r;
12765     suppress_error = 0;
12766     r = guestfs_umount_all (g);
12767     if (r == -1)
12768       return -1;
12769   }
12770   {
12771     int r;
12772     suppress_error = 0;
12773     r = guestfs_lvm_remove_all (g);
12774     if (r == -1)
12775       return -1;
12776   }
12777   {
12778     char device[] = "/dev/sda";
12779     char lines_0[] = ",";
12780     char *lines[] = {
12781       lines_0,
12782       NULL
12783     };
12784     int r;
12785     suppress_error = 0;
12786     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12787     if (r == -1)
12788       return -1;
12789   }
12790   {
12791     char fstype[] = "ext2";
12792     char device[] = "/dev/sda1";
12793     int r;
12794     suppress_error = 0;
12795     r = guestfs_mkfs (g, fstype, device);
12796     if (r == -1)
12797       return -1;
12798   }
12799   {
12800     char device[] = "/dev/sda1";
12801     char mountpoint[] = "/";
12802     int r;
12803     suppress_error = 0;
12804     r = guestfs_mount (g, device, mountpoint);
12805     if (r == -1)
12806       return -1;
12807   }
12808   /* TestLastFail for mkdir_p (4) */
12809   {
12810     char path[] = "/new";
12811     int r;
12812     suppress_error = 0;
12813     r = guestfs_touch (g, path);
12814     if (r == -1)
12815       return -1;
12816   }
12817   {
12818     char path[] = "/new";
12819     int r;
12820     suppress_error = 1;
12821     r = guestfs_mkdir_p (g, path);
12822     if (r != -1)
12823       return -1;
12824   }
12825   return 0;
12826 }
12827
12828 static int test_mkdir_0_skip (void)
12829 {
12830   const char *str;
12831
12832   str = getenv ("SKIP_TEST_MKDIR_0");
12833   if (str && strcmp (str, "1") == 0) return 1;
12834   str = getenv ("SKIP_TEST_MKDIR");
12835   if (str && strcmp (str, "1") == 0) return 1;
12836   return 0;
12837 }
12838
12839 static int test_mkdir_0 (void)
12840 {
12841   if (test_mkdir_0_skip ()) {
12842     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
12843     return 0;
12844   }
12845
12846   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
12847   {
12848     char device[] = "/dev/sda";
12849     int r;
12850     suppress_error = 0;
12851     r = guestfs_blockdev_setrw (g, device);
12852     if (r == -1)
12853       return -1;
12854   }
12855   {
12856     int r;
12857     suppress_error = 0;
12858     r = guestfs_umount_all (g);
12859     if (r == -1)
12860       return -1;
12861   }
12862   {
12863     int r;
12864     suppress_error = 0;
12865     r = guestfs_lvm_remove_all (g);
12866     if (r == -1)
12867       return -1;
12868   }
12869   {
12870     char device[] = "/dev/sda";
12871     char lines_0[] = ",";
12872     char *lines[] = {
12873       lines_0,
12874       NULL
12875     };
12876     int r;
12877     suppress_error = 0;
12878     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12879     if (r == -1)
12880       return -1;
12881   }
12882   {
12883     char fstype[] = "ext2";
12884     char device[] = "/dev/sda1";
12885     int r;
12886     suppress_error = 0;
12887     r = guestfs_mkfs (g, fstype, device);
12888     if (r == -1)
12889       return -1;
12890   }
12891   {
12892     char device[] = "/dev/sda1";
12893     char mountpoint[] = "/";
12894     int r;
12895     suppress_error = 0;
12896     r = guestfs_mount (g, device, mountpoint);
12897     if (r == -1)
12898       return -1;
12899   }
12900   /* TestOutputTrue for mkdir (0) */
12901   {
12902     char path[] = "/new";
12903     int r;
12904     suppress_error = 0;
12905     r = guestfs_mkdir (g, path);
12906     if (r == -1)
12907       return -1;
12908   }
12909   {
12910     char path[] = "/new";
12911     int r;
12912     suppress_error = 0;
12913     r = guestfs_is_dir (g, path);
12914     if (r == -1)
12915       return -1;
12916     if (!r) {
12917       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
12918       return -1;
12919     }
12920   }
12921   return 0;
12922 }
12923
12924 static int test_mkdir_1_skip (void)
12925 {
12926   const char *str;
12927
12928   str = getenv ("SKIP_TEST_MKDIR_1");
12929   if (str && strcmp (str, "1") == 0) return 1;
12930   str = getenv ("SKIP_TEST_MKDIR");
12931   if (str && strcmp (str, "1") == 0) return 1;
12932   return 0;
12933 }
12934
12935 static int test_mkdir_1 (void)
12936 {
12937   if (test_mkdir_1_skip ()) {
12938     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
12939     return 0;
12940   }
12941
12942   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
12943   {
12944     char device[] = "/dev/sda";
12945     int r;
12946     suppress_error = 0;
12947     r = guestfs_blockdev_setrw (g, device);
12948     if (r == -1)
12949       return -1;
12950   }
12951   {
12952     int r;
12953     suppress_error = 0;
12954     r = guestfs_umount_all (g);
12955     if (r == -1)
12956       return -1;
12957   }
12958   {
12959     int r;
12960     suppress_error = 0;
12961     r = guestfs_lvm_remove_all (g);
12962     if (r == -1)
12963       return -1;
12964   }
12965   {
12966     char device[] = "/dev/sda";
12967     char lines_0[] = ",";
12968     char *lines[] = {
12969       lines_0,
12970       NULL
12971     };
12972     int r;
12973     suppress_error = 0;
12974     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12975     if (r == -1)
12976       return -1;
12977   }
12978   {
12979     char fstype[] = "ext2";
12980     char device[] = "/dev/sda1";
12981     int r;
12982     suppress_error = 0;
12983     r = guestfs_mkfs (g, fstype, device);
12984     if (r == -1)
12985       return -1;
12986   }
12987   {
12988     char device[] = "/dev/sda1";
12989     char mountpoint[] = "/";
12990     int r;
12991     suppress_error = 0;
12992     r = guestfs_mount (g, device, mountpoint);
12993     if (r == -1)
12994       return -1;
12995   }
12996   /* TestLastFail for mkdir (1) */
12997   {
12998     char path[] = "/new/foo/bar";
12999     int r;
13000     suppress_error = 1;
13001     r = guestfs_mkdir (g, path);
13002     if (r != -1)
13003       return -1;
13004   }
13005   return 0;
13006 }
13007
13008 static int test_rm_rf_0_skip (void)
13009 {
13010   const char *str;
13011
13012   str = getenv ("SKIP_TEST_RM_RF_0");
13013   if (str && strcmp (str, "1") == 0) return 1;
13014   str = getenv ("SKIP_TEST_RM_RF");
13015   if (str && strcmp (str, "1") == 0) return 1;
13016   return 0;
13017 }
13018
13019 static int test_rm_rf_0 (void)
13020 {
13021   if (test_rm_rf_0_skip ()) {
13022     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13023     return 0;
13024   }
13025
13026   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13027   {
13028     char device[] = "/dev/sda";
13029     int r;
13030     suppress_error = 0;
13031     r = guestfs_blockdev_setrw (g, device);
13032     if (r == -1)
13033       return -1;
13034   }
13035   {
13036     int r;
13037     suppress_error = 0;
13038     r = guestfs_umount_all (g);
13039     if (r == -1)
13040       return -1;
13041   }
13042   {
13043     int r;
13044     suppress_error = 0;
13045     r = guestfs_lvm_remove_all (g);
13046     if (r == -1)
13047       return -1;
13048   }
13049   {
13050     char device[] = "/dev/sda";
13051     char lines_0[] = ",";
13052     char *lines[] = {
13053       lines_0,
13054       NULL
13055     };
13056     int r;
13057     suppress_error = 0;
13058     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13059     if (r == -1)
13060       return -1;
13061   }
13062   {
13063     char fstype[] = "ext2";
13064     char device[] = "/dev/sda1";
13065     int r;
13066     suppress_error = 0;
13067     r = guestfs_mkfs (g, fstype, device);
13068     if (r == -1)
13069       return -1;
13070   }
13071   {
13072     char device[] = "/dev/sda1";
13073     char mountpoint[] = "/";
13074     int r;
13075     suppress_error = 0;
13076     r = guestfs_mount (g, device, mountpoint);
13077     if (r == -1)
13078       return -1;
13079   }
13080   /* TestOutputFalse for rm_rf (0) */
13081   {
13082     char path[] = "/new";
13083     int r;
13084     suppress_error = 0;
13085     r = guestfs_mkdir (g, path);
13086     if (r == -1)
13087       return -1;
13088   }
13089   {
13090     char path[] = "/new/foo";
13091     int r;
13092     suppress_error = 0;
13093     r = guestfs_mkdir (g, path);
13094     if (r == -1)
13095       return -1;
13096   }
13097   {
13098     char path[] = "/new/foo/bar";
13099     int r;
13100     suppress_error = 0;
13101     r = guestfs_touch (g, path);
13102     if (r == -1)
13103       return -1;
13104   }
13105   {
13106     char path[] = "/new";
13107     int r;
13108     suppress_error = 0;
13109     r = guestfs_rm_rf (g, path);
13110     if (r == -1)
13111       return -1;
13112   }
13113   {
13114     char path[] = "/new";
13115     int r;
13116     suppress_error = 0;
13117     r = guestfs_exists (g, path);
13118     if (r == -1)
13119       return -1;
13120     if (r) {
13121       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13122       return -1;
13123     }
13124   }
13125   return 0;
13126 }
13127
13128 static int test_rmdir_0_skip (void)
13129 {
13130   const char *str;
13131
13132   str = getenv ("SKIP_TEST_RMDIR_0");
13133   if (str && strcmp (str, "1") == 0) return 1;
13134   str = getenv ("SKIP_TEST_RMDIR");
13135   if (str && strcmp (str, "1") == 0) return 1;
13136   return 0;
13137 }
13138
13139 static int test_rmdir_0 (void)
13140 {
13141   if (test_rmdir_0_skip ()) {
13142     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13143     return 0;
13144   }
13145
13146   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13147   {
13148     char device[] = "/dev/sda";
13149     int r;
13150     suppress_error = 0;
13151     r = guestfs_blockdev_setrw (g, device);
13152     if (r == -1)
13153       return -1;
13154   }
13155   {
13156     int r;
13157     suppress_error = 0;
13158     r = guestfs_umount_all (g);
13159     if (r == -1)
13160       return -1;
13161   }
13162   {
13163     int r;
13164     suppress_error = 0;
13165     r = guestfs_lvm_remove_all (g);
13166     if (r == -1)
13167       return -1;
13168   }
13169   {
13170     char device[] = "/dev/sda";
13171     char lines_0[] = ",";
13172     char *lines[] = {
13173       lines_0,
13174       NULL
13175     };
13176     int r;
13177     suppress_error = 0;
13178     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13179     if (r == -1)
13180       return -1;
13181   }
13182   {
13183     char fstype[] = "ext2";
13184     char device[] = "/dev/sda1";
13185     int r;
13186     suppress_error = 0;
13187     r = guestfs_mkfs (g, fstype, device);
13188     if (r == -1)
13189       return -1;
13190   }
13191   {
13192     char device[] = "/dev/sda1";
13193     char mountpoint[] = "/";
13194     int r;
13195     suppress_error = 0;
13196     r = guestfs_mount (g, device, mountpoint);
13197     if (r == -1)
13198       return -1;
13199   }
13200   /* TestRun for rmdir (0) */
13201   {
13202     char path[] = "/new";
13203     int r;
13204     suppress_error = 0;
13205     r = guestfs_mkdir (g, path);
13206     if (r == -1)
13207       return -1;
13208   }
13209   {
13210     char path[] = "/new";
13211     int r;
13212     suppress_error = 0;
13213     r = guestfs_rmdir (g, path);
13214     if (r == -1)
13215       return -1;
13216   }
13217   return 0;
13218 }
13219
13220 static int test_rmdir_1_skip (void)
13221 {
13222   const char *str;
13223
13224   str = getenv ("SKIP_TEST_RMDIR_1");
13225   if (str && strcmp (str, "1") == 0) return 1;
13226   str = getenv ("SKIP_TEST_RMDIR");
13227   if (str && strcmp (str, "1") == 0) return 1;
13228   return 0;
13229 }
13230
13231 static int test_rmdir_1 (void)
13232 {
13233   if (test_rmdir_1_skip ()) {
13234     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13235     return 0;
13236   }
13237
13238   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13239   {
13240     char device[] = "/dev/sda";
13241     int r;
13242     suppress_error = 0;
13243     r = guestfs_blockdev_setrw (g, device);
13244     if (r == -1)
13245       return -1;
13246   }
13247   {
13248     int r;
13249     suppress_error = 0;
13250     r = guestfs_umount_all (g);
13251     if (r == -1)
13252       return -1;
13253   }
13254   {
13255     int r;
13256     suppress_error = 0;
13257     r = guestfs_lvm_remove_all (g);
13258     if (r == -1)
13259       return -1;
13260   }
13261   {
13262     char device[] = "/dev/sda";
13263     char lines_0[] = ",";
13264     char *lines[] = {
13265       lines_0,
13266       NULL
13267     };
13268     int r;
13269     suppress_error = 0;
13270     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13271     if (r == -1)
13272       return -1;
13273   }
13274   {
13275     char fstype[] = "ext2";
13276     char device[] = "/dev/sda1";
13277     int r;
13278     suppress_error = 0;
13279     r = guestfs_mkfs (g, fstype, device);
13280     if (r == -1)
13281       return -1;
13282   }
13283   {
13284     char device[] = "/dev/sda1";
13285     char mountpoint[] = "/";
13286     int r;
13287     suppress_error = 0;
13288     r = guestfs_mount (g, device, mountpoint);
13289     if (r == -1)
13290       return -1;
13291   }
13292   /* TestLastFail for rmdir (1) */
13293   {
13294     char path[] = "/new";
13295     int r;
13296     suppress_error = 1;
13297     r = guestfs_rmdir (g, path);
13298     if (r != -1)
13299       return -1;
13300   }
13301   return 0;
13302 }
13303
13304 static int test_rmdir_2_skip (void)
13305 {
13306   const char *str;
13307
13308   str = getenv ("SKIP_TEST_RMDIR_2");
13309   if (str && strcmp (str, "1") == 0) return 1;
13310   str = getenv ("SKIP_TEST_RMDIR");
13311   if (str && strcmp (str, "1") == 0) return 1;
13312   return 0;
13313 }
13314
13315 static int test_rmdir_2 (void)
13316 {
13317   if (test_rmdir_2_skip ()) {
13318     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13319     return 0;
13320   }
13321
13322   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13323   {
13324     char device[] = "/dev/sda";
13325     int r;
13326     suppress_error = 0;
13327     r = guestfs_blockdev_setrw (g, device);
13328     if (r == -1)
13329       return -1;
13330   }
13331   {
13332     int r;
13333     suppress_error = 0;
13334     r = guestfs_umount_all (g);
13335     if (r == -1)
13336       return -1;
13337   }
13338   {
13339     int r;
13340     suppress_error = 0;
13341     r = guestfs_lvm_remove_all (g);
13342     if (r == -1)
13343       return -1;
13344   }
13345   {
13346     char device[] = "/dev/sda";
13347     char lines_0[] = ",";
13348     char *lines[] = {
13349       lines_0,
13350       NULL
13351     };
13352     int r;
13353     suppress_error = 0;
13354     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13355     if (r == -1)
13356       return -1;
13357   }
13358   {
13359     char fstype[] = "ext2";
13360     char device[] = "/dev/sda1";
13361     int r;
13362     suppress_error = 0;
13363     r = guestfs_mkfs (g, fstype, device);
13364     if (r == -1)
13365       return -1;
13366   }
13367   {
13368     char device[] = "/dev/sda1";
13369     char mountpoint[] = "/";
13370     int r;
13371     suppress_error = 0;
13372     r = guestfs_mount (g, device, mountpoint);
13373     if (r == -1)
13374       return -1;
13375   }
13376   /* TestLastFail for rmdir (2) */
13377   {
13378     char path[] = "/new";
13379     int r;
13380     suppress_error = 0;
13381     r = guestfs_touch (g, path);
13382     if (r == -1)
13383       return -1;
13384   }
13385   {
13386     char path[] = "/new";
13387     int r;
13388     suppress_error = 1;
13389     r = guestfs_rmdir (g, path);
13390     if (r != -1)
13391       return -1;
13392   }
13393   return 0;
13394 }
13395
13396 static int test_rm_0_skip (void)
13397 {
13398   const char *str;
13399
13400   str = getenv ("SKIP_TEST_RM_0");
13401   if (str && strcmp (str, "1") == 0) return 1;
13402   str = getenv ("SKIP_TEST_RM");
13403   if (str && strcmp (str, "1") == 0) return 1;
13404   return 0;
13405 }
13406
13407 static int test_rm_0 (void)
13408 {
13409   if (test_rm_0_skip ()) {
13410     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13411     return 0;
13412   }
13413
13414   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13415   {
13416     char device[] = "/dev/sda";
13417     int r;
13418     suppress_error = 0;
13419     r = guestfs_blockdev_setrw (g, device);
13420     if (r == -1)
13421       return -1;
13422   }
13423   {
13424     int r;
13425     suppress_error = 0;
13426     r = guestfs_umount_all (g);
13427     if (r == -1)
13428       return -1;
13429   }
13430   {
13431     int r;
13432     suppress_error = 0;
13433     r = guestfs_lvm_remove_all (g);
13434     if (r == -1)
13435       return -1;
13436   }
13437   {
13438     char device[] = "/dev/sda";
13439     char lines_0[] = ",";
13440     char *lines[] = {
13441       lines_0,
13442       NULL
13443     };
13444     int r;
13445     suppress_error = 0;
13446     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13447     if (r == -1)
13448       return -1;
13449   }
13450   {
13451     char fstype[] = "ext2";
13452     char device[] = "/dev/sda1";
13453     int r;
13454     suppress_error = 0;
13455     r = guestfs_mkfs (g, fstype, device);
13456     if (r == -1)
13457       return -1;
13458   }
13459   {
13460     char device[] = "/dev/sda1";
13461     char mountpoint[] = "/";
13462     int r;
13463     suppress_error = 0;
13464     r = guestfs_mount (g, device, mountpoint);
13465     if (r == -1)
13466       return -1;
13467   }
13468   /* TestRun for rm (0) */
13469   {
13470     char path[] = "/new";
13471     int r;
13472     suppress_error = 0;
13473     r = guestfs_touch (g, path);
13474     if (r == -1)
13475       return -1;
13476   }
13477   {
13478     char path[] = "/new";
13479     int r;
13480     suppress_error = 0;
13481     r = guestfs_rm (g, path);
13482     if (r == -1)
13483       return -1;
13484   }
13485   return 0;
13486 }
13487
13488 static int test_rm_1_skip (void)
13489 {
13490   const char *str;
13491
13492   str = getenv ("SKIP_TEST_RM_1");
13493   if (str && strcmp (str, "1") == 0) return 1;
13494   str = getenv ("SKIP_TEST_RM");
13495   if (str && strcmp (str, "1") == 0) return 1;
13496   return 0;
13497 }
13498
13499 static int test_rm_1 (void)
13500 {
13501   if (test_rm_1_skip ()) {
13502     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13503     return 0;
13504   }
13505
13506   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13507   {
13508     char device[] = "/dev/sda";
13509     int r;
13510     suppress_error = 0;
13511     r = guestfs_blockdev_setrw (g, device);
13512     if (r == -1)
13513       return -1;
13514   }
13515   {
13516     int r;
13517     suppress_error = 0;
13518     r = guestfs_umount_all (g);
13519     if (r == -1)
13520       return -1;
13521   }
13522   {
13523     int r;
13524     suppress_error = 0;
13525     r = guestfs_lvm_remove_all (g);
13526     if (r == -1)
13527       return -1;
13528   }
13529   {
13530     char device[] = "/dev/sda";
13531     char lines_0[] = ",";
13532     char *lines[] = {
13533       lines_0,
13534       NULL
13535     };
13536     int r;
13537     suppress_error = 0;
13538     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13539     if (r == -1)
13540       return -1;
13541   }
13542   {
13543     char fstype[] = "ext2";
13544     char device[] = "/dev/sda1";
13545     int r;
13546     suppress_error = 0;
13547     r = guestfs_mkfs (g, fstype, device);
13548     if (r == -1)
13549       return -1;
13550   }
13551   {
13552     char device[] = "/dev/sda1";
13553     char mountpoint[] = "/";
13554     int r;
13555     suppress_error = 0;
13556     r = guestfs_mount (g, device, mountpoint);
13557     if (r == -1)
13558       return -1;
13559   }
13560   /* TestLastFail for rm (1) */
13561   {
13562     char path[] = "/new";
13563     int r;
13564     suppress_error = 1;
13565     r = guestfs_rm (g, path);
13566     if (r != -1)
13567       return -1;
13568   }
13569   return 0;
13570 }
13571
13572 static int test_rm_2_skip (void)
13573 {
13574   const char *str;
13575
13576   str = getenv ("SKIP_TEST_RM_2");
13577   if (str && strcmp (str, "1") == 0) return 1;
13578   str = getenv ("SKIP_TEST_RM");
13579   if (str && strcmp (str, "1") == 0) return 1;
13580   return 0;
13581 }
13582
13583 static int test_rm_2 (void)
13584 {
13585   if (test_rm_2_skip ()) {
13586     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13587     return 0;
13588   }
13589
13590   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13591   {
13592     char device[] = "/dev/sda";
13593     int r;
13594     suppress_error = 0;
13595     r = guestfs_blockdev_setrw (g, device);
13596     if (r == -1)
13597       return -1;
13598   }
13599   {
13600     int r;
13601     suppress_error = 0;
13602     r = guestfs_umount_all (g);
13603     if (r == -1)
13604       return -1;
13605   }
13606   {
13607     int r;
13608     suppress_error = 0;
13609     r = guestfs_lvm_remove_all (g);
13610     if (r == -1)
13611       return -1;
13612   }
13613   {
13614     char device[] = "/dev/sda";
13615     char lines_0[] = ",";
13616     char *lines[] = {
13617       lines_0,
13618       NULL
13619     };
13620     int r;
13621     suppress_error = 0;
13622     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13623     if (r == -1)
13624       return -1;
13625   }
13626   {
13627     char fstype[] = "ext2";
13628     char device[] = "/dev/sda1";
13629     int r;
13630     suppress_error = 0;
13631     r = guestfs_mkfs (g, fstype, device);
13632     if (r == -1)
13633       return -1;
13634   }
13635   {
13636     char device[] = "/dev/sda1";
13637     char mountpoint[] = "/";
13638     int r;
13639     suppress_error = 0;
13640     r = guestfs_mount (g, device, mountpoint);
13641     if (r == -1)
13642       return -1;
13643   }
13644   /* TestLastFail for rm (2) */
13645   {
13646     char path[] = "/new";
13647     int r;
13648     suppress_error = 0;
13649     r = guestfs_mkdir (g, path);
13650     if (r == -1)
13651       return -1;
13652   }
13653   {
13654     char path[] = "/new";
13655     int r;
13656     suppress_error = 1;
13657     r = guestfs_rm (g, path);
13658     if (r != -1)
13659       return -1;
13660   }
13661   return 0;
13662 }
13663
13664 static int test_read_lines_0_skip (void)
13665 {
13666   const char *str;
13667
13668   str = getenv ("SKIP_TEST_READ_LINES_0");
13669   if (str && strcmp (str, "1") == 0) return 1;
13670   str = getenv ("SKIP_TEST_READ_LINES");
13671   if (str && strcmp (str, "1") == 0) return 1;
13672   return 0;
13673 }
13674
13675 static int test_read_lines_0 (void)
13676 {
13677   if (test_read_lines_0_skip ()) {
13678     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13679     return 0;
13680   }
13681
13682   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13683   {
13684     char device[] = "/dev/sda";
13685     int r;
13686     suppress_error = 0;
13687     r = guestfs_blockdev_setrw (g, device);
13688     if (r == -1)
13689       return -1;
13690   }
13691   {
13692     int r;
13693     suppress_error = 0;
13694     r = guestfs_umount_all (g);
13695     if (r == -1)
13696       return -1;
13697   }
13698   {
13699     int r;
13700     suppress_error = 0;
13701     r = guestfs_lvm_remove_all (g);
13702     if (r == -1)
13703       return -1;
13704   }
13705   {
13706     char device[] = "/dev/sda";
13707     char lines_0[] = ",";
13708     char *lines[] = {
13709       lines_0,
13710       NULL
13711     };
13712     int r;
13713     suppress_error = 0;
13714     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13715     if (r == -1)
13716       return -1;
13717   }
13718   {
13719     char fstype[] = "ext2";
13720     char device[] = "/dev/sda1";
13721     int r;
13722     suppress_error = 0;
13723     r = guestfs_mkfs (g, fstype, device);
13724     if (r == -1)
13725       return -1;
13726   }
13727   {
13728     char device[] = "/dev/sda1";
13729     char mountpoint[] = "/";
13730     int r;
13731     suppress_error = 0;
13732     r = guestfs_mount (g, device, mountpoint);
13733     if (r == -1)
13734       return -1;
13735   }
13736   /* TestOutputList for read_lines (0) */
13737   {
13738     char path[] = "/new";
13739     char content[] = "line1\r\nline2\nline3";
13740     int r;
13741     suppress_error = 0;
13742     r = guestfs_write_file (g, path, content, 0);
13743     if (r == -1)
13744       return -1;
13745   }
13746   {
13747     char path[] = "/new";
13748     char **r;
13749     int i;
13750     suppress_error = 0;
13751     r = guestfs_read_lines (g, path);
13752     if (r == NULL)
13753       return -1;
13754     if (!r[0]) {
13755       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13756       print_strings (r);
13757       return -1;
13758     }
13759     {
13760       char expected[] = "line1";
13761       if (strcmp (r[0], expected) != 0) {
13762         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13763         return -1;
13764       }
13765     }
13766     if (!r[1]) {
13767       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13768       print_strings (r);
13769       return -1;
13770     }
13771     {
13772       char expected[] = "line2";
13773       if (strcmp (r[1], expected) != 0) {
13774         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13775         return -1;
13776       }
13777     }
13778     if (!r[2]) {
13779       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13780       print_strings (r);
13781       return -1;
13782     }
13783     {
13784       char expected[] = "line3";
13785       if (strcmp (r[2], expected) != 0) {
13786         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13787         return -1;
13788       }
13789     }
13790     if (r[3] != NULL) {
13791       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
13792       print_strings (r);
13793       return -1;
13794     }
13795     for (i = 0; r[i] != NULL; ++i)
13796       free (r[i]);
13797     free (r);
13798   }
13799   return 0;
13800 }
13801
13802 static int test_read_lines_1_skip (void)
13803 {
13804   const char *str;
13805
13806   str = getenv ("SKIP_TEST_READ_LINES_1");
13807   if (str && strcmp (str, "1") == 0) return 1;
13808   str = getenv ("SKIP_TEST_READ_LINES");
13809   if (str && strcmp (str, "1") == 0) return 1;
13810   return 0;
13811 }
13812
13813 static int test_read_lines_1 (void)
13814 {
13815   if (test_read_lines_1_skip ()) {
13816     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
13817     return 0;
13818   }
13819
13820   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
13821   {
13822     char device[] = "/dev/sda";
13823     int r;
13824     suppress_error = 0;
13825     r = guestfs_blockdev_setrw (g, device);
13826     if (r == -1)
13827       return -1;
13828   }
13829   {
13830     int r;
13831     suppress_error = 0;
13832     r = guestfs_umount_all (g);
13833     if (r == -1)
13834       return -1;
13835   }
13836   {
13837     int r;
13838     suppress_error = 0;
13839     r = guestfs_lvm_remove_all (g);
13840     if (r == -1)
13841       return -1;
13842   }
13843   {
13844     char device[] = "/dev/sda";
13845     char lines_0[] = ",";
13846     char *lines[] = {
13847       lines_0,
13848       NULL
13849     };
13850     int r;
13851     suppress_error = 0;
13852     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13853     if (r == -1)
13854       return -1;
13855   }
13856   {
13857     char fstype[] = "ext2";
13858     char device[] = "/dev/sda1";
13859     int r;
13860     suppress_error = 0;
13861     r = guestfs_mkfs (g, fstype, device);
13862     if (r == -1)
13863       return -1;
13864   }
13865   {
13866     char device[] = "/dev/sda1";
13867     char mountpoint[] = "/";
13868     int r;
13869     suppress_error = 0;
13870     r = guestfs_mount (g, device, mountpoint);
13871     if (r == -1)
13872       return -1;
13873   }
13874   /* TestOutputList for read_lines (1) */
13875   {
13876     char path[] = "/new";
13877     char content[] = "";
13878     int r;
13879     suppress_error = 0;
13880     r = guestfs_write_file (g, path, content, 0);
13881     if (r == -1)
13882       return -1;
13883   }
13884   {
13885     char path[] = "/new";
13886     char **r;
13887     int i;
13888     suppress_error = 0;
13889     r = guestfs_read_lines (g, path);
13890     if (r == NULL)
13891       return -1;
13892     if (r[0] != NULL) {
13893       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
13894       print_strings (r);
13895       return -1;
13896     }
13897     for (i = 0; r[i] != NULL; ++i)
13898       free (r[i]);
13899     free (r);
13900   }
13901   return 0;
13902 }
13903
13904 static int test_lvs_0_skip (void)
13905 {
13906   const char *str;
13907
13908   str = getenv ("SKIP_TEST_LVS_0");
13909   if (str && strcmp (str, "1") == 0) return 1;
13910   str = getenv ("SKIP_TEST_LVS");
13911   if (str && strcmp (str, "1") == 0) return 1;
13912   return 0;
13913 }
13914
13915 static int test_lvs_0 (void)
13916 {
13917   if (test_lvs_0_skip ()) {
13918     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
13919     return 0;
13920   }
13921
13922   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
13923   {
13924     char device[] = "/dev/sda";
13925     int r;
13926     suppress_error = 0;
13927     r = guestfs_blockdev_setrw (g, device);
13928     if (r == -1)
13929       return -1;
13930   }
13931   {
13932     int r;
13933     suppress_error = 0;
13934     r = guestfs_umount_all (g);
13935     if (r == -1)
13936       return -1;
13937   }
13938   {
13939     int r;
13940     suppress_error = 0;
13941     r = guestfs_lvm_remove_all (g);
13942     if (r == -1)
13943       return -1;
13944   }
13945   {
13946     char device[] = "/dev/sda";
13947     char lines_0[] = ",";
13948     char *lines[] = {
13949       lines_0,
13950       NULL
13951     };
13952     int r;
13953     suppress_error = 0;
13954     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13955     if (r == -1)
13956       return -1;
13957   }
13958   {
13959     char device[] = "/dev/sda1";
13960     int r;
13961     suppress_error = 0;
13962     r = guestfs_pvcreate (g, device);
13963     if (r == -1)
13964       return -1;
13965   }
13966   {
13967     char volgroup[] = "VG";
13968     char physvols_0[] = "/dev/sda1";
13969     char *physvols[] = {
13970       physvols_0,
13971       NULL
13972     };
13973     int r;
13974     suppress_error = 0;
13975     r = guestfs_vgcreate (g, volgroup, physvols);
13976     if (r == -1)
13977       return -1;
13978   }
13979   {
13980     char logvol[] = "LV";
13981     char volgroup[] = "VG";
13982     int r;
13983     suppress_error = 0;
13984     r = guestfs_lvcreate (g, logvol, volgroup, 8);
13985     if (r == -1)
13986       return -1;
13987   }
13988   {
13989     char fstype[] = "ext2";
13990     char device[] = "/dev/VG/LV";
13991     int r;
13992     suppress_error = 0;
13993     r = guestfs_mkfs (g, fstype, device);
13994     if (r == -1)
13995       return -1;
13996   }
13997   {
13998     char device[] = "/dev/VG/LV";
13999     char mountpoint[] = "/";
14000     int r;
14001     suppress_error = 0;
14002     r = guestfs_mount (g, device, mountpoint);
14003     if (r == -1)
14004       return -1;
14005   }
14006   /* TestOutputList for lvs (0) */
14007   {
14008     char **r;
14009     int i;
14010     suppress_error = 0;
14011     r = guestfs_lvs (g);
14012     if (r == NULL)
14013       return -1;
14014     if (!r[0]) {
14015       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14016       print_strings (r);
14017       return -1;
14018     }
14019     {
14020       char expected[] = "/dev/VG/LV";
14021       if (strcmp (r[0], expected) != 0) {
14022         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14023         return -1;
14024       }
14025     }
14026     if (r[1] != NULL) {
14027       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14028       print_strings (r);
14029       return -1;
14030     }
14031     for (i = 0; r[i] != NULL; ++i)
14032       free (r[i]);
14033     free (r);
14034   }
14035   return 0;
14036 }
14037
14038 static int test_lvs_1_skip (void)
14039 {
14040   const char *str;
14041
14042   str = getenv ("SKIP_TEST_LVS_1");
14043   if (str && strcmp (str, "1") == 0) return 1;
14044   str = getenv ("SKIP_TEST_LVS");
14045   if (str && strcmp (str, "1") == 0) return 1;
14046   return 0;
14047 }
14048
14049 static int test_lvs_1 (void)
14050 {
14051   if (test_lvs_1_skip ()) {
14052     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14053     return 0;
14054   }
14055
14056   /* InitNone|InitEmpty for test_lvs_1 */
14057   {
14058     char device[] = "/dev/sda";
14059     int r;
14060     suppress_error = 0;
14061     r = guestfs_blockdev_setrw (g, device);
14062     if (r == -1)
14063       return -1;
14064   }
14065   {
14066     int r;
14067     suppress_error = 0;
14068     r = guestfs_umount_all (g);
14069     if (r == -1)
14070       return -1;
14071   }
14072   {
14073     int r;
14074     suppress_error = 0;
14075     r = guestfs_lvm_remove_all (g);
14076     if (r == -1)
14077       return -1;
14078   }
14079   /* TestOutputList for lvs (1) */
14080   {
14081     char device[] = "/dev/sda";
14082     char lines_0[] = ",10";
14083     char lines_1[] = ",20";
14084     char lines_2[] = ",";
14085     char *lines[] = {
14086       lines_0,
14087       lines_1,
14088       lines_2,
14089       NULL
14090     };
14091     int r;
14092     suppress_error = 0;
14093     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14094     if (r == -1)
14095       return -1;
14096   }
14097   {
14098     char device[] = "/dev/sda1";
14099     int r;
14100     suppress_error = 0;
14101     r = guestfs_pvcreate (g, device);
14102     if (r == -1)
14103       return -1;
14104   }
14105   {
14106     char device[] = "/dev/sda2";
14107     int r;
14108     suppress_error = 0;
14109     r = guestfs_pvcreate (g, device);
14110     if (r == -1)
14111       return -1;
14112   }
14113   {
14114     char device[] = "/dev/sda3";
14115     int r;
14116     suppress_error = 0;
14117     r = guestfs_pvcreate (g, device);
14118     if (r == -1)
14119       return -1;
14120   }
14121   {
14122     char volgroup[] = "VG1";
14123     char physvols_0[] = "/dev/sda1";
14124     char physvols_1[] = "/dev/sda2";
14125     char *physvols[] = {
14126       physvols_0,
14127       physvols_1,
14128       NULL
14129     };
14130     int r;
14131     suppress_error = 0;
14132     r = guestfs_vgcreate (g, volgroup, physvols);
14133     if (r == -1)
14134       return -1;
14135   }
14136   {
14137     char volgroup[] = "VG2";
14138     char physvols_0[] = "/dev/sda3";
14139     char *physvols[] = {
14140       physvols_0,
14141       NULL
14142     };
14143     int r;
14144     suppress_error = 0;
14145     r = guestfs_vgcreate (g, volgroup, physvols);
14146     if (r == -1)
14147       return -1;
14148   }
14149   {
14150     char logvol[] = "LV1";
14151     char volgroup[] = "VG1";
14152     int r;
14153     suppress_error = 0;
14154     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14155     if (r == -1)
14156       return -1;
14157   }
14158   {
14159     char logvol[] = "LV2";
14160     char volgroup[] = "VG1";
14161     int r;
14162     suppress_error = 0;
14163     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14164     if (r == -1)
14165       return -1;
14166   }
14167   {
14168     char logvol[] = "LV3";
14169     char volgroup[] = "VG2";
14170     int r;
14171     suppress_error = 0;
14172     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14173     if (r == -1)
14174       return -1;
14175   }
14176   {
14177     char **r;
14178     int i;
14179     suppress_error = 0;
14180     r = guestfs_lvs (g);
14181     if (r == NULL)
14182       return -1;
14183     if (!r[0]) {
14184       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14185       print_strings (r);
14186       return -1;
14187     }
14188     {
14189       char expected[] = "/dev/VG1/LV1";
14190       if (strcmp (r[0], expected) != 0) {
14191         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14192         return -1;
14193       }
14194     }
14195     if (!r[1]) {
14196       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14197       print_strings (r);
14198       return -1;
14199     }
14200     {
14201       char expected[] = "/dev/VG1/LV2";
14202       if (strcmp (r[1], expected) != 0) {
14203         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14204         return -1;
14205       }
14206     }
14207     if (!r[2]) {
14208       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14209       print_strings (r);
14210       return -1;
14211     }
14212     {
14213       char expected[] = "/dev/VG2/LV3";
14214       if (strcmp (r[2], expected) != 0) {
14215         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14216         return -1;
14217       }
14218     }
14219     if (r[3] != NULL) {
14220       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14221       print_strings (r);
14222       return -1;
14223     }
14224     for (i = 0; r[i] != NULL; ++i)
14225       free (r[i]);
14226     free (r);
14227   }
14228   return 0;
14229 }
14230
14231 static int test_vgs_0_skip (void)
14232 {
14233   const char *str;
14234
14235   str = getenv ("SKIP_TEST_VGS_0");
14236   if (str && strcmp (str, "1") == 0) return 1;
14237   str = getenv ("SKIP_TEST_VGS");
14238   if (str && strcmp (str, "1") == 0) return 1;
14239   return 0;
14240 }
14241
14242 static int test_vgs_0 (void)
14243 {
14244   if (test_vgs_0_skip ()) {
14245     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14246     return 0;
14247   }
14248
14249   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14250   {
14251     char device[] = "/dev/sda";
14252     int r;
14253     suppress_error = 0;
14254     r = guestfs_blockdev_setrw (g, device);
14255     if (r == -1)
14256       return -1;
14257   }
14258   {
14259     int r;
14260     suppress_error = 0;
14261     r = guestfs_umount_all (g);
14262     if (r == -1)
14263       return -1;
14264   }
14265   {
14266     int r;
14267     suppress_error = 0;
14268     r = guestfs_lvm_remove_all (g);
14269     if (r == -1)
14270       return -1;
14271   }
14272   {
14273     char device[] = "/dev/sda";
14274     char lines_0[] = ",";
14275     char *lines[] = {
14276       lines_0,
14277       NULL
14278     };
14279     int r;
14280     suppress_error = 0;
14281     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14282     if (r == -1)
14283       return -1;
14284   }
14285   {
14286     char device[] = "/dev/sda1";
14287     int r;
14288     suppress_error = 0;
14289     r = guestfs_pvcreate (g, device);
14290     if (r == -1)
14291       return -1;
14292   }
14293   {
14294     char volgroup[] = "VG";
14295     char physvols_0[] = "/dev/sda1";
14296     char *physvols[] = {
14297       physvols_0,
14298       NULL
14299     };
14300     int r;
14301     suppress_error = 0;
14302     r = guestfs_vgcreate (g, volgroup, physvols);
14303     if (r == -1)
14304       return -1;
14305   }
14306   {
14307     char logvol[] = "LV";
14308     char volgroup[] = "VG";
14309     int r;
14310     suppress_error = 0;
14311     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14312     if (r == -1)
14313       return -1;
14314   }
14315   {
14316     char fstype[] = "ext2";
14317     char device[] = "/dev/VG/LV";
14318     int r;
14319     suppress_error = 0;
14320     r = guestfs_mkfs (g, fstype, device);
14321     if (r == -1)
14322       return -1;
14323   }
14324   {
14325     char device[] = "/dev/VG/LV";
14326     char mountpoint[] = "/";
14327     int r;
14328     suppress_error = 0;
14329     r = guestfs_mount (g, device, mountpoint);
14330     if (r == -1)
14331       return -1;
14332   }
14333   /* TestOutputList for vgs (0) */
14334   {
14335     char **r;
14336     int i;
14337     suppress_error = 0;
14338     r = guestfs_vgs (g);
14339     if (r == NULL)
14340       return -1;
14341     if (!r[0]) {
14342       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14343       print_strings (r);
14344       return -1;
14345     }
14346     {
14347       char expected[] = "VG";
14348       if (strcmp (r[0], expected) != 0) {
14349         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14350         return -1;
14351       }
14352     }
14353     if (r[1] != NULL) {
14354       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14355       print_strings (r);
14356       return -1;
14357     }
14358     for (i = 0; r[i] != NULL; ++i)
14359       free (r[i]);
14360     free (r);
14361   }
14362   return 0;
14363 }
14364
14365 static int test_vgs_1_skip (void)
14366 {
14367   const char *str;
14368
14369   str = getenv ("SKIP_TEST_VGS_1");
14370   if (str && strcmp (str, "1") == 0) return 1;
14371   str = getenv ("SKIP_TEST_VGS");
14372   if (str && strcmp (str, "1") == 0) return 1;
14373   return 0;
14374 }
14375
14376 static int test_vgs_1 (void)
14377 {
14378   if (test_vgs_1_skip ()) {
14379     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14380     return 0;
14381   }
14382
14383   /* InitNone|InitEmpty for test_vgs_1 */
14384   {
14385     char device[] = "/dev/sda";
14386     int r;
14387     suppress_error = 0;
14388     r = guestfs_blockdev_setrw (g, device);
14389     if (r == -1)
14390       return -1;
14391   }
14392   {
14393     int r;
14394     suppress_error = 0;
14395     r = guestfs_umount_all (g);
14396     if (r == -1)
14397       return -1;
14398   }
14399   {
14400     int r;
14401     suppress_error = 0;
14402     r = guestfs_lvm_remove_all (g);
14403     if (r == -1)
14404       return -1;
14405   }
14406   /* TestOutputList for vgs (1) */
14407   {
14408     char device[] = "/dev/sda";
14409     char lines_0[] = ",10";
14410     char lines_1[] = ",20";
14411     char lines_2[] = ",";
14412     char *lines[] = {
14413       lines_0,
14414       lines_1,
14415       lines_2,
14416       NULL
14417     };
14418     int r;
14419     suppress_error = 0;
14420     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14421     if (r == -1)
14422       return -1;
14423   }
14424   {
14425     char device[] = "/dev/sda1";
14426     int r;
14427     suppress_error = 0;
14428     r = guestfs_pvcreate (g, device);
14429     if (r == -1)
14430       return -1;
14431   }
14432   {
14433     char device[] = "/dev/sda2";
14434     int r;
14435     suppress_error = 0;
14436     r = guestfs_pvcreate (g, device);
14437     if (r == -1)
14438       return -1;
14439   }
14440   {
14441     char device[] = "/dev/sda3";
14442     int r;
14443     suppress_error = 0;
14444     r = guestfs_pvcreate (g, device);
14445     if (r == -1)
14446       return -1;
14447   }
14448   {
14449     char volgroup[] = "VG1";
14450     char physvols_0[] = "/dev/sda1";
14451     char physvols_1[] = "/dev/sda2";
14452     char *physvols[] = {
14453       physvols_0,
14454       physvols_1,
14455       NULL
14456     };
14457     int r;
14458     suppress_error = 0;
14459     r = guestfs_vgcreate (g, volgroup, physvols);
14460     if (r == -1)
14461       return -1;
14462   }
14463   {
14464     char volgroup[] = "VG2";
14465     char physvols_0[] = "/dev/sda3";
14466     char *physvols[] = {
14467       physvols_0,
14468       NULL
14469     };
14470     int r;
14471     suppress_error = 0;
14472     r = guestfs_vgcreate (g, volgroup, physvols);
14473     if (r == -1)
14474       return -1;
14475   }
14476   {
14477     char **r;
14478     int i;
14479     suppress_error = 0;
14480     r = guestfs_vgs (g);
14481     if (r == NULL)
14482       return -1;
14483     if (!r[0]) {
14484       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14485       print_strings (r);
14486       return -1;
14487     }
14488     {
14489       char expected[] = "VG1";
14490       if (strcmp (r[0], expected) != 0) {
14491         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14492         return -1;
14493       }
14494     }
14495     if (!r[1]) {
14496       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14497       print_strings (r);
14498       return -1;
14499     }
14500     {
14501       char expected[] = "VG2";
14502       if (strcmp (r[1], expected) != 0) {
14503         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14504         return -1;
14505       }
14506     }
14507     if (r[2] != NULL) {
14508       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14509       print_strings (r);
14510       return -1;
14511     }
14512     for (i = 0; r[i] != NULL; ++i)
14513       free (r[i]);
14514     free (r);
14515   }
14516   return 0;
14517 }
14518
14519 static int test_pvs_0_skip (void)
14520 {
14521   const char *str;
14522
14523   str = getenv ("SKIP_TEST_PVS_0");
14524   if (str && strcmp (str, "1") == 0) return 1;
14525   str = getenv ("SKIP_TEST_PVS");
14526   if (str && strcmp (str, "1") == 0) return 1;
14527   return 0;
14528 }
14529
14530 static int test_pvs_0 (void)
14531 {
14532   if (test_pvs_0_skip ()) {
14533     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14534     return 0;
14535   }
14536
14537   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14538   {
14539     char device[] = "/dev/sda";
14540     int r;
14541     suppress_error = 0;
14542     r = guestfs_blockdev_setrw (g, device);
14543     if (r == -1)
14544       return -1;
14545   }
14546   {
14547     int r;
14548     suppress_error = 0;
14549     r = guestfs_umount_all (g);
14550     if (r == -1)
14551       return -1;
14552   }
14553   {
14554     int r;
14555     suppress_error = 0;
14556     r = guestfs_lvm_remove_all (g);
14557     if (r == -1)
14558       return -1;
14559   }
14560   {
14561     char device[] = "/dev/sda";
14562     char lines_0[] = ",";
14563     char *lines[] = {
14564       lines_0,
14565       NULL
14566     };
14567     int r;
14568     suppress_error = 0;
14569     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14570     if (r == -1)
14571       return -1;
14572   }
14573   {
14574     char device[] = "/dev/sda1";
14575     int r;
14576     suppress_error = 0;
14577     r = guestfs_pvcreate (g, device);
14578     if (r == -1)
14579       return -1;
14580   }
14581   {
14582     char volgroup[] = "VG";
14583     char physvols_0[] = "/dev/sda1";
14584     char *physvols[] = {
14585       physvols_0,
14586       NULL
14587     };
14588     int r;
14589     suppress_error = 0;
14590     r = guestfs_vgcreate (g, volgroup, physvols);
14591     if (r == -1)
14592       return -1;
14593   }
14594   {
14595     char logvol[] = "LV";
14596     char volgroup[] = "VG";
14597     int r;
14598     suppress_error = 0;
14599     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14600     if (r == -1)
14601       return -1;
14602   }
14603   {
14604     char fstype[] = "ext2";
14605     char device[] = "/dev/VG/LV";
14606     int r;
14607     suppress_error = 0;
14608     r = guestfs_mkfs (g, fstype, device);
14609     if (r == -1)
14610       return -1;
14611   }
14612   {
14613     char device[] = "/dev/VG/LV";
14614     char mountpoint[] = "/";
14615     int r;
14616     suppress_error = 0;
14617     r = guestfs_mount (g, device, mountpoint);
14618     if (r == -1)
14619       return -1;
14620   }
14621   /* TestOutputListOfDevices for pvs (0) */
14622   {
14623     char **r;
14624     int i;
14625     suppress_error = 0;
14626     r = guestfs_pvs (g);
14627     if (r == NULL)
14628       return -1;
14629     if (!r[0]) {
14630       fprintf (stderr, "test_pvs_0: short list returned from command\n");
14631       print_strings (r);
14632       return -1;
14633     }
14634     {
14635       char expected[] = "/dev/sda1";
14636       r[0][5] = 's';
14637       if (strcmp (r[0], expected) != 0) {
14638         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14639         return -1;
14640       }
14641     }
14642     if (r[1] != NULL) {
14643       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14644       print_strings (r);
14645       return -1;
14646     }
14647     for (i = 0; r[i] != NULL; ++i)
14648       free (r[i]);
14649     free (r);
14650   }
14651   return 0;
14652 }
14653
14654 static int test_pvs_1_skip (void)
14655 {
14656   const char *str;
14657
14658   str = getenv ("SKIP_TEST_PVS_1");
14659   if (str && strcmp (str, "1") == 0) return 1;
14660   str = getenv ("SKIP_TEST_PVS");
14661   if (str && strcmp (str, "1") == 0) return 1;
14662   return 0;
14663 }
14664
14665 static int test_pvs_1 (void)
14666 {
14667   if (test_pvs_1_skip ()) {
14668     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
14669     return 0;
14670   }
14671
14672   /* InitNone|InitEmpty for test_pvs_1 */
14673   {
14674     char device[] = "/dev/sda";
14675     int r;
14676     suppress_error = 0;
14677     r = guestfs_blockdev_setrw (g, device);
14678     if (r == -1)
14679       return -1;
14680   }
14681   {
14682     int r;
14683     suppress_error = 0;
14684     r = guestfs_umount_all (g);
14685     if (r == -1)
14686       return -1;
14687   }
14688   {
14689     int r;
14690     suppress_error = 0;
14691     r = guestfs_lvm_remove_all (g);
14692     if (r == -1)
14693       return -1;
14694   }
14695   /* TestOutputListOfDevices for pvs (1) */
14696   {
14697     char device[] = "/dev/sda";
14698     char lines_0[] = ",10";
14699     char lines_1[] = ",20";
14700     char lines_2[] = ",";
14701     char *lines[] = {
14702       lines_0,
14703       lines_1,
14704       lines_2,
14705       NULL
14706     };
14707     int r;
14708     suppress_error = 0;
14709     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14710     if (r == -1)
14711       return -1;
14712   }
14713   {
14714     char device[] = "/dev/sda1";
14715     int r;
14716     suppress_error = 0;
14717     r = guestfs_pvcreate (g, device);
14718     if (r == -1)
14719       return -1;
14720   }
14721   {
14722     char device[] = "/dev/sda2";
14723     int r;
14724     suppress_error = 0;
14725     r = guestfs_pvcreate (g, device);
14726     if (r == -1)
14727       return -1;
14728   }
14729   {
14730     char device[] = "/dev/sda3";
14731     int r;
14732     suppress_error = 0;
14733     r = guestfs_pvcreate (g, device);
14734     if (r == -1)
14735       return -1;
14736   }
14737   {
14738     char **r;
14739     int i;
14740     suppress_error = 0;
14741     r = guestfs_pvs (g);
14742     if (r == NULL)
14743       return -1;
14744     if (!r[0]) {
14745       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14746       print_strings (r);
14747       return -1;
14748     }
14749     {
14750       char expected[] = "/dev/sda1";
14751       r[0][5] = 's';
14752       if (strcmp (r[0], expected) != 0) {
14753         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14754         return -1;
14755       }
14756     }
14757     if (!r[1]) {
14758       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14759       print_strings (r);
14760       return -1;
14761     }
14762     {
14763       char expected[] = "/dev/sda2";
14764       r[1][5] = 's';
14765       if (strcmp (r[1], expected) != 0) {
14766         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14767         return -1;
14768       }
14769     }
14770     if (!r[2]) {
14771       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14772       print_strings (r);
14773       return -1;
14774     }
14775     {
14776       char expected[] = "/dev/sda3";
14777       r[2][5] = 's';
14778       if (strcmp (r[2], expected) != 0) {
14779         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14780         return -1;
14781       }
14782     }
14783     if (r[3] != NULL) {
14784       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
14785       print_strings (r);
14786       return -1;
14787     }
14788     for (i = 0; r[i] != NULL; ++i)
14789       free (r[i]);
14790     free (r);
14791   }
14792   return 0;
14793 }
14794
14795 static int test_list_partitions_0_skip (void)
14796 {
14797   const char *str;
14798
14799   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
14800   if (str && strcmp (str, "1") == 0) return 1;
14801   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14802   if (str && strcmp (str, "1") == 0) return 1;
14803   return 0;
14804 }
14805
14806 static int test_list_partitions_0 (void)
14807 {
14808   if (test_list_partitions_0_skip ()) {
14809     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
14810     return 0;
14811   }
14812
14813   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
14814   {
14815     char device[] = "/dev/sda";
14816     int r;
14817     suppress_error = 0;
14818     r = guestfs_blockdev_setrw (g, device);
14819     if (r == -1)
14820       return -1;
14821   }
14822   {
14823     int r;
14824     suppress_error = 0;
14825     r = guestfs_umount_all (g);
14826     if (r == -1)
14827       return -1;
14828   }
14829   {
14830     int r;
14831     suppress_error = 0;
14832     r = guestfs_lvm_remove_all (g);
14833     if (r == -1)
14834       return -1;
14835   }
14836   {
14837     char device[] = "/dev/sda";
14838     char lines_0[] = ",";
14839     char *lines[] = {
14840       lines_0,
14841       NULL
14842     };
14843     int r;
14844     suppress_error = 0;
14845     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14846     if (r == -1)
14847       return -1;
14848   }
14849   {
14850     char fstype[] = "ext2";
14851     char device[] = "/dev/sda1";
14852     int r;
14853     suppress_error = 0;
14854     r = guestfs_mkfs (g, fstype, device);
14855     if (r == -1)
14856       return -1;
14857   }
14858   {
14859     char device[] = "/dev/sda1";
14860     char mountpoint[] = "/";
14861     int r;
14862     suppress_error = 0;
14863     r = guestfs_mount (g, device, mountpoint);
14864     if (r == -1)
14865       return -1;
14866   }
14867   /* TestOutputListOfDevices for list_partitions (0) */
14868   {
14869     char **r;
14870     int i;
14871     suppress_error = 0;
14872     r = guestfs_list_partitions (g);
14873     if (r == NULL)
14874       return -1;
14875     if (!r[0]) {
14876       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
14877       print_strings (r);
14878       return -1;
14879     }
14880     {
14881       char expected[] = "/dev/sda1";
14882       r[0][5] = 's';
14883       if (strcmp (r[0], expected) != 0) {
14884         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14885         return -1;
14886       }
14887     }
14888     if (r[1] != NULL) {
14889       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
14890       print_strings (r);
14891       return -1;
14892     }
14893     for (i = 0; r[i] != NULL; ++i)
14894       free (r[i]);
14895     free (r);
14896   }
14897   return 0;
14898 }
14899
14900 static int test_list_partitions_1_skip (void)
14901 {
14902   const char *str;
14903
14904   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
14905   if (str && strcmp (str, "1") == 0) return 1;
14906   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14907   if (str && strcmp (str, "1") == 0) return 1;
14908   return 0;
14909 }
14910
14911 static int test_list_partitions_1 (void)
14912 {
14913   if (test_list_partitions_1_skip ()) {
14914     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
14915     return 0;
14916   }
14917
14918   /* InitNone|InitEmpty for test_list_partitions_1 */
14919   {
14920     char device[] = "/dev/sda";
14921     int r;
14922     suppress_error = 0;
14923     r = guestfs_blockdev_setrw (g, device);
14924     if (r == -1)
14925       return -1;
14926   }
14927   {
14928     int r;
14929     suppress_error = 0;
14930     r = guestfs_umount_all (g);
14931     if (r == -1)
14932       return -1;
14933   }
14934   {
14935     int r;
14936     suppress_error = 0;
14937     r = guestfs_lvm_remove_all (g);
14938     if (r == -1)
14939       return -1;
14940   }
14941   /* TestOutputListOfDevices for list_partitions (1) */
14942   {
14943     char device[] = "/dev/sda";
14944     char lines_0[] = ",10";
14945     char lines_1[] = ",20";
14946     char lines_2[] = ",";
14947     char *lines[] = {
14948       lines_0,
14949       lines_1,
14950       lines_2,
14951       NULL
14952     };
14953     int r;
14954     suppress_error = 0;
14955     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14956     if (r == -1)
14957       return -1;
14958   }
14959   {
14960     char **r;
14961     int i;
14962     suppress_error = 0;
14963     r = guestfs_list_partitions (g);
14964     if (r == NULL)
14965       return -1;
14966     if (!r[0]) {
14967       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14968       print_strings (r);
14969       return -1;
14970     }
14971     {
14972       char expected[] = "/dev/sda1";
14973       r[0][5] = 's';
14974       if (strcmp (r[0], expected) != 0) {
14975         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14976         return -1;
14977       }
14978     }
14979     if (!r[1]) {
14980       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14981       print_strings (r);
14982       return -1;
14983     }
14984     {
14985       char expected[] = "/dev/sda2";
14986       r[1][5] = 's';
14987       if (strcmp (r[1], expected) != 0) {
14988         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14989         return -1;
14990       }
14991     }
14992     if (!r[2]) {
14993       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14994       print_strings (r);
14995       return -1;
14996     }
14997     {
14998       char expected[] = "/dev/sda3";
14999       r[2][5] = 's';
15000       if (strcmp (r[2], expected) != 0) {
15001         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15002         return -1;
15003       }
15004     }
15005     if (r[3] != NULL) {
15006       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15007       print_strings (r);
15008       return -1;
15009     }
15010     for (i = 0; r[i] != NULL; ++i)
15011       free (r[i]);
15012     free (r);
15013   }
15014   return 0;
15015 }
15016
15017 static int test_list_devices_0_skip (void)
15018 {
15019   const char *str;
15020
15021   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15022   if (str && strcmp (str, "1") == 0) return 1;
15023   str = getenv ("SKIP_TEST_LIST_DEVICES");
15024   if (str && strcmp (str, "1") == 0) return 1;
15025   return 0;
15026 }
15027
15028 static int test_list_devices_0 (void)
15029 {
15030   if (test_list_devices_0_skip ()) {
15031     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15032     return 0;
15033   }
15034
15035   /* InitNone|InitEmpty for test_list_devices_0 */
15036   {
15037     char device[] = "/dev/sda";
15038     int r;
15039     suppress_error = 0;
15040     r = guestfs_blockdev_setrw (g, device);
15041     if (r == -1)
15042       return -1;
15043   }
15044   {
15045     int r;
15046     suppress_error = 0;
15047     r = guestfs_umount_all (g);
15048     if (r == -1)
15049       return -1;
15050   }
15051   {
15052     int r;
15053     suppress_error = 0;
15054     r = guestfs_lvm_remove_all (g);
15055     if (r == -1)
15056       return -1;
15057   }
15058   /* TestOutputListOfDevices for list_devices (0) */
15059   {
15060     char **r;
15061     int i;
15062     suppress_error = 0;
15063     r = guestfs_list_devices (g);
15064     if (r == NULL)
15065       return -1;
15066     if (!r[0]) {
15067       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15068       print_strings (r);
15069       return -1;
15070     }
15071     {
15072       char expected[] = "/dev/sda";
15073       r[0][5] = 's';
15074       if (strcmp (r[0], expected) != 0) {
15075         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15076         return -1;
15077       }
15078     }
15079     if (!r[1]) {
15080       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15081       print_strings (r);
15082       return -1;
15083     }
15084     {
15085       char expected[] = "/dev/sdb";
15086       r[1][5] = 's';
15087       if (strcmp (r[1], expected) != 0) {
15088         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15089         return -1;
15090       }
15091     }
15092     if (!r[2]) {
15093       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15094       print_strings (r);
15095       return -1;
15096     }
15097     {
15098       char expected[] = "/dev/sdc";
15099       r[2][5] = 's';
15100       if (strcmp (r[2], expected) != 0) {
15101         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15102         return -1;
15103       }
15104     }
15105     if (!r[3]) {
15106       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15107       print_strings (r);
15108       return -1;
15109     }
15110     {
15111       char expected[] = "/dev/sdd";
15112       r[3][5] = 's';
15113       if (strcmp (r[3], expected) != 0) {
15114         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15115         return -1;
15116       }
15117     }
15118     if (r[4] != NULL) {
15119       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15120       print_strings (r);
15121       return -1;
15122     }
15123     for (i = 0; r[i] != NULL; ++i)
15124       free (r[i]);
15125     free (r);
15126   }
15127   return 0;
15128 }
15129
15130 static int test_ls_0_skip (void)
15131 {
15132   const char *str;
15133
15134   str = getenv ("SKIP_TEST_LS_0");
15135   if (str && strcmp (str, "1") == 0) return 1;
15136   str = getenv ("SKIP_TEST_LS");
15137   if (str && strcmp (str, "1") == 0) return 1;
15138   return 0;
15139 }
15140
15141 static int test_ls_0 (void)
15142 {
15143   if (test_ls_0_skip ()) {
15144     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15145     return 0;
15146   }
15147
15148   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15149   {
15150     char device[] = "/dev/sda";
15151     int r;
15152     suppress_error = 0;
15153     r = guestfs_blockdev_setrw (g, device);
15154     if (r == -1)
15155       return -1;
15156   }
15157   {
15158     int r;
15159     suppress_error = 0;
15160     r = guestfs_umount_all (g);
15161     if (r == -1)
15162       return -1;
15163   }
15164   {
15165     int r;
15166     suppress_error = 0;
15167     r = guestfs_lvm_remove_all (g);
15168     if (r == -1)
15169       return -1;
15170   }
15171   {
15172     char device[] = "/dev/sda";
15173     char lines_0[] = ",";
15174     char *lines[] = {
15175       lines_0,
15176       NULL
15177     };
15178     int r;
15179     suppress_error = 0;
15180     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15181     if (r == -1)
15182       return -1;
15183   }
15184   {
15185     char fstype[] = "ext2";
15186     char device[] = "/dev/sda1";
15187     int r;
15188     suppress_error = 0;
15189     r = guestfs_mkfs (g, fstype, device);
15190     if (r == -1)
15191       return -1;
15192   }
15193   {
15194     char device[] = "/dev/sda1";
15195     char mountpoint[] = "/";
15196     int r;
15197     suppress_error = 0;
15198     r = guestfs_mount (g, device, mountpoint);
15199     if (r == -1)
15200       return -1;
15201   }
15202   /* TestOutputList for ls (0) */
15203   {
15204     char path[] = "/new";
15205     int r;
15206     suppress_error = 0;
15207     r = guestfs_touch (g, path);
15208     if (r == -1)
15209       return -1;
15210   }
15211   {
15212     char path[] = "/newer";
15213     int r;
15214     suppress_error = 0;
15215     r = guestfs_touch (g, path);
15216     if (r == -1)
15217       return -1;
15218   }
15219   {
15220     char path[] = "/newest";
15221     int r;
15222     suppress_error = 0;
15223     r = guestfs_touch (g, path);
15224     if (r == -1)
15225       return -1;
15226   }
15227   {
15228     char directory[] = "/";
15229     char **r;
15230     int i;
15231     suppress_error = 0;
15232     r = guestfs_ls (g, directory);
15233     if (r == NULL)
15234       return -1;
15235     if (!r[0]) {
15236       fprintf (stderr, "test_ls_0: short list returned from command\n");
15237       print_strings (r);
15238       return -1;
15239     }
15240     {
15241       char expected[] = "lost+found";
15242       if (strcmp (r[0], expected) != 0) {
15243         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15244         return -1;
15245       }
15246     }
15247     if (!r[1]) {
15248       fprintf (stderr, "test_ls_0: short list returned from command\n");
15249       print_strings (r);
15250       return -1;
15251     }
15252     {
15253       char expected[] = "new";
15254       if (strcmp (r[1], expected) != 0) {
15255         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15256         return -1;
15257       }
15258     }
15259     if (!r[2]) {
15260       fprintf (stderr, "test_ls_0: short list returned from command\n");
15261       print_strings (r);
15262       return -1;
15263     }
15264     {
15265       char expected[] = "newer";
15266       if (strcmp (r[2], expected) != 0) {
15267         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15268         return -1;
15269       }
15270     }
15271     if (!r[3]) {
15272       fprintf (stderr, "test_ls_0: short list returned from command\n");
15273       print_strings (r);
15274       return -1;
15275     }
15276     {
15277       char expected[] = "newest";
15278       if (strcmp (r[3], expected) != 0) {
15279         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15280         return -1;
15281       }
15282     }
15283     if (r[4] != NULL) {
15284       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15285       print_strings (r);
15286       return -1;
15287     }
15288     for (i = 0; r[i] != NULL; ++i)
15289       free (r[i]);
15290     free (r);
15291   }
15292   return 0;
15293 }
15294
15295 static int test_cat_0_skip (void)
15296 {
15297   const char *str;
15298
15299   str = getenv ("SKIP_TEST_CAT_0");
15300   if (str && strcmp (str, "1") == 0) return 1;
15301   str = getenv ("SKIP_TEST_CAT");
15302   if (str && strcmp (str, "1") == 0) return 1;
15303   return 0;
15304 }
15305
15306 static int test_cat_0 (void)
15307 {
15308   if (test_cat_0_skip ()) {
15309     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15310     return 0;
15311   }
15312
15313   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15314   {
15315     char device[] = "/dev/sda";
15316     int r;
15317     suppress_error = 0;
15318     r = guestfs_blockdev_setrw (g, device);
15319     if (r == -1)
15320       return -1;
15321   }
15322   {
15323     int r;
15324     suppress_error = 0;
15325     r = guestfs_umount_all (g);
15326     if (r == -1)
15327       return -1;
15328   }
15329   {
15330     int r;
15331     suppress_error = 0;
15332     r = guestfs_lvm_remove_all (g);
15333     if (r == -1)
15334       return -1;
15335   }
15336   {
15337     char device[] = "/dev/sda";
15338     char lines_0[] = ",";
15339     char *lines[] = {
15340       lines_0,
15341       NULL
15342     };
15343     int r;
15344     suppress_error = 0;
15345     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15346     if (r == -1)
15347       return -1;
15348   }
15349   {
15350     char fstype[] = "ext2";
15351     char device[] = "/dev/sda1";
15352     int r;
15353     suppress_error = 0;
15354     r = guestfs_mkfs (g, fstype, device);
15355     if (r == -1)
15356       return -1;
15357   }
15358   {
15359     char device[] = "/dev/sda1";
15360     char mountpoint[] = "/";
15361     int r;
15362     suppress_error = 0;
15363     r = guestfs_mount (g, device, mountpoint);
15364     if (r == -1)
15365       return -1;
15366   }
15367   /* TestOutput for cat (0) */
15368   char expected[] = "new file contents";
15369   {
15370     char path[] = "/new";
15371     char content[] = "new file contents";
15372     int r;
15373     suppress_error = 0;
15374     r = guestfs_write_file (g, path, content, 0);
15375     if (r == -1)
15376       return -1;
15377   }
15378   {
15379     char path[] = "/new";
15380     char *r;
15381     suppress_error = 0;
15382     r = guestfs_cat (g, path);
15383     if (r == NULL)
15384       return -1;
15385     if (strcmp (r, expected) != 0) {
15386       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15387       return -1;
15388     }
15389     free (r);
15390   }
15391   return 0;
15392 }
15393
15394 static int test_touch_0_skip (void)
15395 {
15396   const char *str;
15397
15398   str = getenv ("SKIP_TEST_TOUCH_0");
15399   if (str && strcmp (str, "1") == 0) return 1;
15400   str = getenv ("SKIP_TEST_TOUCH");
15401   if (str && strcmp (str, "1") == 0) return 1;
15402   return 0;
15403 }
15404
15405 static int test_touch_0 (void)
15406 {
15407   if (test_touch_0_skip ()) {
15408     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15409     return 0;
15410   }
15411
15412   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15413   {
15414     char device[] = "/dev/sda";
15415     int r;
15416     suppress_error = 0;
15417     r = guestfs_blockdev_setrw (g, device);
15418     if (r == -1)
15419       return -1;
15420   }
15421   {
15422     int r;
15423     suppress_error = 0;
15424     r = guestfs_umount_all (g);
15425     if (r == -1)
15426       return -1;
15427   }
15428   {
15429     int r;
15430     suppress_error = 0;
15431     r = guestfs_lvm_remove_all (g);
15432     if (r == -1)
15433       return -1;
15434   }
15435   {
15436     char device[] = "/dev/sda";
15437     char lines_0[] = ",";
15438     char *lines[] = {
15439       lines_0,
15440       NULL
15441     };
15442     int r;
15443     suppress_error = 0;
15444     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15445     if (r == -1)
15446       return -1;
15447   }
15448   {
15449     char fstype[] = "ext2";
15450     char device[] = "/dev/sda1";
15451     int r;
15452     suppress_error = 0;
15453     r = guestfs_mkfs (g, fstype, device);
15454     if (r == -1)
15455       return -1;
15456   }
15457   {
15458     char device[] = "/dev/sda1";
15459     char mountpoint[] = "/";
15460     int r;
15461     suppress_error = 0;
15462     r = guestfs_mount (g, device, mountpoint);
15463     if (r == -1)
15464       return -1;
15465   }
15466   /* TestOutputTrue for touch (0) */
15467   {
15468     char path[] = "/new";
15469     int r;
15470     suppress_error = 0;
15471     r = guestfs_touch (g, path);
15472     if (r == -1)
15473       return -1;
15474   }
15475   {
15476     char path[] = "/new";
15477     int r;
15478     suppress_error = 0;
15479     r = guestfs_exists (g, path);
15480     if (r == -1)
15481       return -1;
15482     if (!r) {
15483       fprintf (stderr, "test_touch_0: expected true, got false\n");
15484       return -1;
15485     }
15486   }
15487   return 0;
15488 }
15489
15490 static int test_sync_0_skip (void)
15491 {
15492   const char *str;
15493
15494   str = getenv ("SKIP_TEST_SYNC_0");
15495   if (str && strcmp (str, "1") == 0) return 1;
15496   str = getenv ("SKIP_TEST_SYNC");
15497   if (str && strcmp (str, "1") == 0) return 1;
15498   return 0;
15499 }
15500
15501 static int test_sync_0 (void)
15502 {
15503   if (test_sync_0_skip ()) {
15504     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15505     return 0;
15506   }
15507
15508   /* InitNone|InitEmpty for test_sync_0 */
15509   {
15510     char device[] = "/dev/sda";
15511     int r;
15512     suppress_error = 0;
15513     r = guestfs_blockdev_setrw (g, device);
15514     if (r == -1)
15515       return -1;
15516   }
15517   {
15518     int r;
15519     suppress_error = 0;
15520     r = guestfs_umount_all (g);
15521     if (r == -1)
15522       return -1;
15523   }
15524   {
15525     int r;
15526     suppress_error = 0;
15527     r = guestfs_lvm_remove_all (g);
15528     if (r == -1)
15529       return -1;
15530   }
15531   /* TestRun for sync (0) */
15532   {
15533     int r;
15534     suppress_error = 0;
15535     r = guestfs_sync (g);
15536     if (r == -1)
15537       return -1;
15538   }
15539   return 0;
15540 }
15541
15542 static int test_mount_0_skip (void)
15543 {
15544   const char *str;
15545
15546   str = getenv ("SKIP_TEST_MOUNT_0");
15547   if (str && strcmp (str, "1") == 0) return 1;
15548   str = getenv ("SKIP_TEST_MOUNT");
15549   if (str && strcmp (str, "1") == 0) return 1;
15550   return 0;
15551 }
15552
15553 static int test_mount_0 (void)
15554 {
15555   if (test_mount_0_skip ()) {
15556     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15557     return 0;
15558   }
15559
15560   /* InitNone|InitEmpty for test_mount_0 */
15561   {
15562     char device[] = "/dev/sda";
15563     int r;
15564     suppress_error = 0;
15565     r = guestfs_blockdev_setrw (g, device);
15566     if (r == -1)
15567       return -1;
15568   }
15569   {
15570     int r;
15571     suppress_error = 0;
15572     r = guestfs_umount_all (g);
15573     if (r == -1)
15574       return -1;
15575   }
15576   {
15577     int r;
15578     suppress_error = 0;
15579     r = guestfs_lvm_remove_all (g);
15580     if (r == -1)
15581       return -1;
15582   }
15583   /* TestOutput for mount (0) */
15584   char expected[] = "new file contents";
15585   {
15586     char device[] = "/dev/sda";
15587     char lines_0[] = ",";
15588     char *lines[] = {
15589       lines_0,
15590       NULL
15591     };
15592     int r;
15593     suppress_error = 0;
15594     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15595     if (r == -1)
15596       return -1;
15597   }
15598   {
15599     char fstype[] = "ext2";
15600     char device[] = "/dev/sda1";
15601     int r;
15602     suppress_error = 0;
15603     r = guestfs_mkfs (g, fstype, device);
15604     if (r == -1)
15605       return -1;
15606   }
15607   {
15608     char device[] = "/dev/sda1";
15609     char mountpoint[] = "/";
15610     int r;
15611     suppress_error = 0;
15612     r = guestfs_mount (g, device, mountpoint);
15613     if (r == -1)
15614       return -1;
15615   }
15616   {
15617     char path[] = "/new";
15618     char content[] = "new file contents";
15619     int r;
15620     suppress_error = 0;
15621     r = guestfs_write_file (g, path, content, 0);
15622     if (r == -1)
15623       return -1;
15624   }
15625   {
15626     char path[] = "/new";
15627     char *r;
15628     suppress_error = 0;
15629     r = guestfs_cat (g, path);
15630     if (r == NULL)
15631       return -1;
15632     if (strcmp (r, expected) != 0) {
15633       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
15634       return -1;
15635     }
15636     free (r);
15637   }
15638   return 0;
15639 }
15640
15641 int main (int argc, char *argv[])
15642 {
15643   char c = 0;
15644   int failed = 0;
15645   const char *filename;
15646   int fd;
15647   int nr_tests, test_num = 0;
15648
15649   no_test_warnings ();
15650
15651   g = guestfs_create ();
15652   if (g == NULL) {
15653     printf ("guestfs_create FAILED\n");
15654     exit (1);
15655   }
15656
15657   guestfs_set_error_handler (g, print_error, NULL);
15658
15659   guestfs_set_path (g, "../appliance");
15660
15661   filename = "test1.img";
15662   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15663   if (fd == -1) {
15664     perror (filename);
15665     exit (1);
15666   }
15667   if (lseek (fd, 524288000, SEEK_SET) == -1) {
15668     perror ("lseek");
15669     close (fd);
15670     unlink (filename);
15671     exit (1);
15672   }
15673   if (write (fd, &c, 1) == -1) {
15674     perror ("write");
15675     close (fd);
15676     unlink (filename);
15677     exit (1);
15678   }
15679   if (close (fd) == -1) {
15680     perror (filename);
15681     unlink (filename);
15682     exit (1);
15683   }
15684   if (guestfs_add_drive (g, filename) == -1) {
15685     printf ("guestfs_add_drive %s FAILED\n", filename);
15686     exit (1);
15687   }
15688
15689   filename = "test2.img";
15690   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15691   if (fd == -1) {
15692     perror (filename);
15693     exit (1);
15694   }
15695   if (lseek (fd, 52428800, SEEK_SET) == -1) {
15696     perror ("lseek");
15697     close (fd);
15698     unlink (filename);
15699     exit (1);
15700   }
15701   if (write (fd, &c, 1) == -1) {
15702     perror ("write");
15703     close (fd);
15704     unlink (filename);
15705     exit (1);
15706   }
15707   if (close (fd) == -1) {
15708     perror (filename);
15709     unlink (filename);
15710     exit (1);
15711   }
15712   if (guestfs_add_drive (g, filename) == -1) {
15713     printf ("guestfs_add_drive %s FAILED\n", filename);
15714     exit (1);
15715   }
15716
15717   filename = "test3.img";
15718   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15719   if (fd == -1) {
15720     perror (filename);
15721     exit (1);
15722   }
15723   if (lseek (fd, 10485760, SEEK_SET) == -1) {
15724     perror ("lseek");
15725     close (fd);
15726     unlink (filename);
15727     exit (1);
15728   }
15729   if (write (fd, &c, 1) == -1) {
15730     perror ("write");
15731     close (fd);
15732     unlink (filename);
15733     exit (1);
15734   }
15735   if (close (fd) == -1) {
15736     perror (filename);
15737     unlink (filename);
15738     exit (1);
15739   }
15740   if (guestfs_add_drive (g, filename) == -1) {
15741     printf ("guestfs_add_drive %s FAILED\n", filename);
15742     exit (1);
15743   }
15744
15745   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
15746     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
15747     exit (1);
15748   }
15749
15750   if (guestfs_launch (g) == -1) {
15751     printf ("guestfs_launch FAILED\n");
15752     exit (1);
15753   }
15754   if (guestfs_wait_ready (g) == -1) {
15755     printf ("guestfs_wait_ready FAILED\n");
15756     exit (1);
15757   }
15758
15759   nr_tests = 146;
15760
15761   test_num++;
15762   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
15763   if (test_ntfs_3g_probe_0 () == -1) {
15764     printf ("test_ntfs_3g_probe_0 FAILED\n");
15765     failed++;
15766   }
15767   test_num++;
15768   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
15769   if (test_ntfs_3g_probe_1 () == -1) {
15770     printf ("test_ntfs_3g_probe_1 FAILED\n");
15771     failed++;
15772   }
15773   test_num++;
15774   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
15775   if (test_sleep_0 () == -1) {
15776     printf ("test_sleep_0 FAILED\n");
15777     failed++;
15778   }
15779   test_num++;
15780   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
15781   if (test_find_0 () == -1) {
15782     printf ("test_find_0 FAILED\n");
15783     failed++;
15784   }
15785   test_num++;
15786   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
15787   if (test_find_1 () == -1) {
15788     printf ("test_find_1 FAILED\n");
15789     failed++;
15790   }
15791   test_num++;
15792   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
15793   if (test_find_2 () == -1) {
15794     printf ("test_find_2 FAILED\n");
15795     failed++;
15796   }
15797   test_num++;
15798   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
15799   if (test_lvresize_0 () == -1) {
15800     printf ("test_lvresize_0 FAILED\n");
15801     failed++;
15802   }
15803   test_num++;
15804   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
15805   if (test_zerofree_0 () == -1) {
15806     printf ("test_zerofree_0 FAILED\n");
15807     failed++;
15808   }
15809   test_num++;
15810   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
15811   if (test_hexdump_0 () == -1) {
15812     printf ("test_hexdump_0 FAILED\n");
15813     failed++;
15814   }
15815   test_num++;
15816   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
15817   if (test_strings_e_0 () == -1) {
15818     printf ("test_strings_e_0 FAILED\n");
15819     failed++;
15820   }
15821   test_num++;
15822   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
15823   if (test_strings_e_1 () == -1) {
15824     printf ("test_strings_e_1 FAILED\n");
15825     failed++;
15826   }
15827   test_num++;
15828   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
15829   if (test_strings_0 () == -1) {
15830     printf ("test_strings_0 FAILED\n");
15831     failed++;
15832   }
15833   test_num++;
15834   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
15835   if (test_strings_1 () == -1) {
15836     printf ("test_strings_1 FAILED\n");
15837     failed++;
15838   }
15839   test_num++;
15840   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
15841   if (test_equal_0 () == -1) {
15842     printf ("test_equal_0 FAILED\n");
15843     failed++;
15844   }
15845   test_num++;
15846   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
15847   if (test_equal_1 () == -1) {
15848     printf ("test_equal_1 FAILED\n");
15849     failed++;
15850   }
15851   test_num++;
15852   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
15853   if (test_equal_2 () == -1) {
15854     printf ("test_equal_2 FAILED\n");
15855     failed++;
15856   }
15857   test_num++;
15858   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
15859   if (test_ping_daemon_0 () == -1) {
15860     printf ("test_ping_daemon_0 FAILED\n");
15861     failed++;
15862   }
15863   test_num++;
15864   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
15865   if (test_dmesg_0 () == -1) {
15866     printf ("test_dmesg_0 FAILED\n");
15867     failed++;
15868   }
15869   test_num++;
15870   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
15871   if (test_drop_caches_0 () == -1) {
15872     printf ("test_drop_caches_0 FAILED\n");
15873     failed++;
15874   }
15875   test_num++;
15876   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
15877   if (test_mv_0 () == -1) {
15878     printf ("test_mv_0 FAILED\n");
15879     failed++;
15880   }
15881   test_num++;
15882   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
15883   if (test_mv_1 () == -1) {
15884     printf ("test_mv_1 FAILED\n");
15885     failed++;
15886   }
15887   test_num++;
15888   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
15889   if (test_cp_a_0 () == -1) {
15890     printf ("test_cp_a_0 FAILED\n");
15891     failed++;
15892   }
15893   test_num++;
15894   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
15895   if (test_cp_0 () == -1) {
15896     printf ("test_cp_0 FAILED\n");
15897     failed++;
15898   }
15899   test_num++;
15900   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
15901   if (test_cp_1 () == -1) {
15902     printf ("test_cp_1 FAILED\n");
15903     failed++;
15904   }
15905   test_num++;
15906   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
15907   if (test_cp_2 () == -1) {
15908     printf ("test_cp_2 FAILED\n");
15909     failed++;
15910   }
15911   test_num++;
15912   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
15913   if (test_grub_install_0 () == -1) {
15914     printf ("test_grub_install_0 FAILED\n");
15915     failed++;
15916   }
15917   test_num++;
15918   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
15919   if (test_zero_0 () == -1) {
15920     printf ("test_zero_0 FAILED\n");
15921     failed++;
15922   }
15923   test_num++;
15924   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
15925   if (test_fsck_0 () == -1) {
15926     printf ("test_fsck_0 FAILED\n");
15927     failed++;
15928   }
15929   test_num++;
15930   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
15931   if (test_fsck_1 () == -1) {
15932     printf ("test_fsck_1 FAILED\n");
15933     failed++;
15934   }
15935   test_num++;
15936   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
15937   if (test_set_e2uuid_0 () == -1) {
15938     printf ("test_set_e2uuid_0 FAILED\n");
15939     failed++;
15940   }
15941   test_num++;
15942   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
15943   if (test_set_e2uuid_1 () == -1) {
15944     printf ("test_set_e2uuid_1 FAILED\n");
15945     failed++;
15946   }
15947   test_num++;
15948   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
15949   if (test_set_e2uuid_2 () == -1) {
15950     printf ("test_set_e2uuid_2 FAILED\n");
15951     failed++;
15952   }
15953   test_num++;
15954   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
15955   if (test_set_e2uuid_3 () == -1) {
15956     printf ("test_set_e2uuid_3 FAILED\n");
15957     failed++;
15958   }
15959   test_num++;
15960   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
15961   if (test_set_e2label_0 () == -1) {
15962     printf ("test_set_e2label_0 FAILED\n");
15963     failed++;
15964   }
15965   test_num++;
15966   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
15967   if (test_pvremove_0 () == -1) {
15968     printf ("test_pvremove_0 FAILED\n");
15969     failed++;
15970   }
15971   test_num++;
15972   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
15973   if (test_pvremove_1 () == -1) {
15974     printf ("test_pvremove_1 FAILED\n");
15975     failed++;
15976   }
15977   test_num++;
15978   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
15979   if (test_pvremove_2 () == -1) {
15980     printf ("test_pvremove_2 FAILED\n");
15981     failed++;
15982   }
15983   test_num++;
15984   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
15985   if (test_vgremove_0 () == -1) {
15986     printf ("test_vgremove_0 FAILED\n");
15987     failed++;
15988   }
15989   test_num++;
15990   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
15991   if (test_vgremove_1 () == -1) {
15992     printf ("test_vgremove_1 FAILED\n");
15993     failed++;
15994   }
15995   test_num++;
15996   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
15997   if (test_lvremove_0 () == -1) {
15998     printf ("test_lvremove_0 FAILED\n");
15999     failed++;
16000   }
16001   test_num++;
16002   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16003   if (test_lvremove_1 () == -1) {
16004     printf ("test_lvremove_1 FAILED\n");
16005     failed++;
16006   }
16007   test_num++;
16008   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16009   if (test_lvremove_2 () == -1) {
16010     printf ("test_lvremove_2 FAILED\n");
16011     failed++;
16012   }
16013   test_num++;
16014   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16015   if (test_mount_ro_0 () == -1) {
16016     printf ("test_mount_ro_0 FAILED\n");
16017     failed++;
16018   }
16019   test_num++;
16020   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16021   if (test_mount_ro_1 () == -1) {
16022     printf ("test_mount_ro_1 FAILED\n");
16023     failed++;
16024   }
16025   test_num++;
16026   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16027   if (test_tgz_in_0 () == -1) {
16028     printf ("test_tgz_in_0 FAILED\n");
16029     failed++;
16030   }
16031   test_num++;
16032   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16033   if (test_tar_in_0 () == -1) {
16034     printf ("test_tar_in_0 FAILED\n");
16035     failed++;
16036   }
16037   test_num++;
16038   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16039   if (test_checksum_0 () == -1) {
16040     printf ("test_checksum_0 FAILED\n");
16041     failed++;
16042   }
16043   test_num++;
16044   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16045   if (test_checksum_1 () == -1) {
16046     printf ("test_checksum_1 FAILED\n");
16047     failed++;
16048   }
16049   test_num++;
16050   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16051   if (test_checksum_2 () == -1) {
16052     printf ("test_checksum_2 FAILED\n");
16053     failed++;
16054   }
16055   test_num++;
16056   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16057   if (test_checksum_3 () == -1) {
16058     printf ("test_checksum_3 FAILED\n");
16059     failed++;
16060   }
16061   test_num++;
16062   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16063   if (test_checksum_4 () == -1) {
16064     printf ("test_checksum_4 FAILED\n");
16065     failed++;
16066   }
16067   test_num++;
16068   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16069   if (test_checksum_5 () == -1) {
16070     printf ("test_checksum_5 FAILED\n");
16071     failed++;
16072   }
16073   test_num++;
16074   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16075   if (test_checksum_6 () == -1) {
16076     printf ("test_checksum_6 FAILED\n");
16077     failed++;
16078   }
16079   test_num++;
16080   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16081   if (test_checksum_7 () == -1) {
16082     printf ("test_checksum_7 FAILED\n");
16083     failed++;
16084   }
16085   test_num++;
16086   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16087   if (test_checksum_8 () == -1) {
16088     printf ("test_checksum_8 FAILED\n");
16089     failed++;
16090   }
16091   test_num++;
16092   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16093   if (test_download_0 () == -1) {
16094     printf ("test_download_0 FAILED\n");
16095     failed++;
16096   }
16097   test_num++;
16098   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16099   if (test_upload_0 () == -1) {
16100     printf ("test_upload_0 FAILED\n");
16101     failed++;
16102   }
16103   test_num++;
16104   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16105   if (test_blockdev_rereadpt_0 () == -1) {
16106     printf ("test_blockdev_rereadpt_0 FAILED\n");
16107     failed++;
16108   }
16109   test_num++;
16110   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16111   if (test_blockdev_flushbufs_0 () == -1) {
16112     printf ("test_blockdev_flushbufs_0 FAILED\n");
16113     failed++;
16114   }
16115   test_num++;
16116   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16117   if (test_blockdev_getsize64_0 () == -1) {
16118     printf ("test_blockdev_getsize64_0 FAILED\n");
16119     failed++;
16120   }
16121   test_num++;
16122   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16123   if (test_blockdev_getsz_0 () == -1) {
16124     printf ("test_blockdev_getsz_0 FAILED\n");
16125     failed++;
16126   }
16127   test_num++;
16128   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16129   if (test_blockdev_getbsz_0 () == -1) {
16130     printf ("test_blockdev_getbsz_0 FAILED\n");
16131     failed++;
16132   }
16133   test_num++;
16134   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16135   if (test_blockdev_getss_0 () == -1) {
16136     printf ("test_blockdev_getss_0 FAILED\n");
16137     failed++;
16138   }
16139   test_num++;
16140   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16141   if (test_blockdev_getro_0 () == -1) {
16142     printf ("test_blockdev_getro_0 FAILED\n");
16143     failed++;
16144   }
16145   test_num++;
16146   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16147   if (test_blockdev_setrw_0 () == -1) {
16148     printf ("test_blockdev_setrw_0 FAILED\n");
16149     failed++;
16150   }
16151   test_num++;
16152   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16153   if (test_blockdev_setro_0 () == -1) {
16154     printf ("test_blockdev_setro_0 FAILED\n");
16155     failed++;
16156   }
16157   test_num++;
16158   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16159   if (test_statvfs_0 () == -1) {
16160     printf ("test_statvfs_0 FAILED\n");
16161     failed++;
16162   }
16163   test_num++;
16164   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16165   if (test_lstat_0 () == -1) {
16166     printf ("test_lstat_0 FAILED\n");
16167     failed++;
16168   }
16169   test_num++;
16170   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16171   if (test_stat_0 () == -1) {
16172     printf ("test_stat_0 FAILED\n");
16173     failed++;
16174   }
16175   test_num++;
16176   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16177   if (test_command_lines_0 () == -1) {
16178     printf ("test_command_lines_0 FAILED\n");
16179     failed++;
16180   }
16181   test_num++;
16182   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16183   if (test_command_lines_1 () == -1) {
16184     printf ("test_command_lines_1 FAILED\n");
16185     failed++;
16186   }
16187   test_num++;
16188   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16189   if (test_command_lines_2 () == -1) {
16190     printf ("test_command_lines_2 FAILED\n");
16191     failed++;
16192   }
16193   test_num++;
16194   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16195   if (test_command_lines_3 () == -1) {
16196     printf ("test_command_lines_3 FAILED\n");
16197     failed++;
16198   }
16199   test_num++;
16200   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16201   if (test_command_lines_4 () == -1) {
16202     printf ("test_command_lines_4 FAILED\n");
16203     failed++;
16204   }
16205   test_num++;
16206   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16207   if (test_command_lines_5 () == -1) {
16208     printf ("test_command_lines_5 FAILED\n");
16209     failed++;
16210   }
16211   test_num++;
16212   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16213   if (test_command_lines_6 () == -1) {
16214     printf ("test_command_lines_6 FAILED\n");
16215     failed++;
16216   }
16217   test_num++;
16218   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16219   if (test_command_lines_7 () == -1) {
16220     printf ("test_command_lines_7 FAILED\n");
16221     failed++;
16222   }
16223   test_num++;
16224   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16225   if (test_command_lines_8 () == -1) {
16226     printf ("test_command_lines_8 FAILED\n");
16227     failed++;
16228   }
16229   test_num++;
16230   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16231   if (test_command_lines_9 () == -1) {
16232     printf ("test_command_lines_9 FAILED\n");
16233     failed++;
16234   }
16235   test_num++;
16236   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16237   if (test_command_lines_10 () == -1) {
16238     printf ("test_command_lines_10 FAILED\n");
16239     failed++;
16240   }
16241   test_num++;
16242   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16243   if (test_command_0 () == -1) {
16244     printf ("test_command_0 FAILED\n");
16245     failed++;
16246   }
16247   test_num++;
16248   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16249   if (test_command_1 () == -1) {
16250     printf ("test_command_1 FAILED\n");
16251     failed++;
16252   }
16253   test_num++;
16254   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16255   if (test_command_2 () == -1) {
16256     printf ("test_command_2 FAILED\n");
16257     failed++;
16258   }
16259   test_num++;
16260   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16261   if (test_command_3 () == -1) {
16262     printf ("test_command_3 FAILED\n");
16263     failed++;
16264   }
16265   test_num++;
16266   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16267   if (test_command_4 () == -1) {
16268     printf ("test_command_4 FAILED\n");
16269     failed++;
16270   }
16271   test_num++;
16272   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16273   if (test_command_5 () == -1) {
16274     printf ("test_command_5 FAILED\n");
16275     failed++;
16276   }
16277   test_num++;
16278   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16279   if (test_command_6 () == -1) {
16280     printf ("test_command_6 FAILED\n");
16281     failed++;
16282   }
16283   test_num++;
16284   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16285   if (test_command_7 () == -1) {
16286     printf ("test_command_7 FAILED\n");
16287     failed++;
16288   }
16289   test_num++;
16290   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16291   if (test_command_8 () == -1) {
16292     printf ("test_command_8 FAILED\n");
16293     failed++;
16294   }
16295   test_num++;
16296   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16297   if (test_command_9 () == -1) {
16298     printf ("test_command_9 FAILED\n");
16299     failed++;
16300   }
16301   test_num++;
16302   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16303   if (test_command_10 () == -1) {
16304     printf ("test_command_10 FAILED\n");
16305     failed++;
16306   }
16307   test_num++;
16308   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16309   if (test_command_11 () == -1) {
16310     printf ("test_command_11 FAILED\n");
16311     failed++;
16312   }
16313   test_num++;
16314   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16315   if (test_file_0 () == -1) {
16316     printf ("test_file_0 FAILED\n");
16317     failed++;
16318   }
16319   test_num++;
16320   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16321   if (test_file_1 () == -1) {
16322     printf ("test_file_1 FAILED\n");
16323     failed++;
16324   }
16325   test_num++;
16326   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16327   if (test_file_2 () == -1) {
16328     printf ("test_file_2 FAILED\n");
16329     failed++;
16330   }
16331   test_num++;
16332   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16333   if (test_umount_all_0 () == -1) {
16334     printf ("test_umount_all_0 FAILED\n");
16335     failed++;
16336   }
16337   test_num++;
16338   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16339   if (test_umount_all_1 () == -1) {
16340     printf ("test_umount_all_1 FAILED\n");
16341     failed++;
16342   }
16343   test_num++;
16344   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16345   if (test_mounts_0 () == -1) {
16346     printf ("test_mounts_0 FAILED\n");
16347     failed++;
16348   }
16349   test_num++;
16350   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16351   if (test_umount_0 () == -1) {
16352     printf ("test_umount_0 FAILED\n");
16353     failed++;
16354   }
16355   test_num++;
16356   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16357   if (test_umount_1 () == -1) {
16358     printf ("test_umount_1 FAILED\n");
16359     failed++;
16360   }
16361   test_num++;
16362   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16363   if (test_write_file_0 () == -1) {
16364     printf ("test_write_file_0 FAILED\n");
16365     failed++;
16366   }
16367   test_num++;
16368   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16369   if (test_write_file_1 () == -1) {
16370     printf ("test_write_file_1 FAILED\n");
16371     failed++;
16372   }
16373   test_num++;
16374   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16375   if (test_write_file_2 () == -1) {
16376     printf ("test_write_file_2 FAILED\n");
16377     failed++;
16378   }
16379   test_num++;
16380   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16381   if (test_write_file_3 () == -1) {
16382     printf ("test_write_file_3 FAILED\n");
16383     failed++;
16384   }
16385   test_num++;
16386   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16387   if (test_write_file_4 () == -1) {
16388     printf ("test_write_file_4 FAILED\n");
16389     failed++;
16390   }
16391   test_num++;
16392   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16393   if (test_write_file_5 () == -1) {
16394     printf ("test_write_file_5 FAILED\n");
16395     failed++;
16396   }
16397   test_num++;
16398   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16399   if (test_mkfs_0 () == -1) {
16400     printf ("test_mkfs_0 FAILED\n");
16401     failed++;
16402   }
16403   test_num++;
16404   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16405   if (test_lvcreate_0 () == -1) {
16406     printf ("test_lvcreate_0 FAILED\n");
16407     failed++;
16408   }
16409   test_num++;
16410   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16411   if (test_vgcreate_0 () == -1) {
16412     printf ("test_vgcreate_0 FAILED\n");
16413     failed++;
16414   }
16415   test_num++;
16416   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16417   if (test_pvcreate_0 () == -1) {
16418     printf ("test_pvcreate_0 FAILED\n");
16419     failed++;
16420   }
16421   test_num++;
16422   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16423   if (test_is_dir_0 () == -1) {
16424     printf ("test_is_dir_0 FAILED\n");
16425     failed++;
16426   }
16427   test_num++;
16428   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16429   if (test_is_dir_1 () == -1) {
16430     printf ("test_is_dir_1 FAILED\n");
16431     failed++;
16432   }
16433   test_num++;
16434   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16435   if (test_is_file_0 () == -1) {
16436     printf ("test_is_file_0 FAILED\n");
16437     failed++;
16438   }
16439   test_num++;
16440   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16441   if (test_is_file_1 () == -1) {
16442     printf ("test_is_file_1 FAILED\n");
16443     failed++;
16444   }
16445   test_num++;
16446   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16447   if (test_exists_0 () == -1) {
16448     printf ("test_exists_0 FAILED\n");
16449     failed++;
16450   }
16451   test_num++;
16452   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16453   if (test_exists_1 () == -1) {
16454     printf ("test_exists_1 FAILED\n");
16455     failed++;
16456   }
16457   test_num++;
16458   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16459   if (test_mkdir_p_0 () == -1) {
16460     printf ("test_mkdir_p_0 FAILED\n");
16461     failed++;
16462   }
16463   test_num++;
16464   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16465   if (test_mkdir_p_1 () == -1) {
16466     printf ("test_mkdir_p_1 FAILED\n");
16467     failed++;
16468   }
16469   test_num++;
16470   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16471   if (test_mkdir_p_2 () == -1) {
16472     printf ("test_mkdir_p_2 FAILED\n");
16473     failed++;
16474   }
16475   test_num++;
16476   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16477   if (test_mkdir_p_3 () == -1) {
16478     printf ("test_mkdir_p_3 FAILED\n");
16479     failed++;
16480   }
16481   test_num++;
16482   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16483   if (test_mkdir_p_4 () == -1) {
16484     printf ("test_mkdir_p_4 FAILED\n");
16485     failed++;
16486   }
16487   test_num++;
16488   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16489   if (test_mkdir_0 () == -1) {
16490     printf ("test_mkdir_0 FAILED\n");
16491     failed++;
16492   }
16493   test_num++;
16494   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16495   if (test_mkdir_1 () == -1) {
16496     printf ("test_mkdir_1 FAILED\n");
16497     failed++;
16498   }
16499   test_num++;
16500   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16501   if (test_rm_rf_0 () == -1) {
16502     printf ("test_rm_rf_0 FAILED\n");
16503     failed++;
16504   }
16505   test_num++;
16506   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16507   if (test_rmdir_0 () == -1) {
16508     printf ("test_rmdir_0 FAILED\n");
16509     failed++;
16510   }
16511   test_num++;
16512   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16513   if (test_rmdir_1 () == -1) {
16514     printf ("test_rmdir_1 FAILED\n");
16515     failed++;
16516   }
16517   test_num++;
16518   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16519   if (test_rmdir_2 () == -1) {
16520     printf ("test_rmdir_2 FAILED\n");
16521     failed++;
16522   }
16523   test_num++;
16524   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16525   if (test_rm_0 () == -1) {
16526     printf ("test_rm_0 FAILED\n");
16527     failed++;
16528   }
16529   test_num++;
16530   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16531   if (test_rm_1 () == -1) {
16532     printf ("test_rm_1 FAILED\n");
16533     failed++;
16534   }
16535   test_num++;
16536   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16537   if (test_rm_2 () == -1) {
16538     printf ("test_rm_2 FAILED\n");
16539     failed++;
16540   }
16541   test_num++;
16542   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16543   if (test_read_lines_0 () == -1) {
16544     printf ("test_read_lines_0 FAILED\n");
16545     failed++;
16546   }
16547   test_num++;
16548   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16549   if (test_read_lines_1 () == -1) {
16550     printf ("test_read_lines_1 FAILED\n");
16551     failed++;
16552   }
16553   test_num++;
16554   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16555   if (test_lvs_0 () == -1) {
16556     printf ("test_lvs_0 FAILED\n");
16557     failed++;
16558   }
16559   test_num++;
16560   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16561   if (test_lvs_1 () == -1) {
16562     printf ("test_lvs_1 FAILED\n");
16563     failed++;
16564   }
16565   test_num++;
16566   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16567   if (test_vgs_0 () == -1) {
16568     printf ("test_vgs_0 FAILED\n");
16569     failed++;
16570   }
16571   test_num++;
16572   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16573   if (test_vgs_1 () == -1) {
16574     printf ("test_vgs_1 FAILED\n");
16575     failed++;
16576   }
16577   test_num++;
16578   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16579   if (test_pvs_0 () == -1) {
16580     printf ("test_pvs_0 FAILED\n");
16581     failed++;
16582   }
16583   test_num++;
16584   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16585   if (test_pvs_1 () == -1) {
16586     printf ("test_pvs_1 FAILED\n");
16587     failed++;
16588   }
16589   test_num++;
16590   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16591   if (test_list_partitions_0 () == -1) {
16592     printf ("test_list_partitions_0 FAILED\n");
16593     failed++;
16594   }
16595   test_num++;
16596   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16597   if (test_list_partitions_1 () == -1) {
16598     printf ("test_list_partitions_1 FAILED\n");
16599     failed++;
16600   }
16601   test_num++;
16602   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16603   if (test_list_devices_0 () == -1) {
16604     printf ("test_list_devices_0 FAILED\n");
16605     failed++;
16606   }
16607   test_num++;
16608   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16609   if (test_ls_0 () == -1) {
16610     printf ("test_ls_0 FAILED\n");
16611     failed++;
16612   }
16613   test_num++;
16614   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16615   if (test_cat_0 () == -1) {
16616     printf ("test_cat_0 FAILED\n");
16617     failed++;
16618   }
16619   test_num++;
16620   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
16621   if (test_touch_0 () == -1) {
16622     printf ("test_touch_0 FAILED\n");
16623     failed++;
16624   }
16625   test_num++;
16626   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
16627   if (test_sync_0 () == -1) {
16628     printf ("test_sync_0 FAILED\n");
16629     failed++;
16630   }
16631   test_num++;
16632   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
16633   if (test_mount_0 () == -1) {
16634     printf ("test_mount_0 FAILED\n");
16635     failed++;
16636   }
16637
16638   guestfs_close (g);
16639   unlink ("test1.img");
16640   unlink ("test2.img");
16641   unlink ("test3.img");
16642
16643   if (failed > 0) {
16644     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
16645     exit (1);
16646   }
16647
16648   exit (0);
16649 }