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 options[] = "ro";
5798     char vfstype[] = "squashfs";
5799     char device[] = "/dev/sdd";
5800     char mountpoint[] = "/";
5801     int r;
5802     suppress_error = 0;
5803     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
5804     if (r == -1)
5805       return -1;
5806   }
5807   {
5808     char csumtype[] = "md5";
5809     char path[] = "/known-3";
5810     char *r;
5811     suppress_error = 0;
5812     r = guestfs_checksum (g, csumtype, path);
5813     if (r == NULL)
5814       return -1;
5815     if (strcmp (r, expected) != 0) {
5816       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
5817       return -1;
5818     }
5819     free (r);
5820   }
5821   return 0;
5822 }
5823
5824 static int test_download_0_skip (void)
5825 {
5826   const char *str;
5827
5828   str = getenv ("SKIP_TEST_DOWNLOAD_0");
5829   if (str && strcmp (str, "1") == 0) return 1;
5830   str = getenv ("SKIP_TEST_DOWNLOAD");
5831   if (str && strcmp (str, "1") == 0) return 1;
5832   return 0;
5833 }
5834
5835 static int test_download_0 (void)
5836 {
5837   if (test_download_0_skip ()) {
5838     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5839     return 0;
5840   }
5841
5842   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5843   {
5844     char device[] = "/dev/sda";
5845     int r;
5846     suppress_error = 0;
5847     r = guestfs_blockdev_setrw (g, device);
5848     if (r == -1)
5849       return -1;
5850   }
5851   {
5852     int r;
5853     suppress_error = 0;
5854     r = guestfs_umount_all (g);
5855     if (r == -1)
5856       return -1;
5857   }
5858   {
5859     int r;
5860     suppress_error = 0;
5861     r = guestfs_lvm_remove_all (g);
5862     if (r == -1)
5863       return -1;
5864   }
5865   {
5866     char device[] = "/dev/sda";
5867     char lines_0[] = ",";
5868     char *lines[] = {
5869       lines_0,
5870       NULL
5871     };
5872     int r;
5873     suppress_error = 0;
5874     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5875     if (r == -1)
5876       return -1;
5877   }
5878   {
5879     char fstype[] = "ext2";
5880     char device[] = "/dev/sda1";
5881     int r;
5882     suppress_error = 0;
5883     r = guestfs_mkfs (g, fstype, device);
5884     if (r == -1)
5885       return -1;
5886   }
5887   {
5888     char device[] = "/dev/sda1";
5889     char mountpoint[] = "/";
5890     int r;
5891     suppress_error = 0;
5892     r = guestfs_mount (g, device, mountpoint);
5893     if (r == -1)
5894       return -1;
5895   }
5896   /* TestOutput for download (0) */
5897   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5898   {
5899     char remotefilename[] = "/COPYING.LIB";
5900     int r;
5901     suppress_error = 0;
5902     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5903     if (r == -1)
5904       return -1;
5905   }
5906   {
5907     char remotefilename[] = "/COPYING.LIB";
5908     int r;
5909     suppress_error = 0;
5910     r = guestfs_download (g, remotefilename, "testdownload.tmp");
5911     if (r == -1)
5912       return -1;
5913   }
5914   {
5915     char remotefilename[] = "/upload";
5916     int r;
5917     suppress_error = 0;
5918     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5919     if (r == -1)
5920       return -1;
5921   }
5922   {
5923     char csumtype[] = "md5";
5924     char path[] = "/upload";
5925     char *r;
5926     suppress_error = 0;
5927     r = guestfs_checksum (g, csumtype, path);
5928     if (r == NULL)
5929       return -1;
5930     if (strcmp (r, expected) != 0) {
5931       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5932       return -1;
5933     }
5934     free (r);
5935   }
5936   return 0;
5937 }
5938
5939 static int test_upload_0_skip (void)
5940 {
5941   const char *str;
5942
5943   str = getenv ("SKIP_TEST_UPLOAD_0");
5944   if (str && strcmp (str, "1") == 0) return 1;
5945   str = getenv ("SKIP_TEST_UPLOAD");
5946   if (str && strcmp (str, "1") == 0) return 1;
5947   return 0;
5948 }
5949
5950 static int test_upload_0 (void)
5951 {
5952   if (test_upload_0_skip ()) {
5953     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5954     return 0;
5955   }
5956
5957   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5958   {
5959     char device[] = "/dev/sda";
5960     int r;
5961     suppress_error = 0;
5962     r = guestfs_blockdev_setrw (g, device);
5963     if (r == -1)
5964       return -1;
5965   }
5966   {
5967     int r;
5968     suppress_error = 0;
5969     r = guestfs_umount_all (g);
5970     if (r == -1)
5971       return -1;
5972   }
5973   {
5974     int r;
5975     suppress_error = 0;
5976     r = guestfs_lvm_remove_all (g);
5977     if (r == -1)
5978       return -1;
5979   }
5980   {
5981     char device[] = "/dev/sda";
5982     char lines_0[] = ",";
5983     char *lines[] = {
5984       lines_0,
5985       NULL
5986     };
5987     int r;
5988     suppress_error = 0;
5989     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5990     if (r == -1)
5991       return -1;
5992   }
5993   {
5994     char fstype[] = "ext2";
5995     char device[] = "/dev/sda1";
5996     int r;
5997     suppress_error = 0;
5998     r = guestfs_mkfs (g, fstype, device);
5999     if (r == -1)
6000       return -1;
6001   }
6002   {
6003     char device[] = "/dev/sda1";
6004     char mountpoint[] = "/";
6005     int r;
6006     suppress_error = 0;
6007     r = guestfs_mount (g, device, mountpoint);
6008     if (r == -1)
6009       return -1;
6010   }
6011   /* TestOutput for upload (0) */
6012   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6013   {
6014     char remotefilename[] = "/COPYING.LIB";
6015     int r;
6016     suppress_error = 0;
6017     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6018     if (r == -1)
6019       return -1;
6020   }
6021   {
6022     char csumtype[] = "md5";
6023     char path[] = "/COPYING.LIB";
6024     char *r;
6025     suppress_error = 0;
6026     r = guestfs_checksum (g, csumtype, path);
6027     if (r == NULL)
6028       return -1;
6029     if (strcmp (r, expected) != 0) {
6030       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6031       return -1;
6032     }
6033     free (r);
6034   }
6035   return 0;
6036 }
6037
6038 static int test_blockdev_rereadpt_0_skip (void)
6039 {
6040   const char *str;
6041
6042   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6043   if (str && strcmp (str, "1") == 0) return 1;
6044   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6045   if (str && strcmp (str, "1") == 0) return 1;
6046   return 0;
6047 }
6048
6049 static int test_blockdev_rereadpt_0 (void)
6050 {
6051   if (test_blockdev_rereadpt_0_skip ()) {
6052     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6053     return 0;
6054   }
6055
6056   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6057   {
6058     char device[] = "/dev/sda";
6059     int r;
6060     suppress_error = 0;
6061     r = guestfs_blockdev_setrw (g, device);
6062     if (r == -1)
6063       return -1;
6064   }
6065   {
6066     int r;
6067     suppress_error = 0;
6068     r = guestfs_umount_all (g);
6069     if (r == -1)
6070       return -1;
6071   }
6072   {
6073     int r;
6074     suppress_error = 0;
6075     r = guestfs_lvm_remove_all (g);
6076     if (r == -1)
6077       return -1;
6078   }
6079   /* TestRun for blockdev_rereadpt (0) */
6080   {
6081     char device[] = "/dev/sda";
6082     int r;
6083     suppress_error = 0;
6084     r = guestfs_blockdev_rereadpt (g, device);
6085     if (r == -1)
6086       return -1;
6087   }
6088   return 0;
6089 }
6090
6091 static int test_blockdev_flushbufs_0_skip (void)
6092 {
6093   const char *str;
6094
6095   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6096   if (str && strcmp (str, "1") == 0) return 1;
6097   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6098   if (str && strcmp (str, "1") == 0) return 1;
6099   return 0;
6100 }
6101
6102 static int test_blockdev_flushbufs_0 (void)
6103 {
6104   if (test_blockdev_flushbufs_0_skip ()) {
6105     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6106     return 0;
6107   }
6108
6109   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6110   {
6111     char device[] = "/dev/sda";
6112     int r;
6113     suppress_error = 0;
6114     r = guestfs_blockdev_setrw (g, device);
6115     if (r == -1)
6116       return -1;
6117   }
6118   {
6119     int r;
6120     suppress_error = 0;
6121     r = guestfs_umount_all (g);
6122     if (r == -1)
6123       return -1;
6124   }
6125   {
6126     int r;
6127     suppress_error = 0;
6128     r = guestfs_lvm_remove_all (g);
6129     if (r == -1)
6130       return -1;
6131   }
6132   /* TestRun for blockdev_flushbufs (0) */
6133   {
6134     char device[] = "/dev/sda";
6135     int r;
6136     suppress_error = 0;
6137     r = guestfs_blockdev_flushbufs (g, device);
6138     if (r == -1)
6139       return -1;
6140   }
6141   return 0;
6142 }
6143
6144 static int test_blockdev_getsize64_0_skip (void)
6145 {
6146   const char *str;
6147
6148   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6149   if (str && strcmp (str, "1") == 0) return 1;
6150   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6151   if (str && strcmp (str, "1") == 0) return 1;
6152   return 0;
6153 }
6154
6155 static int test_blockdev_getsize64_0 (void)
6156 {
6157   if (test_blockdev_getsize64_0_skip ()) {
6158     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6159     return 0;
6160   }
6161
6162   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6163   {
6164     char device[] = "/dev/sda";
6165     int r;
6166     suppress_error = 0;
6167     r = guestfs_blockdev_setrw (g, device);
6168     if (r == -1)
6169       return -1;
6170   }
6171   {
6172     int r;
6173     suppress_error = 0;
6174     r = guestfs_umount_all (g);
6175     if (r == -1)
6176       return -1;
6177   }
6178   {
6179     int r;
6180     suppress_error = 0;
6181     r = guestfs_lvm_remove_all (g);
6182     if (r == -1)
6183       return -1;
6184   }
6185   /* TestOutputInt for blockdev_getsize64 (0) */
6186   {
6187     char device[] = "/dev/sda";
6188     int64_t r;
6189     suppress_error = 0;
6190     r = guestfs_blockdev_getsize64 (g, device);
6191     if (r == -1)
6192       return -1;
6193     if (r != 524288000) {
6194       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6195       return -1;
6196     }
6197   }
6198   return 0;
6199 }
6200
6201 static int test_blockdev_getsz_0_skip (void)
6202 {
6203   const char *str;
6204
6205   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6206   if (str && strcmp (str, "1") == 0) return 1;
6207   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6208   if (str && strcmp (str, "1") == 0) return 1;
6209   return 0;
6210 }
6211
6212 static int test_blockdev_getsz_0 (void)
6213 {
6214   if (test_blockdev_getsz_0_skip ()) {
6215     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6216     return 0;
6217   }
6218
6219   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6220   {
6221     char device[] = "/dev/sda";
6222     int r;
6223     suppress_error = 0;
6224     r = guestfs_blockdev_setrw (g, device);
6225     if (r == -1)
6226       return -1;
6227   }
6228   {
6229     int r;
6230     suppress_error = 0;
6231     r = guestfs_umount_all (g);
6232     if (r == -1)
6233       return -1;
6234   }
6235   {
6236     int r;
6237     suppress_error = 0;
6238     r = guestfs_lvm_remove_all (g);
6239     if (r == -1)
6240       return -1;
6241   }
6242   /* TestOutputInt for blockdev_getsz (0) */
6243   {
6244     char device[] = "/dev/sda";
6245     int64_t r;
6246     suppress_error = 0;
6247     r = guestfs_blockdev_getsz (g, device);
6248     if (r == -1)
6249       return -1;
6250     if (r != 1024000) {
6251       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6252       return -1;
6253     }
6254   }
6255   return 0;
6256 }
6257
6258 static int test_blockdev_getbsz_0_skip (void)
6259 {
6260   const char *str;
6261
6262   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6263   if (str && strcmp (str, "1") == 0) return 1;
6264   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6265   if (str && strcmp (str, "1") == 0) return 1;
6266   return 0;
6267 }
6268
6269 static int test_blockdev_getbsz_0 (void)
6270 {
6271   if (test_blockdev_getbsz_0_skip ()) {
6272     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6273     return 0;
6274   }
6275
6276   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6277   {
6278     char device[] = "/dev/sda";
6279     int r;
6280     suppress_error = 0;
6281     r = guestfs_blockdev_setrw (g, device);
6282     if (r == -1)
6283       return -1;
6284   }
6285   {
6286     int r;
6287     suppress_error = 0;
6288     r = guestfs_umount_all (g);
6289     if (r == -1)
6290       return -1;
6291   }
6292   {
6293     int r;
6294     suppress_error = 0;
6295     r = guestfs_lvm_remove_all (g);
6296     if (r == -1)
6297       return -1;
6298   }
6299   /* TestOutputInt for blockdev_getbsz (0) */
6300   {
6301     char device[] = "/dev/sda";
6302     int r;
6303     suppress_error = 0;
6304     r = guestfs_blockdev_getbsz (g, device);
6305     if (r == -1)
6306       return -1;
6307     if (r != 4096) {
6308       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6309       return -1;
6310     }
6311   }
6312   return 0;
6313 }
6314
6315 static int test_blockdev_getss_0_skip (void)
6316 {
6317   const char *str;
6318
6319   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6320   if (str && strcmp (str, "1") == 0) return 1;
6321   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6322   if (str && strcmp (str, "1") == 0) return 1;
6323   return 0;
6324 }
6325
6326 static int test_blockdev_getss_0 (void)
6327 {
6328   if (test_blockdev_getss_0_skip ()) {
6329     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6330     return 0;
6331   }
6332
6333   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6334   {
6335     char device[] = "/dev/sda";
6336     int r;
6337     suppress_error = 0;
6338     r = guestfs_blockdev_setrw (g, device);
6339     if (r == -1)
6340       return -1;
6341   }
6342   {
6343     int r;
6344     suppress_error = 0;
6345     r = guestfs_umount_all (g);
6346     if (r == -1)
6347       return -1;
6348   }
6349   {
6350     int r;
6351     suppress_error = 0;
6352     r = guestfs_lvm_remove_all (g);
6353     if (r == -1)
6354       return -1;
6355   }
6356   /* TestOutputInt for blockdev_getss (0) */
6357   {
6358     char device[] = "/dev/sda";
6359     int r;
6360     suppress_error = 0;
6361     r = guestfs_blockdev_getss (g, device);
6362     if (r == -1)
6363       return -1;
6364     if (r != 512) {
6365       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6366       return -1;
6367     }
6368   }
6369   return 0;
6370 }
6371
6372 static int test_blockdev_getro_0_skip (void)
6373 {
6374   const char *str;
6375
6376   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6377   if (str && strcmp (str, "1") == 0) return 1;
6378   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6379   if (str && strcmp (str, "1") == 0) return 1;
6380   return 0;
6381 }
6382
6383 static int test_blockdev_getro_0 (void)
6384 {
6385   if (test_blockdev_getro_0_skip ()) {
6386     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6387     return 0;
6388   }
6389
6390   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6391   {
6392     char device[] = "/dev/sda";
6393     int r;
6394     suppress_error = 0;
6395     r = guestfs_blockdev_setrw (g, device);
6396     if (r == -1)
6397       return -1;
6398   }
6399   {
6400     int r;
6401     suppress_error = 0;
6402     r = guestfs_umount_all (g);
6403     if (r == -1)
6404       return -1;
6405   }
6406   {
6407     int r;
6408     suppress_error = 0;
6409     r = guestfs_lvm_remove_all (g);
6410     if (r == -1)
6411       return -1;
6412   }
6413   /* TestOutputTrue for blockdev_getro (0) */
6414   {
6415     char device[] = "/dev/sda";
6416     int r;
6417     suppress_error = 0;
6418     r = guestfs_blockdev_setro (g, device);
6419     if (r == -1)
6420       return -1;
6421   }
6422   {
6423     char device[] = "/dev/sda";
6424     int r;
6425     suppress_error = 0;
6426     r = guestfs_blockdev_getro (g, device);
6427     if (r == -1)
6428       return -1;
6429     if (!r) {
6430       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6431       return -1;
6432     }
6433   }
6434   return 0;
6435 }
6436
6437 static int test_blockdev_setrw_0_skip (void)
6438 {
6439   const char *str;
6440
6441   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6442   if (str && strcmp (str, "1") == 0) return 1;
6443   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6444   if (str && strcmp (str, "1") == 0) return 1;
6445   return 0;
6446 }
6447
6448 static int test_blockdev_setrw_0 (void)
6449 {
6450   if (test_blockdev_setrw_0_skip ()) {
6451     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6452     return 0;
6453   }
6454
6455   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6456   {
6457     char device[] = "/dev/sda";
6458     int r;
6459     suppress_error = 0;
6460     r = guestfs_blockdev_setrw (g, device);
6461     if (r == -1)
6462       return -1;
6463   }
6464   {
6465     int r;
6466     suppress_error = 0;
6467     r = guestfs_umount_all (g);
6468     if (r == -1)
6469       return -1;
6470   }
6471   {
6472     int r;
6473     suppress_error = 0;
6474     r = guestfs_lvm_remove_all (g);
6475     if (r == -1)
6476       return -1;
6477   }
6478   /* TestOutputFalse for blockdev_setrw (0) */
6479   {
6480     char device[] = "/dev/sda";
6481     int r;
6482     suppress_error = 0;
6483     r = guestfs_blockdev_setrw (g, device);
6484     if (r == -1)
6485       return -1;
6486   }
6487   {
6488     char device[] = "/dev/sda";
6489     int r;
6490     suppress_error = 0;
6491     r = guestfs_blockdev_getro (g, device);
6492     if (r == -1)
6493       return -1;
6494     if (r) {
6495       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6496       return -1;
6497     }
6498   }
6499   return 0;
6500 }
6501
6502 static int test_blockdev_setro_0_skip (void)
6503 {
6504   const char *str;
6505
6506   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6507   if (str && strcmp (str, "1") == 0) return 1;
6508   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6509   if (str && strcmp (str, "1") == 0) return 1;
6510   return 0;
6511 }
6512
6513 static int test_blockdev_setro_0 (void)
6514 {
6515   if (test_blockdev_setro_0_skip ()) {
6516     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6517     return 0;
6518   }
6519
6520   /* InitNone|InitEmpty for test_blockdev_setro_0 */
6521   {
6522     char device[] = "/dev/sda";
6523     int r;
6524     suppress_error = 0;
6525     r = guestfs_blockdev_setrw (g, device);
6526     if (r == -1)
6527       return -1;
6528   }
6529   {
6530     int r;
6531     suppress_error = 0;
6532     r = guestfs_umount_all (g);
6533     if (r == -1)
6534       return -1;
6535   }
6536   {
6537     int r;
6538     suppress_error = 0;
6539     r = guestfs_lvm_remove_all (g);
6540     if (r == -1)
6541       return -1;
6542   }
6543   /* TestOutputTrue for blockdev_setro (0) */
6544   {
6545     char device[] = "/dev/sda";
6546     int r;
6547     suppress_error = 0;
6548     r = guestfs_blockdev_setro (g, device);
6549     if (r == -1)
6550       return -1;
6551   }
6552   {
6553     char device[] = "/dev/sda";
6554     int r;
6555     suppress_error = 0;
6556     r = guestfs_blockdev_getro (g, device);
6557     if (r == -1)
6558       return -1;
6559     if (!r) {
6560       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6561       return -1;
6562     }
6563   }
6564   return 0;
6565 }
6566
6567 static int test_statvfs_0_skip (void)
6568 {
6569   const char *str;
6570
6571   str = getenv ("SKIP_TEST_STATVFS_0");
6572   if (str && strcmp (str, "1") == 0) return 1;
6573   str = getenv ("SKIP_TEST_STATVFS");
6574   if (str && strcmp (str, "1") == 0) return 1;
6575   return 0;
6576 }
6577
6578 static int test_statvfs_0 (void)
6579 {
6580   if (test_statvfs_0_skip ()) {
6581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6582     return 0;
6583   }
6584
6585   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6586   {
6587     char device[] = "/dev/sda";
6588     int r;
6589     suppress_error = 0;
6590     r = guestfs_blockdev_setrw (g, device);
6591     if (r == -1)
6592       return -1;
6593   }
6594   {
6595     int r;
6596     suppress_error = 0;
6597     r = guestfs_umount_all (g);
6598     if (r == -1)
6599       return -1;
6600   }
6601   {
6602     int r;
6603     suppress_error = 0;
6604     r = guestfs_lvm_remove_all (g);
6605     if (r == -1)
6606       return -1;
6607   }
6608   {
6609     char device[] = "/dev/sda";
6610     char lines_0[] = ",";
6611     char *lines[] = {
6612       lines_0,
6613       NULL
6614     };
6615     int r;
6616     suppress_error = 0;
6617     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6618     if (r == -1)
6619       return -1;
6620   }
6621   {
6622     char fstype[] = "ext2";
6623     char device[] = "/dev/sda1";
6624     int r;
6625     suppress_error = 0;
6626     r = guestfs_mkfs (g, fstype, device);
6627     if (r == -1)
6628       return -1;
6629   }
6630   {
6631     char device[] = "/dev/sda1";
6632     char mountpoint[] = "/";
6633     int r;
6634     suppress_error = 0;
6635     r = guestfs_mount (g, device, mountpoint);
6636     if (r == -1)
6637       return -1;
6638   }
6639   /* TestOutputStruct for statvfs (0) */
6640   {
6641     char path[] = "/";
6642     struct guestfs_statvfs *r;
6643     suppress_error = 0;
6644     r = guestfs_statvfs (g, path);
6645     if (r == NULL)
6646       return -1;
6647     if (r->bfree != 487702) {
6648       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6649                (int) r->bfree);
6650       return -1;
6651     }
6652     if (r->blocks != 490020) {
6653       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6654                (int) r->blocks);
6655       return -1;
6656     }
6657     if (r->bsize != 1024) {
6658       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6659                (int) r->bsize);
6660       return -1;
6661     }
6662     free (r);
6663   }
6664   return 0;
6665 }
6666
6667 static int test_lstat_0_skip (void)
6668 {
6669   const char *str;
6670
6671   str = getenv ("SKIP_TEST_LSTAT_0");
6672   if (str && strcmp (str, "1") == 0) return 1;
6673   str = getenv ("SKIP_TEST_LSTAT");
6674   if (str && strcmp (str, "1") == 0) return 1;
6675   return 0;
6676 }
6677
6678 static int test_lstat_0 (void)
6679 {
6680   if (test_lstat_0_skip ()) {
6681     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6682     return 0;
6683   }
6684
6685   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6686   {
6687     char device[] = "/dev/sda";
6688     int r;
6689     suppress_error = 0;
6690     r = guestfs_blockdev_setrw (g, device);
6691     if (r == -1)
6692       return -1;
6693   }
6694   {
6695     int r;
6696     suppress_error = 0;
6697     r = guestfs_umount_all (g);
6698     if (r == -1)
6699       return -1;
6700   }
6701   {
6702     int r;
6703     suppress_error = 0;
6704     r = guestfs_lvm_remove_all (g);
6705     if (r == -1)
6706       return -1;
6707   }
6708   {
6709     char device[] = "/dev/sda";
6710     char lines_0[] = ",";
6711     char *lines[] = {
6712       lines_0,
6713       NULL
6714     };
6715     int r;
6716     suppress_error = 0;
6717     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6718     if (r == -1)
6719       return -1;
6720   }
6721   {
6722     char fstype[] = "ext2";
6723     char device[] = "/dev/sda1";
6724     int r;
6725     suppress_error = 0;
6726     r = guestfs_mkfs (g, fstype, device);
6727     if (r == -1)
6728       return -1;
6729   }
6730   {
6731     char device[] = "/dev/sda1";
6732     char mountpoint[] = "/";
6733     int r;
6734     suppress_error = 0;
6735     r = guestfs_mount (g, device, mountpoint);
6736     if (r == -1)
6737       return -1;
6738   }
6739   /* TestOutputStruct for lstat (0) */
6740   {
6741     char path[] = "/new";
6742     int r;
6743     suppress_error = 0;
6744     r = guestfs_touch (g, path);
6745     if (r == -1)
6746       return -1;
6747   }
6748   {
6749     char path[] = "/new";
6750     struct guestfs_stat *r;
6751     suppress_error = 0;
6752     r = guestfs_lstat (g, path);
6753     if (r == NULL)
6754       return -1;
6755     if (r->size != 0) {
6756       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6757                (int) r->size);
6758       return -1;
6759     }
6760     free (r);
6761   }
6762   return 0;
6763 }
6764
6765 static int test_stat_0_skip (void)
6766 {
6767   const char *str;
6768
6769   str = getenv ("SKIP_TEST_STAT_0");
6770   if (str && strcmp (str, "1") == 0) return 1;
6771   str = getenv ("SKIP_TEST_STAT");
6772   if (str && strcmp (str, "1") == 0) return 1;
6773   return 0;
6774 }
6775
6776 static int test_stat_0 (void)
6777 {
6778   if (test_stat_0_skip ()) {
6779     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6780     return 0;
6781   }
6782
6783   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6784   {
6785     char device[] = "/dev/sda";
6786     int r;
6787     suppress_error = 0;
6788     r = guestfs_blockdev_setrw (g, device);
6789     if (r == -1)
6790       return -1;
6791   }
6792   {
6793     int r;
6794     suppress_error = 0;
6795     r = guestfs_umount_all (g);
6796     if (r == -1)
6797       return -1;
6798   }
6799   {
6800     int r;
6801     suppress_error = 0;
6802     r = guestfs_lvm_remove_all (g);
6803     if (r == -1)
6804       return -1;
6805   }
6806   {
6807     char device[] = "/dev/sda";
6808     char lines_0[] = ",";
6809     char *lines[] = {
6810       lines_0,
6811       NULL
6812     };
6813     int r;
6814     suppress_error = 0;
6815     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6816     if (r == -1)
6817       return -1;
6818   }
6819   {
6820     char fstype[] = "ext2";
6821     char device[] = "/dev/sda1";
6822     int r;
6823     suppress_error = 0;
6824     r = guestfs_mkfs (g, fstype, device);
6825     if (r == -1)
6826       return -1;
6827   }
6828   {
6829     char device[] = "/dev/sda1";
6830     char mountpoint[] = "/";
6831     int r;
6832     suppress_error = 0;
6833     r = guestfs_mount (g, device, mountpoint);
6834     if (r == -1)
6835       return -1;
6836   }
6837   /* TestOutputStruct for stat (0) */
6838   {
6839     char path[] = "/new";
6840     int r;
6841     suppress_error = 0;
6842     r = guestfs_touch (g, path);
6843     if (r == -1)
6844       return -1;
6845   }
6846   {
6847     char path[] = "/new";
6848     struct guestfs_stat *r;
6849     suppress_error = 0;
6850     r = guestfs_stat (g, path);
6851     if (r == NULL)
6852       return -1;
6853     if (r->size != 0) {
6854       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6855                (int) r->size);
6856       return -1;
6857     }
6858     free (r);
6859   }
6860   return 0;
6861 }
6862
6863 static int test_command_lines_0_skip (void)
6864 {
6865   const char *str;
6866
6867   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6868   if (str && strcmp (str, "1") == 0) return 1;
6869   str = getenv ("SKIP_TEST_COMMAND_LINES");
6870   if (str && strcmp (str, "1") == 0) return 1;
6871   return 0;
6872 }
6873
6874 static int test_command_lines_0 (void)
6875 {
6876   if (test_command_lines_0_skip ()) {
6877     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6878     return 0;
6879   }
6880
6881   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6882   {
6883     char device[] = "/dev/sda";
6884     int r;
6885     suppress_error = 0;
6886     r = guestfs_blockdev_setrw (g, device);
6887     if (r == -1)
6888       return -1;
6889   }
6890   {
6891     int r;
6892     suppress_error = 0;
6893     r = guestfs_umount_all (g);
6894     if (r == -1)
6895       return -1;
6896   }
6897   {
6898     int r;
6899     suppress_error = 0;
6900     r = guestfs_lvm_remove_all (g);
6901     if (r == -1)
6902       return -1;
6903   }
6904   {
6905     char device[] = "/dev/sda";
6906     char lines_0[] = ",";
6907     char *lines[] = {
6908       lines_0,
6909       NULL
6910     };
6911     int r;
6912     suppress_error = 0;
6913     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6914     if (r == -1)
6915       return -1;
6916   }
6917   {
6918     char fstype[] = "ext2";
6919     char device[] = "/dev/sda1";
6920     int r;
6921     suppress_error = 0;
6922     r = guestfs_mkfs (g, fstype, device);
6923     if (r == -1)
6924       return -1;
6925   }
6926   {
6927     char device[] = "/dev/sda1";
6928     char mountpoint[] = "/";
6929     int r;
6930     suppress_error = 0;
6931     r = guestfs_mount (g, device, mountpoint);
6932     if (r == -1)
6933       return -1;
6934   }
6935   /* TestOutputList for command_lines (0) */
6936   {
6937     char remotefilename[] = "/test-command";
6938     int r;
6939     suppress_error = 0;
6940     r = guestfs_upload (g, "test-command", remotefilename);
6941     if (r == -1)
6942       return -1;
6943   }
6944   {
6945     char path[] = "/test-command";
6946     int r;
6947     suppress_error = 0;
6948     r = guestfs_chmod (g, 493, path);
6949     if (r == -1)
6950       return -1;
6951   }
6952   {
6953     char arguments_0[] = "/test-command";
6954     char arguments_1[] = "1";
6955     char *arguments[] = {
6956       arguments_0,
6957       arguments_1,
6958       NULL
6959     };
6960     char **r;
6961     int i;
6962     suppress_error = 0;
6963     r = guestfs_command_lines (g, arguments);
6964     if (r == NULL)
6965       return -1;
6966     if (!r[0]) {
6967       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
6968       print_strings (r);
6969       return -1;
6970     }
6971     {
6972       char expected[] = "Result1";
6973       if (strcmp (r[0], expected) != 0) {
6974         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6975         return -1;
6976       }
6977     }
6978     if (r[1] != NULL) {
6979       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
6980       print_strings (r);
6981       return -1;
6982     }
6983     for (i = 0; r[i] != NULL; ++i)
6984       free (r[i]);
6985     free (r);
6986   }
6987   return 0;
6988 }
6989
6990 static int test_command_lines_1_skip (void)
6991 {
6992   const char *str;
6993
6994   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
6995   if (str && strcmp (str, "1") == 0) return 1;
6996   str = getenv ("SKIP_TEST_COMMAND_LINES");
6997   if (str && strcmp (str, "1") == 0) return 1;
6998   return 0;
6999 }
7000
7001 static int test_command_lines_1 (void)
7002 {
7003   if (test_command_lines_1_skip ()) {
7004     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7005     return 0;
7006   }
7007
7008   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7009   {
7010     char device[] = "/dev/sda";
7011     int r;
7012     suppress_error = 0;
7013     r = guestfs_blockdev_setrw (g, device);
7014     if (r == -1)
7015       return -1;
7016   }
7017   {
7018     int r;
7019     suppress_error = 0;
7020     r = guestfs_umount_all (g);
7021     if (r == -1)
7022       return -1;
7023   }
7024   {
7025     int r;
7026     suppress_error = 0;
7027     r = guestfs_lvm_remove_all (g);
7028     if (r == -1)
7029       return -1;
7030   }
7031   {
7032     char device[] = "/dev/sda";
7033     char lines_0[] = ",";
7034     char *lines[] = {
7035       lines_0,
7036       NULL
7037     };
7038     int r;
7039     suppress_error = 0;
7040     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7041     if (r == -1)
7042       return -1;
7043   }
7044   {
7045     char fstype[] = "ext2";
7046     char device[] = "/dev/sda1";
7047     int r;
7048     suppress_error = 0;
7049     r = guestfs_mkfs (g, fstype, device);
7050     if (r == -1)
7051       return -1;
7052   }
7053   {
7054     char device[] = "/dev/sda1";
7055     char mountpoint[] = "/";
7056     int r;
7057     suppress_error = 0;
7058     r = guestfs_mount (g, device, mountpoint);
7059     if (r == -1)
7060       return -1;
7061   }
7062   /* TestOutputList for command_lines (1) */
7063   {
7064     char remotefilename[] = "/test-command";
7065     int r;
7066     suppress_error = 0;
7067     r = guestfs_upload (g, "test-command", remotefilename);
7068     if (r == -1)
7069       return -1;
7070   }
7071   {
7072     char path[] = "/test-command";
7073     int r;
7074     suppress_error = 0;
7075     r = guestfs_chmod (g, 493, path);
7076     if (r == -1)
7077       return -1;
7078   }
7079   {
7080     char arguments_0[] = "/test-command";
7081     char arguments_1[] = "2";
7082     char *arguments[] = {
7083       arguments_0,
7084       arguments_1,
7085       NULL
7086     };
7087     char **r;
7088     int i;
7089     suppress_error = 0;
7090     r = guestfs_command_lines (g, arguments);
7091     if (r == NULL)
7092       return -1;
7093     if (!r[0]) {
7094       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7095       print_strings (r);
7096       return -1;
7097     }
7098     {
7099       char expected[] = "Result2";
7100       if (strcmp (r[0], expected) != 0) {
7101         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7102         return -1;
7103       }
7104     }
7105     if (r[1] != NULL) {
7106       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7107       print_strings (r);
7108       return -1;
7109     }
7110     for (i = 0; r[i] != NULL; ++i)
7111       free (r[i]);
7112     free (r);
7113   }
7114   return 0;
7115 }
7116
7117 static int test_command_lines_2_skip (void)
7118 {
7119   const char *str;
7120
7121   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7122   if (str && strcmp (str, "1") == 0) return 1;
7123   str = getenv ("SKIP_TEST_COMMAND_LINES");
7124   if (str && strcmp (str, "1") == 0) return 1;
7125   return 0;
7126 }
7127
7128 static int test_command_lines_2 (void)
7129 {
7130   if (test_command_lines_2_skip ()) {
7131     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7132     return 0;
7133   }
7134
7135   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7136   {
7137     char device[] = "/dev/sda";
7138     int r;
7139     suppress_error = 0;
7140     r = guestfs_blockdev_setrw (g, device);
7141     if (r == -1)
7142       return -1;
7143   }
7144   {
7145     int r;
7146     suppress_error = 0;
7147     r = guestfs_umount_all (g);
7148     if (r == -1)
7149       return -1;
7150   }
7151   {
7152     int r;
7153     suppress_error = 0;
7154     r = guestfs_lvm_remove_all (g);
7155     if (r == -1)
7156       return -1;
7157   }
7158   {
7159     char device[] = "/dev/sda";
7160     char lines_0[] = ",";
7161     char *lines[] = {
7162       lines_0,
7163       NULL
7164     };
7165     int r;
7166     suppress_error = 0;
7167     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7168     if (r == -1)
7169       return -1;
7170   }
7171   {
7172     char fstype[] = "ext2";
7173     char device[] = "/dev/sda1";
7174     int r;
7175     suppress_error = 0;
7176     r = guestfs_mkfs (g, fstype, device);
7177     if (r == -1)
7178       return -1;
7179   }
7180   {
7181     char device[] = "/dev/sda1";
7182     char mountpoint[] = "/";
7183     int r;
7184     suppress_error = 0;
7185     r = guestfs_mount (g, device, mountpoint);
7186     if (r == -1)
7187       return -1;
7188   }
7189   /* TestOutputList for command_lines (2) */
7190   {
7191     char remotefilename[] = "/test-command";
7192     int r;
7193     suppress_error = 0;
7194     r = guestfs_upload (g, "test-command", remotefilename);
7195     if (r == -1)
7196       return -1;
7197   }
7198   {
7199     char path[] = "/test-command";
7200     int r;
7201     suppress_error = 0;
7202     r = guestfs_chmod (g, 493, path);
7203     if (r == -1)
7204       return -1;
7205   }
7206   {
7207     char arguments_0[] = "/test-command";
7208     char arguments_1[] = "3";
7209     char *arguments[] = {
7210       arguments_0,
7211       arguments_1,
7212       NULL
7213     };
7214     char **r;
7215     int i;
7216     suppress_error = 0;
7217     r = guestfs_command_lines (g, arguments);
7218     if (r == NULL)
7219       return -1;
7220     if (!r[0]) {
7221       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7222       print_strings (r);
7223       return -1;
7224     }
7225     {
7226       char expected[] = "";
7227       if (strcmp (r[0], expected) != 0) {
7228         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7229         return -1;
7230       }
7231     }
7232     if (!r[1]) {
7233       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7234       print_strings (r);
7235       return -1;
7236     }
7237     {
7238       char expected[] = "Result3";
7239       if (strcmp (r[1], expected) != 0) {
7240         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7241         return -1;
7242       }
7243     }
7244     if (r[2] != NULL) {
7245       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7246       print_strings (r);
7247       return -1;
7248     }
7249     for (i = 0; r[i] != NULL; ++i)
7250       free (r[i]);
7251     free (r);
7252   }
7253   return 0;
7254 }
7255
7256 static int test_command_lines_3_skip (void)
7257 {
7258   const char *str;
7259
7260   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7261   if (str && strcmp (str, "1") == 0) return 1;
7262   str = getenv ("SKIP_TEST_COMMAND_LINES");
7263   if (str && strcmp (str, "1") == 0) return 1;
7264   return 0;
7265 }
7266
7267 static int test_command_lines_3 (void)
7268 {
7269   if (test_command_lines_3_skip ()) {
7270     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7271     return 0;
7272   }
7273
7274   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7275   {
7276     char device[] = "/dev/sda";
7277     int r;
7278     suppress_error = 0;
7279     r = guestfs_blockdev_setrw (g, device);
7280     if (r == -1)
7281       return -1;
7282   }
7283   {
7284     int r;
7285     suppress_error = 0;
7286     r = guestfs_umount_all (g);
7287     if (r == -1)
7288       return -1;
7289   }
7290   {
7291     int r;
7292     suppress_error = 0;
7293     r = guestfs_lvm_remove_all (g);
7294     if (r == -1)
7295       return -1;
7296   }
7297   {
7298     char device[] = "/dev/sda";
7299     char lines_0[] = ",";
7300     char *lines[] = {
7301       lines_0,
7302       NULL
7303     };
7304     int r;
7305     suppress_error = 0;
7306     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7307     if (r == -1)
7308       return -1;
7309   }
7310   {
7311     char fstype[] = "ext2";
7312     char device[] = "/dev/sda1";
7313     int r;
7314     suppress_error = 0;
7315     r = guestfs_mkfs (g, fstype, device);
7316     if (r == -1)
7317       return -1;
7318   }
7319   {
7320     char device[] = "/dev/sda1";
7321     char mountpoint[] = "/";
7322     int r;
7323     suppress_error = 0;
7324     r = guestfs_mount (g, device, mountpoint);
7325     if (r == -1)
7326       return -1;
7327   }
7328   /* TestOutputList for command_lines (3) */
7329   {
7330     char remotefilename[] = "/test-command";
7331     int r;
7332     suppress_error = 0;
7333     r = guestfs_upload (g, "test-command", remotefilename);
7334     if (r == -1)
7335       return -1;
7336   }
7337   {
7338     char path[] = "/test-command";
7339     int r;
7340     suppress_error = 0;
7341     r = guestfs_chmod (g, 493, path);
7342     if (r == -1)
7343       return -1;
7344   }
7345   {
7346     char arguments_0[] = "/test-command";
7347     char arguments_1[] = "4";
7348     char *arguments[] = {
7349       arguments_0,
7350       arguments_1,
7351       NULL
7352     };
7353     char **r;
7354     int i;
7355     suppress_error = 0;
7356     r = guestfs_command_lines (g, arguments);
7357     if (r == NULL)
7358       return -1;
7359     if (!r[0]) {
7360       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7361       print_strings (r);
7362       return -1;
7363     }
7364     {
7365       char expected[] = "";
7366       if (strcmp (r[0], expected) != 0) {
7367         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7368         return -1;
7369       }
7370     }
7371     if (!r[1]) {
7372       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7373       print_strings (r);
7374       return -1;
7375     }
7376     {
7377       char expected[] = "Result4";
7378       if (strcmp (r[1], expected) != 0) {
7379         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7380         return -1;
7381       }
7382     }
7383     if (r[2] != NULL) {
7384       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7385       print_strings (r);
7386       return -1;
7387     }
7388     for (i = 0; r[i] != NULL; ++i)
7389       free (r[i]);
7390     free (r);
7391   }
7392   return 0;
7393 }
7394
7395 static int test_command_lines_4_skip (void)
7396 {
7397   const char *str;
7398
7399   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7400   if (str && strcmp (str, "1") == 0) return 1;
7401   str = getenv ("SKIP_TEST_COMMAND_LINES");
7402   if (str && strcmp (str, "1") == 0) return 1;
7403   return 0;
7404 }
7405
7406 static int test_command_lines_4 (void)
7407 {
7408   if (test_command_lines_4_skip ()) {
7409     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7410     return 0;
7411   }
7412
7413   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7414   {
7415     char device[] = "/dev/sda";
7416     int r;
7417     suppress_error = 0;
7418     r = guestfs_blockdev_setrw (g, device);
7419     if (r == -1)
7420       return -1;
7421   }
7422   {
7423     int r;
7424     suppress_error = 0;
7425     r = guestfs_umount_all (g);
7426     if (r == -1)
7427       return -1;
7428   }
7429   {
7430     int r;
7431     suppress_error = 0;
7432     r = guestfs_lvm_remove_all (g);
7433     if (r == -1)
7434       return -1;
7435   }
7436   {
7437     char device[] = "/dev/sda";
7438     char lines_0[] = ",";
7439     char *lines[] = {
7440       lines_0,
7441       NULL
7442     };
7443     int r;
7444     suppress_error = 0;
7445     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7446     if (r == -1)
7447       return -1;
7448   }
7449   {
7450     char fstype[] = "ext2";
7451     char device[] = "/dev/sda1";
7452     int r;
7453     suppress_error = 0;
7454     r = guestfs_mkfs (g, fstype, device);
7455     if (r == -1)
7456       return -1;
7457   }
7458   {
7459     char device[] = "/dev/sda1";
7460     char mountpoint[] = "/";
7461     int r;
7462     suppress_error = 0;
7463     r = guestfs_mount (g, device, mountpoint);
7464     if (r == -1)
7465       return -1;
7466   }
7467   /* TestOutputList for command_lines (4) */
7468   {
7469     char remotefilename[] = "/test-command";
7470     int r;
7471     suppress_error = 0;
7472     r = guestfs_upload (g, "test-command", remotefilename);
7473     if (r == -1)
7474       return -1;
7475   }
7476   {
7477     char path[] = "/test-command";
7478     int r;
7479     suppress_error = 0;
7480     r = guestfs_chmod (g, 493, path);
7481     if (r == -1)
7482       return -1;
7483   }
7484   {
7485     char arguments_0[] = "/test-command";
7486     char arguments_1[] = "5";
7487     char *arguments[] = {
7488       arguments_0,
7489       arguments_1,
7490       NULL
7491     };
7492     char **r;
7493     int i;
7494     suppress_error = 0;
7495     r = guestfs_command_lines (g, arguments);
7496     if (r == NULL)
7497       return -1;
7498     if (!r[0]) {
7499       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7500       print_strings (r);
7501       return -1;
7502     }
7503     {
7504       char expected[] = "";
7505       if (strcmp (r[0], expected) != 0) {
7506         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7507         return -1;
7508       }
7509     }
7510     if (!r[1]) {
7511       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7512       print_strings (r);
7513       return -1;
7514     }
7515     {
7516       char expected[] = "Result5";
7517       if (strcmp (r[1], expected) != 0) {
7518         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7519         return -1;
7520       }
7521     }
7522     if (!r[2]) {
7523       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7524       print_strings (r);
7525       return -1;
7526     }
7527     {
7528       char expected[] = "";
7529       if (strcmp (r[2], expected) != 0) {
7530         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7531         return -1;
7532       }
7533     }
7534     if (r[3] != NULL) {
7535       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7536       print_strings (r);
7537       return -1;
7538     }
7539     for (i = 0; r[i] != NULL; ++i)
7540       free (r[i]);
7541     free (r);
7542   }
7543   return 0;
7544 }
7545
7546 static int test_command_lines_5_skip (void)
7547 {
7548   const char *str;
7549
7550   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7551   if (str && strcmp (str, "1") == 0) return 1;
7552   str = getenv ("SKIP_TEST_COMMAND_LINES");
7553   if (str && strcmp (str, "1") == 0) return 1;
7554   return 0;
7555 }
7556
7557 static int test_command_lines_5 (void)
7558 {
7559   if (test_command_lines_5_skip ()) {
7560     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7561     return 0;
7562   }
7563
7564   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7565   {
7566     char device[] = "/dev/sda";
7567     int r;
7568     suppress_error = 0;
7569     r = guestfs_blockdev_setrw (g, device);
7570     if (r == -1)
7571       return -1;
7572   }
7573   {
7574     int r;
7575     suppress_error = 0;
7576     r = guestfs_umount_all (g);
7577     if (r == -1)
7578       return -1;
7579   }
7580   {
7581     int r;
7582     suppress_error = 0;
7583     r = guestfs_lvm_remove_all (g);
7584     if (r == -1)
7585       return -1;
7586   }
7587   {
7588     char device[] = "/dev/sda";
7589     char lines_0[] = ",";
7590     char *lines[] = {
7591       lines_0,
7592       NULL
7593     };
7594     int r;
7595     suppress_error = 0;
7596     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7597     if (r == -1)
7598       return -1;
7599   }
7600   {
7601     char fstype[] = "ext2";
7602     char device[] = "/dev/sda1";
7603     int r;
7604     suppress_error = 0;
7605     r = guestfs_mkfs (g, fstype, device);
7606     if (r == -1)
7607       return -1;
7608   }
7609   {
7610     char device[] = "/dev/sda1";
7611     char mountpoint[] = "/";
7612     int r;
7613     suppress_error = 0;
7614     r = guestfs_mount (g, device, mountpoint);
7615     if (r == -1)
7616       return -1;
7617   }
7618   /* TestOutputList for command_lines (5) */
7619   {
7620     char remotefilename[] = "/test-command";
7621     int r;
7622     suppress_error = 0;
7623     r = guestfs_upload (g, "test-command", remotefilename);
7624     if (r == -1)
7625       return -1;
7626   }
7627   {
7628     char path[] = "/test-command";
7629     int r;
7630     suppress_error = 0;
7631     r = guestfs_chmod (g, 493, path);
7632     if (r == -1)
7633       return -1;
7634   }
7635   {
7636     char arguments_0[] = "/test-command";
7637     char arguments_1[] = "6";
7638     char *arguments[] = {
7639       arguments_0,
7640       arguments_1,
7641       NULL
7642     };
7643     char **r;
7644     int i;
7645     suppress_error = 0;
7646     r = guestfs_command_lines (g, arguments);
7647     if (r == NULL)
7648       return -1;
7649     if (!r[0]) {
7650       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7651       print_strings (r);
7652       return -1;
7653     }
7654     {
7655       char expected[] = "";
7656       if (strcmp (r[0], expected) != 0) {
7657         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7658         return -1;
7659       }
7660     }
7661     if (!r[1]) {
7662       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7663       print_strings (r);
7664       return -1;
7665     }
7666     {
7667       char expected[] = "";
7668       if (strcmp (r[1], expected) != 0) {
7669         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7670         return -1;
7671       }
7672     }
7673     if (!r[2]) {
7674       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7675       print_strings (r);
7676       return -1;
7677     }
7678     {
7679       char expected[] = "Result6";
7680       if (strcmp (r[2], expected) != 0) {
7681         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7682         return -1;
7683       }
7684     }
7685     if (!r[3]) {
7686       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7687       print_strings (r);
7688       return -1;
7689     }
7690     {
7691       char expected[] = "";
7692       if (strcmp (r[3], expected) != 0) {
7693         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7694         return -1;
7695       }
7696     }
7697     if (r[4] != NULL) {
7698       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7699       print_strings (r);
7700       return -1;
7701     }
7702     for (i = 0; r[i] != NULL; ++i)
7703       free (r[i]);
7704     free (r);
7705   }
7706   return 0;
7707 }
7708
7709 static int test_command_lines_6_skip (void)
7710 {
7711   const char *str;
7712
7713   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7714   if (str && strcmp (str, "1") == 0) return 1;
7715   str = getenv ("SKIP_TEST_COMMAND_LINES");
7716   if (str && strcmp (str, "1") == 0) return 1;
7717   return 0;
7718 }
7719
7720 static int test_command_lines_6 (void)
7721 {
7722   if (test_command_lines_6_skip ()) {
7723     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7724     return 0;
7725   }
7726
7727   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7728   {
7729     char device[] = "/dev/sda";
7730     int r;
7731     suppress_error = 0;
7732     r = guestfs_blockdev_setrw (g, device);
7733     if (r == -1)
7734       return -1;
7735   }
7736   {
7737     int r;
7738     suppress_error = 0;
7739     r = guestfs_umount_all (g);
7740     if (r == -1)
7741       return -1;
7742   }
7743   {
7744     int r;
7745     suppress_error = 0;
7746     r = guestfs_lvm_remove_all (g);
7747     if (r == -1)
7748       return -1;
7749   }
7750   {
7751     char device[] = "/dev/sda";
7752     char lines_0[] = ",";
7753     char *lines[] = {
7754       lines_0,
7755       NULL
7756     };
7757     int r;
7758     suppress_error = 0;
7759     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7760     if (r == -1)
7761       return -1;
7762   }
7763   {
7764     char fstype[] = "ext2";
7765     char device[] = "/dev/sda1";
7766     int r;
7767     suppress_error = 0;
7768     r = guestfs_mkfs (g, fstype, device);
7769     if (r == -1)
7770       return -1;
7771   }
7772   {
7773     char device[] = "/dev/sda1";
7774     char mountpoint[] = "/";
7775     int r;
7776     suppress_error = 0;
7777     r = guestfs_mount (g, device, mountpoint);
7778     if (r == -1)
7779       return -1;
7780   }
7781   /* TestOutputList for command_lines (6) */
7782   {
7783     char remotefilename[] = "/test-command";
7784     int r;
7785     suppress_error = 0;
7786     r = guestfs_upload (g, "test-command", remotefilename);
7787     if (r == -1)
7788       return -1;
7789   }
7790   {
7791     char path[] = "/test-command";
7792     int r;
7793     suppress_error = 0;
7794     r = guestfs_chmod (g, 493, path);
7795     if (r == -1)
7796       return -1;
7797   }
7798   {
7799     char arguments_0[] = "/test-command";
7800     char arguments_1[] = "7";
7801     char *arguments[] = {
7802       arguments_0,
7803       arguments_1,
7804       NULL
7805     };
7806     char **r;
7807     int i;
7808     suppress_error = 0;
7809     r = guestfs_command_lines (g, arguments);
7810     if (r == NULL)
7811       return -1;
7812     if (r[0] != NULL) {
7813       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7814       print_strings (r);
7815       return -1;
7816     }
7817     for (i = 0; r[i] != NULL; ++i)
7818       free (r[i]);
7819     free (r);
7820   }
7821   return 0;
7822 }
7823
7824 static int test_command_lines_7_skip (void)
7825 {
7826   const char *str;
7827
7828   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7829   if (str && strcmp (str, "1") == 0) return 1;
7830   str = getenv ("SKIP_TEST_COMMAND_LINES");
7831   if (str && strcmp (str, "1") == 0) return 1;
7832   return 0;
7833 }
7834
7835 static int test_command_lines_7 (void)
7836 {
7837   if (test_command_lines_7_skip ()) {
7838     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7839     return 0;
7840   }
7841
7842   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7843   {
7844     char device[] = "/dev/sda";
7845     int r;
7846     suppress_error = 0;
7847     r = guestfs_blockdev_setrw (g, device);
7848     if (r == -1)
7849       return -1;
7850   }
7851   {
7852     int r;
7853     suppress_error = 0;
7854     r = guestfs_umount_all (g);
7855     if (r == -1)
7856       return -1;
7857   }
7858   {
7859     int r;
7860     suppress_error = 0;
7861     r = guestfs_lvm_remove_all (g);
7862     if (r == -1)
7863       return -1;
7864   }
7865   {
7866     char device[] = "/dev/sda";
7867     char lines_0[] = ",";
7868     char *lines[] = {
7869       lines_0,
7870       NULL
7871     };
7872     int r;
7873     suppress_error = 0;
7874     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7875     if (r == -1)
7876       return -1;
7877   }
7878   {
7879     char fstype[] = "ext2";
7880     char device[] = "/dev/sda1";
7881     int r;
7882     suppress_error = 0;
7883     r = guestfs_mkfs (g, fstype, device);
7884     if (r == -1)
7885       return -1;
7886   }
7887   {
7888     char device[] = "/dev/sda1";
7889     char mountpoint[] = "/";
7890     int r;
7891     suppress_error = 0;
7892     r = guestfs_mount (g, device, mountpoint);
7893     if (r == -1)
7894       return -1;
7895   }
7896   /* TestOutputList for command_lines (7) */
7897   {
7898     char remotefilename[] = "/test-command";
7899     int r;
7900     suppress_error = 0;
7901     r = guestfs_upload (g, "test-command", remotefilename);
7902     if (r == -1)
7903       return -1;
7904   }
7905   {
7906     char path[] = "/test-command";
7907     int r;
7908     suppress_error = 0;
7909     r = guestfs_chmod (g, 493, path);
7910     if (r == -1)
7911       return -1;
7912   }
7913   {
7914     char arguments_0[] = "/test-command";
7915     char arguments_1[] = "8";
7916     char *arguments[] = {
7917       arguments_0,
7918       arguments_1,
7919       NULL
7920     };
7921     char **r;
7922     int i;
7923     suppress_error = 0;
7924     r = guestfs_command_lines (g, arguments);
7925     if (r == NULL)
7926       return -1;
7927     if (!r[0]) {
7928       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
7929       print_strings (r);
7930       return -1;
7931     }
7932     {
7933       char expected[] = "";
7934       if (strcmp (r[0], expected) != 0) {
7935         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7936         return -1;
7937       }
7938     }
7939     if (r[1] != NULL) {
7940       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
7941       print_strings (r);
7942       return -1;
7943     }
7944     for (i = 0; r[i] != NULL; ++i)
7945       free (r[i]);
7946     free (r);
7947   }
7948   return 0;
7949 }
7950
7951 static int test_command_lines_8_skip (void)
7952 {
7953   const char *str;
7954
7955   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
7956   if (str && strcmp (str, "1") == 0) return 1;
7957   str = getenv ("SKIP_TEST_COMMAND_LINES");
7958   if (str && strcmp (str, "1") == 0) return 1;
7959   return 0;
7960 }
7961
7962 static int test_command_lines_8 (void)
7963 {
7964   if (test_command_lines_8_skip ()) {
7965     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
7966     return 0;
7967   }
7968
7969   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
7970   {
7971     char device[] = "/dev/sda";
7972     int r;
7973     suppress_error = 0;
7974     r = guestfs_blockdev_setrw (g, device);
7975     if (r == -1)
7976       return -1;
7977   }
7978   {
7979     int r;
7980     suppress_error = 0;
7981     r = guestfs_umount_all (g);
7982     if (r == -1)
7983       return -1;
7984   }
7985   {
7986     int r;
7987     suppress_error = 0;
7988     r = guestfs_lvm_remove_all (g);
7989     if (r == -1)
7990       return -1;
7991   }
7992   {
7993     char device[] = "/dev/sda";
7994     char lines_0[] = ",";
7995     char *lines[] = {
7996       lines_0,
7997       NULL
7998     };
7999     int r;
8000     suppress_error = 0;
8001     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8002     if (r == -1)
8003       return -1;
8004   }
8005   {
8006     char fstype[] = "ext2";
8007     char device[] = "/dev/sda1";
8008     int r;
8009     suppress_error = 0;
8010     r = guestfs_mkfs (g, fstype, device);
8011     if (r == -1)
8012       return -1;
8013   }
8014   {
8015     char device[] = "/dev/sda1";
8016     char mountpoint[] = "/";
8017     int r;
8018     suppress_error = 0;
8019     r = guestfs_mount (g, device, mountpoint);
8020     if (r == -1)
8021       return -1;
8022   }
8023   /* TestOutputList for command_lines (8) */
8024   {
8025     char remotefilename[] = "/test-command";
8026     int r;
8027     suppress_error = 0;
8028     r = guestfs_upload (g, "test-command", remotefilename);
8029     if (r == -1)
8030       return -1;
8031   }
8032   {
8033     char path[] = "/test-command";
8034     int r;
8035     suppress_error = 0;
8036     r = guestfs_chmod (g, 493, path);
8037     if (r == -1)
8038       return -1;
8039   }
8040   {
8041     char arguments_0[] = "/test-command";
8042     char arguments_1[] = "9";
8043     char *arguments[] = {
8044       arguments_0,
8045       arguments_1,
8046       NULL
8047     };
8048     char **r;
8049     int i;
8050     suppress_error = 0;
8051     r = guestfs_command_lines (g, arguments);
8052     if (r == NULL)
8053       return -1;
8054     if (!r[0]) {
8055       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8056       print_strings (r);
8057       return -1;
8058     }
8059     {
8060       char expected[] = "";
8061       if (strcmp (r[0], expected) != 0) {
8062         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8063         return -1;
8064       }
8065     }
8066     if (!r[1]) {
8067       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8068       print_strings (r);
8069       return -1;
8070     }
8071     {
8072       char expected[] = "";
8073       if (strcmp (r[1], expected) != 0) {
8074         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8075         return -1;
8076       }
8077     }
8078     if (r[2] != NULL) {
8079       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8080       print_strings (r);
8081       return -1;
8082     }
8083     for (i = 0; r[i] != NULL; ++i)
8084       free (r[i]);
8085     free (r);
8086   }
8087   return 0;
8088 }
8089
8090 static int test_command_lines_9_skip (void)
8091 {
8092   const char *str;
8093
8094   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8095   if (str && strcmp (str, "1") == 0) return 1;
8096   str = getenv ("SKIP_TEST_COMMAND_LINES");
8097   if (str && strcmp (str, "1") == 0) return 1;
8098   return 0;
8099 }
8100
8101 static int test_command_lines_9 (void)
8102 {
8103   if (test_command_lines_9_skip ()) {
8104     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8105     return 0;
8106   }
8107
8108   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8109   {
8110     char device[] = "/dev/sda";
8111     int r;
8112     suppress_error = 0;
8113     r = guestfs_blockdev_setrw (g, device);
8114     if (r == -1)
8115       return -1;
8116   }
8117   {
8118     int r;
8119     suppress_error = 0;
8120     r = guestfs_umount_all (g);
8121     if (r == -1)
8122       return -1;
8123   }
8124   {
8125     int r;
8126     suppress_error = 0;
8127     r = guestfs_lvm_remove_all (g);
8128     if (r == -1)
8129       return -1;
8130   }
8131   {
8132     char device[] = "/dev/sda";
8133     char lines_0[] = ",";
8134     char *lines[] = {
8135       lines_0,
8136       NULL
8137     };
8138     int r;
8139     suppress_error = 0;
8140     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8141     if (r == -1)
8142       return -1;
8143   }
8144   {
8145     char fstype[] = "ext2";
8146     char device[] = "/dev/sda1";
8147     int r;
8148     suppress_error = 0;
8149     r = guestfs_mkfs (g, fstype, device);
8150     if (r == -1)
8151       return -1;
8152   }
8153   {
8154     char device[] = "/dev/sda1";
8155     char mountpoint[] = "/";
8156     int r;
8157     suppress_error = 0;
8158     r = guestfs_mount (g, device, mountpoint);
8159     if (r == -1)
8160       return -1;
8161   }
8162   /* TestOutputList for command_lines (9) */
8163   {
8164     char remotefilename[] = "/test-command";
8165     int r;
8166     suppress_error = 0;
8167     r = guestfs_upload (g, "test-command", remotefilename);
8168     if (r == -1)
8169       return -1;
8170   }
8171   {
8172     char path[] = "/test-command";
8173     int r;
8174     suppress_error = 0;
8175     r = guestfs_chmod (g, 493, path);
8176     if (r == -1)
8177       return -1;
8178   }
8179   {
8180     char arguments_0[] = "/test-command";
8181     char arguments_1[] = "10";
8182     char *arguments[] = {
8183       arguments_0,
8184       arguments_1,
8185       NULL
8186     };
8187     char **r;
8188     int i;
8189     suppress_error = 0;
8190     r = guestfs_command_lines (g, arguments);
8191     if (r == NULL)
8192       return -1;
8193     if (!r[0]) {
8194       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8195       print_strings (r);
8196       return -1;
8197     }
8198     {
8199       char expected[] = "Result10-1";
8200       if (strcmp (r[0], expected) != 0) {
8201         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8202         return -1;
8203       }
8204     }
8205     if (!r[1]) {
8206       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8207       print_strings (r);
8208       return -1;
8209     }
8210     {
8211       char expected[] = "Result10-2";
8212       if (strcmp (r[1], expected) != 0) {
8213         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8214         return -1;
8215       }
8216     }
8217     if (r[2] != NULL) {
8218       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8219       print_strings (r);
8220       return -1;
8221     }
8222     for (i = 0; r[i] != NULL; ++i)
8223       free (r[i]);
8224     free (r);
8225   }
8226   return 0;
8227 }
8228
8229 static int test_command_lines_10_skip (void)
8230 {
8231   const char *str;
8232
8233   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8234   if (str && strcmp (str, "1") == 0) return 1;
8235   str = getenv ("SKIP_TEST_COMMAND_LINES");
8236   if (str && strcmp (str, "1") == 0) return 1;
8237   return 0;
8238 }
8239
8240 static int test_command_lines_10 (void)
8241 {
8242   if (test_command_lines_10_skip ()) {
8243     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8244     return 0;
8245   }
8246
8247   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8248   {
8249     char device[] = "/dev/sda";
8250     int r;
8251     suppress_error = 0;
8252     r = guestfs_blockdev_setrw (g, device);
8253     if (r == -1)
8254       return -1;
8255   }
8256   {
8257     int r;
8258     suppress_error = 0;
8259     r = guestfs_umount_all (g);
8260     if (r == -1)
8261       return -1;
8262   }
8263   {
8264     int r;
8265     suppress_error = 0;
8266     r = guestfs_lvm_remove_all (g);
8267     if (r == -1)
8268       return -1;
8269   }
8270   {
8271     char device[] = "/dev/sda";
8272     char lines_0[] = ",";
8273     char *lines[] = {
8274       lines_0,
8275       NULL
8276     };
8277     int r;
8278     suppress_error = 0;
8279     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8280     if (r == -1)
8281       return -1;
8282   }
8283   {
8284     char fstype[] = "ext2";
8285     char device[] = "/dev/sda1";
8286     int r;
8287     suppress_error = 0;
8288     r = guestfs_mkfs (g, fstype, device);
8289     if (r == -1)
8290       return -1;
8291   }
8292   {
8293     char device[] = "/dev/sda1";
8294     char mountpoint[] = "/";
8295     int r;
8296     suppress_error = 0;
8297     r = guestfs_mount (g, device, mountpoint);
8298     if (r == -1)
8299       return -1;
8300   }
8301   /* TestOutputList for command_lines (10) */
8302   {
8303     char remotefilename[] = "/test-command";
8304     int r;
8305     suppress_error = 0;
8306     r = guestfs_upload (g, "test-command", remotefilename);
8307     if (r == -1)
8308       return -1;
8309   }
8310   {
8311     char path[] = "/test-command";
8312     int r;
8313     suppress_error = 0;
8314     r = guestfs_chmod (g, 493, path);
8315     if (r == -1)
8316       return -1;
8317   }
8318   {
8319     char arguments_0[] = "/test-command";
8320     char arguments_1[] = "11";
8321     char *arguments[] = {
8322       arguments_0,
8323       arguments_1,
8324       NULL
8325     };
8326     char **r;
8327     int i;
8328     suppress_error = 0;
8329     r = guestfs_command_lines (g, arguments);
8330     if (r == NULL)
8331       return -1;
8332     if (!r[0]) {
8333       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8334       print_strings (r);
8335       return -1;
8336     }
8337     {
8338       char expected[] = "Result11-1";
8339       if (strcmp (r[0], expected) != 0) {
8340         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8341         return -1;
8342       }
8343     }
8344     if (!r[1]) {
8345       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8346       print_strings (r);
8347       return -1;
8348     }
8349     {
8350       char expected[] = "Result11-2";
8351       if (strcmp (r[1], expected) != 0) {
8352         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8353         return -1;
8354       }
8355     }
8356     if (r[2] != NULL) {
8357       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8358       print_strings (r);
8359       return -1;
8360     }
8361     for (i = 0; r[i] != NULL; ++i)
8362       free (r[i]);
8363     free (r);
8364   }
8365   return 0;
8366 }
8367
8368 static int test_command_0_skip (void)
8369 {
8370   const char *str;
8371
8372   str = getenv ("SKIP_TEST_COMMAND_0");
8373   if (str && strcmp (str, "1") == 0) return 1;
8374   str = getenv ("SKIP_TEST_COMMAND");
8375   if (str && strcmp (str, "1") == 0) return 1;
8376   return 0;
8377 }
8378
8379 static int test_command_0 (void)
8380 {
8381   if (test_command_0_skip ()) {
8382     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8383     return 0;
8384   }
8385
8386   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8387   {
8388     char device[] = "/dev/sda";
8389     int r;
8390     suppress_error = 0;
8391     r = guestfs_blockdev_setrw (g, device);
8392     if (r == -1)
8393       return -1;
8394   }
8395   {
8396     int r;
8397     suppress_error = 0;
8398     r = guestfs_umount_all (g);
8399     if (r == -1)
8400       return -1;
8401   }
8402   {
8403     int r;
8404     suppress_error = 0;
8405     r = guestfs_lvm_remove_all (g);
8406     if (r == -1)
8407       return -1;
8408   }
8409   {
8410     char device[] = "/dev/sda";
8411     char lines_0[] = ",";
8412     char *lines[] = {
8413       lines_0,
8414       NULL
8415     };
8416     int r;
8417     suppress_error = 0;
8418     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8419     if (r == -1)
8420       return -1;
8421   }
8422   {
8423     char fstype[] = "ext2";
8424     char device[] = "/dev/sda1";
8425     int r;
8426     suppress_error = 0;
8427     r = guestfs_mkfs (g, fstype, device);
8428     if (r == -1)
8429       return -1;
8430   }
8431   {
8432     char device[] = "/dev/sda1";
8433     char mountpoint[] = "/";
8434     int r;
8435     suppress_error = 0;
8436     r = guestfs_mount (g, device, mountpoint);
8437     if (r == -1)
8438       return -1;
8439   }
8440   /* TestOutput for command (0) */
8441   char expected[] = "Result1";
8442   {
8443     char remotefilename[] = "/test-command";
8444     int r;
8445     suppress_error = 0;
8446     r = guestfs_upload (g, "test-command", remotefilename);
8447     if (r == -1)
8448       return -1;
8449   }
8450   {
8451     char path[] = "/test-command";
8452     int r;
8453     suppress_error = 0;
8454     r = guestfs_chmod (g, 493, path);
8455     if (r == -1)
8456       return -1;
8457   }
8458   {
8459     char arguments_0[] = "/test-command";
8460     char arguments_1[] = "1";
8461     char *arguments[] = {
8462       arguments_0,
8463       arguments_1,
8464       NULL
8465     };
8466     char *r;
8467     suppress_error = 0;
8468     r = guestfs_command (g, arguments);
8469     if (r == NULL)
8470       return -1;
8471     if (strcmp (r, expected) != 0) {
8472       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8473       return -1;
8474     }
8475     free (r);
8476   }
8477   return 0;
8478 }
8479
8480 static int test_command_1_skip (void)
8481 {
8482   const char *str;
8483
8484   str = getenv ("SKIP_TEST_COMMAND_1");
8485   if (str && strcmp (str, "1") == 0) return 1;
8486   str = getenv ("SKIP_TEST_COMMAND");
8487   if (str && strcmp (str, "1") == 0) return 1;
8488   return 0;
8489 }
8490
8491 static int test_command_1 (void)
8492 {
8493   if (test_command_1_skip ()) {
8494     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8495     return 0;
8496   }
8497
8498   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8499   {
8500     char device[] = "/dev/sda";
8501     int r;
8502     suppress_error = 0;
8503     r = guestfs_blockdev_setrw (g, device);
8504     if (r == -1)
8505       return -1;
8506   }
8507   {
8508     int r;
8509     suppress_error = 0;
8510     r = guestfs_umount_all (g);
8511     if (r == -1)
8512       return -1;
8513   }
8514   {
8515     int r;
8516     suppress_error = 0;
8517     r = guestfs_lvm_remove_all (g);
8518     if (r == -1)
8519       return -1;
8520   }
8521   {
8522     char device[] = "/dev/sda";
8523     char lines_0[] = ",";
8524     char *lines[] = {
8525       lines_0,
8526       NULL
8527     };
8528     int r;
8529     suppress_error = 0;
8530     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8531     if (r == -1)
8532       return -1;
8533   }
8534   {
8535     char fstype[] = "ext2";
8536     char device[] = "/dev/sda1";
8537     int r;
8538     suppress_error = 0;
8539     r = guestfs_mkfs (g, fstype, device);
8540     if (r == -1)
8541       return -1;
8542   }
8543   {
8544     char device[] = "/dev/sda1";
8545     char mountpoint[] = "/";
8546     int r;
8547     suppress_error = 0;
8548     r = guestfs_mount (g, device, mountpoint);
8549     if (r == -1)
8550       return -1;
8551   }
8552   /* TestOutput for command (1) */
8553   char expected[] = "Result2\n";
8554   {
8555     char remotefilename[] = "/test-command";
8556     int r;
8557     suppress_error = 0;
8558     r = guestfs_upload (g, "test-command", remotefilename);
8559     if (r == -1)
8560       return -1;
8561   }
8562   {
8563     char path[] = "/test-command";
8564     int r;
8565     suppress_error = 0;
8566     r = guestfs_chmod (g, 493, path);
8567     if (r == -1)
8568       return -1;
8569   }
8570   {
8571     char arguments_0[] = "/test-command";
8572     char arguments_1[] = "2";
8573     char *arguments[] = {
8574       arguments_0,
8575       arguments_1,
8576       NULL
8577     };
8578     char *r;
8579     suppress_error = 0;
8580     r = guestfs_command (g, arguments);
8581     if (r == NULL)
8582       return -1;
8583     if (strcmp (r, expected) != 0) {
8584       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8585       return -1;
8586     }
8587     free (r);
8588   }
8589   return 0;
8590 }
8591
8592 static int test_command_2_skip (void)
8593 {
8594   const char *str;
8595
8596   str = getenv ("SKIP_TEST_COMMAND_2");
8597   if (str && strcmp (str, "1") == 0) return 1;
8598   str = getenv ("SKIP_TEST_COMMAND");
8599   if (str && strcmp (str, "1") == 0) return 1;
8600   return 0;
8601 }
8602
8603 static int test_command_2 (void)
8604 {
8605   if (test_command_2_skip ()) {
8606     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8607     return 0;
8608   }
8609
8610   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8611   {
8612     char device[] = "/dev/sda";
8613     int r;
8614     suppress_error = 0;
8615     r = guestfs_blockdev_setrw (g, device);
8616     if (r == -1)
8617       return -1;
8618   }
8619   {
8620     int r;
8621     suppress_error = 0;
8622     r = guestfs_umount_all (g);
8623     if (r == -1)
8624       return -1;
8625   }
8626   {
8627     int r;
8628     suppress_error = 0;
8629     r = guestfs_lvm_remove_all (g);
8630     if (r == -1)
8631       return -1;
8632   }
8633   {
8634     char device[] = "/dev/sda";
8635     char lines_0[] = ",";
8636     char *lines[] = {
8637       lines_0,
8638       NULL
8639     };
8640     int r;
8641     suppress_error = 0;
8642     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8643     if (r == -1)
8644       return -1;
8645   }
8646   {
8647     char fstype[] = "ext2";
8648     char device[] = "/dev/sda1";
8649     int r;
8650     suppress_error = 0;
8651     r = guestfs_mkfs (g, fstype, device);
8652     if (r == -1)
8653       return -1;
8654   }
8655   {
8656     char device[] = "/dev/sda1";
8657     char mountpoint[] = "/";
8658     int r;
8659     suppress_error = 0;
8660     r = guestfs_mount (g, device, mountpoint);
8661     if (r == -1)
8662       return -1;
8663   }
8664   /* TestOutput for command (2) */
8665   char expected[] = "\nResult3";
8666   {
8667     char remotefilename[] = "/test-command";
8668     int r;
8669     suppress_error = 0;
8670     r = guestfs_upload (g, "test-command", remotefilename);
8671     if (r == -1)
8672       return -1;
8673   }
8674   {
8675     char path[] = "/test-command";
8676     int r;
8677     suppress_error = 0;
8678     r = guestfs_chmod (g, 493, path);
8679     if (r == -1)
8680       return -1;
8681   }
8682   {
8683     char arguments_0[] = "/test-command";
8684     char arguments_1[] = "3";
8685     char *arguments[] = {
8686       arguments_0,
8687       arguments_1,
8688       NULL
8689     };
8690     char *r;
8691     suppress_error = 0;
8692     r = guestfs_command (g, arguments);
8693     if (r == NULL)
8694       return -1;
8695     if (strcmp (r, expected) != 0) {
8696       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8697       return -1;
8698     }
8699     free (r);
8700   }
8701   return 0;
8702 }
8703
8704 static int test_command_3_skip (void)
8705 {
8706   const char *str;
8707
8708   str = getenv ("SKIP_TEST_COMMAND_3");
8709   if (str && strcmp (str, "1") == 0) return 1;
8710   str = getenv ("SKIP_TEST_COMMAND");
8711   if (str && strcmp (str, "1") == 0) return 1;
8712   return 0;
8713 }
8714
8715 static int test_command_3 (void)
8716 {
8717   if (test_command_3_skip ()) {
8718     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8719     return 0;
8720   }
8721
8722   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8723   {
8724     char device[] = "/dev/sda";
8725     int r;
8726     suppress_error = 0;
8727     r = guestfs_blockdev_setrw (g, device);
8728     if (r == -1)
8729       return -1;
8730   }
8731   {
8732     int r;
8733     suppress_error = 0;
8734     r = guestfs_umount_all (g);
8735     if (r == -1)
8736       return -1;
8737   }
8738   {
8739     int r;
8740     suppress_error = 0;
8741     r = guestfs_lvm_remove_all (g);
8742     if (r == -1)
8743       return -1;
8744   }
8745   {
8746     char device[] = "/dev/sda";
8747     char lines_0[] = ",";
8748     char *lines[] = {
8749       lines_0,
8750       NULL
8751     };
8752     int r;
8753     suppress_error = 0;
8754     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8755     if (r == -1)
8756       return -1;
8757   }
8758   {
8759     char fstype[] = "ext2";
8760     char device[] = "/dev/sda1";
8761     int r;
8762     suppress_error = 0;
8763     r = guestfs_mkfs (g, fstype, device);
8764     if (r == -1)
8765       return -1;
8766   }
8767   {
8768     char device[] = "/dev/sda1";
8769     char mountpoint[] = "/";
8770     int r;
8771     suppress_error = 0;
8772     r = guestfs_mount (g, device, mountpoint);
8773     if (r == -1)
8774       return -1;
8775   }
8776   /* TestOutput for command (3) */
8777   char expected[] = "\nResult4\n";
8778   {
8779     char remotefilename[] = "/test-command";
8780     int r;
8781     suppress_error = 0;
8782     r = guestfs_upload (g, "test-command", remotefilename);
8783     if (r == -1)
8784       return -1;
8785   }
8786   {
8787     char path[] = "/test-command";
8788     int r;
8789     suppress_error = 0;
8790     r = guestfs_chmod (g, 493, path);
8791     if (r == -1)
8792       return -1;
8793   }
8794   {
8795     char arguments_0[] = "/test-command";
8796     char arguments_1[] = "4";
8797     char *arguments[] = {
8798       arguments_0,
8799       arguments_1,
8800       NULL
8801     };
8802     char *r;
8803     suppress_error = 0;
8804     r = guestfs_command (g, arguments);
8805     if (r == NULL)
8806       return -1;
8807     if (strcmp (r, expected) != 0) {
8808       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8809       return -1;
8810     }
8811     free (r);
8812   }
8813   return 0;
8814 }
8815
8816 static int test_command_4_skip (void)
8817 {
8818   const char *str;
8819
8820   str = getenv ("SKIP_TEST_COMMAND_4");
8821   if (str && strcmp (str, "1") == 0) return 1;
8822   str = getenv ("SKIP_TEST_COMMAND");
8823   if (str && strcmp (str, "1") == 0) return 1;
8824   return 0;
8825 }
8826
8827 static int test_command_4 (void)
8828 {
8829   if (test_command_4_skip ()) {
8830     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8831     return 0;
8832   }
8833
8834   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8835   {
8836     char device[] = "/dev/sda";
8837     int r;
8838     suppress_error = 0;
8839     r = guestfs_blockdev_setrw (g, device);
8840     if (r == -1)
8841       return -1;
8842   }
8843   {
8844     int r;
8845     suppress_error = 0;
8846     r = guestfs_umount_all (g);
8847     if (r == -1)
8848       return -1;
8849   }
8850   {
8851     int r;
8852     suppress_error = 0;
8853     r = guestfs_lvm_remove_all (g);
8854     if (r == -1)
8855       return -1;
8856   }
8857   {
8858     char device[] = "/dev/sda";
8859     char lines_0[] = ",";
8860     char *lines[] = {
8861       lines_0,
8862       NULL
8863     };
8864     int r;
8865     suppress_error = 0;
8866     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8867     if (r == -1)
8868       return -1;
8869   }
8870   {
8871     char fstype[] = "ext2";
8872     char device[] = "/dev/sda1";
8873     int r;
8874     suppress_error = 0;
8875     r = guestfs_mkfs (g, fstype, device);
8876     if (r == -1)
8877       return -1;
8878   }
8879   {
8880     char device[] = "/dev/sda1";
8881     char mountpoint[] = "/";
8882     int r;
8883     suppress_error = 0;
8884     r = guestfs_mount (g, device, mountpoint);
8885     if (r == -1)
8886       return -1;
8887   }
8888   /* TestOutput for command (4) */
8889   char expected[] = "\nResult5\n\n";
8890   {
8891     char remotefilename[] = "/test-command";
8892     int r;
8893     suppress_error = 0;
8894     r = guestfs_upload (g, "test-command", remotefilename);
8895     if (r == -1)
8896       return -1;
8897   }
8898   {
8899     char path[] = "/test-command";
8900     int r;
8901     suppress_error = 0;
8902     r = guestfs_chmod (g, 493, path);
8903     if (r == -1)
8904       return -1;
8905   }
8906   {
8907     char arguments_0[] = "/test-command";
8908     char arguments_1[] = "5";
8909     char *arguments[] = {
8910       arguments_0,
8911       arguments_1,
8912       NULL
8913     };
8914     char *r;
8915     suppress_error = 0;
8916     r = guestfs_command (g, arguments);
8917     if (r == NULL)
8918       return -1;
8919     if (strcmp (r, expected) != 0) {
8920       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
8921       return -1;
8922     }
8923     free (r);
8924   }
8925   return 0;
8926 }
8927
8928 static int test_command_5_skip (void)
8929 {
8930   const char *str;
8931
8932   str = getenv ("SKIP_TEST_COMMAND_5");
8933   if (str && strcmp (str, "1") == 0) return 1;
8934   str = getenv ("SKIP_TEST_COMMAND");
8935   if (str && strcmp (str, "1") == 0) return 1;
8936   return 0;
8937 }
8938
8939 static int test_command_5 (void)
8940 {
8941   if (test_command_5_skip ()) {
8942     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
8943     return 0;
8944   }
8945
8946   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
8947   {
8948     char device[] = "/dev/sda";
8949     int r;
8950     suppress_error = 0;
8951     r = guestfs_blockdev_setrw (g, device);
8952     if (r == -1)
8953       return -1;
8954   }
8955   {
8956     int r;
8957     suppress_error = 0;
8958     r = guestfs_umount_all (g);
8959     if (r == -1)
8960       return -1;
8961   }
8962   {
8963     int r;
8964     suppress_error = 0;
8965     r = guestfs_lvm_remove_all (g);
8966     if (r == -1)
8967       return -1;
8968   }
8969   {
8970     char device[] = "/dev/sda";
8971     char lines_0[] = ",";
8972     char *lines[] = {
8973       lines_0,
8974       NULL
8975     };
8976     int r;
8977     suppress_error = 0;
8978     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8979     if (r == -1)
8980       return -1;
8981   }
8982   {
8983     char fstype[] = "ext2";
8984     char device[] = "/dev/sda1";
8985     int r;
8986     suppress_error = 0;
8987     r = guestfs_mkfs (g, fstype, device);
8988     if (r == -1)
8989       return -1;
8990   }
8991   {
8992     char device[] = "/dev/sda1";
8993     char mountpoint[] = "/";
8994     int r;
8995     suppress_error = 0;
8996     r = guestfs_mount (g, device, mountpoint);
8997     if (r == -1)
8998       return -1;
8999   }
9000   /* TestOutput for command (5) */
9001   char expected[] = "\n\nResult6\n\n";
9002   {
9003     char remotefilename[] = "/test-command";
9004     int r;
9005     suppress_error = 0;
9006     r = guestfs_upload (g, "test-command", remotefilename);
9007     if (r == -1)
9008       return -1;
9009   }
9010   {
9011     char path[] = "/test-command";
9012     int r;
9013     suppress_error = 0;
9014     r = guestfs_chmod (g, 493, path);
9015     if (r == -1)
9016       return -1;
9017   }
9018   {
9019     char arguments_0[] = "/test-command";
9020     char arguments_1[] = "6";
9021     char *arguments[] = {
9022       arguments_0,
9023       arguments_1,
9024       NULL
9025     };
9026     char *r;
9027     suppress_error = 0;
9028     r = guestfs_command (g, arguments);
9029     if (r == NULL)
9030       return -1;
9031     if (strcmp (r, expected) != 0) {
9032       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9033       return -1;
9034     }
9035     free (r);
9036   }
9037   return 0;
9038 }
9039
9040 static int test_command_6_skip (void)
9041 {
9042   const char *str;
9043
9044   str = getenv ("SKIP_TEST_COMMAND_6");
9045   if (str && strcmp (str, "1") == 0) return 1;
9046   str = getenv ("SKIP_TEST_COMMAND");
9047   if (str && strcmp (str, "1") == 0) return 1;
9048   return 0;
9049 }
9050
9051 static int test_command_6 (void)
9052 {
9053   if (test_command_6_skip ()) {
9054     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9055     return 0;
9056   }
9057
9058   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9059   {
9060     char device[] = "/dev/sda";
9061     int r;
9062     suppress_error = 0;
9063     r = guestfs_blockdev_setrw (g, device);
9064     if (r == -1)
9065       return -1;
9066   }
9067   {
9068     int r;
9069     suppress_error = 0;
9070     r = guestfs_umount_all (g);
9071     if (r == -1)
9072       return -1;
9073   }
9074   {
9075     int r;
9076     suppress_error = 0;
9077     r = guestfs_lvm_remove_all (g);
9078     if (r == -1)
9079       return -1;
9080   }
9081   {
9082     char device[] = "/dev/sda";
9083     char lines_0[] = ",";
9084     char *lines[] = {
9085       lines_0,
9086       NULL
9087     };
9088     int r;
9089     suppress_error = 0;
9090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9091     if (r == -1)
9092       return -1;
9093   }
9094   {
9095     char fstype[] = "ext2";
9096     char device[] = "/dev/sda1";
9097     int r;
9098     suppress_error = 0;
9099     r = guestfs_mkfs (g, fstype, device);
9100     if (r == -1)
9101       return -1;
9102   }
9103   {
9104     char device[] = "/dev/sda1";
9105     char mountpoint[] = "/";
9106     int r;
9107     suppress_error = 0;
9108     r = guestfs_mount (g, device, mountpoint);
9109     if (r == -1)
9110       return -1;
9111   }
9112   /* TestOutput for command (6) */
9113   char expected[] = "";
9114   {
9115     char remotefilename[] = "/test-command";
9116     int r;
9117     suppress_error = 0;
9118     r = guestfs_upload (g, "test-command", remotefilename);
9119     if (r == -1)
9120       return -1;
9121   }
9122   {
9123     char path[] = "/test-command";
9124     int r;
9125     suppress_error = 0;
9126     r = guestfs_chmod (g, 493, path);
9127     if (r == -1)
9128       return -1;
9129   }
9130   {
9131     char arguments_0[] = "/test-command";
9132     char arguments_1[] = "7";
9133     char *arguments[] = {
9134       arguments_0,
9135       arguments_1,
9136       NULL
9137     };
9138     char *r;
9139     suppress_error = 0;
9140     r = guestfs_command (g, arguments);
9141     if (r == NULL)
9142       return -1;
9143     if (strcmp (r, expected) != 0) {
9144       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9145       return -1;
9146     }
9147     free (r);
9148   }
9149   return 0;
9150 }
9151
9152 static int test_command_7_skip (void)
9153 {
9154   const char *str;
9155
9156   str = getenv ("SKIP_TEST_COMMAND_7");
9157   if (str && strcmp (str, "1") == 0) return 1;
9158   str = getenv ("SKIP_TEST_COMMAND");
9159   if (str && strcmp (str, "1") == 0) return 1;
9160   return 0;
9161 }
9162
9163 static int test_command_7 (void)
9164 {
9165   if (test_command_7_skip ()) {
9166     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9167     return 0;
9168   }
9169
9170   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9171   {
9172     char device[] = "/dev/sda";
9173     int r;
9174     suppress_error = 0;
9175     r = guestfs_blockdev_setrw (g, device);
9176     if (r == -1)
9177       return -1;
9178   }
9179   {
9180     int r;
9181     suppress_error = 0;
9182     r = guestfs_umount_all (g);
9183     if (r == -1)
9184       return -1;
9185   }
9186   {
9187     int r;
9188     suppress_error = 0;
9189     r = guestfs_lvm_remove_all (g);
9190     if (r == -1)
9191       return -1;
9192   }
9193   {
9194     char device[] = "/dev/sda";
9195     char lines_0[] = ",";
9196     char *lines[] = {
9197       lines_0,
9198       NULL
9199     };
9200     int r;
9201     suppress_error = 0;
9202     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9203     if (r == -1)
9204       return -1;
9205   }
9206   {
9207     char fstype[] = "ext2";
9208     char device[] = "/dev/sda1";
9209     int r;
9210     suppress_error = 0;
9211     r = guestfs_mkfs (g, fstype, device);
9212     if (r == -1)
9213       return -1;
9214   }
9215   {
9216     char device[] = "/dev/sda1";
9217     char mountpoint[] = "/";
9218     int r;
9219     suppress_error = 0;
9220     r = guestfs_mount (g, device, mountpoint);
9221     if (r == -1)
9222       return -1;
9223   }
9224   /* TestOutput for command (7) */
9225   char expected[] = "\n";
9226   {
9227     char remotefilename[] = "/test-command";
9228     int r;
9229     suppress_error = 0;
9230     r = guestfs_upload (g, "test-command", remotefilename);
9231     if (r == -1)
9232       return -1;
9233   }
9234   {
9235     char path[] = "/test-command";
9236     int r;
9237     suppress_error = 0;
9238     r = guestfs_chmod (g, 493, path);
9239     if (r == -1)
9240       return -1;
9241   }
9242   {
9243     char arguments_0[] = "/test-command";
9244     char arguments_1[] = "8";
9245     char *arguments[] = {
9246       arguments_0,
9247       arguments_1,
9248       NULL
9249     };
9250     char *r;
9251     suppress_error = 0;
9252     r = guestfs_command (g, arguments);
9253     if (r == NULL)
9254       return -1;
9255     if (strcmp (r, expected) != 0) {
9256       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9257       return -1;
9258     }
9259     free (r);
9260   }
9261   return 0;
9262 }
9263
9264 static int test_command_8_skip (void)
9265 {
9266   const char *str;
9267
9268   str = getenv ("SKIP_TEST_COMMAND_8");
9269   if (str && strcmp (str, "1") == 0) return 1;
9270   str = getenv ("SKIP_TEST_COMMAND");
9271   if (str && strcmp (str, "1") == 0) return 1;
9272   return 0;
9273 }
9274
9275 static int test_command_8 (void)
9276 {
9277   if (test_command_8_skip ()) {
9278     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9279     return 0;
9280   }
9281
9282   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9283   {
9284     char device[] = "/dev/sda";
9285     int r;
9286     suppress_error = 0;
9287     r = guestfs_blockdev_setrw (g, device);
9288     if (r == -1)
9289       return -1;
9290   }
9291   {
9292     int r;
9293     suppress_error = 0;
9294     r = guestfs_umount_all (g);
9295     if (r == -1)
9296       return -1;
9297   }
9298   {
9299     int r;
9300     suppress_error = 0;
9301     r = guestfs_lvm_remove_all (g);
9302     if (r == -1)
9303       return -1;
9304   }
9305   {
9306     char device[] = "/dev/sda";
9307     char lines_0[] = ",";
9308     char *lines[] = {
9309       lines_0,
9310       NULL
9311     };
9312     int r;
9313     suppress_error = 0;
9314     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9315     if (r == -1)
9316       return -1;
9317   }
9318   {
9319     char fstype[] = "ext2";
9320     char device[] = "/dev/sda1";
9321     int r;
9322     suppress_error = 0;
9323     r = guestfs_mkfs (g, fstype, device);
9324     if (r == -1)
9325       return -1;
9326   }
9327   {
9328     char device[] = "/dev/sda1";
9329     char mountpoint[] = "/";
9330     int r;
9331     suppress_error = 0;
9332     r = guestfs_mount (g, device, mountpoint);
9333     if (r == -1)
9334       return -1;
9335   }
9336   /* TestOutput for command (8) */
9337   char expected[] = "\n\n";
9338   {
9339     char remotefilename[] = "/test-command";
9340     int r;
9341     suppress_error = 0;
9342     r = guestfs_upload (g, "test-command", remotefilename);
9343     if (r == -1)
9344       return -1;
9345   }
9346   {
9347     char path[] = "/test-command";
9348     int r;
9349     suppress_error = 0;
9350     r = guestfs_chmod (g, 493, path);
9351     if (r == -1)
9352       return -1;
9353   }
9354   {
9355     char arguments_0[] = "/test-command";
9356     char arguments_1[] = "9";
9357     char *arguments[] = {
9358       arguments_0,
9359       arguments_1,
9360       NULL
9361     };
9362     char *r;
9363     suppress_error = 0;
9364     r = guestfs_command (g, arguments);
9365     if (r == NULL)
9366       return -1;
9367     if (strcmp (r, expected) != 0) {
9368       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9369       return -1;
9370     }
9371     free (r);
9372   }
9373   return 0;
9374 }
9375
9376 static int test_command_9_skip (void)
9377 {
9378   const char *str;
9379
9380   str = getenv ("SKIP_TEST_COMMAND_9");
9381   if (str && strcmp (str, "1") == 0) return 1;
9382   str = getenv ("SKIP_TEST_COMMAND");
9383   if (str && strcmp (str, "1") == 0) return 1;
9384   return 0;
9385 }
9386
9387 static int test_command_9 (void)
9388 {
9389   if (test_command_9_skip ()) {
9390     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9391     return 0;
9392   }
9393
9394   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9395   {
9396     char device[] = "/dev/sda";
9397     int r;
9398     suppress_error = 0;
9399     r = guestfs_blockdev_setrw (g, device);
9400     if (r == -1)
9401       return -1;
9402   }
9403   {
9404     int r;
9405     suppress_error = 0;
9406     r = guestfs_umount_all (g);
9407     if (r == -1)
9408       return -1;
9409   }
9410   {
9411     int r;
9412     suppress_error = 0;
9413     r = guestfs_lvm_remove_all (g);
9414     if (r == -1)
9415       return -1;
9416   }
9417   {
9418     char device[] = "/dev/sda";
9419     char lines_0[] = ",";
9420     char *lines[] = {
9421       lines_0,
9422       NULL
9423     };
9424     int r;
9425     suppress_error = 0;
9426     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9427     if (r == -1)
9428       return -1;
9429   }
9430   {
9431     char fstype[] = "ext2";
9432     char device[] = "/dev/sda1";
9433     int r;
9434     suppress_error = 0;
9435     r = guestfs_mkfs (g, fstype, device);
9436     if (r == -1)
9437       return -1;
9438   }
9439   {
9440     char device[] = "/dev/sda1";
9441     char mountpoint[] = "/";
9442     int r;
9443     suppress_error = 0;
9444     r = guestfs_mount (g, device, mountpoint);
9445     if (r == -1)
9446       return -1;
9447   }
9448   /* TestOutput for command (9) */
9449   char expected[] = "Result10-1\nResult10-2\n";
9450   {
9451     char remotefilename[] = "/test-command";
9452     int r;
9453     suppress_error = 0;
9454     r = guestfs_upload (g, "test-command", remotefilename);
9455     if (r == -1)
9456       return -1;
9457   }
9458   {
9459     char path[] = "/test-command";
9460     int r;
9461     suppress_error = 0;
9462     r = guestfs_chmod (g, 493, path);
9463     if (r == -1)
9464       return -1;
9465   }
9466   {
9467     char arguments_0[] = "/test-command";
9468     char arguments_1[] = "10";
9469     char *arguments[] = {
9470       arguments_0,
9471       arguments_1,
9472       NULL
9473     };
9474     char *r;
9475     suppress_error = 0;
9476     r = guestfs_command (g, arguments);
9477     if (r == NULL)
9478       return -1;
9479     if (strcmp (r, expected) != 0) {
9480       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9481       return -1;
9482     }
9483     free (r);
9484   }
9485   return 0;
9486 }
9487
9488 static int test_command_10_skip (void)
9489 {
9490   const char *str;
9491
9492   str = getenv ("SKIP_TEST_COMMAND_10");
9493   if (str && strcmp (str, "1") == 0) return 1;
9494   str = getenv ("SKIP_TEST_COMMAND");
9495   if (str && strcmp (str, "1") == 0) return 1;
9496   return 0;
9497 }
9498
9499 static int test_command_10 (void)
9500 {
9501   if (test_command_10_skip ()) {
9502     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9503     return 0;
9504   }
9505
9506   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9507   {
9508     char device[] = "/dev/sda";
9509     int r;
9510     suppress_error = 0;
9511     r = guestfs_blockdev_setrw (g, device);
9512     if (r == -1)
9513       return -1;
9514   }
9515   {
9516     int r;
9517     suppress_error = 0;
9518     r = guestfs_umount_all (g);
9519     if (r == -1)
9520       return -1;
9521   }
9522   {
9523     int r;
9524     suppress_error = 0;
9525     r = guestfs_lvm_remove_all (g);
9526     if (r == -1)
9527       return -1;
9528   }
9529   {
9530     char device[] = "/dev/sda";
9531     char lines_0[] = ",";
9532     char *lines[] = {
9533       lines_0,
9534       NULL
9535     };
9536     int r;
9537     suppress_error = 0;
9538     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9539     if (r == -1)
9540       return -1;
9541   }
9542   {
9543     char fstype[] = "ext2";
9544     char device[] = "/dev/sda1";
9545     int r;
9546     suppress_error = 0;
9547     r = guestfs_mkfs (g, fstype, device);
9548     if (r == -1)
9549       return -1;
9550   }
9551   {
9552     char device[] = "/dev/sda1";
9553     char mountpoint[] = "/";
9554     int r;
9555     suppress_error = 0;
9556     r = guestfs_mount (g, device, mountpoint);
9557     if (r == -1)
9558       return -1;
9559   }
9560   /* TestOutput for command (10) */
9561   char expected[] = "Result11-1\nResult11-2";
9562   {
9563     char remotefilename[] = "/test-command";
9564     int r;
9565     suppress_error = 0;
9566     r = guestfs_upload (g, "test-command", remotefilename);
9567     if (r == -1)
9568       return -1;
9569   }
9570   {
9571     char path[] = "/test-command";
9572     int r;
9573     suppress_error = 0;
9574     r = guestfs_chmod (g, 493, path);
9575     if (r == -1)
9576       return -1;
9577   }
9578   {
9579     char arguments_0[] = "/test-command";
9580     char arguments_1[] = "11";
9581     char *arguments[] = {
9582       arguments_0,
9583       arguments_1,
9584       NULL
9585     };
9586     char *r;
9587     suppress_error = 0;
9588     r = guestfs_command (g, arguments);
9589     if (r == NULL)
9590       return -1;
9591     if (strcmp (r, expected) != 0) {
9592       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9593       return -1;
9594     }
9595     free (r);
9596   }
9597   return 0;
9598 }
9599
9600 static int test_command_11_skip (void)
9601 {
9602   const char *str;
9603
9604   str = getenv ("SKIP_TEST_COMMAND_11");
9605   if (str && strcmp (str, "1") == 0) return 1;
9606   str = getenv ("SKIP_TEST_COMMAND");
9607   if (str && strcmp (str, "1") == 0) return 1;
9608   return 0;
9609 }
9610
9611 static int test_command_11 (void)
9612 {
9613   if (test_command_11_skip ()) {
9614     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9615     return 0;
9616   }
9617
9618   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9619   {
9620     char device[] = "/dev/sda";
9621     int r;
9622     suppress_error = 0;
9623     r = guestfs_blockdev_setrw (g, device);
9624     if (r == -1)
9625       return -1;
9626   }
9627   {
9628     int r;
9629     suppress_error = 0;
9630     r = guestfs_umount_all (g);
9631     if (r == -1)
9632       return -1;
9633   }
9634   {
9635     int r;
9636     suppress_error = 0;
9637     r = guestfs_lvm_remove_all (g);
9638     if (r == -1)
9639       return -1;
9640   }
9641   {
9642     char device[] = "/dev/sda";
9643     char lines_0[] = ",";
9644     char *lines[] = {
9645       lines_0,
9646       NULL
9647     };
9648     int r;
9649     suppress_error = 0;
9650     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9651     if (r == -1)
9652       return -1;
9653   }
9654   {
9655     char fstype[] = "ext2";
9656     char device[] = "/dev/sda1";
9657     int r;
9658     suppress_error = 0;
9659     r = guestfs_mkfs (g, fstype, device);
9660     if (r == -1)
9661       return -1;
9662   }
9663   {
9664     char device[] = "/dev/sda1";
9665     char mountpoint[] = "/";
9666     int r;
9667     suppress_error = 0;
9668     r = guestfs_mount (g, device, mountpoint);
9669     if (r == -1)
9670       return -1;
9671   }
9672   /* TestLastFail for command (11) */
9673   {
9674     char remotefilename[] = "/test-command";
9675     int r;
9676     suppress_error = 0;
9677     r = guestfs_upload (g, "test-command", remotefilename);
9678     if (r == -1)
9679       return -1;
9680   }
9681   {
9682     char path[] = "/test-command";
9683     int r;
9684     suppress_error = 0;
9685     r = guestfs_chmod (g, 493, path);
9686     if (r == -1)
9687       return -1;
9688   }
9689   {
9690     char arguments_0[] = "/test-command";
9691     char *arguments[] = {
9692       arguments_0,
9693       NULL
9694     };
9695     char *r;
9696     suppress_error = 1;
9697     r = guestfs_command (g, arguments);
9698     if (r != NULL)
9699       return -1;
9700     free (r);
9701   }
9702   return 0;
9703 }
9704
9705 static int test_file_0_skip (void)
9706 {
9707   const char *str;
9708
9709   str = getenv ("SKIP_TEST_FILE_0");
9710   if (str && strcmp (str, "1") == 0) return 1;
9711   str = getenv ("SKIP_TEST_FILE");
9712   if (str && strcmp (str, "1") == 0) return 1;
9713   return 0;
9714 }
9715
9716 static int test_file_0 (void)
9717 {
9718   if (test_file_0_skip ()) {
9719     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9720     return 0;
9721   }
9722
9723   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9724   {
9725     char device[] = "/dev/sda";
9726     int r;
9727     suppress_error = 0;
9728     r = guestfs_blockdev_setrw (g, device);
9729     if (r == -1)
9730       return -1;
9731   }
9732   {
9733     int r;
9734     suppress_error = 0;
9735     r = guestfs_umount_all (g);
9736     if (r == -1)
9737       return -1;
9738   }
9739   {
9740     int r;
9741     suppress_error = 0;
9742     r = guestfs_lvm_remove_all (g);
9743     if (r == -1)
9744       return -1;
9745   }
9746   {
9747     char device[] = "/dev/sda";
9748     char lines_0[] = ",";
9749     char *lines[] = {
9750       lines_0,
9751       NULL
9752     };
9753     int r;
9754     suppress_error = 0;
9755     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9756     if (r == -1)
9757       return -1;
9758   }
9759   {
9760     char fstype[] = "ext2";
9761     char device[] = "/dev/sda1";
9762     int r;
9763     suppress_error = 0;
9764     r = guestfs_mkfs (g, fstype, device);
9765     if (r == -1)
9766       return -1;
9767   }
9768   {
9769     char device[] = "/dev/sda1";
9770     char mountpoint[] = "/";
9771     int r;
9772     suppress_error = 0;
9773     r = guestfs_mount (g, device, mountpoint);
9774     if (r == -1)
9775       return -1;
9776   }
9777   /* TestOutput for file (0) */
9778   char expected[] = "empty";
9779   {
9780     char path[] = "/new";
9781     int r;
9782     suppress_error = 0;
9783     r = guestfs_touch (g, path);
9784     if (r == -1)
9785       return -1;
9786   }
9787   {
9788     char path[] = "/new";
9789     char *r;
9790     suppress_error = 0;
9791     r = guestfs_file (g, path);
9792     if (r == NULL)
9793       return -1;
9794     if (strcmp (r, expected) != 0) {
9795       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9796       return -1;
9797     }
9798     free (r);
9799   }
9800   return 0;
9801 }
9802
9803 static int test_file_1_skip (void)
9804 {
9805   const char *str;
9806
9807   str = getenv ("SKIP_TEST_FILE_1");
9808   if (str && strcmp (str, "1") == 0) return 1;
9809   str = getenv ("SKIP_TEST_FILE");
9810   if (str && strcmp (str, "1") == 0) return 1;
9811   return 0;
9812 }
9813
9814 static int test_file_1 (void)
9815 {
9816   if (test_file_1_skip ()) {
9817     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9818     return 0;
9819   }
9820
9821   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9822   {
9823     char device[] = "/dev/sda";
9824     int r;
9825     suppress_error = 0;
9826     r = guestfs_blockdev_setrw (g, device);
9827     if (r == -1)
9828       return -1;
9829   }
9830   {
9831     int r;
9832     suppress_error = 0;
9833     r = guestfs_umount_all (g);
9834     if (r == -1)
9835       return -1;
9836   }
9837   {
9838     int r;
9839     suppress_error = 0;
9840     r = guestfs_lvm_remove_all (g);
9841     if (r == -1)
9842       return -1;
9843   }
9844   {
9845     char device[] = "/dev/sda";
9846     char lines_0[] = ",";
9847     char *lines[] = {
9848       lines_0,
9849       NULL
9850     };
9851     int r;
9852     suppress_error = 0;
9853     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9854     if (r == -1)
9855       return -1;
9856   }
9857   {
9858     char fstype[] = "ext2";
9859     char device[] = "/dev/sda1";
9860     int r;
9861     suppress_error = 0;
9862     r = guestfs_mkfs (g, fstype, device);
9863     if (r == -1)
9864       return -1;
9865   }
9866   {
9867     char device[] = "/dev/sda1";
9868     char mountpoint[] = "/";
9869     int r;
9870     suppress_error = 0;
9871     r = guestfs_mount (g, device, mountpoint);
9872     if (r == -1)
9873       return -1;
9874   }
9875   /* TestOutput for file (1) */
9876   char expected[] = "ASCII text";
9877   {
9878     char path[] = "/new";
9879     char content[] = "some content\n";
9880     int r;
9881     suppress_error = 0;
9882     r = guestfs_write_file (g, path, content, 0);
9883     if (r == -1)
9884       return -1;
9885   }
9886   {
9887     char path[] = "/new";
9888     char *r;
9889     suppress_error = 0;
9890     r = guestfs_file (g, path);
9891     if (r == NULL)
9892       return -1;
9893     if (strcmp (r, expected) != 0) {
9894       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9895       return -1;
9896     }
9897     free (r);
9898   }
9899   return 0;
9900 }
9901
9902 static int test_file_2_skip (void)
9903 {
9904   const char *str;
9905
9906   str = getenv ("SKIP_TEST_FILE_2");
9907   if (str && strcmp (str, "1") == 0) return 1;
9908   str = getenv ("SKIP_TEST_FILE");
9909   if (str && strcmp (str, "1") == 0) return 1;
9910   return 0;
9911 }
9912
9913 static int test_file_2 (void)
9914 {
9915   if (test_file_2_skip ()) {
9916     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
9917     return 0;
9918   }
9919
9920   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
9921   {
9922     char device[] = "/dev/sda";
9923     int r;
9924     suppress_error = 0;
9925     r = guestfs_blockdev_setrw (g, device);
9926     if (r == -1)
9927       return -1;
9928   }
9929   {
9930     int r;
9931     suppress_error = 0;
9932     r = guestfs_umount_all (g);
9933     if (r == -1)
9934       return -1;
9935   }
9936   {
9937     int r;
9938     suppress_error = 0;
9939     r = guestfs_lvm_remove_all (g);
9940     if (r == -1)
9941       return -1;
9942   }
9943   {
9944     char device[] = "/dev/sda";
9945     char lines_0[] = ",";
9946     char *lines[] = {
9947       lines_0,
9948       NULL
9949     };
9950     int r;
9951     suppress_error = 0;
9952     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9953     if (r == -1)
9954       return -1;
9955   }
9956   {
9957     char fstype[] = "ext2";
9958     char device[] = "/dev/sda1";
9959     int r;
9960     suppress_error = 0;
9961     r = guestfs_mkfs (g, fstype, device);
9962     if (r == -1)
9963       return -1;
9964   }
9965   {
9966     char device[] = "/dev/sda1";
9967     char mountpoint[] = "/";
9968     int r;
9969     suppress_error = 0;
9970     r = guestfs_mount (g, device, mountpoint);
9971     if (r == -1)
9972       return -1;
9973   }
9974   /* TestLastFail for file (2) */
9975   {
9976     char path[] = "/nofile";
9977     char *r;
9978     suppress_error = 1;
9979     r = guestfs_file (g, path);
9980     if (r != NULL)
9981       return -1;
9982     free (r);
9983   }
9984   return 0;
9985 }
9986
9987 static int test_umount_all_0_skip (void)
9988 {
9989   const char *str;
9990
9991   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
9992   if (str && strcmp (str, "1") == 0) return 1;
9993   str = getenv ("SKIP_TEST_UMOUNT_ALL");
9994   if (str && strcmp (str, "1") == 0) return 1;
9995   return 0;
9996 }
9997
9998 static int test_umount_all_0 (void)
9999 {
10000   if (test_umount_all_0_skip ()) {
10001     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10002     return 0;
10003   }
10004
10005   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10006   {
10007     char device[] = "/dev/sda";
10008     int r;
10009     suppress_error = 0;
10010     r = guestfs_blockdev_setrw (g, device);
10011     if (r == -1)
10012       return -1;
10013   }
10014   {
10015     int r;
10016     suppress_error = 0;
10017     r = guestfs_umount_all (g);
10018     if (r == -1)
10019       return -1;
10020   }
10021   {
10022     int r;
10023     suppress_error = 0;
10024     r = guestfs_lvm_remove_all (g);
10025     if (r == -1)
10026       return -1;
10027   }
10028   {
10029     char device[] = "/dev/sda";
10030     char lines_0[] = ",";
10031     char *lines[] = {
10032       lines_0,
10033       NULL
10034     };
10035     int r;
10036     suppress_error = 0;
10037     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10038     if (r == -1)
10039       return -1;
10040   }
10041   {
10042     char fstype[] = "ext2";
10043     char device[] = "/dev/sda1";
10044     int r;
10045     suppress_error = 0;
10046     r = guestfs_mkfs (g, fstype, device);
10047     if (r == -1)
10048       return -1;
10049   }
10050   {
10051     char device[] = "/dev/sda1";
10052     char mountpoint[] = "/";
10053     int r;
10054     suppress_error = 0;
10055     r = guestfs_mount (g, device, mountpoint);
10056     if (r == -1)
10057       return -1;
10058   }
10059   /* TestOutputList for umount_all (0) */
10060   {
10061     int r;
10062     suppress_error = 0;
10063     r = guestfs_umount_all (g);
10064     if (r == -1)
10065       return -1;
10066   }
10067   {
10068     char **r;
10069     int i;
10070     suppress_error = 0;
10071     r = guestfs_mounts (g);
10072     if (r == NULL)
10073       return -1;
10074     if (r[0] != NULL) {
10075       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10076       print_strings (r);
10077       return -1;
10078     }
10079     for (i = 0; r[i] != NULL; ++i)
10080       free (r[i]);
10081     free (r);
10082   }
10083   return 0;
10084 }
10085
10086 static int test_umount_all_1_skip (void)
10087 {
10088   const char *str;
10089
10090   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10091   if (str && strcmp (str, "1") == 0) return 1;
10092   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10093   if (str && strcmp (str, "1") == 0) return 1;
10094   return 0;
10095 }
10096
10097 static int test_umount_all_1 (void)
10098 {
10099   if (test_umount_all_1_skip ()) {
10100     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10101     return 0;
10102   }
10103
10104   /* InitNone|InitEmpty for test_umount_all_1 */
10105   {
10106     char device[] = "/dev/sda";
10107     int r;
10108     suppress_error = 0;
10109     r = guestfs_blockdev_setrw (g, device);
10110     if (r == -1)
10111       return -1;
10112   }
10113   {
10114     int r;
10115     suppress_error = 0;
10116     r = guestfs_umount_all (g);
10117     if (r == -1)
10118       return -1;
10119   }
10120   {
10121     int r;
10122     suppress_error = 0;
10123     r = guestfs_lvm_remove_all (g);
10124     if (r == -1)
10125       return -1;
10126   }
10127   /* TestOutputList for umount_all (1) */
10128   {
10129     char device[] = "/dev/sda";
10130     char lines_0[] = ",10";
10131     char lines_1[] = ",20";
10132     char lines_2[] = ",";
10133     char *lines[] = {
10134       lines_0,
10135       lines_1,
10136       lines_2,
10137       NULL
10138     };
10139     int r;
10140     suppress_error = 0;
10141     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10142     if (r == -1)
10143       return -1;
10144   }
10145   {
10146     char fstype[] = "ext2";
10147     char device[] = "/dev/sda1";
10148     int r;
10149     suppress_error = 0;
10150     r = guestfs_mkfs (g, fstype, device);
10151     if (r == -1)
10152       return -1;
10153   }
10154   {
10155     char fstype[] = "ext2";
10156     char device[] = "/dev/sda2";
10157     int r;
10158     suppress_error = 0;
10159     r = guestfs_mkfs (g, fstype, device);
10160     if (r == -1)
10161       return -1;
10162   }
10163   {
10164     char fstype[] = "ext2";
10165     char device[] = "/dev/sda3";
10166     int r;
10167     suppress_error = 0;
10168     r = guestfs_mkfs (g, fstype, device);
10169     if (r == -1)
10170       return -1;
10171   }
10172   {
10173     char device[] = "/dev/sda1";
10174     char mountpoint[] = "/";
10175     int r;
10176     suppress_error = 0;
10177     r = guestfs_mount (g, device, mountpoint);
10178     if (r == -1)
10179       return -1;
10180   }
10181   {
10182     char path[] = "/mp1";
10183     int r;
10184     suppress_error = 0;
10185     r = guestfs_mkdir (g, path);
10186     if (r == -1)
10187       return -1;
10188   }
10189   {
10190     char device[] = "/dev/sda2";
10191     char mountpoint[] = "/mp1";
10192     int r;
10193     suppress_error = 0;
10194     r = guestfs_mount (g, device, mountpoint);
10195     if (r == -1)
10196       return -1;
10197   }
10198   {
10199     char path[] = "/mp1/mp2";
10200     int r;
10201     suppress_error = 0;
10202     r = guestfs_mkdir (g, path);
10203     if (r == -1)
10204       return -1;
10205   }
10206   {
10207     char device[] = "/dev/sda3";
10208     char mountpoint[] = "/mp1/mp2";
10209     int r;
10210     suppress_error = 0;
10211     r = guestfs_mount (g, device, mountpoint);
10212     if (r == -1)
10213       return -1;
10214   }
10215   {
10216     char path[] = "/mp1/mp2/mp3";
10217     int r;
10218     suppress_error = 0;
10219     r = guestfs_mkdir (g, path);
10220     if (r == -1)
10221       return -1;
10222   }
10223   {
10224     int r;
10225     suppress_error = 0;
10226     r = guestfs_umount_all (g);
10227     if (r == -1)
10228       return -1;
10229   }
10230   {
10231     char **r;
10232     int i;
10233     suppress_error = 0;
10234     r = guestfs_mounts (g);
10235     if (r == NULL)
10236       return -1;
10237     if (r[0] != NULL) {
10238       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10239       print_strings (r);
10240       return -1;
10241     }
10242     for (i = 0; r[i] != NULL; ++i)
10243       free (r[i]);
10244     free (r);
10245   }
10246   return 0;
10247 }
10248
10249 static int test_mounts_0_skip (void)
10250 {
10251   const char *str;
10252
10253   str = getenv ("SKIP_TEST_MOUNTS_0");
10254   if (str && strcmp (str, "1") == 0) return 1;
10255   str = getenv ("SKIP_TEST_MOUNTS");
10256   if (str && strcmp (str, "1") == 0) return 1;
10257   return 0;
10258 }
10259
10260 static int test_mounts_0 (void)
10261 {
10262   if (test_mounts_0_skip ()) {
10263     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10264     return 0;
10265   }
10266
10267   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10268   {
10269     char device[] = "/dev/sda";
10270     int r;
10271     suppress_error = 0;
10272     r = guestfs_blockdev_setrw (g, device);
10273     if (r == -1)
10274       return -1;
10275   }
10276   {
10277     int r;
10278     suppress_error = 0;
10279     r = guestfs_umount_all (g);
10280     if (r == -1)
10281       return -1;
10282   }
10283   {
10284     int r;
10285     suppress_error = 0;
10286     r = guestfs_lvm_remove_all (g);
10287     if (r == -1)
10288       return -1;
10289   }
10290   {
10291     char device[] = "/dev/sda";
10292     char lines_0[] = ",";
10293     char *lines[] = {
10294       lines_0,
10295       NULL
10296     };
10297     int r;
10298     suppress_error = 0;
10299     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10300     if (r == -1)
10301       return -1;
10302   }
10303   {
10304     char fstype[] = "ext2";
10305     char device[] = "/dev/sda1";
10306     int r;
10307     suppress_error = 0;
10308     r = guestfs_mkfs (g, fstype, device);
10309     if (r == -1)
10310       return -1;
10311   }
10312   {
10313     char device[] = "/dev/sda1";
10314     char mountpoint[] = "/";
10315     int r;
10316     suppress_error = 0;
10317     r = guestfs_mount (g, device, mountpoint);
10318     if (r == -1)
10319       return -1;
10320   }
10321   /* TestOutputListOfDevices for mounts (0) */
10322   {
10323     char **r;
10324     int i;
10325     suppress_error = 0;
10326     r = guestfs_mounts (g);
10327     if (r == NULL)
10328       return -1;
10329     if (!r[0]) {
10330       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10331       print_strings (r);
10332       return -1;
10333     }
10334     {
10335       char expected[] = "/dev/sda1";
10336       r[0][5] = 's';
10337       if (strcmp (r[0], expected) != 0) {
10338         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10339         return -1;
10340       }
10341     }
10342     if (r[1] != NULL) {
10343       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10344       print_strings (r);
10345       return -1;
10346     }
10347     for (i = 0; r[i] != NULL; ++i)
10348       free (r[i]);
10349     free (r);
10350   }
10351   return 0;
10352 }
10353
10354 static int test_umount_0_skip (void)
10355 {
10356   const char *str;
10357
10358   str = getenv ("SKIP_TEST_UMOUNT_0");
10359   if (str && strcmp (str, "1") == 0) return 1;
10360   str = getenv ("SKIP_TEST_UMOUNT");
10361   if (str && strcmp (str, "1") == 0) return 1;
10362   return 0;
10363 }
10364
10365 static int test_umount_0 (void)
10366 {
10367   if (test_umount_0_skip ()) {
10368     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10369     return 0;
10370   }
10371
10372   /* InitNone|InitEmpty for test_umount_0 */
10373   {
10374     char device[] = "/dev/sda";
10375     int r;
10376     suppress_error = 0;
10377     r = guestfs_blockdev_setrw (g, device);
10378     if (r == -1)
10379       return -1;
10380   }
10381   {
10382     int r;
10383     suppress_error = 0;
10384     r = guestfs_umount_all (g);
10385     if (r == -1)
10386       return -1;
10387   }
10388   {
10389     int r;
10390     suppress_error = 0;
10391     r = guestfs_lvm_remove_all (g);
10392     if (r == -1)
10393       return -1;
10394   }
10395   /* TestOutputListOfDevices for umount (0) */
10396   {
10397     char device[] = "/dev/sda";
10398     char lines_0[] = ",";
10399     char *lines[] = {
10400       lines_0,
10401       NULL
10402     };
10403     int r;
10404     suppress_error = 0;
10405     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10406     if (r == -1)
10407       return -1;
10408   }
10409   {
10410     char fstype[] = "ext2";
10411     char device[] = "/dev/sda1";
10412     int r;
10413     suppress_error = 0;
10414     r = guestfs_mkfs (g, fstype, device);
10415     if (r == -1)
10416       return -1;
10417   }
10418   {
10419     char device[] = "/dev/sda1";
10420     char mountpoint[] = "/";
10421     int r;
10422     suppress_error = 0;
10423     r = guestfs_mount (g, device, mountpoint);
10424     if (r == -1)
10425       return -1;
10426   }
10427   {
10428     char **r;
10429     int i;
10430     suppress_error = 0;
10431     r = guestfs_mounts (g);
10432     if (r == NULL)
10433       return -1;
10434     if (!r[0]) {
10435       fprintf (stderr, "test_umount_0: short list returned from command\n");
10436       print_strings (r);
10437       return -1;
10438     }
10439     {
10440       char expected[] = "/dev/sda1";
10441       r[0][5] = 's';
10442       if (strcmp (r[0], expected) != 0) {
10443         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10444         return -1;
10445       }
10446     }
10447     if (r[1] != NULL) {
10448       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10449       print_strings (r);
10450       return -1;
10451     }
10452     for (i = 0; r[i] != NULL; ++i)
10453       free (r[i]);
10454     free (r);
10455   }
10456   return 0;
10457 }
10458
10459 static int test_umount_1_skip (void)
10460 {
10461   const char *str;
10462
10463   str = getenv ("SKIP_TEST_UMOUNT_1");
10464   if (str && strcmp (str, "1") == 0) return 1;
10465   str = getenv ("SKIP_TEST_UMOUNT");
10466   if (str && strcmp (str, "1") == 0) return 1;
10467   return 0;
10468 }
10469
10470 static int test_umount_1 (void)
10471 {
10472   if (test_umount_1_skip ()) {
10473     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10474     return 0;
10475   }
10476
10477   /* InitNone|InitEmpty for test_umount_1 */
10478   {
10479     char device[] = "/dev/sda";
10480     int r;
10481     suppress_error = 0;
10482     r = guestfs_blockdev_setrw (g, device);
10483     if (r == -1)
10484       return -1;
10485   }
10486   {
10487     int r;
10488     suppress_error = 0;
10489     r = guestfs_umount_all (g);
10490     if (r == -1)
10491       return -1;
10492   }
10493   {
10494     int r;
10495     suppress_error = 0;
10496     r = guestfs_lvm_remove_all (g);
10497     if (r == -1)
10498       return -1;
10499   }
10500   /* TestOutputList for umount (1) */
10501   {
10502     char device[] = "/dev/sda";
10503     char lines_0[] = ",";
10504     char *lines[] = {
10505       lines_0,
10506       NULL
10507     };
10508     int r;
10509     suppress_error = 0;
10510     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10511     if (r == -1)
10512       return -1;
10513   }
10514   {
10515     char fstype[] = "ext2";
10516     char device[] = "/dev/sda1";
10517     int r;
10518     suppress_error = 0;
10519     r = guestfs_mkfs (g, fstype, device);
10520     if (r == -1)
10521       return -1;
10522   }
10523   {
10524     char device[] = "/dev/sda1";
10525     char mountpoint[] = "/";
10526     int r;
10527     suppress_error = 0;
10528     r = guestfs_mount (g, device, mountpoint);
10529     if (r == -1)
10530       return -1;
10531   }
10532   {
10533     char pathordevice[] = "/";
10534     int r;
10535     suppress_error = 0;
10536     r = guestfs_umount (g, pathordevice);
10537     if (r == -1)
10538       return -1;
10539   }
10540   {
10541     char **r;
10542     int i;
10543     suppress_error = 0;
10544     r = guestfs_mounts (g);
10545     if (r == NULL)
10546       return -1;
10547     if (r[0] != NULL) {
10548       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10549       print_strings (r);
10550       return -1;
10551     }
10552     for (i = 0; r[i] != NULL; ++i)
10553       free (r[i]);
10554     free (r);
10555   }
10556   return 0;
10557 }
10558
10559 static int test_write_file_0_skip (void)
10560 {
10561   const char *str;
10562
10563   str = getenv ("SKIP_TEST_WRITE_FILE_0");
10564   if (str && strcmp (str, "1") == 0) return 1;
10565   str = getenv ("SKIP_TEST_WRITE_FILE");
10566   if (str && strcmp (str, "1") == 0) return 1;
10567   return 0;
10568 }
10569
10570 static int test_write_file_0 (void)
10571 {
10572   if (test_write_file_0_skip ()) {
10573     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10574     return 0;
10575   }
10576
10577   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10578   {
10579     char device[] = "/dev/sda";
10580     int r;
10581     suppress_error = 0;
10582     r = guestfs_blockdev_setrw (g, device);
10583     if (r == -1)
10584       return -1;
10585   }
10586   {
10587     int r;
10588     suppress_error = 0;
10589     r = guestfs_umount_all (g);
10590     if (r == -1)
10591       return -1;
10592   }
10593   {
10594     int r;
10595     suppress_error = 0;
10596     r = guestfs_lvm_remove_all (g);
10597     if (r == -1)
10598       return -1;
10599   }
10600   {
10601     char device[] = "/dev/sda";
10602     char lines_0[] = ",";
10603     char *lines[] = {
10604       lines_0,
10605       NULL
10606     };
10607     int r;
10608     suppress_error = 0;
10609     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10610     if (r == -1)
10611       return -1;
10612   }
10613   {
10614     char fstype[] = "ext2";
10615     char device[] = "/dev/sda1";
10616     int r;
10617     suppress_error = 0;
10618     r = guestfs_mkfs (g, fstype, device);
10619     if (r == -1)
10620       return -1;
10621   }
10622   {
10623     char device[] = "/dev/sda1";
10624     char mountpoint[] = "/";
10625     int r;
10626     suppress_error = 0;
10627     r = guestfs_mount (g, device, mountpoint);
10628     if (r == -1)
10629       return -1;
10630   }
10631   /* TestOutput for write_file (0) */
10632   char expected[] = "new file contents";
10633   {
10634     char path[] = "/new";
10635     char content[] = "new file contents";
10636     int r;
10637     suppress_error = 0;
10638     r = guestfs_write_file (g, path, content, 0);
10639     if (r == -1)
10640       return -1;
10641   }
10642   {
10643     char path[] = "/new";
10644     char *r;
10645     suppress_error = 0;
10646     r = guestfs_cat (g, path);
10647     if (r == NULL)
10648       return -1;
10649     if (strcmp (r, expected) != 0) {
10650       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10651       return -1;
10652     }
10653     free (r);
10654   }
10655   return 0;
10656 }
10657
10658 static int test_write_file_1_skip (void)
10659 {
10660   const char *str;
10661
10662   str = getenv ("SKIP_TEST_WRITE_FILE_1");
10663   if (str && strcmp (str, "1") == 0) return 1;
10664   str = getenv ("SKIP_TEST_WRITE_FILE");
10665   if (str && strcmp (str, "1") == 0) return 1;
10666   return 0;
10667 }
10668
10669 static int test_write_file_1 (void)
10670 {
10671   if (test_write_file_1_skip ()) {
10672     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10673     return 0;
10674   }
10675
10676   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10677   {
10678     char device[] = "/dev/sda";
10679     int r;
10680     suppress_error = 0;
10681     r = guestfs_blockdev_setrw (g, device);
10682     if (r == -1)
10683       return -1;
10684   }
10685   {
10686     int r;
10687     suppress_error = 0;
10688     r = guestfs_umount_all (g);
10689     if (r == -1)
10690       return -1;
10691   }
10692   {
10693     int r;
10694     suppress_error = 0;
10695     r = guestfs_lvm_remove_all (g);
10696     if (r == -1)
10697       return -1;
10698   }
10699   {
10700     char device[] = "/dev/sda";
10701     char lines_0[] = ",";
10702     char *lines[] = {
10703       lines_0,
10704       NULL
10705     };
10706     int r;
10707     suppress_error = 0;
10708     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10709     if (r == -1)
10710       return -1;
10711   }
10712   {
10713     char fstype[] = "ext2";
10714     char device[] = "/dev/sda1";
10715     int r;
10716     suppress_error = 0;
10717     r = guestfs_mkfs (g, fstype, device);
10718     if (r == -1)
10719       return -1;
10720   }
10721   {
10722     char device[] = "/dev/sda1";
10723     char mountpoint[] = "/";
10724     int r;
10725     suppress_error = 0;
10726     r = guestfs_mount (g, device, mountpoint);
10727     if (r == -1)
10728       return -1;
10729   }
10730   /* TestOutput for write_file (1) */
10731   char expected[] = "\nnew file contents\n";
10732   {
10733     char path[] = "/new";
10734     char content[] = "\nnew file contents\n";
10735     int r;
10736     suppress_error = 0;
10737     r = guestfs_write_file (g, path, content, 0);
10738     if (r == -1)
10739       return -1;
10740   }
10741   {
10742     char path[] = "/new";
10743     char *r;
10744     suppress_error = 0;
10745     r = guestfs_cat (g, path);
10746     if (r == NULL)
10747       return -1;
10748     if (strcmp (r, expected) != 0) {
10749       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10750       return -1;
10751     }
10752     free (r);
10753   }
10754   return 0;
10755 }
10756
10757 static int test_write_file_2_skip (void)
10758 {
10759   const char *str;
10760
10761   str = getenv ("SKIP_TEST_WRITE_FILE_2");
10762   if (str && strcmp (str, "1") == 0) return 1;
10763   str = getenv ("SKIP_TEST_WRITE_FILE");
10764   if (str && strcmp (str, "1") == 0) return 1;
10765   return 0;
10766 }
10767
10768 static int test_write_file_2 (void)
10769 {
10770   if (test_write_file_2_skip ()) {
10771     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10772     return 0;
10773   }
10774
10775   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10776   {
10777     char device[] = "/dev/sda";
10778     int r;
10779     suppress_error = 0;
10780     r = guestfs_blockdev_setrw (g, device);
10781     if (r == -1)
10782       return -1;
10783   }
10784   {
10785     int r;
10786     suppress_error = 0;
10787     r = guestfs_umount_all (g);
10788     if (r == -1)
10789       return -1;
10790   }
10791   {
10792     int r;
10793     suppress_error = 0;
10794     r = guestfs_lvm_remove_all (g);
10795     if (r == -1)
10796       return -1;
10797   }
10798   {
10799     char device[] = "/dev/sda";
10800     char lines_0[] = ",";
10801     char *lines[] = {
10802       lines_0,
10803       NULL
10804     };
10805     int r;
10806     suppress_error = 0;
10807     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10808     if (r == -1)
10809       return -1;
10810   }
10811   {
10812     char fstype[] = "ext2";
10813     char device[] = "/dev/sda1";
10814     int r;
10815     suppress_error = 0;
10816     r = guestfs_mkfs (g, fstype, device);
10817     if (r == -1)
10818       return -1;
10819   }
10820   {
10821     char device[] = "/dev/sda1";
10822     char mountpoint[] = "/";
10823     int r;
10824     suppress_error = 0;
10825     r = guestfs_mount (g, device, mountpoint);
10826     if (r == -1)
10827       return -1;
10828   }
10829   /* TestOutput for write_file (2) */
10830   char expected[] = "\n\n";
10831   {
10832     char path[] = "/new";
10833     char content[] = "\n\n";
10834     int r;
10835     suppress_error = 0;
10836     r = guestfs_write_file (g, path, content, 0);
10837     if (r == -1)
10838       return -1;
10839   }
10840   {
10841     char path[] = "/new";
10842     char *r;
10843     suppress_error = 0;
10844     r = guestfs_cat (g, path);
10845     if (r == NULL)
10846       return -1;
10847     if (strcmp (r, expected) != 0) {
10848       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
10849       return -1;
10850     }
10851     free (r);
10852   }
10853   return 0;
10854 }
10855
10856 static int test_write_file_3_skip (void)
10857 {
10858   const char *str;
10859
10860   str = getenv ("SKIP_TEST_WRITE_FILE_3");
10861   if (str && strcmp (str, "1") == 0) return 1;
10862   str = getenv ("SKIP_TEST_WRITE_FILE");
10863   if (str && strcmp (str, "1") == 0) return 1;
10864   return 0;
10865 }
10866
10867 static int test_write_file_3 (void)
10868 {
10869   if (test_write_file_3_skip ()) {
10870     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
10871     return 0;
10872   }
10873
10874   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
10875   {
10876     char device[] = "/dev/sda";
10877     int r;
10878     suppress_error = 0;
10879     r = guestfs_blockdev_setrw (g, device);
10880     if (r == -1)
10881       return -1;
10882   }
10883   {
10884     int r;
10885     suppress_error = 0;
10886     r = guestfs_umount_all (g);
10887     if (r == -1)
10888       return -1;
10889   }
10890   {
10891     int r;
10892     suppress_error = 0;
10893     r = guestfs_lvm_remove_all (g);
10894     if (r == -1)
10895       return -1;
10896   }
10897   {
10898     char device[] = "/dev/sda";
10899     char lines_0[] = ",";
10900     char *lines[] = {
10901       lines_0,
10902       NULL
10903     };
10904     int r;
10905     suppress_error = 0;
10906     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10907     if (r == -1)
10908       return -1;
10909   }
10910   {
10911     char fstype[] = "ext2";
10912     char device[] = "/dev/sda1";
10913     int r;
10914     suppress_error = 0;
10915     r = guestfs_mkfs (g, fstype, device);
10916     if (r == -1)
10917       return -1;
10918   }
10919   {
10920     char device[] = "/dev/sda1";
10921     char mountpoint[] = "/";
10922     int r;
10923     suppress_error = 0;
10924     r = guestfs_mount (g, device, mountpoint);
10925     if (r == -1)
10926       return -1;
10927   }
10928   /* TestOutput for write_file (3) */
10929   char expected[] = "";
10930   {
10931     char path[] = "/new";
10932     char content[] = "";
10933     int r;
10934     suppress_error = 0;
10935     r = guestfs_write_file (g, path, content, 0);
10936     if (r == -1)
10937       return -1;
10938   }
10939   {
10940     char path[] = "/new";
10941     char *r;
10942     suppress_error = 0;
10943     r = guestfs_cat (g, path);
10944     if (r == NULL)
10945       return -1;
10946     if (strcmp (r, expected) != 0) {
10947       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
10948       return -1;
10949     }
10950     free (r);
10951   }
10952   return 0;
10953 }
10954
10955 static int test_write_file_4_skip (void)
10956 {
10957   const char *str;
10958
10959   str = getenv ("SKIP_TEST_WRITE_FILE_4");
10960   if (str && strcmp (str, "1") == 0) return 1;
10961   str = getenv ("SKIP_TEST_WRITE_FILE");
10962   if (str && strcmp (str, "1") == 0) return 1;
10963   return 0;
10964 }
10965
10966 static int test_write_file_4 (void)
10967 {
10968   if (test_write_file_4_skip ()) {
10969     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
10970     return 0;
10971   }
10972
10973   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
10974   {
10975     char device[] = "/dev/sda";
10976     int r;
10977     suppress_error = 0;
10978     r = guestfs_blockdev_setrw (g, device);
10979     if (r == -1)
10980       return -1;
10981   }
10982   {
10983     int r;
10984     suppress_error = 0;
10985     r = guestfs_umount_all (g);
10986     if (r == -1)
10987       return -1;
10988   }
10989   {
10990     int r;
10991     suppress_error = 0;
10992     r = guestfs_lvm_remove_all (g);
10993     if (r == -1)
10994       return -1;
10995   }
10996   {
10997     char device[] = "/dev/sda";
10998     char lines_0[] = ",";
10999     char *lines[] = {
11000       lines_0,
11001       NULL
11002     };
11003     int r;
11004     suppress_error = 0;
11005     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11006     if (r == -1)
11007       return -1;
11008   }
11009   {
11010     char fstype[] = "ext2";
11011     char device[] = "/dev/sda1";
11012     int r;
11013     suppress_error = 0;
11014     r = guestfs_mkfs (g, fstype, device);
11015     if (r == -1)
11016       return -1;
11017   }
11018   {
11019     char device[] = "/dev/sda1";
11020     char mountpoint[] = "/";
11021     int r;
11022     suppress_error = 0;
11023     r = guestfs_mount (g, device, mountpoint);
11024     if (r == -1)
11025       return -1;
11026   }
11027   /* TestOutput for write_file (4) */
11028   char expected[] = "\n\n\n";
11029   {
11030     char path[] = "/new";
11031     char content[] = "\n\n\n";
11032     int r;
11033     suppress_error = 0;
11034     r = guestfs_write_file (g, path, content, 0);
11035     if (r == -1)
11036       return -1;
11037   }
11038   {
11039     char path[] = "/new";
11040     char *r;
11041     suppress_error = 0;
11042     r = guestfs_cat (g, path);
11043     if (r == NULL)
11044       return -1;
11045     if (strcmp (r, expected) != 0) {
11046       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11047       return -1;
11048     }
11049     free (r);
11050   }
11051   return 0;
11052 }
11053
11054 static int test_write_file_5_skip (void)
11055 {
11056   const char *str;
11057
11058   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11059   if (str && strcmp (str, "1") == 0) return 1;
11060   str = getenv ("SKIP_TEST_WRITE_FILE");
11061   if (str && strcmp (str, "1") == 0) return 1;
11062   return 0;
11063 }
11064
11065 static int test_write_file_5 (void)
11066 {
11067   if (test_write_file_5_skip ()) {
11068     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11069     return 0;
11070   }
11071
11072   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11073   {
11074     char device[] = "/dev/sda";
11075     int r;
11076     suppress_error = 0;
11077     r = guestfs_blockdev_setrw (g, device);
11078     if (r == -1)
11079       return -1;
11080   }
11081   {
11082     int r;
11083     suppress_error = 0;
11084     r = guestfs_umount_all (g);
11085     if (r == -1)
11086       return -1;
11087   }
11088   {
11089     int r;
11090     suppress_error = 0;
11091     r = guestfs_lvm_remove_all (g);
11092     if (r == -1)
11093       return -1;
11094   }
11095   {
11096     char device[] = "/dev/sda";
11097     char lines_0[] = ",";
11098     char *lines[] = {
11099       lines_0,
11100       NULL
11101     };
11102     int r;
11103     suppress_error = 0;
11104     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11105     if (r == -1)
11106       return -1;
11107   }
11108   {
11109     char fstype[] = "ext2";
11110     char device[] = "/dev/sda1";
11111     int r;
11112     suppress_error = 0;
11113     r = guestfs_mkfs (g, fstype, device);
11114     if (r == -1)
11115       return -1;
11116   }
11117   {
11118     char device[] = "/dev/sda1";
11119     char mountpoint[] = "/";
11120     int r;
11121     suppress_error = 0;
11122     r = guestfs_mount (g, device, mountpoint);
11123     if (r == -1)
11124       return -1;
11125   }
11126   /* TestOutput for write_file (5) */
11127   char expected[] = "\n";
11128   {
11129     char path[] = "/new";
11130     char content[] = "\n";
11131     int r;
11132     suppress_error = 0;
11133     r = guestfs_write_file (g, path, content, 0);
11134     if (r == -1)
11135       return -1;
11136   }
11137   {
11138     char path[] = "/new";
11139     char *r;
11140     suppress_error = 0;
11141     r = guestfs_cat (g, path);
11142     if (r == NULL)
11143       return -1;
11144     if (strcmp (r, expected) != 0) {
11145       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11146       return -1;
11147     }
11148     free (r);
11149   }
11150   return 0;
11151 }
11152
11153 static int test_mkfs_0_skip (void)
11154 {
11155   const char *str;
11156
11157   str = getenv ("SKIP_TEST_MKFS_0");
11158   if (str && strcmp (str, "1") == 0) return 1;
11159   str = getenv ("SKIP_TEST_MKFS");
11160   if (str && strcmp (str, "1") == 0) return 1;
11161   return 0;
11162 }
11163
11164 static int test_mkfs_0 (void)
11165 {
11166   if (test_mkfs_0_skip ()) {
11167     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11168     return 0;
11169   }
11170
11171   /* InitNone|InitEmpty for test_mkfs_0 */
11172   {
11173     char device[] = "/dev/sda";
11174     int r;
11175     suppress_error = 0;
11176     r = guestfs_blockdev_setrw (g, device);
11177     if (r == -1)
11178       return -1;
11179   }
11180   {
11181     int r;
11182     suppress_error = 0;
11183     r = guestfs_umount_all (g);
11184     if (r == -1)
11185       return -1;
11186   }
11187   {
11188     int r;
11189     suppress_error = 0;
11190     r = guestfs_lvm_remove_all (g);
11191     if (r == -1)
11192       return -1;
11193   }
11194   /* TestOutput for mkfs (0) */
11195   char expected[] = "new file contents";
11196   {
11197     char device[] = "/dev/sda";
11198     char lines_0[] = ",";
11199     char *lines[] = {
11200       lines_0,
11201       NULL
11202     };
11203     int r;
11204     suppress_error = 0;
11205     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11206     if (r == -1)
11207       return -1;
11208   }
11209   {
11210     char fstype[] = "ext2";
11211     char device[] = "/dev/sda1";
11212     int r;
11213     suppress_error = 0;
11214     r = guestfs_mkfs (g, fstype, device);
11215     if (r == -1)
11216       return -1;
11217   }
11218   {
11219     char device[] = "/dev/sda1";
11220     char mountpoint[] = "/";
11221     int r;
11222     suppress_error = 0;
11223     r = guestfs_mount (g, device, mountpoint);
11224     if (r == -1)
11225       return -1;
11226   }
11227   {
11228     char path[] = "/new";
11229     char content[] = "new file contents";
11230     int r;
11231     suppress_error = 0;
11232     r = guestfs_write_file (g, path, content, 0);
11233     if (r == -1)
11234       return -1;
11235   }
11236   {
11237     char path[] = "/new";
11238     char *r;
11239     suppress_error = 0;
11240     r = guestfs_cat (g, path);
11241     if (r == NULL)
11242       return -1;
11243     if (strcmp (r, expected) != 0) {
11244       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11245       return -1;
11246     }
11247     free (r);
11248   }
11249   return 0;
11250 }
11251
11252 static int test_lvcreate_0_skip (void)
11253 {
11254   const char *str;
11255
11256   str = getenv ("SKIP_TEST_LVCREATE_0");
11257   if (str && strcmp (str, "1") == 0) return 1;
11258   str = getenv ("SKIP_TEST_LVCREATE");
11259   if (str && strcmp (str, "1") == 0) return 1;
11260   return 0;
11261 }
11262
11263 static int test_lvcreate_0 (void)
11264 {
11265   if (test_lvcreate_0_skip ()) {
11266     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11267     return 0;
11268   }
11269
11270   /* InitNone|InitEmpty for test_lvcreate_0 */
11271   {
11272     char device[] = "/dev/sda";
11273     int r;
11274     suppress_error = 0;
11275     r = guestfs_blockdev_setrw (g, device);
11276     if (r == -1)
11277       return -1;
11278   }
11279   {
11280     int r;
11281     suppress_error = 0;
11282     r = guestfs_umount_all (g);
11283     if (r == -1)
11284       return -1;
11285   }
11286   {
11287     int r;
11288     suppress_error = 0;
11289     r = guestfs_lvm_remove_all (g);
11290     if (r == -1)
11291       return -1;
11292   }
11293   /* TestOutputList for lvcreate (0) */
11294   {
11295     char device[] = "/dev/sda";
11296     char lines_0[] = ",10";
11297     char lines_1[] = ",20";
11298     char lines_2[] = ",";
11299     char *lines[] = {
11300       lines_0,
11301       lines_1,
11302       lines_2,
11303       NULL
11304     };
11305     int r;
11306     suppress_error = 0;
11307     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11308     if (r == -1)
11309       return -1;
11310   }
11311   {
11312     char device[] = "/dev/sda1";
11313     int r;
11314     suppress_error = 0;
11315     r = guestfs_pvcreate (g, device);
11316     if (r == -1)
11317       return -1;
11318   }
11319   {
11320     char device[] = "/dev/sda2";
11321     int r;
11322     suppress_error = 0;
11323     r = guestfs_pvcreate (g, device);
11324     if (r == -1)
11325       return -1;
11326   }
11327   {
11328     char device[] = "/dev/sda3";
11329     int r;
11330     suppress_error = 0;
11331     r = guestfs_pvcreate (g, device);
11332     if (r == -1)
11333       return -1;
11334   }
11335   {
11336     char volgroup[] = "VG1";
11337     char physvols_0[] = "/dev/sda1";
11338     char physvols_1[] = "/dev/sda2";
11339     char *physvols[] = {
11340       physvols_0,
11341       physvols_1,
11342       NULL
11343     };
11344     int r;
11345     suppress_error = 0;
11346     r = guestfs_vgcreate (g, volgroup, physvols);
11347     if (r == -1)
11348       return -1;
11349   }
11350   {
11351     char volgroup[] = "VG2";
11352     char physvols_0[] = "/dev/sda3";
11353     char *physvols[] = {
11354       physvols_0,
11355       NULL
11356     };
11357     int r;
11358     suppress_error = 0;
11359     r = guestfs_vgcreate (g, volgroup, physvols);
11360     if (r == -1)
11361       return -1;
11362   }
11363   {
11364     char logvol[] = "LV1";
11365     char volgroup[] = "VG1";
11366     int r;
11367     suppress_error = 0;
11368     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11369     if (r == -1)
11370       return -1;
11371   }
11372   {
11373     char logvol[] = "LV2";
11374     char volgroup[] = "VG1";
11375     int r;
11376     suppress_error = 0;
11377     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11378     if (r == -1)
11379       return -1;
11380   }
11381   {
11382     char logvol[] = "LV3";
11383     char volgroup[] = "VG2";
11384     int r;
11385     suppress_error = 0;
11386     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11387     if (r == -1)
11388       return -1;
11389   }
11390   {
11391     char logvol[] = "LV4";
11392     char volgroup[] = "VG2";
11393     int r;
11394     suppress_error = 0;
11395     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11396     if (r == -1)
11397       return -1;
11398   }
11399   {
11400     char logvol[] = "LV5";
11401     char volgroup[] = "VG2";
11402     int r;
11403     suppress_error = 0;
11404     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11405     if (r == -1)
11406       return -1;
11407   }
11408   {
11409     char **r;
11410     int i;
11411     suppress_error = 0;
11412     r = guestfs_lvs (g);
11413     if (r == NULL)
11414       return -1;
11415     if (!r[0]) {
11416       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11417       print_strings (r);
11418       return -1;
11419     }
11420     {
11421       char expected[] = "/dev/VG1/LV1";
11422       if (strcmp (r[0], expected) != 0) {
11423         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11424         return -1;
11425       }
11426     }
11427     if (!r[1]) {
11428       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11429       print_strings (r);
11430       return -1;
11431     }
11432     {
11433       char expected[] = "/dev/VG1/LV2";
11434       if (strcmp (r[1], expected) != 0) {
11435         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11436         return -1;
11437       }
11438     }
11439     if (!r[2]) {
11440       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11441       print_strings (r);
11442       return -1;
11443     }
11444     {
11445       char expected[] = "/dev/VG2/LV3";
11446       if (strcmp (r[2], expected) != 0) {
11447         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11448         return -1;
11449       }
11450     }
11451     if (!r[3]) {
11452       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11453       print_strings (r);
11454       return -1;
11455     }
11456     {
11457       char expected[] = "/dev/VG2/LV4";
11458       if (strcmp (r[3], expected) != 0) {
11459         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11460         return -1;
11461       }
11462     }
11463     if (!r[4]) {
11464       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11465       print_strings (r);
11466       return -1;
11467     }
11468     {
11469       char expected[] = "/dev/VG2/LV5";
11470       if (strcmp (r[4], expected) != 0) {
11471         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11472         return -1;
11473       }
11474     }
11475     if (r[5] != NULL) {
11476       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11477       print_strings (r);
11478       return -1;
11479     }
11480     for (i = 0; r[i] != NULL; ++i)
11481       free (r[i]);
11482     free (r);
11483   }
11484   return 0;
11485 }
11486
11487 static int test_vgcreate_0_skip (void)
11488 {
11489   const char *str;
11490
11491   str = getenv ("SKIP_TEST_VGCREATE_0");
11492   if (str && strcmp (str, "1") == 0) return 1;
11493   str = getenv ("SKIP_TEST_VGCREATE");
11494   if (str && strcmp (str, "1") == 0) return 1;
11495   return 0;
11496 }
11497
11498 static int test_vgcreate_0 (void)
11499 {
11500   if (test_vgcreate_0_skip ()) {
11501     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11502     return 0;
11503   }
11504
11505   /* InitNone|InitEmpty for test_vgcreate_0 */
11506   {
11507     char device[] = "/dev/sda";
11508     int r;
11509     suppress_error = 0;
11510     r = guestfs_blockdev_setrw (g, device);
11511     if (r == -1)
11512       return -1;
11513   }
11514   {
11515     int r;
11516     suppress_error = 0;
11517     r = guestfs_umount_all (g);
11518     if (r == -1)
11519       return -1;
11520   }
11521   {
11522     int r;
11523     suppress_error = 0;
11524     r = guestfs_lvm_remove_all (g);
11525     if (r == -1)
11526       return -1;
11527   }
11528   /* TestOutputList for vgcreate (0) */
11529   {
11530     char device[] = "/dev/sda";
11531     char lines_0[] = ",10";
11532     char lines_1[] = ",20";
11533     char lines_2[] = ",";
11534     char *lines[] = {
11535       lines_0,
11536       lines_1,
11537       lines_2,
11538       NULL
11539     };
11540     int r;
11541     suppress_error = 0;
11542     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11543     if (r == -1)
11544       return -1;
11545   }
11546   {
11547     char device[] = "/dev/sda1";
11548     int r;
11549     suppress_error = 0;
11550     r = guestfs_pvcreate (g, device);
11551     if (r == -1)
11552       return -1;
11553   }
11554   {
11555     char device[] = "/dev/sda2";
11556     int r;
11557     suppress_error = 0;
11558     r = guestfs_pvcreate (g, device);
11559     if (r == -1)
11560       return -1;
11561   }
11562   {
11563     char device[] = "/dev/sda3";
11564     int r;
11565     suppress_error = 0;
11566     r = guestfs_pvcreate (g, device);
11567     if (r == -1)
11568       return -1;
11569   }
11570   {
11571     char volgroup[] = "VG1";
11572     char physvols_0[] = "/dev/sda1";
11573     char physvols_1[] = "/dev/sda2";
11574     char *physvols[] = {
11575       physvols_0,
11576       physvols_1,
11577       NULL
11578     };
11579     int r;
11580     suppress_error = 0;
11581     r = guestfs_vgcreate (g, volgroup, physvols);
11582     if (r == -1)
11583       return -1;
11584   }
11585   {
11586     char volgroup[] = "VG2";
11587     char physvols_0[] = "/dev/sda3";
11588     char *physvols[] = {
11589       physvols_0,
11590       NULL
11591     };
11592     int r;
11593     suppress_error = 0;
11594     r = guestfs_vgcreate (g, volgroup, physvols);
11595     if (r == -1)
11596       return -1;
11597   }
11598   {
11599     char **r;
11600     int i;
11601     suppress_error = 0;
11602     r = guestfs_vgs (g);
11603     if (r == NULL)
11604       return -1;
11605     if (!r[0]) {
11606       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11607       print_strings (r);
11608       return -1;
11609     }
11610     {
11611       char expected[] = "VG1";
11612       if (strcmp (r[0], expected) != 0) {
11613         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11614         return -1;
11615       }
11616     }
11617     if (!r[1]) {
11618       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11619       print_strings (r);
11620       return -1;
11621     }
11622     {
11623       char expected[] = "VG2";
11624       if (strcmp (r[1], expected) != 0) {
11625         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11626         return -1;
11627       }
11628     }
11629     if (r[2] != NULL) {
11630       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11631       print_strings (r);
11632       return -1;
11633     }
11634     for (i = 0; r[i] != NULL; ++i)
11635       free (r[i]);
11636     free (r);
11637   }
11638   return 0;
11639 }
11640
11641 static int test_pvcreate_0_skip (void)
11642 {
11643   const char *str;
11644
11645   str = getenv ("SKIP_TEST_PVCREATE_0");
11646   if (str && strcmp (str, "1") == 0) return 1;
11647   str = getenv ("SKIP_TEST_PVCREATE");
11648   if (str && strcmp (str, "1") == 0) return 1;
11649   return 0;
11650 }
11651
11652 static int test_pvcreate_0 (void)
11653 {
11654   if (test_pvcreate_0_skip ()) {
11655     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11656     return 0;
11657   }
11658
11659   /* InitNone|InitEmpty for test_pvcreate_0 */
11660   {
11661     char device[] = "/dev/sda";
11662     int r;
11663     suppress_error = 0;
11664     r = guestfs_blockdev_setrw (g, device);
11665     if (r == -1)
11666       return -1;
11667   }
11668   {
11669     int r;
11670     suppress_error = 0;
11671     r = guestfs_umount_all (g);
11672     if (r == -1)
11673       return -1;
11674   }
11675   {
11676     int r;
11677     suppress_error = 0;
11678     r = guestfs_lvm_remove_all (g);
11679     if (r == -1)
11680       return -1;
11681   }
11682   /* TestOutputListOfDevices for pvcreate (0) */
11683   {
11684     char device[] = "/dev/sda";
11685     char lines_0[] = ",10";
11686     char lines_1[] = ",20";
11687     char lines_2[] = ",";
11688     char *lines[] = {
11689       lines_0,
11690       lines_1,
11691       lines_2,
11692       NULL
11693     };
11694     int r;
11695     suppress_error = 0;
11696     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11697     if (r == -1)
11698       return -1;
11699   }
11700   {
11701     char device[] = "/dev/sda1";
11702     int r;
11703     suppress_error = 0;
11704     r = guestfs_pvcreate (g, device);
11705     if (r == -1)
11706       return -1;
11707   }
11708   {
11709     char device[] = "/dev/sda2";
11710     int r;
11711     suppress_error = 0;
11712     r = guestfs_pvcreate (g, device);
11713     if (r == -1)
11714       return -1;
11715   }
11716   {
11717     char device[] = "/dev/sda3";
11718     int r;
11719     suppress_error = 0;
11720     r = guestfs_pvcreate (g, device);
11721     if (r == -1)
11722       return -1;
11723   }
11724   {
11725     char **r;
11726     int i;
11727     suppress_error = 0;
11728     r = guestfs_pvs (g);
11729     if (r == NULL)
11730       return -1;
11731     if (!r[0]) {
11732       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11733       print_strings (r);
11734       return -1;
11735     }
11736     {
11737       char expected[] = "/dev/sda1";
11738       r[0][5] = 's';
11739       if (strcmp (r[0], expected) != 0) {
11740         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11741         return -1;
11742       }
11743     }
11744     if (!r[1]) {
11745       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11746       print_strings (r);
11747       return -1;
11748     }
11749     {
11750       char expected[] = "/dev/sda2";
11751       r[1][5] = 's';
11752       if (strcmp (r[1], expected) != 0) {
11753         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11754         return -1;
11755       }
11756     }
11757     if (!r[2]) {
11758       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11759       print_strings (r);
11760       return -1;
11761     }
11762     {
11763       char expected[] = "/dev/sda3";
11764       r[2][5] = 's';
11765       if (strcmp (r[2], expected) != 0) {
11766         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11767         return -1;
11768       }
11769     }
11770     if (r[3] != NULL) {
11771       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
11772       print_strings (r);
11773       return -1;
11774     }
11775     for (i = 0; r[i] != NULL; ++i)
11776       free (r[i]);
11777     free (r);
11778   }
11779   return 0;
11780 }
11781
11782 static int test_is_dir_0_skip (void)
11783 {
11784   const char *str;
11785
11786   str = getenv ("SKIP_TEST_IS_DIR_0");
11787   if (str && strcmp (str, "1") == 0) return 1;
11788   str = getenv ("SKIP_TEST_IS_DIR");
11789   if (str && strcmp (str, "1") == 0) return 1;
11790   return 0;
11791 }
11792
11793 static int test_is_dir_0 (void)
11794 {
11795   if (test_is_dir_0_skip ()) {
11796     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
11797     return 0;
11798   }
11799
11800   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
11801   {
11802     char device[] = "/dev/sda";
11803     int r;
11804     suppress_error = 0;
11805     r = guestfs_blockdev_setrw (g, device);
11806     if (r == -1)
11807       return -1;
11808   }
11809   {
11810     int r;
11811     suppress_error = 0;
11812     r = guestfs_umount_all (g);
11813     if (r == -1)
11814       return -1;
11815   }
11816   {
11817     int r;
11818     suppress_error = 0;
11819     r = guestfs_lvm_remove_all (g);
11820     if (r == -1)
11821       return -1;
11822   }
11823   {
11824     char device[] = "/dev/sda";
11825     char lines_0[] = ",";
11826     char *lines[] = {
11827       lines_0,
11828       NULL
11829     };
11830     int r;
11831     suppress_error = 0;
11832     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11833     if (r == -1)
11834       return -1;
11835   }
11836   {
11837     char fstype[] = "ext2";
11838     char device[] = "/dev/sda1";
11839     int r;
11840     suppress_error = 0;
11841     r = guestfs_mkfs (g, fstype, device);
11842     if (r == -1)
11843       return -1;
11844   }
11845   {
11846     char device[] = "/dev/sda1";
11847     char mountpoint[] = "/";
11848     int r;
11849     suppress_error = 0;
11850     r = guestfs_mount (g, device, mountpoint);
11851     if (r == -1)
11852       return -1;
11853   }
11854   /* TestOutputFalse for is_dir (0) */
11855   {
11856     char path[] = "/new";
11857     int r;
11858     suppress_error = 0;
11859     r = guestfs_touch (g, path);
11860     if (r == -1)
11861       return -1;
11862   }
11863   {
11864     char path[] = "/new";
11865     int r;
11866     suppress_error = 0;
11867     r = guestfs_is_dir (g, path);
11868     if (r == -1)
11869       return -1;
11870     if (r) {
11871       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
11872       return -1;
11873     }
11874   }
11875   return 0;
11876 }
11877
11878 static int test_is_dir_1_skip (void)
11879 {
11880   const char *str;
11881
11882   str = getenv ("SKIP_TEST_IS_DIR_1");
11883   if (str && strcmp (str, "1") == 0) return 1;
11884   str = getenv ("SKIP_TEST_IS_DIR");
11885   if (str && strcmp (str, "1") == 0) return 1;
11886   return 0;
11887 }
11888
11889 static int test_is_dir_1 (void)
11890 {
11891   if (test_is_dir_1_skip ()) {
11892     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
11893     return 0;
11894   }
11895
11896   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
11897   {
11898     char device[] = "/dev/sda";
11899     int r;
11900     suppress_error = 0;
11901     r = guestfs_blockdev_setrw (g, device);
11902     if (r == -1)
11903       return -1;
11904   }
11905   {
11906     int r;
11907     suppress_error = 0;
11908     r = guestfs_umount_all (g);
11909     if (r == -1)
11910       return -1;
11911   }
11912   {
11913     int r;
11914     suppress_error = 0;
11915     r = guestfs_lvm_remove_all (g);
11916     if (r == -1)
11917       return -1;
11918   }
11919   {
11920     char device[] = "/dev/sda";
11921     char lines_0[] = ",";
11922     char *lines[] = {
11923       lines_0,
11924       NULL
11925     };
11926     int r;
11927     suppress_error = 0;
11928     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11929     if (r == -1)
11930       return -1;
11931   }
11932   {
11933     char fstype[] = "ext2";
11934     char device[] = "/dev/sda1";
11935     int r;
11936     suppress_error = 0;
11937     r = guestfs_mkfs (g, fstype, device);
11938     if (r == -1)
11939       return -1;
11940   }
11941   {
11942     char device[] = "/dev/sda1";
11943     char mountpoint[] = "/";
11944     int r;
11945     suppress_error = 0;
11946     r = guestfs_mount (g, device, mountpoint);
11947     if (r == -1)
11948       return -1;
11949   }
11950   /* TestOutputTrue for is_dir (1) */
11951   {
11952     char path[] = "/new";
11953     int r;
11954     suppress_error = 0;
11955     r = guestfs_mkdir (g, path);
11956     if (r == -1)
11957       return -1;
11958   }
11959   {
11960     char path[] = "/new";
11961     int r;
11962     suppress_error = 0;
11963     r = guestfs_is_dir (g, path);
11964     if (r == -1)
11965       return -1;
11966     if (!r) {
11967       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
11968       return -1;
11969     }
11970   }
11971   return 0;
11972 }
11973
11974 static int test_is_file_0_skip (void)
11975 {
11976   const char *str;
11977
11978   str = getenv ("SKIP_TEST_IS_FILE_0");
11979   if (str && strcmp (str, "1") == 0) return 1;
11980   str = getenv ("SKIP_TEST_IS_FILE");
11981   if (str && strcmp (str, "1") == 0) return 1;
11982   return 0;
11983 }
11984
11985 static int test_is_file_0 (void)
11986 {
11987   if (test_is_file_0_skip ()) {
11988     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
11989     return 0;
11990   }
11991
11992   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
11993   {
11994     char device[] = "/dev/sda";
11995     int r;
11996     suppress_error = 0;
11997     r = guestfs_blockdev_setrw (g, device);
11998     if (r == -1)
11999       return -1;
12000   }
12001   {
12002     int r;
12003     suppress_error = 0;
12004     r = guestfs_umount_all (g);
12005     if (r == -1)
12006       return -1;
12007   }
12008   {
12009     int r;
12010     suppress_error = 0;
12011     r = guestfs_lvm_remove_all (g);
12012     if (r == -1)
12013       return -1;
12014   }
12015   {
12016     char device[] = "/dev/sda";
12017     char lines_0[] = ",";
12018     char *lines[] = {
12019       lines_0,
12020       NULL
12021     };
12022     int r;
12023     suppress_error = 0;
12024     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12025     if (r == -1)
12026       return -1;
12027   }
12028   {
12029     char fstype[] = "ext2";
12030     char device[] = "/dev/sda1";
12031     int r;
12032     suppress_error = 0;
12033     r = guestfs_mkfs (g, fstype, device);
12034     if (r == -1)
12035       return -1;
12036   }
12037   {
12038     char device[] = "/dev/sda1";
12039     char mountpoint[] = "/";
12040     int r;
12041     suppress_error = 0;
12042     r = guestfs_mount (g, device, mountpoint);
12043     if (r == -1)
12044       return -1;
12045   }
12046   /* TestOutputTrue for is_file (0) */
12047   {
12048     char path[] = "/new";
12049     int r;
12050     suppress_error = 0;
12051     r = guestfs_touch (g, path);
12052     if (r == -1)
12053       return -1;
12054   }
12055   {
12056     char path[] = "/new";
12057     int r;
12058     suppress_error = 0;
12059     r = guestfs_is_file (g, path);
12060     if (r == -1)
12061       return -1;
12062     if (!r) {
12063       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12064       return -1;
12065     }
12066   }
12067   return 0;
12068 }
12069
12070 static int test_is_file_1_skip (void)
12071 {
12072   const char *str;
12073
12074   str = getenv ("SKIP_TEST_IS_FILE_1");
12075   if (str && strcmp (str, "1") == 0) return 1;
12076   str = getenv ("SKIP_TEST_IS_FILE");
12077   if (str && strcmp (str, "1") == 0) return 1;
12078   return 0;
12079 }
12080
12081 static int test_is_file_1 (void)
12082 {
12083   if (test_is_file_1_skip ()) {
12084     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12085     return 0;
12086   }
12087
12088   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12089   {
12090     char device[] = "/dev/sda";
12091     int r;
12092     suppress_error = 0;
12093     r = guestfs_blockdev_setrw (g, device);
12094     if (r == -1)
12095       return -1;
12096   }
12097   {
12098     int r;
12099     suppress_error = 0;
12100     r = guestfs_umount_all (g);
12101     if (r == -1)
12102       return -1;
12103   }
12104   {
12105     int r;
12106     suppress_error = 0;
12107     r = guestfs_lvm_remove_all (g);
12108     if (r == -1)
12109       return -1;
12110   }
12111   {
12112     char device[] = "/dev/sda";
12113     char lines_0[] = ",";
12114     char *lines[] = {
12115       lines_0,
12116       NULL
12117     };
12118     int r;
12119     suppress_error = 0;
12120     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12121     if (r == -1)
12122       return -1;
12123   }
12124   {
12125     char fstype[] = "ext2";
12126     char device[] = "/dev/sda1";
12127     int r;
12128     suppress_error = 0;
12129     r = guestfs_mkfs (g, fstype, device);
12130     if (r == -1)
12131       return -1;
12132   }
12133   {
12134     char device[] = "/dev/sda1";
12135     char mountpoint[] = "/";
12136     int r;
12137     suppress_error = 0;
12138     r = guestfs_mount (g, device, mountpoint);
12139     if (r == -1)
12140       return -1;
12141   }
12142   /* TestOutputFalse for is_file (1) */
12143   {
12144     char path[] = "/new";
12145     int r;
12146     suppress_error = 0;
12147     r = guestfs_mkdir (g, path);
12148     if (r == -1)
12149       return -1;
12150   }
12151   {
12152     char path[] = "/new";
12153     int r;
12154     suppress_error = 0;
12155     r = guestfs_is_file (g, path);
12156     if (r == -1)
12157       return -1;
12158     if (r) {
12159       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12160       return -1;
12161     }
12162   }
12163   return 0;
12164 }
12165
12166 static int test_exists_0_skip (void)
12167 {
12168   const char *str;
12169
12170   str = getenv ("SKIP_TEST_EXISTS_0");
12171   if (str && strcmp (str, "1") == 0) return 1;
12172   str = getenv ("SKIP_TEST_EXISTS");
12173   if (str && strcmp (str, "1") == 0) return 1;
12174   return 0;
12175 }
12176
12177 static int test_exists_0 (void)
12178 {
12179   if (test_exists_0_skip ()) {
12180     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12181     return 0;
12182   }
12183
12184   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12185   {
12186     char device[] = "/dev/sda";
12187     int r;
12188     suppress_error = 0;
12189     r = guestfs_blockdev_setrw (g, device);
12190     if (r == -1)
12191       return -1;
12192   }
12193   {
12194     int r;
12195     suppress_error = 0;
12196     r = guestfs_umount_all (g);
12197     if (r == -1)
12198       return -1;
12199   }
12200   {
12201     int r;
12202     suppress_error = 0;
12203     r = guestfs_lvm_remove_all (g);
12204     if (r == -1)
12205       return -1;
12206   }
12207   {
12208     char device[] = "/dev/sda";
12209     char lines_0[] = ",";
12210     char *lines[] = {
12211       lines_0,
12212       NULL
12213     };
12214     int r;
12215     suppress_error = 0;
12216     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12217     if (r == -1)
12218       return -1;
12219   }
12220   {
12221     char fstype[] = "ext2";
12222     char device[] = "/dev/sda1";
12223     int r;
12224     suppress_error = 0;
12225     r = guestfs_mkfs (g, fstype, device);
12226     if (r == -1)
12227       return -1;
12228   }
12229   {
12230     char device[] = "/dev/sda1";
12231     char mountpoint[] = "/";
12232     int r;
12233     suppress_error = 0;
12234     r = guestfs_mount (g, device, mountpoint);
12235     if (r == -1)
12236       return -1;
12237   }
12238   /* TestOutputTrue for exists (0) */
12239   {
12240     char path[] = "/new";
12241     int r;
12242     suppress_error = 0;
12243     r = guestfs_touch (g, path);
12244     if (r == -1)
12245       return -1;
12246   }
12247   {
12248     char path[] = "/new";
12249     int r;
12250     suppress_error = 0;
12251     r = guestfs_exists (g, path);
12252     if (r == -1)
12253       return -1;
12254     if (!r) {
12255       fprintf (stderr, "test_exists_0: expected true, got false\n");
12256       return -1;
12257     }
12258   }
12259   return 0;
12260 }
12261
12262 static int test_exists_1_skip (void)
12263 {
12264   const char *str;
12265
12266   str = getenv ("SKIP_TEST_EXISTS_1");
12267   if (str && strcmp (str, "1") == 0) return 1;
12268   str = getenv ("SKIP_TEST_EXISTS");
12269   if (str && strcmp (str, "1") == 0) return 1;
12270   return 0;
12271 }
12272
12273 static int test_exists_1 (void)
12274 {
12275   if (test_exists_1_skip ()) {
12276     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12277     return 0;
12278   }
12279
12280   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12281   {
12282     char device[] = "/dev/sda";
12283     int r;
12284     suppress_error = 0;
12285     r = guestfs_blockdev_setrw (g, device);
12286     if (r == -1)
12287       return -1;
12288   }
12289   {
12290     int r;
12291     suppress_error = 0;
12292     r = guestfs_umount_all (g);
12293     if (r == -1)
12294       return -1;
12295   }
12296   {
12297     int r;
12298     suppress_error = 0;
12299     r = guestfs_lvm_remove_all (g);
12300     if (r == -1)
12301       return -1;
12302   }
12303   {
12304     char device[] = "/dev/sda";
12305     char lines_0[] = ",";
12306     char *lines[] = {
12307       lines_0,
12308       NULL
12309     };
12310     int r;
12311     suppress_error = 0;
12312     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12313     if (r == -1)
12314       return -1;
12315   }
12316   {
12317     char fstype[] = "ext2";
12318     char device[] = "/dev/sda1";
12319     int r;
12320     suppress_error = 0;
12321     r = guestfs_mkfs (g, fstype, device);
12322     if (r == -1)
12323       return -1;
12324   }
12325   {
12326     char device[] = "/dev/sda1";
12327     char mountpoint[] = "/";
12328     int r;
12329     suppress_error = 0;
12330     r = guestfs_mount (g, device, mountpoint);
12331     if (r == -1)
12332       return -1;
12333   }
12334   /* TestOutputTrue for exists (1) */
12335   {
12336     char path[] = "/new";
12337     int r;
12338     suppress_error = 0;
12339     r = guestfs_mkdir (g, path);
12340     if (r == -1)
12341       return -1;
12342   }
12343   {
12344     char path[] = "/new";
12345     int r;
12346     suppress_error = 0;
12347     r = guestfs_exists (g, path);
12348     if (r == -1)
12349       return -1;
12350     if (!r) {
12351       fprintf (stderr, "test_exists_1: expected true, got false\n");
12352       return -1;
12353     }
12354   }
12355   return 0;
12356 }
12357
12358 static int test_mkdir_p_0_skip (void)
12359 {
12360   const char *str;
12361
12362   str = getenv ("SKIP_TEST_MKDIR_P_0");
12363   if (str && strcmp (str, "1") == 0) return 1;
12364   str = getenv ("SKIP_TEST_MKDIR_P");
12365   if (str && strcmp (str, "1") == 0) return 1;
12366   return 0;
12367 }
12368
12369 static int test_mkdir_p_0 (void)
12370 {
12371   if (test_mkdir_p_0_skip ()) {
12372     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12373     return 0;
12374   }
12375
12376   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12377   {
12378     char device[] = "/dev/sda";
12379     int r;
12380     suppress_error = 0;
12381     r = guestfs_blockdev_setrw (g, device);
12382     if (r == -1)
12383       return -1;
12384   }
12385   {
12386     int r;
12387     suppress_error = 0;
12388     r = guestfs_umount_all (g);
12389     if (r == -1)
12390       return -1;
12391   }
12392   {
12393     int r;
12394     suppress_error = 0;
12395     r = guestfs_lvm_remove_all (g);
12396     if (r == -1)
12397       return -1;
12398   }
12399   {
12400     char device[] = "/dev/sda";
12401     char lines_0[] = ",";
12402     char *lines[] = {
12403       lines_0,
12404       NULL
12405     };
12406     int r;
12407     suppress_error = 0;
12408     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12409     if (r == -1)
12410       return -1;
12411   }
12412   {
12413     char fstype[] = "ext2";
12414     char device[] = "/dev/sda1";
12415     int r;
12416     suppress_error = 0;
12417     r = guestfs_mkfs (g, fstype, device);
12418     if (r == -1)
12419       return -1;
12420   }
12421   {
12422     char device[] = "/dev/sda1";
12423     char mountpoint[] = "/";
12424     int r;
12425     suppress_error = 0;
12426     r = guestfs_mount (g, device, mountpoint);
12427     if (r == -1)
12428       return -1;
12429   }
12430   /* TestOutputTrue for mkdir_p (0) */
12431   {
12432     char path[] = "/new/foo/bar";
12433     int r;
12434     suppress_error = 0;
12435     r = guestfs_mkdir_p (g, path);
12436     if (r == -1)
12437       return -1;
12438   }
12439   {
12440     char path[] = "/new/foo/bar";
12441     int r;
12442     suppress_error = 0;
12443     r = guestfs_is_dir (g, path);
12444     if (r == -1)
12445       return -1;
12446     if (!r) {
12447       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12448       return -1;
12449     }
12450   }
12451   return 0;
12452 }
12453
12454 static int test_mkdir_p_1_skip (void)
12455 {
12456   const char *str;
12457
12458   str = getenv ("SKIP_TEST_MKDIR_P_1");
12459   if (str && strcmp (str, "1") == 0) return 1;
12460   str = getenv ("SKIP_TEST_MKDIR_P");
12461   if (str && strcmp (str, "1") == 0) return 1;
12462   return 0;
12463 }
12464
12465 static int test_mkdir_p_1 (void)
12466 {
12467   if (test_mkdir_p_1_skip ()) {
12468     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12469     return 0;
12470   }
12471
12472   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12473   {
12474     char device[] = "/dev/sda";
12475     int r;
12476     suppress_error = 0;
12477     r = guestfs_blockdev_setrw (g, device);
12478     if (r == -1)
12479       return -1;
12480   }
12481   {
12482     int r;
12483     suppress_error = 0;
12484     r = guestfs_umount_all (g);
12485     if (r == -1)
12486       return -1;
12487   }
12488   {
12489     int r;
12490     suppress_error = 0;
12491     r = guestfs_lvm_remove_all (g);
12492     if (r == -1)
12493       return -1;
12494   }
12495   {
12496     char device[] = "/dev/sda";
12497     char lines_0[] = ",";
12498     char *lines[] = {
12499       lines_0,
12500       NULL
12501     };
12502     int r;
12503     suppress_error = 0;
12504     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12505     if (r == -1)
12506       return -1;
12507   }
12508   {
12509     char fstype[] = "ext2";
12510     char device[] = "/dev/sda1";
12511     int r;
12512     suppress_error = 0;
12513     r = guestfs_mkfs (g, fstype, device);
12514     if (r == -1)
12515       return -1;
12516   }
12517   {
12518     char device[] = "/dev/sda1";
12519     char mountpoint[] = "/";
12520     int r;
12521     suppress_error = 0;
12522     r = guestfs_mount (g, device, mountpoint);
12523     if (r == -1)
12524       return -1;
12525   }
12526   /* TestOutputTrue for mkdir_p (1) */
12527   {
12528     char path[] = "/new/foo/bar";
12529     int r;
12530     suppress_error = 0;
12531     r = guestfs_mkdir_p (g, path);
12532     if (r == -1)
12533       return -1;
12534   }
12535   {
12536     char path[] = "/new/foo";
12537     int r;
12538     suppress_error = 0;
12539     r = guestfs_is_dir (g, path);
12540     if (r == -1)
12541       return -1;
12542     if (!r) {
12543       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12544       return -1;
12545     }
12546   }
12547   return 0;
12548 }
12549
12550 static int test_mkdir_p_2_skip (void)
12551 {
12552   const char *str;
12553
12554   str = getenv ("SKIP_TEST_MKDIR_P_2");
12555   if (str && strcmp (str, "1") == 0) return 1;
12556   str = getenv ("SKIP_TEST_MKDIR_P");
12557   if (str && strcmp (str, "1") == 0) return 1;
12558   return 0;
12559 }
12560
12561 static int test_mkdir_p_2 (void)
12562 {
12563   if (test_mkdir_p_2_skip ()) {
12564     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12565     return 0;
12566   }
12567
12568   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12569   {
12570     char device[] = "/dev/sda";
12571     int r;
12572     suppress_error = 0;
12573     r = guestfs_blockdev_setrw (g, device);
12574     if (r == -1)
12575       return -1;
12576   }
12577   {
12578     int r;
12579     suppress_error = 0;
12580     r = guestfs_umount_all (g);
12581     if (r == -1)
12582       return -1;
12583   }
12584   {
12585     int r;
12586     suppress_error = 0;
12587     r = guestfs_lvm_remove_all (g);
12588     if (r == -1)
12589       return -1;
12590   }
12591   {
12592     char device[] = "/dev/sda";
12593     char lines_0[] = ",";
12594     char *lines[] = {
12595       lines_0,
12596       NULL
12597     };
12598     int r;
12599     suppress_error = 0;
12600     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12601     if (r == -1)
12602       return -1;
12603   }
12604   {
12605     char fstype[] = "ext2";
12606     char device[] = "/dev/sda1";
12607     int r;
12608     suppress_error = 0;
12609     r = guestfs_mkfs (g, fstype, device);
12610     if (r == -1)
12611       return -1;
12612   }
12613   {
12614     char device[] = "/dev/sda1";
12615     char mountpoint[] = "/";
12616     int r;
12617     suppress_error = 0;
12618     r = guestfs_mount (g, device, mountpoint);
12619     if (r == -1)
12620       return -1;
12621   }
12622   /* TestOutputTrue for mkdir_p (2) */
12623   {
12624     char path[] = "/new/foo/bar";
12625     int r;
12626     suppress_error = 0;
12627     r = guestfs_mkdir_p (g, path);
12628     if (r == -1)
12629       return -1;
12630   }
12631   {
12632     char path[] = "/new";
12633     int r;
12634     suppress_error = 0;
12635     r = guestfs_is_dir (g, path);
12636     if (r == -1)
12637       return -1;
12638     if (!r) {
12639       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12640       return -1;
12641     }
12642   }
12643   return 0;
12644 }
12645
12646 static int test_mkdir_p_3_skip (void)
12647 {
12648   const char *str;
12649
12650   str = getenv ("SKIP_TEST_MKDIR_P_3");
12651   if (str && strcmp (str, "1") == 0) return 1;
12652   str = getenv ("SKIP_TEST_MKDIR_P");
12653   if (str && strcmp (str, "1") == 0) return 1;
12654   return 0;
12655 }
12656
12657 static int test_mkdir_p_3 (void)
12658 {
12659   if (test_mkdir_p_3_skip ()) {
12660     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12661     return 0;
12662   }
12663
12664   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12665   {
12666     char device[] = "/dev/sda";
12667     int r;
12668     suppress_error = 0;
12669     r = guestfs_blockdev_setrw (g, device);
12670     if (r == -1)
12671       return -1;
12672   }
12673   {
12674     int r;
12675     suppress_error = 0;
12676     r = guestfs_umount_all (g);
12677     if (r == -1)
12678       return -1;
12679   }
12680   {
12681     int r;
12682     suppress_error = 0;
12683     r = guestfs_lvm_remove_all (g);
12684     if (r == -1)
12685       return -1;
12686   }
12687   {
12688     char device[] = "/dev/sda";
12689     char lines_0[] = ",";
12690     char *lines[] = {
12691       lines_0,
12692       NULL
12693     };
12694     int r;
12695     suppress_error = 0;
12696     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12697     if (r == -1)
12698       return -1;
12699   }
12700   {
12701     char fstype[] = "ext2";
12702     char device[] = "/dev/sda1";
12703     int r;
12704     suppress_error = 0;
12705     r = guestfs_mkfs (g, fstype, device);
12706     if (r == -1)
12707       return -1;
12708   }
12709   {
12710     char device[] = "/dev/sda1";
12711     char mountpoint[] = "/";
12712     int r;
12713     suppress_error = 0;
12714     r = guestfs_mount (g, device, mountpoint);
12715     if (r == -1)
12716       return -1;
12717   }
12718   /* TestRun for mkdir_p (3) */
12719   {
12720     char path[] = "/new";
12721     int r;
12722     suppress_error = 0;
12723     r = guestfs_mkdir (g, path);
12724     if (r == -1)
12725       return -1;
12726   }
12727   {
12728     char path[] = "/new";
12729     int r;
12730     suppress_error = 0;
12731     r = guestfs_mkdir_p (g, path);
12732     if (r == -1)
12733       return -1;
12734   }
12735   return 0;
12736 }
12737
12738 static int test_mkdir_p_4_skip (void)
12739 {
12740   const char *str;
12741
12742   str = getenv ("SKIP_TEST_MKDIR_P_4");
12743   if (str && strcmp (str, "1") == 0) return 1;
12744   str = getenv ("SKIP_TEST_MKDIR_P");
12745   if (str && strcmp (str, "1") == 0) return 1;
12746   return 0;
12747 }
12748
12749 static int test_mkdir_p_4 (void)
12750 {
12751   if (test_mkdir_p_4_skip ()) {
12752     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
12753     return 0;
12754   }
12755
12756   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
12757   {
12758     char device[] = "/dev/sda";
12759     int r;
12760     suppress_error = 0;
12761     r = guestfs_blockdev_setrw (g, device);
12762     if (r == -1)
12763       return -1;
12764   }
12765   {
12766     int r;
12767     suppress_error = 0;
12768     r = guestfs_umount_all (g);
12769     if (r == -1)
12770       return -1;
12771   }
12772   {
12773     int r;
12774     suppress_error = 0;
12775     r = guestfs_lvm_remove_all (g);
12776     if (r == -1)
12777       return -1;
12778   }
12779   {
12780     char device[] = "/dev/sda";
12781     char lines_0[] = ",";
12782     char *lines[] = {
12783       lines_0,
12784       NULL
12785     };
12786     int r;
12787     suppress_error = 0;
12788     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12789     if (r == -1)
12790       return -1;
12791   }
12792   {
12793     char fstype[] = "ext2";
12794     char device[] = "/dev/sda1";
12795     int r;
12796     suppress_error = 0;
12797     r = guestfs_mkfs (g, fstype, device);
12798     if (r == -1)
12799       return -1;
12800   }
12801   {
12802     char device[] = "/dev/sda1";
12803     char mountpoint[] = "/";
12804     int r;
12805     suppress_error = 0;
12806     r = guestfs_mount (g, device, mountpoint);
12807     if (r == -1)
12808       return -1;
12809   }
12810   /* TestLastFail for mkdir_p (4) */
12811   {
12812     char path[] = "/new";
12813     int r;
12814     suppress_error = 0;
12815     r = guestfs_touch (g, path);
12816     if (r == -1)
12817       return -1;
12818   }
12819   {
12820     char path[] = "/new";
12821     int r;
12822     suppress_error = 1;
12823     r = guestfs_mkdir_p (g, path);
12824     if (r != -1)
12825       return -1;
12826   }
12827   return 0;
12828 }
12829
12830 static int test_mkdir_0_skip (void)
12831 {
12832   const char *str;
12833
12834   str = getenv ("SKIP_TEST_MKDIR_0");
12835   if (str && strcmp (str, "1") == 0) return 1;
12836   str = getenv ("SKIP_TEST_MKDIR");
12837   if (str && strcmp (str, "1") == 0) return 1;
12838   return 0;
12839 }
12840
12841 static int test_mkdir_0 (void)
12842 {
12843   if (test_mkdir_0_skip ()) {
12844     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
12845     return 0;
12846   }
12847
12848   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
12849   {
12850     char device[] = "/dev/sda";
12851     int r;
12852     suppress_error = 0;
12853     r = guestfs_blockdev_setrw (g, device);
12854     if (r == -1)
12855       return -1;
12856   }
12857   {
12858     int r;
12859     suppress_error = 0;
12860     r = guestfs_umount_all (g);
12861     if (r == -1)
12862       return -1;
12863   }
12864   {
12865     int r;
12866     suppress_error = 0;
12867     r = guestfs_lvm_remove_all (g);
12868     if (r == -1)
12869       return -1;
12870   }
12871   {
12872     char device[] = "/dev/sda";
12873     char lines_0[] = ",";
12874     char *lines[] = {
12875       lines_0,
12876       NULL
12877     };
12878     int r;
12879     suppress_error = 0;
12880     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12881     if (r == -1)
12882       return -1;
12883   }
12884   {
12885     char fstype[] = "ext2";
12886     char device[] = "/dev/sda1";
12887     int r;
12888     suppress_error = 0;
12889     r = guestfs_mkfs (g, fstype, device);
12890     if (r == -1)
12891       return -1;
12892   }
12893   {
12894     char device[] = "/dev/sda1";
12895     char mountpoint[] = "/";
12896     int r;
12897     suppress_error = 0;
12898     r = guestfs_mount (g, device, mountpoint);
12899     if (r == -1)
12900       return -1;
12901   }
12902   /* TestOutputTrue for mkdir (0) */
12903   {
12904     char path[] = "/new";
12905     int r;
12906     suppress_error = 0;
12907     r = guestfs_mkdir (g, path);
12908     if (r == -1)
12909       return -1;
12910   }
12911   {
12912     char path[] = "/new";
12913     int r;
12914     suppress_error = 0;
12915     r = guestfs_is_dir (g, path);
12916     if (r == -1)
12917       return -1;
12918     if (!r) {
12919       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
12920       return -1;
12921     }
12922   }
12923   return 0;
12924 }
12925
12926 static int test_mkdir_1_skip (void)
12927 {
12928   const char *str;
12929
12930   str = getenv ("SKIP_TEST_MKDIR_1");
12931   if (str && strcmp (str, "1") == 0) return 1;
12932   str = getenv ("SKIP_TEST_MKDIR");
12933   if (str && strcmp (str, "1") == 0) return 1;
12934   return 0;
12935 }
12936
12937 static int test_mkdir_1 (void)
12938 {
12939   if (test_mkdir_1_skip ()) {
12940     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
12941     return 0;
12942   }
12943
12944   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
12945   {
12946     char device[] = "/dev/sda";
12947     int r;
12948     suppress_error = 0;
12949     r = guestfs_blockdev_setrw (g, device);
12950     if (r == -1)
12951       return -1;
12952   }
12953   {
12954     int r;
12955     suppress_error = 0;
12956     r = guestfs_umount_all (g);
12957     if (r == -1)
12958       return -1;
12959   }
12960   {
12961     int r;
12962     suppress_error = 0;
12963     r = guestfs_lvm_remove_all (g);
12964     if (r == -1)
12965       return -1;
12966   }
12967   {
12968     char device[] = "/dev/sda";
12969     char lines_0[] = ",";
12970     char *lines[] = {
12971       lines_0,
12972       NULL
12973     };
12974     int r;
12975     suppress_error = 0;
12976     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12977     if (r == -1)
12978       return -1;
12979   }
12980   {
12981     char fstype[] = "ext2";
12982     char device[] = "/dev/sda1";
12983     int r;
12984     suppress_error = 0;
12985     r = guestfs_mkfs (g, fstype, device);
12986     if (r == -1)
12987       return -1;
12988   }
12989   {
12990     char device[] = "/dev/sda1";
12991     char mountpoint[] = "/";
12992     int r;
12993     suppress_error = 0;
12994     r = guestfs_mount (g, device, mountpoint);
12995     if (r == -1)
12996       return -1;
12997   }
12998   /* TestLastFail for mkdir (1) */
12999   {
13000     char path[] = "/new/foo/bar";
13001     int r;
13002     suppress_error = 1;
13003     r = guestfs_mkdir (g, path);
13004     if (r != -1)
13005       return -1;
13006   }
13007   return 0;
13008 }
13009
13010 static int test_rm_rf_0_skip (void)
13011 {
13012   const char *str;
13013
13014   str = getenv ("SKIP_TEST_RM_RF_0");
13015   if (str && strcmp (str, "1") == 0) return 1;
13016   str = getenv ("SKIP_TEST_RM_RF");
13017   if (str && strcmp (str, "1") == 0) return 1;
13018   return 0;
13019 }
13020
13021 static int test_rm_rf_0 (void)
13022 {
13023   if (test_rm_rf_0_skip ()) {
13024     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13025     return 0;
13026   }
13027
13028   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13029   {
13030     char device[] = "/dev/sda";
13031     int r;
13032     suppress_error = 0;
13033     r = guestfs_blockdev_setrw (g, device);
13034     if (r == -1)
13035       return -1;
13036   }
13037   {
13038     int r;
13039     suppress_error = 0;
13040     r = guestfs_umount_all (g);
13041     if (r == -1)
13042       return -1;
13043   }
13044   {
13045     int r;
13046     suppress_error = 0;
13047     r = guestfs_lvm_remove_all (g);
13048     if (r == -1)
13049       return -1;
13050   }
13051   {
13052     char device[] = "/dev/sda";
13053     char lines_0[] = ",";
13054     char *lines[] = {
13055       lines_0,
13056       NULL
13057     };
13058     int r;
13059     suppress_error = 0;
13060     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13061     if (r == -1)
13062       return -1;
13063   }
13064   {
13065     char fstype[] = "ext2";
13066     char device[] = "/dev/sda1";
13067     int r;
13068     suppress_error = 0;
13069     r = guestfs_mkfs (g, fstype, device);
13070     if (r == -1)
13071       return -1;
13072   }
13073   {
13074     char device[] = "/dev/sda1";
13075     char mountpoint[] = "/";
13076     int r;
13077     suppress_error = 0;
13078     r = guestfs_mount (g, device, mountpoint);
13079     if (r == -1)
13080       return -1;
13081   }
13082   /* TestOutputFalse for rm_rf (0) */
13083   {
13084     char path[] = "/new";
13085     int r;
13086     suppress_error = 0;
13087     r = guestfs_mkdir (g, path);
13088     if (r == -1)
13089       return -1;
13090   }
13091   {
13092     char path[] = "/new/foo";
13093     int r;
13094     suppress_error = 0;
13095     r = guestfs_mkdir (g, path);
13096     if (r == -1)
13097       return -1;
13098   }
13099   {
13100     char path[] = "/new/foo/bar";
13101     int r;
13102     suppress_error = 0;
13103     r = guestfs_touch (g, path);
13104     if (r == -1)
13105       return -1;
13106   }
13107   {
13108     char path[] = "/new";
13109     int r;
13110     suppress_error = 0;
13111     r = guestfs_rm_rf (g, path);
13112     if (r == -1)
13113       return -1;
13114   }
13115   {
13116     char path[] = "/new";
13117     int r;
13118     suppress_error = 0;
13119     r = guestfs_exists (g, path);
13120     if (r == -1)
13121       return -1;
13122     if (r) {
13123       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13124       return -1;
13125     }
13126   }
13127   return 0;
13128 }
13129
13130 static int test_rmdir_0_skip (void)
13131 {
13132   const char *str;
13133
13134   str = getenv ("SKIP_TEST_RMDIR_0");
13135   if (str && strcmp (str, "1") == 0) return 1;
13136   str = getenv ("SKIP_TEST_RMDIR");
13137   if (str && strcmp (str, "1") == 0) return 1;
13138   return 0;
13139 }
13140
13141 static int test_rmdir_0 (void)
13142 {
13143   if (test_rmdir_0_skip ()) {
13144     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13145     return 0;
13146   }
13147
13148   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13149   {
13150     char device[] = "/dev/sda";
13151     int r;
13152     suppress_error = 0;
13153     r = guestfs_blockdev_setrw (g, device);
13154     if (r == -1)
13155       return -1;
13156   }
13157   {
13158     int r;
13159     suppress_error = 0;
13160     r = guestfs_umount_all (g);
13161     if (r == -1)
13162       return -1;
13163   }
13164   {
13165     int r;
13166     suppress_error = 0;
13167     r = guestfs_lvm_remove_all (g);
13168     if (r == -1)
13169       return -1;
13170   }
13171   {
13172     char device[] = "/dev/sda";
13173     char lines_0[] = ",";
13174     char *lines[] = {
13175       lines_0,
13176       NULL
13177     };
13178     int r;
13179     suppress_error = 0;
13180     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13181     if (r == -1)
13182       return -1;
13183   }
13184   {
13185     char fstype[] = "ext2";
13186     char device[] = "/dev/sda1";
13187     int r;
13188     suppress_error = 0;
13189     r = guestfs_mkfs (g, fstype, device);
13190     if (r == -1)
13191       return -1;
13192   }
13193   {
13194     char device[] = "/dev/sda1";
13195     char mountpoint[] = "/";
13196     int r;
13197     suppress_error = 0;
13198     r = guestfs_mount (g, device, mountpoint);
13199     if (r == -1)
13200       return -1;
13201   }
13202   /* TestRun for rmdir (0) */
13203   {
13204     char path[] = "/new";
13205     int r;
13206     suppress_error = 0;
13207     r = guestfs_mkdir (g, path);
13208     if (r == -1)
13209       return -1;
13210   }
13211   {
13212     char path[] = "/new";
13213     int r;
13214     suppress_error = 0;
13215     r = guestfs_rmdir (g, path);
13216     if (r == -1)
13217       return -1;
13218   }
13219   return 0;
13220 }
13221
13222 static int test_rmdir_1_skip (void)
13223 {
13224   const char *str;
13225
13226   str = getenv ("SKIP_TEST_RMDIR_1");
13227   if (str && strcmp (str, "1") == 0) return 1;
13228   str = getenv ("SKIP_TEST_RMDIR");
13229   if (str && strcmp (str, "1") == 0) return 1;
13230   return 0;
13231 }
13232
13233 static int test_rmdir_1 (void)
13234 {
13235   if (test_rmdir_1_skip ()) {
13236     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13237     return 0;
13238   }
13239
13240   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13241   {
13242     char device[] = "/dev/sda";
13243     int r;
13244     suppress_error = 0;
13245     r = guestfs_blockdev_setrw (g, device);
13246     if (r == -1)
13247       return -1;
13248   }
13249   {
13250     int r;
13251     suppress_error = 0;
13252     r = guestfs_umount_all (g);
13253     if (r == -1)
13254       return -1;
13255   }
13256   {
13257     int r;
13258     suppress_error = 0;
13259     r = guestfs_lvm_remove_all (g);
13260     if (r == -1)
13261       return -1;
13262   }
13263   {
13264     char device[] = "/dev/sda";
13265     char lines_0[] = ",";
13266     char *lines[] = {
13267       lines_0,
13268       NULL
13269     };
13270     int r;
13271     suppress_error = 0;
13272     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13273     if (r == -1)
13274       return -1;
13275   }
13276   {
13277     char fstype[] = "ext2";
13278     char device[] = "/dev/sda1";
13279     int r;
13280     suppress_error = 0;
13281     r = guestfs_mkfs (g, fstype, device);
13282     if (r == -1)
13283       return -1;
13284   }
13285   {
13286     char device[] = "/dev/sda1";
13287     char mountpoint[] = "/";
13288     int r;
13289     suppress_error = 0;
13290     r = guestfs_mount (g, device, mountpoint);
13291     if (r == -1)
13292       return -1;
13293   }
13294   /* TestLastFail for rmdir (1) */
13295   {
13296     char path[] = "/new";
13297     int r;
13298     suppress_error = 1;
13299     r = guestfs_rmdir (g, path);
13300     if (r != -1)
13301       return -1;
13302   }
13303   return 0;
13304 }
13305
13306 static int test_rmdir_2_skip (void)
13307 {
13308   const char *str;
13309
13310   str = getenv ("SKIP_TEST_RMDIR_2");
13311   if (str && strcmp (str, "1") == 0) return 1;
13312   str = getenv ("SKIP_TEST_RMDIR");
13313   if (str && strcmp (str, "1") == 0) return 1;
13314   return 0;
13315 }
13316
13317 static int test_rmdir_2 (void)
13318 {
13319   if (test_rmdir_2_skip ()) {
13320     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13321     return 0;
13322   }
13323
13324   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13325   {
13326     char device[] = "/dev/sda";
13327     int r;
13328     suppress_error = 0;
13329     r = guestfs_blockdev_setrw (g, device);
13330     if (r == -1)
13331       return -1;
13332   }
13333   {
13334     int r;
13335     suppress_error = 0;
13336     r = guestfs_umount_all (g);
13337     if (r == -1)
13338       return -1;
13339   }
13340   {
13341     int r;
13342     suppress_error = 0;
13343     r = guestfs_lvm_remove_all (g);
13344     if (r == -1)
13345       return -1;
13346   }
13347   {
13348     char device[] = "/dev/sda";
13349     char lines_0[] = ",";
13350     char *lines[] = {
13351       lines_0,
13352       NULL
13353     };
13354     int r;
13355     suppress_error = 0;
13356     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13357     if (r == -1)
13358       return -1;
13359   }
13360   {
13361     char fstype[] = "ext2";
13362     char device[] = "/dev/sda1";
13363     int r;
13364     suppress_error = 0;
13365     r = guestfs_mkfs (g, fstype, device);
13366     if (r == -1)
13367       return -1;
13368   }
13369   {
13370     char device[] = "/dev/sda1";
13371     char mountpoint[] = "/";
13372     int r;
13373     suppress_error = 0;
13374     r = guestfs_mount (g, device, mountpoint);
13375     if (r == -1)
13376       return -1;
13377   }
13378   /* TestLastFail for rmdir (2) */
13379   {
13380     char path[] = "/new";
13381     int r;
13382     suppress_error = 0;
13383     r = guestfs_touch (g, path);
13384     if (r == -1)
13385       return -1;
13386   }
13387   {
13388     char path[] = "/new";
13389     int r;
13390     suppress_error = 1;
13391     r = guestfs_rmdir (g, path);
13392     if (r != -1)
13393       return -1;
13394   }
13395   return 0;
13396 }
13397
13398 static int test_rm_0_skip (void)
13399 {
13400   const char *str;
13401
13402   str = getenv ("SKIP_TEST_RM_0");
13403   if (str && strcmp (str, "1") == 0) return 1;
13404   str = getenv ("SKIP_TEST_RM");
13405   if (str && strcmp (str, "1") == 0) return 1;
13406   return 0;
13407 }
13408
13409 static int test_rm_0 (void)
13410 {
13411   if (test_rm_0_skip ()) {
13412     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13413     return 0;
13414   }
13415
13416   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13417   {
13418     char device[] = "/dev/sda";
13419     int r;
13420     suppress_error = 0;
13421     r = guestfs_blockdev_setrw (g, device);
13422     if (r == -1)
13423       return -1;
13424   }
13425   {
13426     int r;
13427     suppress_error = 0;
13428     r = guestfs_umount_all (g);
13429     if (r == -1)
13430       return -1;
13431   }
13432   {
13433     int r;
13434     suppress_error = 0;
13435     r = guestfs_lvm_remove_all (g);
13436     if (r == -1)
13437       return -1;
13438   }
13439   {
13440     char device[] = "/dev/sda";
13441     char lines_0[] = ",";
13442     char *lines[] = {
13443       lines_0,
13444       NULL
13445     };
13446     int r;
13447     suppress_error = 0;
13448     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13449     if (r == -1)
13450       return -1;
13451   }
13452   {
13453     char fstype[] = "ext2";
13454     char device[] = "/dev/sda1";
13455     int r;
13456     suppress_error = 0;
13457     r = guestfs_mkfs (g, fstype, device);
13458     if (r == -1)
13459       return -1;
13460   }
13461   {
13462     char device[] = "/dev/sda1";
13463     char mountpoint[] = "/";
13464     int r;
13465     suppress_error = 0;
13466     r = guestfs_mount (g, device, mountpoint);
13467     if (r == -1)
13468       return -1;
13469   }
13470   /* TestRun for rm (0) */
13471   {
13472     char path[] = "/new";
13473     int r;
13474     suppress_error = 0;
13475     r = guestfs_touch (g, path);
13476     if (r == -1)
13477       return -1;
13478   }
13479   {
13480     char path[] = "/new";
13481     int r;
13482     suppress_error = 0;
13483     r = guestfs_rm (g, path);
13484     if (r == -1)
13485       return -1;
13486   }
13487   return 0;
13488 }
13489
13490 static int test_rm_1_skip (void)
13491 {
13492   const char *str;
13493
13494   str = getenv ("SKIP_TEST_RM_1");
13495   if (str && strcmp (str, "1") == 0) return 1;
13496   str = getenv ("SKIP_TEST_RM");
13497   if (str && strcmp (str, "1") == 0) return 1;
13498   return 0;
13499 }
13500
13501 static int test_rm_1 (void)
13502 {
13503   if (test_rm_1_skip ()) {
13504     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13505     return 0;
13506   }
13507
13508   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13509   {
13510     char device[] = "/dev/sda";
13511     int r;
13512     suppress_error = 0;
13513     r = guestfs_blockdev_setrw (g, device);
13514     if (r == -1)
13515       return -1;
13516   }
13517   {
13518     int r;
13519     suppress_error = 0;
13520     r = guestfs_umount_all (g);
13521     if (r == -1)
13522       return -1;
13523   }
13524   {
13525     int r;
13526     suppress_error = 0;
13527     r = guestfs_lvm_remove_all (g);
13528     if (r == -1)
13529       return -1;
13530   }
13531   {
13532     char device[] = "/dev/sda";
13533     char lines_0[] = ",";
13534     char *lines[] = {
13535       lines_0,
13536       NULL
13537     };
13538     int r;
13539     suppress_error = 0;
13540     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13541     if (r == -1)
13542       return -1;
13543   }
13544   {
13545     char fstype[] = "ext2";
13546     char device[] = "/dev/sda1";
13547     int r;
13548     suppress_error = 0;
13549     r = guestfs_mkfs (g, fstype, device);
13550     if (r == -1)
13551       return -1;
13552   }
13553   {
13554     char device[] = "/dev/sda1";
13555     char mountpoint[] = "/";
13556     int r;
13557     suppress_error = 0;
13558     r = guestfs_mount (g, device, mountpoint);
13559     if (r == -1)
13560       return -1;
13561   }
13562   /* TestLastFail for rm (1) */
13563   {
13564     char path[] = "/new";
13565     int r;
13566     suppress_error = 1;
13567     r = guestfs_rm (g, path);
13568     if (r != -1)
13569       return -1;
13570   }
13571   return 0;
13572 }
13573
13574 static int test_rm_2_skip (void)
13575 {
13576   const char *str;
13577
13578   str = getenv ("SKIP_TEST_RM_2");
13579   if (str && strcmp (str, "1") == 0) return 1;
13580   str = getenv ("SKIP_TEST_RM");
13581   if (str && strcmp (str, "1") == 0) return 1;
13582   return 0;
13583 }
13584
13585 static int test_rm_2 (void)
13586 {
13587   if (test_rm_2_skip ()) {
13588     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13589     return 0;
13590   }
13591
13592   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13593   {
13594     char device[] = "/dev/sda";
13595     int r;
13596     suppress_error = 0;
13597     r = guestfs_blockdev_setrw (g, device);
13598     if (r == -1)
13599       return -1;
13600   }
13601   {
13602     int r;
13603     suppress_error = 0;
13604     r = guestfs_umount_all (g);
13605     if (r == -1)
13606       return -1;
13607   }
13608   {
13609     int r;
13610     suppress_error = 0;
13611     r = guestfs_lvm_remove_all (g);
13612     if (r == -1)
13613       return -1;
13614   }
13615   {
13616     char device[] = "/dev/sda";
13617     char lines_0[] = ",";
13618     char *lines[] = {
13619       lines_0,
13620       NULL
13621     };
13622     int r;
13623     suppress_error = 0;
13624     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13625     if (r == -1)
13626       return -1;
13627   }
13628   {
13629     char fstype[] = "ext2";
13630     char device[] = "/dev/sda1";
13631     int r;
13632     suppress_error = 0;
13633     r = guestfs_mkfs (g, fstype, device);
13634     if (r == -1)
13635       return -1;
13636   }
13637   {
13638     char device[] = "/dev/sda1";
13639     char mountpoint[] = "/";
13640     int r;
13641     suppress_error = 0;
13642     r = guestfs_mount (g, device, mountpoint);
13643     if (r == -1)
13644       return -1;
13645   }
13646   /* TestLastFail for rm (2) */
13647   {
13648     char path[] = "/new";
13649     int r;
13650     suppress_error = 0;
13651     r = guestfs_mkdir (g, path);
13652     if (r == -1)
13653       return -1;
13654   }
13655   {
13656     char path[] = "/new";
13657     int r;
13658     suppress_error = 1;
13659     r = guestfs_rm (g, path);
13660     if (r != -1)
13661       return -1;
13662   }
13663   return 0;
13664 }
13665
13666 static int test_read_lines_0_skip (void)
13667 {
13668   const char *str;
13669
13670   str = getenv ("SKIP_TEST_READ_LINES_0");
13671   if (str && strcmp (str, "1") == 0) return 1;
13672   str = getenv ("SKIP_TEST_READ_LINES");
13673   if (str && strcmp (str, "1") == 0) return 1;
13674   return 0;
13675 }
13676
13677 static int test_read_lines_0 (void)
13678 {
13679   if (test_read_lines_0_skip ()) {
13680     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13681     return 0;
13682   }
13683
13684   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13685   {
13686     char device[] = "/dev/sda";
13687     int r;
13688     suppress_error = 0;
13689     r = guestfs_blockdev_setrw (g, device);
13690     if (r == -1)
13691       return -1;
13692   }
13693   {
13694     int r;
13695     suppress_error = 0;
13696     r = guestfs_umount_all (g);
13697     if (r == -1)
13698       return -1;
13699   }
13700   {
13701     int r;
13702     suppress_error = 0;
13703     r = guestfs_lvm_remove_all (g);
13704     if (r == -1)
13705       return -1;
13706   }
13707   {
13708     char device[] = "/dev/sda";
13709     char lines_0[] = ",";
13710     char *lines[] = {
13711       lines_0,
13712       NULL
13713     };
13714     int r;
13715     suppress_error = 0;
13716     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13717     if (r == -1)
13718       return -1;
13719   }
13720   {
13721     char fstype[] = "ext2";
13722     char device[] = "/dev/sda1";
13723     int r;
13724     suppress_error = 0;
13725     r = guestfs_mkfs (g, fstype, device);
13726     if (r == -1)
13727       return -1;
13728   }
13729   {
13730     char device[] = "/dev/sda1";
13731     char mountpoint[] = "/";
13732     int r;
13733     suppress_error = 0;
13734     r = guestfs_mount (g, device, mountpoint);
13735     if (r == -1)
13736       return -1;
13737   }
13738   /* TestOutputList for read_lines (0) */
13739   {
13740     char path[] = "/new";
13741     char content[] = "line1\r\nline2\nline3";
13742     int r;
13743     suppress_error = 0;
13744     r = guestfs_write_file (g, path, content, 0);
13745     if (r == -1)
13746       return -1;
13747   }
13748   {
13749     char path[] = "/new";
13750     char **r;
13751     int i;
13752     suppress_error = 0;
13753     r = guestfs_read_lines (g, path);
13754     if (r == NULL)
13755       return -1;
13756     if (!r[0]) {
13757       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13758       print_strings (r);
13759       return -1;
13760     }
13761     {
13762       char expected[] = "line1";
13763       if (strcmp (r[0], expected) != 0) {
13764         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13765         return -1;
13766       }
13767     }
13768     if (!r[1]) {
13769       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13770       print_strings (r);
13771       return -1;
13772     }
13773     {
13774       char expected[] = "line2";
13775       if (strcmp (r[1], expected) != 0) {
13776         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13777         return -1;
13778       }
13779     }
13780     if (!r[2]) {
13781       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13782       print_strings (r);
13783       return -1;
13784     }
13785     {
13786       char expected[] = "line3";
13787       if (strcmp (r[2], expected) != 0) {
13788         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13789         return -1;
13790       }
13791     }
13792     if (r[3] != NULL) {
13793       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
13794       print_strings (r);
13795       return -1;
13796     }
13797     for (i = 0; r[i] != NULL; ++i)
13798       free (r[i]);
13799     free (r);
13800   }
13801   return 0;
13802 }
13803
13804 static int test_read_lines_1_skip (void)
13805 {
13806   const char *str;
13807
13808   str = getenv ("SKIP_TEST_READ_LINES_1");
13809   if (str && strcmp (str, "1") == 0) return 1;
13810   str = getenv ("SKIP_TEST_READ_LINES");
13811   if (str && strcmp (str, "1") == 0) return 1;
13812   return 0;
13813 }
13814
13815 static int test_read_lines_1 (void)
13816 {
13817   if (test_read_lines_1_skip ()) {
13818     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
13819     return 0;
13820   }
13821
13822   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
13823   {
13824     char device[] = "/dev/sda";
13825     int r;
13826     suppress_error = 0;
13827     r = guestfs_blockdev_setrw (g, device);
13828     if (r == -1)
13829       return -1;
13830   }
13831   {
13832     int r;
13833     suppress_error = 0;
13834     r = guestfs_umount_all (g);
13835     if (r == -1)
13836       return -1;
13837   }
13838   {
13839     int r;
13840     suppress_error = 0;
13841     r = guestfs_lvm_remove_all (g);
13842     if (r == -1)
13843       return -1;
13844   }
13845   {
13846     char device[] = "/dev/sda";
13847     char lines_0[] = ",";
13848     char *lines[] = {
13849       lines_0,
13850       NULL
13851     };
13852     int r;
13853     suppress_error = 0;
13854     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13855     if (r == -1)
13856       return -1;
13857   }
13858   {
13859     char fstype[] = "ext2";
13860     char device[] = "/dev/sda1";
13861     int r;
13862     suppress_error = 0;
13863     r = guestfs_mkfs (g, fstype, device);
13864     if (r == -1)
13865       return -1;
13866   }
13867   {
13868     char device[] = "/dev/sda1";
13869     char mountpoint[] = "/";
13870     int r;
13871     suppress_error = 0;
13872     r = guestfs_mount (g, device, mountpoint);
13873     if (r == -1)
13874       return -1;
13875   }
13876   /* TestOutputList for read_lines (1) */
13877   {
13878     char path[] = "/new";
13879     char content[] = "";
13880     int r;
13881     suppress_error = 0;
13882     r = guestfs_write_file (g, path, content, 0);
13883     if (r == -1)
13884       return -1;
13885   }
13886   {
13887     char path[] = "/new";
13888     char **r;
13889     int i;
13890     suppress_error = 0;
13891     r = guestfs_read_lines (g, path);
13892     if (r == NULL)
13893       return -1;
13894     if (r[0] != NULL) {
13895       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
13896       print_strings (r);
13897       return -1;
13898     }
13899     for (i = 0; r[i] != NULL; ++i)
13900       free (r[i]);
13901     free (r);
13902   }
13903   return 0;
13904 }
13905
13906 static int test_lvs_0_skip (void)
13907 {
13908   const char *str;
13909
13910   str = getenv ("SKIP_TEST_LVS_0");
13911   if (str && strcmp (str, "1") == 0) return 1;
13912   str = getenv ("SKIP_TEST_LVS");
13913   if (str && strcmp (str, "1") == 0) return 1;
13914   return 0;
13915 }
13916
13917 static int test_lvs_0 (void)
13918 {
13919   if (test_lvs_0_skip ()) {
13920     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
13921     return 0;
13922   }
13923
13924   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
13925   {
13926     char device[] = "/dev/sda";
13927     int r;
13928     suppress_error = 0;
13929     r = guestfs_blockdev_setrw (g, device);
13930     if (r == -1)
13931       return -1;
13932   }
13933   {
13934     int r;
13935     suppress_error = 0;
13936     r = guestfs_umount_all (g);
13937     if (r == -1)
13938       return -1;
13939   }
13940   {
13941     int r;
13942     suppress_error = 0;
13943     r = guestfs_lvm_remove_all (g);
13944     if (r == -1)
13945       return -1;
13946   }
13947   {
13948     char device[] = "/dev/sda";
13949     char lines_0[] = ",";
13950     char *lines[] = {
13951       lines_0,
13952       NULL
13953     };
13954     int r;
13955     suppress_error = 0;
13956     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13957     if (r == -1)
13958       return -1;
13959   }
13960   {
13961     char device[] = "/dev/sda1";
13962     int r;
13963     suppress_error = 0;
13964     r = guestfs_pvcreate (g, device);
13965     if (r == -1)
13966       return -1;
13967   }
13968   {
13969     char volgroup[] = "VG";
13970     char physvols_0[] = "/dev/sda1";
13971     char *physvols[] = {
13972       physvols_0,
13973       NULL
13974     };
13975     int r;
13976     suppress_error = 0;
13977     r = guestfs_vgcreate (g, volgroup, physvols);
13978     if (r == -1)
13979       return -1;
13980   }
13981   {
13982     char logvol[] = "LV";
13983     char volgroup[] = "VG";
13984     int r;
13985     suppress_error = 0;
13986     r = guestfs_lvcreate (g, logvol, volgroup, 8);
13987     if (r == -1)
13988       return -1;
13989   }
13990   {
13991     char fstype[] = "ext2";
13992     char device[] = "/dev/VG/LV";
13993     int r;
13994     suppress_error = 0;
13995     r = guestfs_mkfs (g, fstype, device);
13996     if (r == -1)
13997       return -1;
13998   }
13999   {
14000     char device[] = "/dev/VG/LV";
14001     char mountpoint[] = "/";
14002     int r;
14003     suppress_error = 0;
14004     r = guestfs_mount (g, device, mountpoint);
14005     if (r == -1)
14006       return -1;
14007   }
14008   /* TestOutputList for lvs (0) */
14009   {
14010     char **r;
14011     int i;
14012     suppress_error = 0;
14013     r = guestfs_lvs (g);
14014     if (r == NULL)
14015       return -1;
14016     if (!r[0]) {
14017       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14018       print_strings (r);
14019       return -1;
14020     }
14021     {
14022       char expected[] = "/dev/VG/LV";
14023       if (strcmp (r[0], expected) != 0) {
14024         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14025         return -1;
14026       }
14027     }
14028     if (r[1] != NULL) {
14029       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14030       print_strings (r);
14031       return -1;
14032     }
14033     for (i = 0; r[i] != NULL; ++i)
14034       free (r[i]);
14035     free (r);
14036   }
14037   return 0;
14038 }
14039
14040 static int test_lvs_1_skip (void)
14041 {
14042   const char *str;
14043
14044   str = getenv ("SKIP_TEST_LVS_1");
14045   if (str && strcmp (str, "1") == 0) return 1;
14046   str = getenv ("SKIP_TEST_LVS");
14047   if (str && strcmp (str, "1") == 0) return 1;
14048   return 0;
14049 }
14050
14051 static int test_lvs_1 (void)
14052 {
14053   if (test_lvs_1_skip ()) {
14054     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14055     return 0;
14056   }
14057
14058   /* InitNone|InitEmpty for test_lvs_1 */
14059   {
14060     char device[] = "/dev/sda";
14061     int r;
14062     suppress_error = 0;
14063     r = guestfs_blockdev_setrw (g, device);
14064     if (r == -1)
14065       return -1;
14066   }
14067   {
14068     int r;
14069     suppress_error = 0;
14070     r = guestfs_umount_all (g);
14071     if (r == -1)
14072       return -1;
14073   }
14074   {
14075     int r;
14076     suppress_error = 0;
14077     r = guestfs_lvm_remove_all (g);
14078     if (r == -1)
14079       return -1;
14080   }
14081   /* TestOutputList for lvs (1) */
14082   {
14083     char device[] = "/dev/sda";
14084     char lines_0[] = ",10";
14085     char lines_1[] = ",20";
14086     char lines_2[] = ",";
14087     char *lines[] = {
14088       lines_0,
14089       lines_1,
14090       lines_2,
14091       NULL
14092     };
14093     int r;
14094     suppress_error = 0;
14095     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14096     if (r == -1)
14097       return -1;
14098   }
14099   {
14100     char device[] = "/dev/sda1";
14101     int r;
14102     suppress_error = 0;
14103     r = guestfs_pvcreate (g, device);
14104     if (r == -1)
14105       return -1;
14106   }
14107   {
14108     char device[] = "/dev/sda2";
14109     int r;
14110     suppress_error = 0;
14111     r = guestfs_pvcreate (g, device);
14112     if (r == -1)
14113       return -1;
14114   }
14115   {
14116     char device[] = "/dev/sda3";
14117     int r;
14118     suppress_error = 0;
14119     r = guestfs_pvcreate (g, device);
14120     if (r == -1)
14121       return -1;
14122   }
14123   {
14124     char volgroup[] = "VG1";
14125     char physvols_0[] = "/dev/sda1";
14126     char physvols_1[] = "/dev/sda2";
14127     char *physvols[] = {
14128       physvols_0,
14129       physvols_1,
14130       NULL
14131     };
14132     int r;
14133     suppress_error = 0;
14134     r = guestfs_vgcreate (g, volgroup, physvols);
14135     if (r == -1)
14136       return -1;
14137   }
14138   {
14139     char volgroup[] = "VG2";
14140     char physvols_0[] = "/dev/sda3";
14141     char *physvols[] = {
14142       physvols_0,
14143       NULL
14144     };
14145     int r;
14146     suppress_error = 0;
14147     r = guestfs_vgcreate (g, volgroup, physvols);
14148     if (r == -1)
14149       return -1;
14150   }
14151   {
14152     char logvol[] = "LV1";
14153     char volgroup[] = "VG1";
14154     int r;
14155     suppress_error = 0;
14156     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14157     if (r == -1)
14158       return -1;
14159   }
14160   {
14161     char logvol[] = "LV2";
14162     char volgroup[] = "VG1";
14163     int r;
14164     suppress_error = 0;
14165     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14166     if (r == -1)
14167       return -1;
14168   }
14169   {
14170     char logvol[] = "LV3";
14171     char volgroup[] = "VG2";
14172     int r;
14173     suppress_error = 0;
14174     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14175     if (r == -1)
14176       return -1;
14177   }
14178   {
14179     char **r;
14180     int i;
14181     suppress_error = 0;
14182     r = guestfs_lvs (g);
14183     if (r == NULL)
14184       return -1;
14185     if (!r[0]) {
14186       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14187       print_strings (r);
14188       return -1;
14189     }
14190     {
14191       char expected[] = "/dev/VG1/LV1";
14192       if (strcmp (r[0], expected) != 0) {
14193         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14194         return -1;
14195       }
14196     }
14197     if (!r[1]) {
14198       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14199       print_strings (r);
14200       return -1;
14201     }
14202     {
14203       char expected[] = "/dev/VG1/LV2";
14204       if (strcmp (r[1], expected) != 0) {
14205         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14206         return -1;
14207       }
14208     }
14209     if (!r[2]) {
14210       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14211       print_strings (r);
14212       return -1;
14213     }
14214     {
14215       char expected[] = "/dev/VG2/LV3";
14216       if (strcmp (r[2], expected) != 0) {
14217         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14218         return -1;
14219       }
14220     }
14221     if (r[3] != NULL) {
14222       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14223       print_strings (r);
14224       return -1;
14225     }
14226     for (i = 0; r[i] != NULL; ++i)
14227       free (r[i]);
14228     free (r);
14229   }
14230   return 0;
14231 }
14232
14233 static int test_vgs_0_skip (void)
14234 {
14235   const char *str;
14236
14237   str = getenv ("SKIP_TEST_VGS_0");
14238   if (str && strcmp (str, "1") == 0) return 1;
14239   str = getenv ("SKIP_TEST_VGS");
14240   if (str && strcmp (str, "1") == 0) return 1;
14241   return 0;
14242 }
14243
14244 static int test_vgs_0 (void)
14245 {
14246   if (test_vgs_0_skip ()) {
14247     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14248     return 0;
14249   }
14250
14251   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14252   {
14253     char device[] = "/dev/sda";
14254     int r;
14255     suppress_error = 0;
14256     r = guestfs_blockdev_setrw (g, device);
14257     if (r == -1)
14258       return -1;
14259   }
14260   {
14261     int r;
14262     suppress_error = 0;
14263     r = guestfs_umount_all (g);
14264     if (r == -1)
14265       return -1;
14266   }
14267   {
14268     int r;
14269     suppress_error = 0;
14270     r = guestfs_lvm_remove_all (g);
14271     if (r == -1)
14272       return -1;
14273   }
14274   {
14275     char device[] = "/dev/sda";
14276     char lines_0[] = ",";
14277     char *lines[] = {
14278       lines_0,
14279       NULL
14280     };
14281     int r;
14282     suppress_error = 0;
14283     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14284     if (r == -1)
14285       return -1;
14286   }
14287   {
14288     char device[] = "/dev/sda1";
14289     int r;
14290     suppress_error = 0;
14291     r = guestfs_pvcreate (g, device);
14292     if (r == -1)
14293       return -1;
14294   }
14295   {
14296     char volgroup[] = "VG";
14297     char physvols_0[] = "/dev/sda1";
14298     char *physvols[] = {
14299       physvols_0,
14300       NULL
14301     };
14302     int r;
14303     suppress_error = 0;
14304     r = guestfs_vgcreate (g, volgroup, physvols);
14305     if (r == -1)
14306       return -1;
14307   }
14308   {
14309     char logvol[] = "LV";
14310     char volgroup[] = "VG";
14311     int r;
14312     suppress_error = 0;
14313     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14314     if (r == -1)
14315       return -1;
14316   }
14317   {
14318     char fstype[] = "ext2";
14319     char device[] = "/dev/VG/LV";
14320     int r;
14321     suppress_error = 0;
14322     r = guestfs_mkfs (g, fstype, device);
14323     if (r == -1)
14324       return -1;
14325   }
14326   {
14327     char device[] = "/dev/VG/LV";
14328     char mountpoint[] = "/";
14329     int r;
14330     suppress_error = 0;
14331     r = guestfs_mount (g, device, mountpoint);
14332     if (r == -1)
14333       return -1;
14334   }
14335   /* TestOutputList for vgs (0) */
14336   {
14337     char **r;
14338     int i;
14339     suppress_error = 0;
14340     r = guestfs_vgs (g);
14341     if (r == NULL)
14342       return -1;
14343     if (!r[0]) {
14344       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14345       print_strings (r);
14346       return -1;
14347     }
14348     {
14349       char expected[] = "VG";
14350       if (strcmp (r[0], expected) != 0) {
14351         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14352         return -1;
14353       }
14354     }
14355     if (r[1] != NULL) {
14356       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14357       print_strings (r);
14358       return -1;
14359     }
14360     for (i = 0; r[i] != NULL; ++i)
14361       free (r[i]);
14362     free (r);
14363   }
14364   return 0;
14365 }
14366
14367 static int test_vgs_1_skip (void)
14368 {
14369   const char *str;
14370
14371   str = getenv ("SKIP_TEST_VGS_1");
14372   if (str && strcmp (str, "1") == 0) return 1;
14373   str = getenv ("SKIP_TEST_VGS");
14374   if (str && strcmp (str, "1") == 0) return 1;
14375   return 0;
14376 }
14377
14378 static int test_vgs_1 (void)
14379 {
14380   if (test_vgs_1_skip ()) {
14381     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14382     return 0;
14383   }
14384
14385   /* InitNone|InitEmpty for test_vgs_1 */
14386   {
14387     char device[] = "/dev/sda";
14388     int r;
14389     suppress_error = 0;
14390     r = guestfs_blockdev_setrw (g, device);
14391     if (r == -1)
14392       return -1;
14393   }
14394   {
14395     int r;
14396     suppress_error = 0;
14397     r = guestfs_umount_all (g);
14398     if (r == -1)
14399       return -1;
14400   }
14401   {
14402     int r;
14403     suppress_error = 0;
14404     r = guestfs_lvm_remove_all (g);
14405     if (r == -1)
14406       return -1;
14407   }
14408   /* TestOutputList for vgs (1) */
14409   {
14410     char device[] = "/dev/sda";
14411     char lines_0[] = ",10";
14412     char lines_1[] = ",20";
14413     char lines_2[] = ",";
14414     char *lines[] = {
14415       lines_0,
14416       lines_1,
14417       lines_2,
14418       NULL
14419     };
14420     int r;
14421     suppress_error = 0;
14422     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14423     if (r == -1)
14424       return -1;
14425   }
14426   {
14427     char device[] = "/dev/sda1";
14428     int r;
14429     suppress_error = 0;
14430     r = guestfs_pvcreate (g, device);
14431     if (r == -1)
14432       return -1;
14433   }
14434   {
14435     char device[] = "/dev/sda2";
14436     int r;
14437     suppress_error = 0;
14438     r = guestfs_pvcreate (g, device);
14439     if (r == -1)
14440       return -1;
14441   }
14442   {
14443     char device[] = "/dev/sda3";
14444     int r;
14445     suppress_error = 0;
14446     r = guestfs_pvcreate (g, device);
14447     if (r == -1)
14448       return -1;
14449   }
14450   {
14451     char volgroup[] = "VG1";
14452     char physvols_0[] = "/dev/sda1";
14453     char physvols_1[] = "/dev/sda2";
14454     char *physvols[] = {
14455       physvols_0,
14456       physvols_1,
14457       NULL
14458     };
14459     int r;
14460     suppress_error = 0;
14461     r = guestfs_vgcreate (g, volgroup, physvols);
14462     if (r == -1)
14463       return -1;
14464   }
14465   {
14466     char volgroup[] = "VG2";
14467     char physvols_0[] = "/dev/sda3";
14468     char *physvols[] = {
14469       physvols_0,
14470       NULL
14471     };
14472     int r;
14473     suppress_error = 0;
14474     r = guestfs_vgcreate (g, volgroup, physvols);
14475     if (r == -1)
14476       return -1;
14477   }
14478   {
14479     char **r;
14480     int i;
14481     suppress_error = 0;
14482     r = guestfs_vgs (g);
14483     if (r == NULL)
14484       return -1;
14485     if (!r[0]) {
14486       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14487       print_strings (r);
14488       return -1;
14489     }
14490     {
14491       char expected[] = "VG1";
14492       if (strcmp (r[0], expected) != 0) {
14493         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14494         return -1;
14495       }
14496     }
14497     if (!r[1]) {
14498       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14499       print_strings (r);
14500       return -1;
14501     }
14502     {
14503       char expected[] = "VG2";
14504       if (strcmp (r[1], expected) != 0) {
14505         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14506         return -1;
14507       }
14508     }
14509     if (r[2] != NULL) {
14510       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14511       print_strings (r);
14512       return -1;
14513     }
14514     for (i = 0; r[i] != NULL; ++i)
14515       free (r[i]);
14516     free (r);
14517   }
14518   return 0;
14519 }
14520
14521 static int test_pvs_0_skip (void)
14522 {
14523   const char *str;
14524
14525   str = getenv ("SKIP_TEST_PVS_0");
14526   if (str && strcmp (str, "1") == 0) return 1;
14527   str = getenv ("SKIP_TEST_PVS");
14528   if (str && strcmp (str, "1") == 0) return 1;
14529   return 0;
14530 }
14531
14532 static int test_pvs_0 (void)
14533 {
14534   if (test_pvs_0_skip ()) {
14535     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14536     return 0;
14537   }
14538
14539   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14540   {
14541     char device[] = "/dev/sda";
14542     int r;
14543     suppress_error = 0;
14544     r = guestfs_blockdev_setrw (g, device);
14545     if (r == -1)
14546       return -1;
14547   }
14548   {
14549     int r;
14550     suppress_error = 0;
14551     r = guestfs_umount_all (g);
14552     if (r == -1)
14553       return -1;
14554   }
14555   {
14556     int r;
14557     suppress_error = 0;
14558     r = guestfs_lvm_remove_all (g);
14559     if (r == -1)
14560       return -1;
14561   }
14562   {
14563     char device[] = "/dev/sda";
14564     char lines_0[] = ",";
14565     char *lines[] = {
14566       lines_0,
14567       NULL
14568     };
14569     int r;
14570     suppress_error = 0;
14571     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14572     if (r == -1)
14573       return -1;
14574   }
14575   {
14576     char device[] = "/dev/sda1";
14577     int r;
14578     suppress_error = 0;
14579     r = guestfs_pvcreate (g, device);
14580     if (r == -1)
14581       return -1;
14582   }
14583   {
14584     char volgroup[] = "VG";
14585     char physvols_0[] = "/dev/sda1";
14586     char *physvols[] = {
14587       physvols_0,
14588       NULL
14589     };
14590     int r;
14591     suppress_error = 0;
14592     r = guestfs_vgcreate (g, volgroup, physvols);
14593     if (r == -1)
14594       return -1;
14595   }
14596   {
14597     char logvol[] = "LV";
14598     char volgroup[] = "VG";
14599     int r;
14600     suppress_error = 0;
14601     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14602     if (r == -1)
14603       return -1;
14604   }
14605   {
14606     char fstype[] = "ext2";
14607     char device[] = "/dev/VG/LV";
14608     int r;
14609     suppress_error = 0;
14610     r = guestfs_mkfs (g, fstype, device);
14611     if (r == -1)
14612       return -1;
14613   }
14614   {
14615     char device[] = "/dev/VG/LV";
14616     char mountpoint[] = "/";
14617     int r;
14618     suppress_error = 0;
14619     r = guestfs_mount (g, device, mountpoint);
14620     if (r == -1)
14621       return -1;
14622   }
14623   /* TestOutputListOfDevices for pvs (0) */
14624   {
14625     char **r;
14626     int i;
14627     suppress_error = 0;
14628     r = guestfs_pvs (g);
14629     if (r == NULL)
14630       return -1;
14631     if (!r[0]) {
14632       fprintf (stderr, "test_pvs_0: short list returned from command\n");
14633       print_strings (r);
14634       return -1;
14635     }
14636     {
14637       char expected[] = "/dev/sda1";
14638       r[0][5] = 's';
14639       if (strcmp (r[0], expected) != 0) {
14640         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14641         return -1;
14642       }
14643     }
14644     if (r[1] != NULL) {
14645       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14646       print_strings (r);
14647       return -1;
14648     }
14649     for (i = 0; r[i] != NULL; ++i)
14650       free (r[i]);
14651     free (r);
14652   }
14653   return 0;
14654 }
14655
14656 static int test_pvs_1_skip (void)
14657 {
14658   const char *str;
14659
14660   str = getenv ("SKIP_TEST_PVS_1");
14661   if (str && strcmp (str, "1") == 0) return 1;
14662   str = getenv ("SKIP_TEST_PVS");
14663   if (str && strcmp (str, "1") == 0) return 1;
14664   return 0;
14665 }
14666
14667 static int test_pvs_1 (void)
14668 {
14669   if (test_pvs_1_skip ()) {
14670     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
14671     return 0;
14672   }
14673
14674   /* InitNone|InitEmpty for test_pvs_1 */
14675   {
14676     char device[] = "/dev/sda";
14677     int r;
14678     suppress_error = 0;
14679     r = guestfs_blockdev_setrw (g, device);
14680     if (r == -1)
14681       return -1;
14682   }
14683   {
14684     int r;
14685     suppress_error = 0;
14686     r = guestfs_umount_all (g);
14687     if (r == -1)
14688       return -1;
14689   }
14690   {
14691     int r;
14692     suppress_error = 0;
14693     r = guestfs_lvm_remove_all (g);
14694     if (r == -1)
14695       return -1;
14696   }
14697   /* TestOutputListOfDevices for pvs (1) */
14698   {
14699     char device[] = "/dev/sda";
14700     char lines_0[] = ",10";
14701     char lines_1[] = ",20";
14702     char lines_2[] = ",";
14703     char *lines[] = {
14704       lines_0,
14705       lines_1,
14706       lines_2,
14707       NULL
14708     };
14709     int r;
14710     suppress_error = 0;
14711     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14712     if (r == -1)
14713       return -1;
14714   }
14715   {
14716     char device[] = "/dev/sda1";
14717     int r;
14718     suppress_error = 0;
14719     r = guestfs_pvcreate (g, device);
14720     if (r == -1)
14721       return -1;
14722   }
14723   {
14724     char device[] = "/dev/sda2";
14725     int r;
14726     suppress_error = 0;
14727     r = guestfs_pvcreate (g, device);
14728     if (r == -1)
14729       return -1;
14730   }
14731   {
14732     char device[] = "/dev/sda3";
14733     int r;
14734     suppress_error = 0;
14735     r = guestfs_pvcreate (g, device);
14736     if (r == -1)
14737       return -1;
14738   }
14739   {
14740     char **r;
14741     int i;
14742     suppress_error = 0;
14743     r = guestfs_pvs (g);
14744     if (r == NULL)
14745       return -1;
14746     if (!r[0]) {
14747       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14748       print_strings (r);
14749       return -1;
14750     }
14751     {
14752       char expected[] = "/dev/sda1";
14753       r[0][5] = 's';
14754       if (strcmp (r[0], expected) != 0) {
14755         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14756         return -1;
14757       }
14758     }
14759     if (!r[1]) {
14760       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14761       print_strings (r);
14762       return -1;
14763     }
14764     {
14765       char expected[] = "/dev/sda2";
14766       r[1][5] = 's';
14767       if (strcmp (r[1], expected) != 0) {
14768         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14769         return -1;
14770       }
14771     }
14772     if (!r[2]) {
14773       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14774       print_strings (r);
14775       return -1;
14776     }
14777     {
14778       char expected[] = "/dev/sda3";
14779       r[2][5] = 's';
14780       if (strcmp (r[2], expected) != 0) {
14781         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14782         return -1;
14783       }
14784     }
14785     if (r[3] != NULL) {
14786       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
14787       print_strings (r);
14788       return -1;
14789     }
14790     for (i = 0; r[i] != NULL; ++i)
14791       free (r[i]);
14792     free (r);
14793   }
14794   return 0;
14795 }
14796
14797 static int test_list_partitions_0_skip (void)
14798 {
14799   const char *str;
14800
14801   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
14802   if (str && strcmp (str, "1") == 0) return 1;
14803   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14804   if (str && strcmp (str, "1") == 0) return 1;
14805   return 0;
14806 }
14807
14808 static int test_list_partitions_0 (void)
14809 {
14810   if (test_list_partitions_0_skip ()) {
14811     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
14812     return 0;
14813   }
14814
14815   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
14816   {
14817     char device[] = "/dev/sda";
14818     int r;
14819     suppress_error = 0;
14820     r = guestfs_blockdev_setrw (g, device);
14821     if (r == -1)
14822       return -1;
14823   }
14824   {
14825     int r;
14826     suppress_error = 0;
14827     r = guestfs_umount_all (g);
14828     if (r == -1)
14829       return -1;
14830   }
14831   {
14832     int r;
14833     suppress_error = 0;
14834     r = guestfs_lvm_remove_all (g);
14835     if (r == -1)
14836       return -1;
14837   }
14838   {
14839     char device[] = "/dev/sda";
14840     char lines_0[] = ",";
14841     char *lines[] = {
14842       lines_0,
14843       NULL
14844     };
14845     int r;
14846     suppress_error = 0;
14847     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14848     if (r == -1)
14849       return -1;
14850   }
14851   {
14852     char fstype[] = "ext2";
14853     char device[] = "/dev/sda1";
14854     int r;
14855     suppress_error = 0;
14856     r = guestfs_mkfs (g, fstype, device);
14857     if (r == -1)
14858       return -1;
14859   }
14860   {
14861     char device[] = "/dev/sda1";
14862     char mountpoint[] = "/";
14863     int r;
14864     suppress_error = 0;
14865     r = guestfs_mount (g, device, mountpoint);
14866     if (r == -1)
14867       return -1;
14868   }
14869   /* TestOutputListOfDevices for list_partitions (0) */
14870   {
14871     char **r;
14872     int i;
14873     suppress_error = 0;
14874     r = guestfs_list_partitions (g);
14875     if (r == NULL)
14876       return -1;
14877     if (!r[0]) {
14878       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
14879       print_strings (r);
14880       return -1;
14881     }
14882     {
14883       char expected[] = "/dev/sda1";
14884       r[0][5] = 's';
14885       if (strcmp (r[0], expected) != 0) {
14886         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14887         return -1;
14888       }
14889     }
14890     if (r[1] != NULL) {
14891       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
14892       print_strings (r);
14893       return -1;
14894     }
14895     for (i = 0; r[i] != NULL; ++i)
14896       free (r[i]);
14897     free (r);
14898   }
14899   return 0;
14900 }
14901
14902 static int test_list_partitions_1_skip (void)
14903 {
14904   const char *str;
14905
14906   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
14907   if (str && strcmp (str, "1") == 0) return 1;
14908   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14909   if (str && strcmp (str, "1") == 0) return 1;
14910   return 0;
14911 }
14912
14913 static int test_list_partitions_1 (void)
14914 {
14915   if (test_list_partitions_1_skip ()) {
14916     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
14917     return 0;
14918   }
14919
14920   /* InitNone|InitEmpty for test_list_partitions_1 */
14921   {
14922     char device[] = "/dev/sda";
14923     int r;
14924     suppress_error = 0;
14925     r = guestfs_blockdev_setrw (g, device);
14926     if (r == -1)
14927       return -1;
14928   }
14929   {
14930     int r;
14931     suppress_error = 0;
14932     r = guestfs_umount_all (g);
14933     if (r == -1)
14934       return -1;
14935   }
14936   {
14937     int r;
14938     suppress_error = 0;
14939     r = guestfs_lvm_remove_all (g);
14940     if (r == -1)
14941       return -1;
14942   }
14943   /* TestOutputListOfDevices for list_partitions (1) */
14944   {
14945     char device[] = "/dev/sda";
14946     char lines_0[] = ",10";
14947     char lines_1[] = ",20";
14948     char lines_2[] = ",";
14949     char *lines[] = {
14950       lines_0,
14951       lines_1,
14952       lines_2,
14953       NULL
14954     };
14955     int r;
14956     suppress_error = 0;
14957     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14958     if (r == -1)
14959       return -1;
14960   }
14961   {
14962     char **r;
14963     int i;
14964     suppress_error = 0;
14965     r = guestfs_list_partitions (g);
14966     if (r == NULL)
14967       return -1;
14968     if (!r[0]) {
14969       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14970       print_strings (r);
14971       return -1;
14972     }
14973     {
14974       char expected[] = "/dev/sda1";
14975       r[0][5] = 's';
14976       if (strcmp (r[0], expected) != 0) {
14977         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14978         return -1;
14979       }
14980     }
14981     if (!r[1]) {
14982       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14983       print_strings (r);
14984       return -1;
14985     }
14986     {
14987       char expected[] = "/dev/sda2";
14988       r[1][5] = 's';
14989       if (strcmp (r[1], expected) != 0) {
14990         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14991         return -1;
14992       }
14993     }
14994     if (!r[2]) {
14995       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14996       print_strings (r);
14997       return -1;
14998     }
14999     {
15000       char expected[] = "/dev/sda3";
15001       r[2][5] = 's';
15002       if (strcmp (r[2], expected) != 0) {
15003         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15004         return -1;
15005       }
15006     }
15007     if (r[3] != NULL) {
15008       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15009       print_strings (r);
15010       return -1;
15011     }
15012     for (i = 0; r[i] != NULL; ++i)
15013       free (r[i]);
15014     free (r);
15015   }
15016   return 0;
15017 }
15018
15019 static int test_list_devices_0_skip (void)
15020 {
15021   const char *str;
15022
15023   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15024   if (str && strcmp (str, "1") == 0) return 1;
15025   str = getenv ("SKIP_TEST_LIST_DEVICES");
15026   if (str && strcmp (str, "1") == 0) return 1;
15027   return 0;
15028 }
15029
15030 static int test_list_devices_0 (void)
15031 {
15032   if (test_list_devices_0_skip ()) {
15033     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15034     return 0;
15035   }
15036
15037   /* InitNone|InitEmpty for test_list_devices_0 */
15038   {
15039     char device[] = "/dev/sda";
15040     int r;
15041     suppress_error = 0;
15042     r = guestfs_blockdev_setrw (g, device);
15043     if (r == -1)
15044       return -1;
15045   }
15046   {
15047     int r;
15048     suppress_error = 0;
15049     r = guestfs_umount_all (g);
15050     if (r == -1)
15051       return -1;
15052   }
15053   {
15054     int r;
15055     suppress_error = 0;
15056     r = guestfs_lvm_remove_all (g);
15057     if (r == -1)
15058       return -1;
15059   }
15060   /* TestOutputListOfDevices for list_devices (0) */
15061   {
15062     char **r;
15063     int i;
15064     suppress_error = 0;
15065     r = guestfs_list_devices (g);
15066     if (r == NULL)
15067       return -1;
15068     if (!r[0]) {
15069       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15070       print_strings (r);
15071       return -1;
15072     }
15073     {
15074       char expected[] = "/dev/sda";
15075       r[0][5] = 's';
15076       if (strcmp (r[0], expected) != 0) {
15077         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15078         return -1;
15079       }
15080     }
15081     if (!r[1]) {
15082       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15083       print_strings (r);
15084       return -1;
15085     }
15086     {
15087       char expected[] = "/dev/sdb";
15088       r[1][5] = 's';
15089       if (strcmp (r[1], expected) != 0) {
15090         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15091         return -1;
15092       }
15093     }
15094     if (!r[2]) {
15095       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15096       print_strings (r);
15097       return -1;
15098     }
15099     {
15100       char expected[] = "/dev/sdc";
15101       r[2][5] = 's';
15102       if (strcmp (r[2], expected) != 0) {
15103         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15104         return -1;
15105       }
15106     }
15107     if (!r[3]) {
15108       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15109       print_strings (r);
15110       return -1;
15111     }
15112     {
15113       char expected[] = "/dev/sdd";
15114       r[3][5] = 's';
15115       if (strcmp (r[3], expected) != 0) {
15116         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15117         return -1;
15118       }
15119     }
15120     if (r[4] != NULL) {
15121       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15122       print_strings (r);
15123       return -1;
15124     }
15125     for (i = 0; r[i] != NULL; ++i)
15126       free (r[i]);
15127     free (r);
15128   }
15129   return 0;
15130 }
15131
15132 static int test_ls_0_skip (void)
15133 {
15134   const char *str;
15135
15136   str = getenv ("SKIP_TEST_LS_0");
15137   if (str && strcmp (str, "1") == 0) return 1;
15138   str = getenv ("SKIP_TEST_LS");
15139   if (str && strcmp (str, "1") == 0) return 1;
15140   return 0;
15141 }
15142
15143 static int test_ls_0 (void)
15144 {
15145   if (test_ls_0_skip ()) {
15146     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15147     return 0;
15148   }
15149
15150   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15151   {
15152     char device[] = "/dev/sda";
15153     int r;
15154     suppress_error = 0;
15155     r = guestfs_blockdev_setrw (g, device);
15156     if (r == -1)
15157       return -1;
15158   }
15159   {
15160     int r;
15161     suppress_error = 0;
15162     r = guestfs_umount_all (g);
15163     if (r == -1)
15164       return -1;
15165   }
15166   {
15167     int r;
15168     suppress_error = 0;
15169     r = guestfs_lvm_remove_all (g);
15170     if (r == -1)
15171       return -1;
15172   }
15173   {
15174     char device[] = "/dev/sda";
15175     char lines_0[] = ",";
15176     char *lines[] = {
15177       lines_0,
15178       NULL
15179     };
15180     int r;
15181     suppress_error = 0;
15182     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15183     if (r == -1)
15184       return -1;
15185   }
15186   {
15187     char fstype[] = "ext2";
15188     char device[] = "/dev/sda1";
15189     int r;
15190     suppress_error = 0;
15191     r = guestfs_mkfs (g, fstype, device);
15192     if (r == -1)
15193       return -1;
15194   }
15195   {
15196     char device[] = "/dev/sda1";
15197     char mountpoint[] = "/";
15198     int r;
15199     suppress_error = 0;
15200     r = guestfs_mount (g, device, mountpoint);
15201     if (r == -1)
15202       return -1;
15203   }
15204   /* TestOutputList for ls (0) */
15205   {
15206     char path[] = "/new";
15207     int r;
15208     suppress_error = 0;
15209     r = guestfs_touch (g, path);
15210     if (r == -1)
15211       return -1;
15212   }
15213   {
15214     char path[] = "/newer";
15215     int r;
15216     suppress_error = 0;
15217     r = guestfs_touch (g, path);
15218     if (r == -1)
15219       return -1;
15220   }
15221   {
15222     char path[] = "/newest";
15223     int r;
15224     suppress_error = 0;
15225     r = guestfs_touch (g, path);
15226     if (r == -1)
15227       return -1;
15228   }
15229   {
15230     char directory[] = "/";
15231     char **r;
15232     int i;
15233     suppress_error = 0;
15234     r = guestfs_ls (g, directory);
15235     if (r == NULL)
15236       return -1;
15237     if (!r[0]) {
15238       fprintf (stderr, "test_ls_0: short list returned from command\n");
15239       print_strings (r);
15240       return -1;
15241     }
15242     {
15243       char expected[] = "lost+found";
15244       if (strcmp (r[0], expected) != 0) {
15245         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15246         return -1;
15247       }
15248     }
15249     if (!r[1]) {
15250       fprintf (stderr, "test_ls_0: short list returned from command\n");
15251       print_strings (r);
15252       return -1;
15253     }
15254     {
15255       char expected[] = "new";
15256       if (strcmp (r[1], expected) != 0) {
15257         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15258         return -1;
15259       }
15260     }
15261     if (!r[2]) {
15262       fprintf (stderr, "test_ls_0: short list returned from command\n");
15263       print_strings (r);
15264       return -1;
15265     }
15266     {
15267       char expected[] = "newer";
15268       if (strcmp (r[2], expected) != 0) {
15269         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15270         return -1;
15271       }
15272     }
15273     if (!r[3]) {
15274       fprintf (stderr, "test_ls_0: short list returned from command\n");
15275       print_strings (r);
15276       return -1;
15277     }
15278     {
15279       char expected[] = "newest";
15280       if (strcmp (r[3], expected) != 0) {
15281         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15282         return -1;
15283       }
15284     }
15285     if (r[4] != NULL) {
15286       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15287       print_strings (r);
15288       return -1;
15289     }
15290     for (i = 0; r[i] != NULL; ++i)
15291       free (r[i]);
15292     free (r);
15293   }
15294   return 0;
15295 }
15296
15297 static int test_cat_0_skip (void)
15298 {
15299   const char *str;
15300
15301   str = getenv ("SKIP_TEST_CAT_0");
15302   if (str && strcmp (str, "1") == 0) return 1;
15303   str = getenv ("SKIP_TEST_CAT");
15304   if (str && strcmp (str, "1") == 0) return 1;
15305   return 0;
15306 }
15307
15308 static int test_cat_0 (void)
15309 {
15310   if (test_cat_0_skip ()) {
15311     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15312     return 0;
15313   }
15314
15315   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15316   {
15317     char device[] = "/dev/sda";
15318     int r;
15319     suppress_error = 0;
15320     r = guestfs_blockdev_setrw (g, device);
15321     if (r == -1)
15322       return -1;
15323   }
15324   {
15325     int r;
15326     suppress_error = 0;
15327     r = guestfs_umount_all (g);
15328     if (r == -1)
15329       return -1;
15330   }
15331   {
15332     int r;
15333     suppress_error = 0;
15334     r = guestfs_lvm_remove_all (g);
15335     if (r == -1)
15336       return -1;
15337   }
15338   {
15339     char device[] = "/dev/sda";
15340     char lines_0[] = ",";
15341     char *lines[] = {
15342       lines_0,
15343       NULL
15344     };
15345     int r;
15346     suppress_error = 0;
15347     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15348     if (r == -1)
15349       return -1;
15350   }
15351   {
15352     char fstype[] = "ext2";
15353     char device[] = "/dev/sda1";
15354     int r;
15355     suppress_error = 0;
15356     r = guestfs_mkfs (g, fstype, device);
15357     if (r == -1)
15358       return -1;
15359   }
15360   {
15361     char device[] = "/dev/sda1";
15362     char mountpoint[] = "/";
15363     int r;
15364     suppress_error = 0;
15365     r = guestfs_mount (g, device, mountpoint);
15366     if (r == -1)
15367       return -1;
15368   }
15369   /* TestOutput for cat (0) */
15370   char expected[] = "new file contents";
15371   {
15372     char path[] = "/new";
15373     char content[] = "new file contents";
15374     int r;
15375     suppress_error = 0;
15376     r = guestfs_write_file (g, path, content, 0);
15377     if (r == -1)
15378       return -1;
15379   }
15380   {
15381     char path[] = "/new";
15382     char *r;
15383     suppress_error = 0;
15384     r = guestfs_cat (g, path);
15385     if (r == NULL)
15386       return -1;
15387     if (strcmp (r, expected) != 0) {
15388       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15389       return -1;
15390     }
15391     free (r);
15392   }
15393   return 0;
15394 }
15395
15396 static int test_touch_0_skip (void)
15397 {
15398   const char *str;
15399
15400   str = getenv ("SKIP_TEST_TOUCH_0");
15401   if (str && strcmp (str, "1") == 0) return 1;
15402   str = getenv ("SKIP_TEST_TOUCH");
15403   if (str && strcmp (str, "1") == 0) return 1;
15404   return 0;
15405 }
15406
15407 static int test_touch_0 (void)
15408 {
15409   if (test_touch_0_skip ()) {
15410     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15411     return 0;
15412   }
15413
15414   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15415   {
15416     char device[] = "/dev/sda";
15417     int r;
15418     suppress_error = 0;
15419     r = guestfs_blockdev_setrw (g, device);
15420     if (r == -1)
15421       return -1;
15422   }
15423   {
15424     int r;
15425     suppress_error = 0;
15426     r = guestfs_umount_all (g);
15427     if (r == -1)
15428       return -1;
15429   }
15430   {
15431     int r;
15432     suppress_error = 0;
15433     r = guestfs_lvm_remove_all (g);
15434     if (r == -1)
15435       return -1;
15436   }
15437   {
15438     char device[] = "/dev/sda";
15439     char lines_0[] = ",";
15440     char *lines[] = {
15441       lines_0,
15442       NULL
15443     };
15444     int r;
15445     suppress_error = 0;
15446     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15447     if (r == -1)
15448       return -1;
15449   }
15450   {
15451     char fstype[] = "ext2";
15452     char device[] = "/dev/sda1";
15453     int r;
15454     suppress_error = 0;
15455     r = guestfs_mkfs (g, fstype, device);
15456     if (r == -1)
15457       return -1;
15458   }
15459   {
15460     char device[] = "/dev/sda1";
15461     char mountpoint[] = "/";
15462     int r;
15463     suppress_error = 0;
15464     r = guestfs_mount (g, device, mountpoint);
15465     if (r == -1)
15466       return -1;
15467   }
15468   /* TestOutputTrue for touch (0) */
15469   {
15470     char path[] = "/new";
15471     int r;
15472     suppress_error = 0;
15473     r = guestfs_touch (g, path);
15474     if (r == -1)
15475       return -1;
15476   }
15477   {
15478     char path[] = "/new";
15479     int r;
15480     suppress_error = 0;
15481     r = guestfs_exists (g, path);
15482     if (r == -1)
15483       return -1;
15484     if (!r) {
15485       fprintf (stderr, "test_touch_0: expected true, got false\n");
15486       return -1;
15487     }
15488   }
15489   return 0;
15490 }
15491
15492 static int test_sync_0_skip (void)
15493 {
15494   const char *str;
15495
15496   str = getenv ("SKIP_TEST_SYNC_0");
15497   if (str && strcmp (str, "1") == 0) return 1;
15498   str = getenv ("SKIP_TEST_SYNC");
15499   if (str && strcmp (str, "1") == 0) return 1;
15500   return 0;
15501 }
15502
15503 static int test_sync_0 (void)
15504 {
15505   if (test_sync_0_skip ()) {
15506     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15507     return 0;
15508   }
15509
15510   /* InitNone|InitEmpty for test_sync_0 */
15511   {
15512     char device[] = "/dev/sda";
15513     int r;
15514     suppress_error = 0;
15515     r = guestfs_blockdev_setrw (g, device);
15516     if (r == -1)
15517       return -1;
15518   }
15519   {
15520     int r;
15521     suppress_error = 0;
15522     r = guestfs_umount_all (g);
15523     if (r == -1)
15524       return -1;
15525   }
15526   {
15527     int r;
15528     suppress_error = 0;
15529     r = guestfs_lvm_remove_all (g);
15530     if (r == -1)
15531       return -1;
15532   }
15533   /* TestRun for sync (0) */
15534   {
15535     int r;
15536     suppress_error = 0;
15537     r = guestfs_sync (g);
15538     if (r == -1)
15539       return -1;
15540   }
15541   return 0;
15542 }
15543
15544 static int test_mount_0_skip (void)
15545 {
15546   const char *str;
15547
15548   str = getenv ("SKIP_TEST_MOUNT_0");
15549   if (str && strcmp (str, "1") == 0) return 1;
15550   str = getenv ("SKIP_TEST_MOUNT");
15551   if (str && strcmp (str, "1") == 0) return 1;
15552   return 0;
15553 }
15554
15555 static int test_mount_0 (void)
15556 {
15557   if (test_mount_0_skip ()) {
15558     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15559     return 0;
15560   }
15561
15562   /* InitNone|InitEmpty for test_mount_0 */
15563   {
15564     char device[] = "/dev/sda";
15565     int r;
15566     suppress_error = 0;
15567     r = guestfs_blockdev_setrw (g, device);
15568     if (r == -1)
15569       return -1;
15570   }
15571   {
15572     int r;
15573     suppress_error = 0;
15574     r = guestfs_umount_all (g);
15575     if (r == -1)
15576       return -1;
15577   }
15578   {
15579     int r;
15580     suppress_error = 0;
15581     r = guestfs_lvm_remove_all (g);
15582     if (r == -1)
15583       return -1;
15584   }
15585   /* TestOutput for mount (0) */
15586   char expected[] = "new file contents";
15587   {
15588     char device[] = "/dev/sda";
15589     char lines_0[] = ",";
15590     char *lines[] = {
15591       lines_0,
15592       NULL
15593     };
15594     int r;
15595     suppress_error = 0;
15596     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15597     if (r == -1)
15598       return -1;
15599   }
15600   {
15601     char fstype[] = "ext2";
15602     char device[] = "/dev/sda1";
15603     int r;
15604     suppress_error = 0;
15605     r = guestfs_mkfs (g, fstype, device);
15606     if (r == -1)
15607       return -1;
15608   }
15609   {
15610     char device[] = "/dev/sda1";
15611     char mountpoint[] = "/";
15612     int r;
15613     suppress_error = 0;
15614     r = guestfs_mount (g, device, mountpoint);
15615     if (r == -1)
15616       return -1;
15617   }
15618   {
15619     char path[] = "/new";
15620     char content[] = "new file contents";
15621     int r;
15622     suppress_error = 0;
15623     r = guestfs_write_file (g, path, content, 0);
15624     if (r == -1)
15625       return -1;
15626   }
15627   {
15628     char path[] = "/new";
15629     char *r;
15630     suppress_error = 0;
15631     r = guestfs_cat (g, path);
15632     if (r == NULL)
15633       return -1;
15634     if (strcmp (r, expected) != 0) {
15635       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
15636       return -1;
15637     }
15638     free (r);
15639   }
15640   return 0;
15641 }
15642
15643 int main (int argc, char *argv[])
15644 {
15645   char c = 0;
15646   int failed = 0;
15647   const char *filename;
15648   int fd;
15649   int nr_tests, test_num = 0;
15650
15651   no_test_warnings ();
15652
15653   g = guestfs_create ();
15654   if (g == NULL) {
15655     printf ("guestfs_create FAILED\n");
15656     exit (1);
15657   }
15658
15659   guestfs_set_error_handler (g, print_error, NULL);
15660
15661   guestfs_set_path (g, "../appliance");
15662
15663   filename = "test1.img";
15664   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15665   if (fd == -1) {
15666     perror (filename);
15667     exit (1);
15668   }
15669   if (lseek (fd, 524288000, SEEK_SET) == -1) {
15670     perror ("lseek");
15671     close (fd);
15672     unlink (filename);
15673     exit (1);
15674   }
15675   if (write (fd, &c, 1) == -1) {
15676     perror ("write");
15677     close (fd);
15678     unlink (filename);
15679     exit (1);
15680   }
15681   if (close (fd) == -1) {
15682     perror (filename);
15683     unlink (filename);
15684     exit (1);
15685   }
15686   if (guestfs_add_drive (g, filename) == -1) {
15687     printf ("guestfs_add_drive %s FAILED\n", filename);
15688     exit (1);
15689   }
15690
15691   filename = "test2.img";
15692   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15693   if (fd == -1) {
15694     perror (filename);
15695     exit (1);
15696   }
15697   if (lseek (fd, 52428800, SEEK_SET) == -1) {
15698     perror ("lseek");
15699     close (fd);
15700     unlink (filename);
15701     exit (1);
15702   }
15703   if (write (fd, &c, 1) == -1) {
15704     perror ("write");
15705     close (fd);
15706     unlink (filename);
15707     exit (1);
15708   }
15709   if (close (fd) == -1) {
15710     perror (filename);
15711     unlink (filename);
15712     exit (1);
15713   }
15714   if (guestfs_add_drive (g, filename) == -1) {
15715     printf ("guestfs_add_drive %s FAILED\n", filename);
15716     exit (1);
15717   }
15718
15719   filename = "test3.img";
15720   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15721   if (fd == -1) {
15722     perror (filename);
15723     exit (1);
15724   }
15725   if (lseek (fd, 10485760, SEEK_SET) == -1) {
15726     perror ("lseek");
15727     close (fd);
15728     unlink (filename);
15729     exit (1);
15730   }
15731   if (write (fd, &c, 1) == -1) {
15732     perror ("write");
15733     close (fd);
15734     unlink (filename);
15735     exit (1);
15736   }
15737   if (close (fd) == -1) {
15738     perror (filename);
15739     unlink (filename);
15740     exit (1);
15741   }
15742   if (guestfs_add_drive (g, filename) == -1) {
15743     printf ("guestfs_add_drive %s FAILED\n", filename);
15744     exit (1);
15745   }
15746
15747   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
15748     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
15749     exit (1);
15750   }
15751
15752   if (guestfs_launch (g) == -1) {
15753     printf ("guestfs_launch FAILED\n");
15754     exit (1);
15755   }
15756
15757   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
15758   alarm (600);
15759
15760   if (guestfs_wait_ready (g) == -1) {
15761     printf ("guestfs_wait_ready FAILED\n");
15762     exit (1);
15763   }
15764
15765   /* Cancel previous alarm. */
15766   alarm (0);
15767
15768   nr_tests = 146;
15769
15770   test_num++;
15771   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
15772   if (test_ntfs_3g_probe_0 () == -1) {
15773     printf ("test_ntfs_3g_probe_0 FAILED\n");
15774     failed++;
15775   }
15776   test_num++;
15777   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
15778   if (test_ntfs_3g_probe_1 () == -1) {
15779     printf ("test_ntfs_3g_probe_1 FAILED\n");
15780     failed++;
15781   }
15782   test_num++;
15783   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
15784   if (test_sleep_0 () == -1) {
15785     printf ("test_sleep_0 FAILED\n");
15786     failed++;
15787   }
15788   test_num++;
15789   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
15790   if (test_find_0 () == -1) {
15791     printf ("test_find_0 FAILED\n");
15792     failed++;
15793   }
15794   test_num++;
15795   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
15796   if (test_find_1 () == -1) {
15797     printf ("test_find_1 FAILED\n");
15798     failed++;
15799   }
15800   test_num++;
15801   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
15802   if (test_find_2 () == -1) {
15803     printf ("test_find_2 FAILED\n");
15804     failed++;
15805   }
15806   test_num++;
15807   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
15808   if (test_lvresize_0 () == -1) {
15809     printf ("test_lvresize_0 FAILED\n");
15810     failed++;
15811   }
15812   test_num++;
15813   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
15814   if (test_zerofree_0 () == -1) {
15815     printf ("test_zerofree_0 FAILED\n");
15816     failed++;
15817   }
15818   test_num++;
15819   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
15820   if (test_hexdump_0 () == -1) {
15821     printf ("test_hexdump_0 FAILED\n");
15822     failed++;
15823   }
15824   test_num++;
15825   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
15826   if (test_strings_e_0 () == -1) {
15827     printf ("test_strings_e_0 FAILED\n");
15828     failed++;
15829   }
15830   test_num++;
15831   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
15832   if (test_strings_e_1 () == -1) {
15833     printf ("test_strings_e_1 FAILED\n");
15834     failed++;
15835   }
15836   test_num++;
15837   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
15838   if (test_strings_0 () == -1) {
15839     printf ("test_strings_0 FAILED\n");
15840     failed++;
15841   }
15842   test_num++;
15843   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
15844   if (test_strings_1 () == -1) {
15845     printf ("test_strings_1 FAILED\n");
15846     failed++;
15847   }
15848   test_num++;
15849   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
15850   if (test_equal_0 () == -1) {
15851     printf ("test_equal_0 FAILED\n");
15852     failed++;
15853   }
15854   test_num++;
15855   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
15856   if (test_equal_1 () == -1) {
15857     printf ("test_equal_1 FAILED\n");
15858     failed++;
15859   }
15860   test_num++;
15861   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
15862   if (test_equal_2 () == -1) {
15863     printf ("test_equal_2 FAILED\n");
15864     failed++;
15865   }
15866   test_num++;
15867   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
15868   if (test_ping_daemon_0 () == -1) {
15869     printf ("test_ping_daemon_0 FAILED\n");
15870     failed++;
15871   }
15872   test_num++;
15873   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
15874   if (test_dmesg_0 () == -1) {
15875     printf ("test_dmesg_0 FAILED\n");
15876     failed++;
15877   }
15878   test_num++;
15879   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
15880   if (test_drop_caches_0 () == -1) {
15881     printf ("test_drop_caches_0 FAILED\n");
15882     failed++;
15883   }
15884   test_num++;
15885   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
15886   if (test_mv_0 () == -1) {
15887     printf ("test_mv_0 FAILED\n");
15888     failed++;
15889   }
15890   test_num++;
15891   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
15892   if (test_mv_1 () == -1) {
15893     printf ("test_mv_1 FAILED\n");
15894     failed++;
15895   }
15896   test_num++;
15897   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
15898   if (test_cp_a_0 () == -1) {
15899     printf ("test_cp_a_0 FAILED\n");
15900     failed++;
15901   }
15902   test_num++;
15903   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
15904   if (test_cp_0 () == -1) {
15905     printf ("test_cp_0 FAILED\n");
15906     failed++;
15907   }
15908   test_num++;
15909   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
15910   if (test_cp_1 () == -1) {
15911     printf ("test_cp_1 FAILED\n");
15912     failed++;
15913   }
15914   test_num++;
15915   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
15916   if (test_cp_2 () == -1) {
15917     printf ("test_cp_2 FAILED\n");
15918     failed++;
15919   }
15920   test_num++;
15921   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
15922   if (test_grub_install_0 () == -1) {
15923     printf ("test_grub_install_0 FAILED\n");
15924     failed++;
15925   }
15926   test_num++;
15927   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
15928   if (test_zero_0 () == -1) {
15929     printf ("test_zero_0 FAILED\n");
15930     failed++;
15931   }
15932   test_num++;
15933   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
15934   if (test_fsck_0 () == -1) {
15935     printf ("test_fsck_0 FAILED\n");
15936     failed++;
15937   }
15938   test_num++;
15939   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
15940   if (test_fsck_1 () == -1) {
15941     printf ("test_fsck_1 FAILED\n");
15942     failed++;
15943   }
15944   test_num++;
15945   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
15946   if (test_set_e2uuid_0 () == -1) {
15947     printf ("test_set_e2uuid_0 FAILED\n");
15948     failed++;
15949   }
15950   test_num++;
15951   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
15952   if (test_set_e2uuid_1 () == -1) {
15953     printf ("test_set_e2uuid_1 FAILED\n");
15954     failed++;
15955   }
15956   test_num++;
15957   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
15958   if (test_set_e2uuid_2 () == -1) {
15959     printf ("test_set_e2uuid_2 FAILED\n");
15960     failed++;
15961   }
15962   test_num++;
15963   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
15964   if (test_set_e2uuid_3 () == -1) {
15965     printf ("test_set_e2uuid_3 FAILED\n");
15966     failed++;
15967   }
15968   test_num++;
15969   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
15970   if (test_set_e2label_0 () == -1) {
15971     printf ("test_set_e2label_0 FAILED\n");
15972     failed++;
15973   }
15974   test_num++;
15975   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
15976   if (test_pvremove_0 () == -1) {
15977     printf ("test_pvremove_0 FAILED\n");
15978     failed++;
15979   }
15980   test_num++;
15981   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
15982   if (test_pvremove_1 () == -1) {
15983     printf ("test_pvremove_1 FAILED\n");
15984     failed++;
15985   }
15986   test_num++;
15987   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
15988   if (test_pvremove_2 () == -1) {
15989     printf ("test_pvremove_2 FAILED\n");
15990     failed++;
15991   }
15992   test_num++;
15993   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
15994   if (test_vgremove_0 () == -1) {
15995     printf ("test_vgremove_0 FAILED\n");
15996     failed++;
15997   }
15998   test_num++;
15999   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16000   if (test_vgremove_1 () == -1) {
16001     printf ("test_vgremove_1 FAILED\n");
16002     failed++;
16003   }
16004   test_num++;
16005   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16006   if (test_lvremove_0 () == -1) {
16007     printf ("test_lvremove_0 FAILED\n");
16008     failed++;
16009   }
16010   test_num++;
16011   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16012   if (test_lvremove_1 () == -1) {
16013     printf ("test_lvremove_1 FAILED\n");
16014     failed++;
16015   }
16016   test_num++;
16017   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16018   if (test_lvremove_2 () == -1) {
16019     printf ("test_lvremove_2 FAILED\n");
16020     failed++;
16021   }
16022   test_num++;
16023   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16024   if (test_mount_ro_0 () == -1) {
16025     printf ("test_mount_ro_0 FAILED\n");
16026     failed++;
16027   }
16028   test_num++;
16029   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16030   if (test_mount_ro_1 () == -1) {
16031     printf ("test_mount_ro_1 FAILED\n");
16032     failed++;
16033   }
16034   test_num++;
16035   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16036   if (test_tgz_in_0 () == -1) {
16037     printf ("test_tgz_in_0 FAILED\n");
16038     failed++;
16039   }
16040   test_num++;
16041   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16042   if (test_tar_in_0 () == -1) {
16043     printf ("test_tar_in_0 FAILED\n");
16044     failed++;
16045   }
16046   test_num++;
16047   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16048   if (test_checksum_0 () == -1) {
16049     printf ("test_checksum_0 FAILED\n");
16050     failed++;
16051   }
16052   test_num++;
16053   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16054   if (test_checksum_1 () == -1) {
16055     printf ("test_checksum_1 FAILED\n");
16056     failed++;
16057   }
16058   test_num++;
16059   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16060   if (test_checksum_2 () == -1) {
16061     printf ("test_checksum_2 FAILED\n");
16062     failed++;
16063   }
16064   test_num++;
16065   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16066   if (test_checksum_3 () == -1) {
16067     printf ("test_checksum_3 FAILED\n");
16068     failed++;
16069   }
16070   test_num++;
16071   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16072   if (test_checksum_4 () == -1) {
16073     printf ("test_checksum_4 FAILED\n");
16074     failed++;
16075   }
16076   test_num++;
16077   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16078   if (test_checksum_5 () == -1) {
16079     printf ("test_checksum_5 FAILED\n");
16080     failed++;
16081   }
16082   test_num++;
16083   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16084   if (test_checksum_6 () == -1) {
16085     printf ("test_checksum_6 FAILED\n");
16086     failed++;
16087   }
16088   test_num++;
16089   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16090   if (test_checksum_7 () == -1) {
16091     printf ("test_checksum_7 FAILED\n");
16092     failed++;
16093   }
16094   test_num++;
16095   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16096   if (test_checksum_8 () == -1) {
16097     printf ("test_checksum_8 FAILED\n");
16098     failed++;
16099   }
16100   test_num++;
16101   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16102   if (test_download_0 () == -1) {
16103     printf ("test_download_0 FAILED\n");
16104     failed++;
16105   }
16106   test_num++;
16107   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16108   if (test_upload_0 () == -1) {
16109     printf ("test_upload_0 FAILED\n");
16110     failed++;
16111   }
16112   test_num++;
16113   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16114   if (test_blockdev_rereadpt_0 () == -1) {
16115     printf ("test_blockdev_rereadpt_0 FAILED\n");
16116     failed++;
16117   }
16118   test_num++;
16119   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16120   if (test_blockdev_flushbufs_0 () == -1) {
16121     printf ("test_blockdev_flushbufs_0 FAILED\n");
16122     failed++;
16123   }
16124   test_num++;
16125   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16126   if (test_blockdev_getsize64_0 () == -1) {
16127     printf ("test_blockdev_getsize64_0 FAILED\n");
16128     failed++;
16129   }
16130   test_num++;
16131   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16132   if (test_blockdev_getsz_0 () == -1) {
16133     printf ("test_blockdev_getsz_0 FAILED\n");
16134     failed++;
16135   }
16136   test_num++;
16137   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16138   if (test_blockdev_getbsz_0 () == -1) {
16139     printf ("test_blockdev_getbsz_0 FAILED\n");
16140     failed++;
16141   }
16142   test_num++;
16143   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16144   if (test_blockdev_getss_0 () == -1) {
16145     printf ("test_blockdev_getss_0 FAILED\n");
16146     failed++;
16147   }
16148   test_num++;
16149   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16150   if (test_blockdev_getro_0 () == -1) {
16151     printf ("test_blockdev_getro_0 FAILED\n");
16152     failed++;
16153   }
16154   test_num++;
16155   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16156   if (test_blockdev_setrw_0 () == -1) {
16157     printf ("test_blockdev_setrw_0 FAILED\n");
16158     failed++;
16159   }
16160   test_num++;
16161   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16162   if (test_blockdev_setro_0 () == -1) {
16163     printf ("test_blockdev_setro_0 FAILED\n");
16164     failed++;
16165   }
16166   test_num++;
16167   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16168   if (test_statvfs_0 () == -1) {
16169     printf ("test_statvfs_0 FAILED\n");
16170     failed++;
16171   }
16172   test_num++;
16173   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16174   if (test_lstat_0 () == -1) {
16175     printf ("test_lstat_0 FAILED\n");
16176     failed++;
16177   }
16178   test_num++;
16179   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16180   if (test_stat_0 () == -1) {
16181     printf ("test_stat_0 FAILED\n");
16182     failed++;
16183   }
16184   test_num++;
16185   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16186   if (test_command_lines_0 () == -1) {
16187     printf ("test_command_lines_0 FAILED\n");
16188     failed++;
16189   }
16190   test_num++;
16191   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16192   if (test_command_lines_1 () == -1) {
16193     printf ("test_command_lines_1 FAILED\n");
16194     failed++;
16195   }
16196   test_num++;
16197   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16198   if (test_command_lines_2 () == -1) {
16199     printf ("test_command_lines_2 FAILED\n");
16200     failed++;
16201   }
16202   test_num++;
16203   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16204   if (test_command_lines_3 () == -1) {
16205     printf ("test_command_lines_3 FAILED\n");
16206     failed++;
16207   }
16208   test_num++;
16209   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16210   if (test_command_lines_4 () == -1) {
16211     printf ("test_command_lines_4 FAILED\n");
16212     failed++;
16213   }
16214   test_num++;
16215   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16216   if (test_command_lines_5 () == -1) {
16217     printf ("test_command_lines_5 FAILED\n");
16218     failed++;
16219   }
16220   test_num++;
16221   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16222   if (test_command_lines_6 () == -1) {
16223     printf ("test_command_lines_6 FAILED\n");
16224     failed++;
16225   }
16226   test_num++;
16227   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16228   if (test_command_lines_7 () == -1) {
16229     printf ("test_command_lines_7 FAILED\n");
16230     failed++;
16231   }
16232   test_num++;
16233   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16234   if (test_command_lines_8 () == -1) {
16235     printf ("test_command_lines_8 FAILED\n");
16236     failed++;
16237   }
16238   test_num++;
16239   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16240   if (test_command_lines_9 () == -1) {
16241     printf ("test_command_lines_9 FAILED\n");
16242     failed++;
16243   }
16244   test_num++;
16245   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16246   if (test_command_lines_10 () == -1) {
16247     printf ("test_command_lines_10 FAILED\n");
16248     failed++;
16249   }
16250   test_num++;
16251   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16252   if (test_command_0 () == -1) {
16253     printf ("test_command_0 FAILED\n");
16254     failed++;
16255   }
16256   test_num++;
16257   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16258   if (test_command_1 () == -1) {
16259     printf ("test_command_1 FAILED\n");
16260     failed++;
16261   }
16262   test_num++;
16263   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16264   if (test_command_2 () == -1) {
16265     printf ("test_command_2 FAILED\n");
16266     failed++;
16267   }
16268   test_num++;
16269   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16270   if (test_command_3 () == -1) {
16271     printf ("test_command_3 FAILED\n");
16272     failed++;
16273   }
16274   test_num++;
16275   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16276   if (test_command_4 () == -1) {
16277     printf ("test_command_4 FAILED\n");
16278     failed++;
16279   }
16280   test_num++;
16281   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16282   if (test_command_5 () == -1) {
16283     printf ("test_command_5 FAILED\n");
16284     failed++;
16285   }
16286   test_num++;
16287   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16288   if (test_command_6 () == -1) {
16289     printf ("test_command_6 FAILED\n");
16290     failed++;
16291   }
16292   test_num++;
16293   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16294   if (test_command_7 () == -1) {
16295     printf ("test_command_7 FAILED\n");
16296     failed++;
16297   }
16298   test_num++;
16299   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16300   if (test_command_8 () == -1) {
16301     printf ("test_command_8 FAILED\n");
16302     failed++;
16303   }
16304   test_num++;
16305   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16306   if (test_command_9 () == -1) {
16307     printf ("test_command_9 FAILED\n");
16308     failed++;
16309   }
16310   test_num++;
16311   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16312   if (test_command_10 () == -1) {
16313     printf ("test_command_10 FAILED\n");
16314     failed++;
16315   }
16316   test_num++;
16317   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16318   if (test_command_11 () == -1) {
16319     printf ("test_command_11 FAILED\n");
16320     failed++;
16321   }
16322   test_num++;
16323   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16324   if (test_file_0 () == -1) {
16325     printf ("test_file_0 FAILED\n");
16326     failed++;
16327   }
16328   test_num++;
16329   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16330   if (test_file_1 () == -1) {
16331     printf ("test_file_1 FAILED\n");
16332     failed++;
16333   }
16334   test_num++;
16335   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16336   if (test_file_2 () == -1) {
16337     printf ("test_file_2 FAILED\n");
16338     failed++;
16339   }
16340   test_num++;
16341   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16342   if (test_umount_all_0 () == -1) {
16343     printf ("test_umount_all_0 FAILED\n");
16344     failed++;
16345   }
16346   test_num++;
16347   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16348   if (test_umount_all_1 () == -1) {
16349     printf ("test_umount_all_1 FAILED\n");
16350     failed++;
16351   }
16352   test_num++;
16353   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16354   if (test_mounts_0 () == -1) {
16355     printf ("test_mounts_0 FAILED\n");
16356     failed++;
16357   }
16358   test_num++;
16359   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16360   if (test_umount_0 () == -1) {
16361     printf ("test_umount_0 FAILED\n");
16362     failed++;
16363   }
16364   test_num++;
16365   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16366   if (test_umount_1 () == -1) {
16367     printf ("test_umount_1 FAILED\n");
16368     failed++;
16369   }
16370   test_num++;
16371   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16372   if (test_write_file_0 () == -1) {
16373     printf ("test_write_file_0 FAILED\n");
16374     failed++;
16375   }
16376   test_num++;
16377   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16378   if (test_write_file_1 () == -1) {
16379     printf ("test_write_file_1 FAILED\n");
16380     failed++;
16381   }
16382   test_num++;
16383   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16384   if (test_write_file_2 () == -1) {
16385     printf ("test_write_file_2 FAILED\n");
16386     failed++;
16387   }
16388   test_num++;
16389   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16390   if (test_write_file_3 () == -1) {
16391     printf ("test_write_file_3 FAILED\n");
16392     failed++;
16393   }
16394   test_num++;
16395   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16396   if (test_write_file_4 () == -1) {
16397     printf ("test_write_file_4 FAILED\n");
16398     failed++;
16399   }
16400   test_num++;
16401   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16402   if (test_write_file_5 () == -1) {
16403     printf ("test_write_file_5 FAILED\n");
16404     failed++;
16405   }
16406   test_num++;
16407   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16408   if (test_mkfs_0 () == -1) {
16409     printf ("test_mkfs_0 FAILED\n");
16410     failed++;
16411   }
16412   test_num++;
16413   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16414   if (test_lvcreate_0 () == -1) {
16415     printf ("test_lvcreate_0 FAILED\n");
16416     failed++;
16417   }
16418   test_num++;
16419   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16420   if (test_vgcreate_0 () == -1) {
16421     printf ("test_vgcreate_0 FAILED\n");
16422     failed++;
16423   }
16424   test_num++;
16425   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16426   if (test_pvcreate_0 () == -1) {
16427     printf ("test_pvcreate_0 FAILED\n");
16428     failed++;
16429   }
16430   test_num++;
16431   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16432   if (test_is_dir_0 () == -1) {
16433     printf ("test_is_dir_0 FAILED\n");
16434     failed++;
16435   }
16436   test_num++;
16437   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16438   if (test_is_dir_1 () == -1) {
16439     printf ("test_is_dir_1 FAILED\n");
16440     failed++;
16441   }
16442   test_num++;
16443   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16444   if (test_is_file_0 () == -1) {
16445     printf ("test_is_file_0 FAILED\n");
16446     failed++;
16447   }
16448   test_num++;
16449   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16450   if (test_is_file_1 () == -1) {
16451     printf ("test_is_file_1 FAILED\n");
16452     failed++;
16453   }
16454   test_num++;
16455   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16456   if (test_exists_0 () == -1) {
16457     printf ("test_exists_0 FAILED\n");
16458     failed++;
16459   }
16460   test_num++;
16461   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16462   if (test_exists_1 () == -1) {
16463     printf ("test_exists_1 FAILED\n");
16464     failed++;
16465   }
16466   test_num++;
16467   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16468   if (test_mkdir_p_0 () == -1) {
16469     printf ("test_mkdir_p_0 FAILED\n");
16470     failed++;
16471   }
16472   test_num++;
16473   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16474   if (test_mkdir_p_1 () == -1) {
16475     printf ("test_mkdir_p_1 FAILED\n");
16476     failed++;
16477   }
16478   test_num++;
16479   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16480   if (test_mkdir_p_2 () == -1) {
16481     printf ("test_mkdir_p_2 FAILED\n");
16482     failed++;
16483   }
16484   test_num++;
16485   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16486   if (test_mkdir_p_3 () == -1) {
16487     printf ("test_mkdir_p_3 FAILED\n");
16488     failed++;
16489   }
16490   test_num++;
16491   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16492   if (test_mkdir_p_4 () == -1) {
16493     printf ("test_mkdir_p_4 FAILED\n");
16494     failed++;
16495   }
16496   test_num++;
16497   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16498   if (test_mkdir_0 () == -1) {
16499     printf ("test_mkdir_0 FAILED\n");
16500     failed++;
16501   }
16502   test_num++;
16503   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16504   if (test_mkdir_1 () == -1) {
16505     printf ("test_mkdir_1 FAILED\n");
16506     failed++;
16507   }
16508   test_num++;
16509   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16510   if (test_rm_rf_0 () == -1) {
16511     printf ("test_rm_rf_0 FAILED\n");
16512     failed++;
16513   }
16514   test_num++;
16515   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16516   if (test_rmdir_0 () == -1) {
16517     printf ("test_rmdir_0 FAILED\n");
16518     failed++;
16519   }
16520   test_num++;
16521   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16522   if (test_rmdir_1 () == -1) {
16523     printf ("test_rmdir_1 FAILED\n");
16524     failed++;
16525   }
16526   test_num++;
16527   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16528   if (test_rmdir_2 () == -1) {
16529     printf ("test_rmdir_2 FAILED\n");
16530     failed++;
16531   }
16532   test_num++;
16533   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16534   if (test_rm_0 () == -1) {
16535     printf ("test_rm_0 FAILED\n");
16536     failed++;
16537   }
16538   test_num++;
16539   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16540   if (test_rm_1 () == -1) {
16541     printf ("test_rm_1 FAILED\n");
16542     failed++;
16543   }
16544   test_num++;
16545   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16546   if (test_rm_2 () == -1) {
16547     printf ("test_rm_2 FAILED\n");
16548     failed++;
16549   }
16550   test_num++;
16551   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16552   if (test_read_lines_0 () == -1) {
16553     printf ("test_read_lines_0 FAILED\n");
16554     failed++;
16555   }
16556   test_num++;
16557   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16558   if (test_read_lines_1 () == -1) {
16559     printf ("test_read_lines_1 FAILED\n");
16560     failed++;
16561   }
16562   test_num++;
16563   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16564   if (test_lvs_0 () == -1) {
16565     printf ("test_lvs_0 FAILED\n");
16566     failed++;
16567   }
16568   test_num++;
16569   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16570   if (test_lvs_1 () == -1) {
16571     printf ("test_lvs_1 FAILED\n");
16572     failed++;
16573   }
16574   test_num++;
16575   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16576   if (test_vgs_0 () == -1) {
16577     printf ("test_vgs_0 FAILED\n");
16578     failed++;
16579   }
16580   test_num++;
16581   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16582   if (test_vgs_1 () == -1) {
16583     printf ("test_vgs_1 FAILED\n");
16584     failed++;
16585   }
16586   test_num++;
16587   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16588   if (test_pvs_0 () == -1) {
16589     printf ("test_pvs_0 FAILED\n");
16590     failed++;
16591   }
16592   test_num++;
16593   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16594   if (test_pvs_1 () == -1) {
16595     printf ("test_pvs_1 FAILED\n");
16596     failed++;
16597   }
16598   test_num++;
16599   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16600   if (test_list_partitions_0 () == -1) {
16601     printf ("test_list_partitions_0 FAILED\n");
16602     failed++;
16603   }
16604   test_num++;
16605   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16606   if (test_list_partitions_1 () == -1) {
16607     printf ("test_list_partitions_1 FAILED\n");
16608     failed++;
16609   }
16610   test_num++;
16611   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16612   if (test_list_devices_0 () == -1) {
16613     printf ("test_list_devices_0 FAILED\n");
16614     failed++;
16615   }
16616   test_num++;
16617   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16618   if (test_ls_0 () == -1) {
16619     printf ("test_ls_0 FAILED\n");
16620     failed++;
16621   }
16622   test_num++;
16623   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16624   if (test_cat_0 () == -1) {
16625     printf ("test_cat_0 FAILED\n");
16626     failed++;
16627   }
16628   test_num++;
16629   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
16630   if (test_touch_0 () == -1) {
16631     printf ("test_touch_0 FAILED\n");
16632     failed++;
16633   }
16634   test_num++;
16635   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
16636   if (test_sync_0 () == -1) {
16637     printf ("test_sync_0 FAILED\n");
16638     failed++;
16639   }
16640   test_num++;
16641   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
16642   if (test_mount_0 () == -1) {
16643     printf ("test_mount_0 FAILED\n");
16644     failed++;
16645   }
16646
16647   guestfs_close (g);
16648   unlink ("test1.img");
16649   unlink ("test2.img");
16650   unlink ("test3.img");
16651
16652   if (failed > 0) {
16653     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
16654     exit (1);
16655   }
16656
16657   exit (0);
16658 }