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   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 154 }
 155
 156 static int test_scrub_file_0_skip (void)
 157 {
 158   const char *str;
 159
 160   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
 161   if (str && strcmp (str, "1") == 0) return 1;
 162   str = getenv ("SKIP_TEST_SCRUB_FILE");
 163   if (str && strcmp (str, "1") == 0) return 1;
 164   return 0;
 165 }
 166
 167 static int test_scrub_file_0 (void)
 168 {
 169   if (test_scrub_file_0_skip ()) {
 170     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_scrub_file_0");
 171     return 0;
 172   }
 173
 174   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
 175   {
 176     char device[] = "/dev/sda";
 177     int r;
 178     suppress_error = 0;
 179     r = guestfs_blockdev_setrw (g, device);
 180     if (r == -1)
 181       return -1;
 182   }
 183   {
 184     int r;
 185     suppress_error = 0;
 186     r = guestfs_umount_all (g);
 187     if (r == -1)
 188       return -1;
 189   }
 190   {
 191     int r;
 192     suppress_error = 0;
 193     r = guestfs_lvm_remove_all (g);
 194     if (r == -1)
 195       return -1;
 196   }
 197   {
 198     char device[] = "/dev/sda";
 199     char lines_0[] = ",";
 200     char *lines[] = {
 201       lines_0,
 202       NULL
 203     };
 204     int r;
 205     suppress_error = 0;
 206     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 207     if (r == -1)
 208       return -1;
 209   }
 210   {
 211     char fstype[] = "ext2";
 212     char device[] = "/dev/sda1";
 213     int r;
 214     suppress_error = 0;
 215     r = guestfs_mkfs (g, fstype, device);
 216     if (r == -1)
 217       return -1;
 218   }
 219   {
 220     char device[] = "/dev/sda1";
 221     char mountpoint[] = "/";
 222     int r;
 223     suppress_error = 0;
 224     r = guestfs_mount (g, device, mountpoint);
 225     if (r == -1)
 226       return -1;
 227   }
 228   /* TestRun for scrub_file (0) */
 229   {
 230     char path[] = "/file";
 231     char content[] = "content";
 232     int r;
 233     suppress_error = 0;
 234     r = guestfs_write_file (g, path, content, 0);
 235     if (r == -1)
 236       return -1;
 237   }
 238   {
 239     char file[] = "/file";
 240     int r;
 241     suppress_error = 0;
 242     r = guestfs_scrub_file (g, file);
 243     if (r == -1)
 244       return -1;
 245   }
 246   return 0;
 247 }
 248
 249 static int test_scrub_device_0_skip (void)
 250 {
 251   const char *str;
 252
 253   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
 254   if (str && strcmp (str, "1") == 0) return 1;
 255   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
 256   if (str && strcmp (str, "1") == 0) return 1;
 257   return 0;
 258 }
 259
 260 static int test_scrub_device_0 (void)
 261 {
 262   if (test_scrub_device_0_skip ()) {
 263     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_scrub_device_0");
 264     return 0;
 265   }
 266
 267   /* InitNone|InitEmpty for test_scrub_device_0 */
 268   {
 269     char device[] = "/dev/sda";
 270     int r;
 271     suppress_error = 0;
 272     r = guestfs_blockdev_setrw (g, device);
 273     if (r == -1)
 274       return -1;
 275   }
 276   {
 277     int r;
 278     suppress_error = 0;
 279     r = guestfs_umount_all (g);
 280     if (r == -1)
 281       return -1;
 282   }
 283   {
 284     int r;
 285     suppress_error = 0;
 286     r = guestfs_lvm_remove_all (g);
 287     if (r == -1)
 288       return -1;
 289   }
 290   /* TestRun for scrub_device (0) */
 291   {
 292     char device[] = "/dev/sdc";
 293     int r;
 294     suppress_error = 0;
 295     r = guestfs_scrub_device (g, device);
 296     if (r == -1)
 297       return -1;
 298   }
 299   return 0;
 300 }
 301
 302 static int test_glob_expand_0_skip (void)
 303 {
 304   const char *str;
 305
 306   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
 307   if (str && strcmp (str, "1") == 0) return 1;
 308   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 309   if (str && strcmp (str, "1") == 0) return 1;
 310   return 0;
 311 }
 312
 313 static int test_glob_expand_0 (void)
 314 {
 315   if (test_glob_expand_0_skip ()) {
 316     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_0");
 317     return 0;
 318   }
 319
 320   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
 321   {
 322     char device[] = "/dev/sda";
 323     int r;
 324     suppress_error = 0;
 325     r = guestfs_blockdev_setrw (g, device);
 326     if (r == -1)
 327       return -1;
 328   }
 329   {
 330     int r;
 331     suppress_error = 0;
 332     r = guestfs_umount_all (g);
 333     if (r == -1)
 334       return -1;
 335   }
 336   {
 337     int r;
 338     suppress_error = 0;
 339     r = guestfs_lvm_remove_all (g);
 340     if (r == -1)
 341       return -1;
 342   }
 343   {
 344     char device[] = "/dev/sda";
 345     char lines_0[] = ",";
 346     char *lines[] = {
 347       lines_0,
 348       NULL
 349     };
 350     int r;
 351     suppress_error = 0;
 352     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 353     if (r == -1)
 354       return -1;
 355   }
 356   {
 357     char fstype[] = "ext2";
 358     char device[] = "/dev/sda1";
 359     int r;
 360     suppress_error = 0;
 361     r = guestfs_mkfs (g, fstype, device);
 362     if (r == -1)
 363       return -1;
 364   }
 365   {
 366     char device[] = "/dev/sda1";
 367     char mountpoint[] = "/";
 368     int r;
 369     suppress_error = 0;
 370     r = guestfs_mount (g, device, mountpoint);
 371     if (r == -1)
 372       return -1;
 373   }
 374   /* TestOutputList for glob_expand (0) */
 375   {
 376     char path[] = "/a/b/c";
 377     int r;
 378     suppress_error = 0;
 379     r = guestfs_mkdir_p (g, path);
 380     if (r == -1)
 381       return -1;
 382   }
 383   {
 384     char path[] = "/a/b/c/d";
 385     int r;
 386     suppress_error = 0;
 387     r = guestfs_touch (g, path);
 388     if (r == -1)
 389       return -1;
 390   }
 391   {
 392     char path[] = "/a/b/c/e";
 393     int r;
 394     suppress_error = 0;
 395     r = guestfs_touch (g, path);
 396     if (r == -1)
 397       return -1;
 398   }
 399   {
 400     char pattern[] = "/a/b/c/*";
 401     char **r;
 402     int i;
 403     suppress_error = 0;
 404     r = guestfs_glob_expand (g, pattern);
 405     if (r == NULL)
 406       return -1;
 407     if (!r[0]) {
 408       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
 409       print_strings (r);
 410       return -1;
 411     }
 412     {
 413       char expected[] = "/a/b/c/d";
 414       if (strcmp (r[0], expected) != 0) {
 415         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 416         return -1;
 417       }
 418     }
 419     if (!r[1]) {
 420       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
 421       print_strings (r);
 422       return -1;
 423     }
 424     {
 425       char expected[] = "/a/b/c/e";
 426       if (strcmp (r[1], expected) != 0) {
 427         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 428         return -1;
 429       }
 430     }
 431     if (r[2] != NULL) {
 432       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
 433       print_strings (r);
 434       return -1;
 435     }
 436     for (i = 0; r[i] != NULL; ++i)
 437       free (r[i]);
 438     free (r);
 439   }
 440   return 0;
 441 }
 442
 443 static int test_glob_expand_1_skip (void)
 444 {
 445   const char *str;
 446
 447   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
 448   if (str && strcmp (str, "1") == 0) return 1;
 449   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 450   if (str && strcmp (str, "1") == 0) return 1;
 451   return 0;
 452 }
 453
 454 static int test_glob_expand_1 (void)
 455 {
 456   if (test_glob_expand_1_skip ()) {
 457     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_1");
 458     return 0;
 459   }
 460
 461   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
 462   {
 463     char device[] = "/dev/sda";
 464     int r;
 465     suppress_error = 0;
 466     r = guestfs_blockdev_setrw (g, device);
 467     if (r == -1)
 468       return -1;
 469   }
 470   {
 471     int r;
 472     suppress_error = 0;
 473     r = guestfs_umount_all (g);
 474     if (r == -1)
 475       return -1;
 476   }
 477   {
 478     int r;
 479     suppress_error = 0;
 480     r = guestfs_lvm_remove_all (g);
 481     if (r == -1)
 482       return -1;
 483   }
 484   {
 485     char device[] = "/dev/sda";
 486     char lines_0[] = ",";
 487     char *lines[] = {
 488       lines_0,
 489       NULL
 490     };
 491     int r;
 492     suppress_error = 0;
 493     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 494     if (r == -1)
 495       return -1;
 496   }
 497   {
 498     char fstype[] = "ext2";
 499     char device[] = "/dev/sda1";
 500     int r;
 501     suppress_error = 0;
 502     r = guestfs_mkfs (g, fstype, device);
 503     if (r == -1)
 504       return -1;
 505   }
 506   {
 507     char device[] = "/dev/sda1";
 508     char mountpoint[] = "/";
 509     int r;
 510     suppress_error = 0;
 511     r = guestfs_mount (g, device, mountpoint);
 512     if (r == -1)
 513       return -1;
 514   }
 515   /* TestOutputList for glob_expand (1) */
 516   {
 517     char path[] = "/a/b/c";
 518     int r;
 519     suppress_error = 0;
 520     r = guestfs_mkdir_p (g, path);
 521     if (r == -1)
 522       return -1;
 523   }
 524   {
 525     char path[] = "/a/b/c/d";
 526     int r;
 527     suppress_error = 0;
 528     r = guestfs_touch (g, path);
 529     if (r == -1)
 530       return -1;
 531   }
 532   {
 533     char path[] = "/a/b/c/e";
 534     int r;
 535     suppress_error = 0;
 536     r = guestfs_touch (g, path);
 537     if (r == -1)
 538       return -1;
 539   }
 540   {
 541     char pattern[] = "/a/*/c/*";
 542     char **r;
 543     int i;
 544     suppress_error = 0;
 545     r = guestfs_glob_expand (g, pattern);
 546     if (r == NULL)
 547       return -1;
 548     if (!r[0]) {
 549       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
 550       print_strings (r);
 551       return -1;
 552     }
 553     {
 554       char expected[] = "/a/b/c/d";
 555       if (strcmp (r[0], expected) != 0) {
 556         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 557         return -1;
 558       }
 559     }
 560     if (!r[1]) {
 561       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
 562       print_strings (r);
 563       return -1;
 564     }
 565     {
 566       char expected[] = "/a/b/c/e";
 567       if (strcmp (r[1], expected) != 0) {
 568         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 569         return -1;
 570       }
 571     }
 572     if (r[2] != NULL) {
 573       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
 574       print_strings (r);
 575       return -1;
 576     }
 577     for (i = 0; r[i] != NULL; ++i)
 578       free (r[i]);
 579     free (r);
 580   }
 581   return 0;
 582 }
 583
 584 static int test_glob_expand_2_skip (void)
 585 {
 586   const char *str;
 587
 588   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
 589   if (str && strcmp (str, "1") == 0) return 1;
 590   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 591   if (str && strcmp (str, "1") == 0) return 1;
 592   return 0;
 593 }
 594
 595 static int test_glob_expand_2 (void)
 596 {
 597   if (test_glob_expand_2_skip ()) {
 598     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_2");
 599     return 0;
 600   }
 601
 602   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
 603   {
 604     char device[] = "/dev/sda";
 605     int r;
 606     suppress_error = 0;
 607     r = guestfs_blockdev_setrw (g, device);
 608     if (r == -1)
 609       return -1;
 610   }
 611   {
 612     int r;
 613     suppress_error = 0;
 614     r = guestfs_umount_all (g);
 615     if (r == -1)
 616       return -1;
 617   }
 618   {
 619     int r;
 620     suppress_error = 0;
 621     r = guestfs_lvm_remove_all (g);
 622     if (r == -1)
 623       return -1;
 624   }
 625   {
 626     char device[] = "/dev/sda";
 627     char lines_0[] = ",";
 628     char *lines[] = {
 629       lines_0,
 630       NULL
 631     };
 632     int r;
 633     suppress_error = 0;
 634     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 635     if (r == -1)
 636       return -1;
 637   }
 638   {
 639     char fstype[] = "ext2";
 640     char device[] = "/dev/sda1";
 641     int r;
 642     suppress_error = 0;
 643     r = guestfs_mkfs (g, fstype, device);
 644     if (r == -1)
 645       return -1;
 646   }
 647   {
 648     char device[] = "/dev/sda1";
 649     char mountpoint[] = "/";
 650     int r;
 651     suppress_error = 0;
 652     r = guestfs_mount (g, device, mountpoint);
 653     if (r == -1)
 654       return -1;
 655   }
 656   /* TestOutputList for glob_expand (2) */
 657   {
 658     char path[] = "/a/b/c";
 659     int r;
 660     suppress_error = 0;
 661     r = guestfs_mkdir_p (g, path);
 662     if (r == -1)
 663       return -1;
 664   }
 665   {
 666     char path[] = "/a/b/c/d";
 667     int r;
 668     suppress_error = 0;
 669     r = guestfs_touch (g, path);
 670     if (r == -1)
 671       return -1;
 672   }
 673   {
 674     char path[] = "/a/b/c/e";
 675     int r;
 676     suppress_error = 0;
 677     r = guestfs_touch (g, path);
 678     if (r == -1)
 679       return -1;
 680   }
 681   {
 682     char pattern[] = "/a/*/x/*";
 683     char **r;
 684     int i;
 685     suppress_error = 0;
 686     r = guestfs_glob_expand (g, pattern);
 687     if (r == NULL)
 688       return -1;
 689     if (r[0] != NULL) {
 690       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
 691       print_strings (r);
 692       return -1;
 693     }
 694     for (i = 0; r[i] != NULL; ++i)
 695       free (r[i]);
 696     free (r);
 697   }
 698   return 0;
 699 }
 700
 701 static int test_ntfs_3g_probe_0_skip (void)
 702 {
 703   const char *str;
 704
 705   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
 706   if (str && strcmp (str, "1") == 0) return 1;
 707   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 708   if (str && strcmp (str, "1") == 0) return 1;
 709   return 0;
 710 }
 711
 712 static int test_ntfs_3g_probe_0 (void)
 713 {
 714   if (test_ntfs_3g_probe_0_skip ()) {
 715     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
 716     return 0;
 717   }
 718
 719   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
 720   {
 721     char device[] = "/dev/sda";
 722     int r;
 723     suppress_error = 0;
 724     r = guestfs_blockdev_setrw (g, device);
 725     if (r == -1)
 726       return -1;
 727   }
 728   {
 729     int r;
 730     suppress_error = 0;
 731     r = guestfs_umount_all (g);
 732     if (r == -1)
 733       return -1;
 734   }
 735   {
 736     int r;
 737     suppress_error = 0;
 738     r = guestfs_lvm_remove_all (g);
 739     if (r == -1)
 740       return -1;
 741   }
 742   /* TestOutputInt for ntfs_3g_probe (0) */
 743   {
 744     char device[] = "/dev/sda";
 745     char lines_0[] = ",";
 746     char *lines[] = {
 747       lines_0,
 748       NULL
 749     };
 750     int r;
 751     suppress_error = 0;
 752     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 753     if (r == -1)
 754       return -1;
 755   }
 756   {
 757     char fstype[] = "ntfs";
 758     char device[] = "/dev/sda1";
 759     int r;
 760     suppress_error = 0;
 761     r = guestfs_mkfs (g, fstype, device);
 762     if (r == -1)
 763       return -1;
 764   }
 765   {
 766     char device[] = "/dev/sda1";
 767     int r;
 768     suppress_error = 0;
 769     r = guestfs_ntfs_3g_probe (g, 1, device);
 770     if (r == -1)
 771       return -1;
 772     if (r != 0) {
 773       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
 774       return -1;
 775     }
 776   }
 777   return 0;
 778 }
 779
 780 static int test_ntfs_3g_probe_1_skip (void)
 781 {
 782   const char *str;
 783
 784   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
 785   if (str && strcmp (str, "1") == 0) return 1;
 786   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 787   if (str && strcmp (str, "1") == 0) return 1;
 788   return 0;
 789 }
 790
 791 static int test_ntfs_3g_probe_1 (void)
 792 {
 793   if (test_ntfs_3g_probe_1_skip ()) {
 794     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
 795     return 0;
 796   }
 797
 798   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
 799   {
 800     char device[] = "/dev/sda";
 801     int r;
 802     suppress_error = 0;
 803     r = guestfs_blockdev_setrw (g, device);
 804     if (r == -1)
 805       return -1;
 806   }
 807   {
 808     int r;
 809     suppress_error = 0;
 810     r = guestfs_umount_all (g);
 811     if (r == -1)
 812       return -1;
 813   }
 814   {
 815     int r;
 816     suppress_error = 0;
 817     r = guestfs_lvm_remove_all (g);
 818     if (r == -1)
 819       return -1;
 820   }
 821   /* TestOutputInt for ntfs_3g_probe (1) */
 822   {
 823     char device[] = "/dev/sda";
 824     char lines_0[] = ",";
 825     char *lines[] = {
 826       lines_0,
 827       NULL
 828     };
 829     int r;
 830     suppress_error = 0;
 831     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 832     if (r == -1)
 833       return -1;
 834   }
 835   {
 836     char fstype[] = "ext2";
 837     char device[] = "/dev/sda1";
 838     int r;
 839     suppress_error = 0;
 840     r = guestfs_mkfs (g, fstype, device);
 841     if (r == -1)
 842       return -1;
 843   }
 844   {
 845     char device[] = "/dev/sda1";
 846     int r;
 847     suppress_error = 0;
 848     r = guestfs_ntfs_3g_probe (g, 1, device);
 849     if (r == -1)
 850       return -1;
 851     if (r != 12) {
 852       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
 853       return -1;
 854     }
 855   }
 856   return 0;
 857 }
 858
 859 static int test_sleep_0_skip (void)
 860 {
 861   const char *str;
 862
 863   str = getenv ("SKIP_TEST_SLEEP_0");
 864   if (str && strcmp (str, "1") == 0) return 1;
 865   str = getenv ("SKIP_TEST_SLEEP");
 866   if (str && strcmp (str, "1") == 0) return 1;
 867   return 0;
 868 }
 869
 870 static int test_sleep_0 (void)
 871 {
 872   if (test_sleep_0_skip ()) {
 873     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
 874     return 0;
 875   }
 876
 877   /* InitNone|InitEmpty for test_sleep_0 */
 878   {
 879     char device[] = "/dev/sda";
 880     int r;
 881     suppress_error = 0;
 882     r = guestfs_blockdev_setrw (g, device);
 883     if (r == -1)
 884       return -1;
 885   }
 886   {
 887     int r;
 888     suppress_error = 0;
 889     r = guestfs_umount_all (g);
 890     if (r == -1)
 891       return -1;
 892   }
 893   {
 894     int r;
 895     suppress_error = 0;
 896     r = guestfs_lvm_remove_all (g);
 897     if (r == -1)
 898       return -1;
 899   }
 900   /* TestRun for sleep (0) */
 901   {
 902     int r;
 903     suppress_error = 0;
 904     r = guestfs_sleep (g, 1);
 905     if (r == -1)
 906       return -1;
 907   }
 908   return 0;
 909 }
 910
 911 static int test_find_0_skip (void)
 912 {
 913   const char *str;
 914
 915   str = getenv ("SKIP_TEST_FIND_0");
 916   if (str && strcmp (str, "1") == 0) return 1;
 917   str = getenv ("SKIP_TEST_FIND");
 918   if (str && strcmp (str, "1") == 0) return 1;
 919   return 0;
 920 }
 921
 922 static int test_find_0 (void)
 923 {
 924   if (test_find_0_skip ()) {
 925     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
 926     return 0;
 927   }
 928
 929   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 930   {
 931     char device[] = "/dev/sda";
 932     int r;
 933     suppress_error = 0;
 934     r = guestfs_blockdev_setrw (g, device);
 935     if (r == -1)
 936       return -1;
 937   }
 938   {
 939     int r;
 940     suppress_error = 0;
 941     r = guestfs_umount_all (g);
 942     if (r == -1)
 943       return -1;
 944   }
 945   {
 946     int r;
 947     suppress_error = 0;
 948     r = guestfs_lvm_remove_all (g);
 949     if (r == -1)
 950       return -1;
 951   }
 952   {
 953     char device[] = "/dev/sda";
 954     char lines_0[] = ",";
 955     char *lines[] = {
 956       lines_0,
 957       NULL
 958     };
 959     int r;
 960     suppress_error = 0;
 961     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 962     if (r == -1)
 963       return -1;
 964   }
 965   {
 966     char fstype[] = "ext2";
 967     char device[] = "/dev/sda1";
 968     int r;
 969     suppress_error = 0;
 970     r = guestfs_mkfs (g, fstype, device);
 971     if (r == -1)
 972       return -1;
 973   }
 974   {
 975     char device[] = "/dev/sda1";
 976     char mountpoint[] = "/";
 977     int r;
 978     suppress_error = 0;
 979     r = guestfs_mount (g, device, mountpoint);
 980     if (r == -1)
 981       return -1;
 982   }
 983   /* TestOutputList for find (0) */
 984   {
 985     char directory[] = "/";
 986     char **r;
 987     int i;
 988     suppress_error = 0;
 989     r = guestfs_find (g, directory);
 990     if (r == NULL)
 991       return -1;
 992     if (!r[0]) {
 993       fprintf (stderr, "test_find_0: short list returned from command\n");
 994       print_strings (r);
 995       return -1;
 996     }
 997     {
 998       char expected[] = "lost+found";
 999       if (strcmp (r[0], expected) != 0) {
1000         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1001         return -1;
1002       }
1003     }
1004     if (r[1] != NULL) {
1005       fprintf (stderr, "test_find_0: extra elements returned from command\n");
1006       print_strings (r);
1007       return -1;
1008     }
1009     for (i = 0; r[i] != NULL; ++i)
1010       free (r[i]);
1011     free (r);
1012   }
1013   return 0;
1014 }
1015
1016 static int test_find_1_skip (void)
1017 {
1018   const char *str;
1019
1020   str = getenv ("SKIP_TEST_FIND_1");
1021   if (str && strcmp (str, "1") == 0) return 1;
1022   str = getenv ("SKIP_TEST_FIND");
1023   if (str && strcmp (str, "1") == 0) return 1;
1024   return 0;
1025 }
1026
1027 static int test_find_1 (void)
1028 {
1029   if (test_find_1_skip ()) {
1030     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
1031     return 0;
1032   }
1033
1034   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
1035   {
1036     char device[] = "/dev/sda";
1037     int r;
1038     suppress_error = 0;
1039     r = guestfs_blockdev_setrw (g, device);
1040     if (r == -1)
1041       return -1;
1042   }
1043   {
1044     int r;
1045     suppress_error = 0;
1046     r = guestfs_umount_all (g);
1047     if (r == -1)
1048       return -1;
1049   }
1050   {
1051     int r;
1052     suppress_error = 0;
1053     r = guestfs_lvm_remove_all (g);
1054     if (r == -1)
1055       return -1;
1056   }
1057   {
1058     char device[] = "/dev/sda";
1059     char lines_0[] = ",";
1060     char *lines[] = {
1061       lines_0,
1062       NULL
1063     };
1064     int r;
1065     suppress_error = 0;
1066     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1067     if (r == -1)
1068       return -1;
1069   }
1070   {
1071     char fstype[] = "ext2";
1072     char device[] = "/dev/sda1";
1073     int r;
1074     suppress_error = 0;
1075     r = guestfs_mkfs (g, fstype, device);
1076     if (r == -1)
1077       return -1;
1078   }
1079   {
1080     char device[] = "/dev/sda1";
1081     char mountpoint[] = "/";
1082     int r;
1083     suppress_error = 0;
1084     r = guestfs_mount (g, device, mountpoint);
1085     if (r == -1)
1086       return -1;
1087   }
1088   /* TestOutputList for find (1) */
1089   {
1090     char path[] = "/a";
1091     int r;
1092     suppress_error = 0;
1093     r = guestfs_touch (g, path);
1094     if (r == -1)
1095       return -1;
1096   }
1097   {
1098     char path[] = "/b";
1099     int r;
1100     suppress_error = 0;
1101     r = guestfs_mkdir (g, path);
1102     if (r == -1)
1103       return -1;
1104   }
1105   {
1106     char path[] = "/b/c";
1107     int r;
1108     suppress_error = 0;
1109     r = guestfs_touch (g, path);
1110     if (r == -1)
1111       return -1;
1112   }
1113   {
1114     char directory[] = "/";
1115     char **r;
1116     int i;
1117     suppress_error = 0;
1118     r = guestfs_find (g, directory);
1119     if (r == NULL)
1120       return -1;
1121     if (!r[0]) {
1122       fprintf (stderr, "test_find_1: short list returned from command\n");
1123       print_strings (r);
1124       return -1;
1125     }
1126     {
1127       char expected[] = "a";
1128       if (strcmp (r[0], expected) != 0) {
1129         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1130         return -1;
1131       }
1132     }
1133     if (!r[1]) {
1134       fprintf (stderr, "test_find_1: short list returned from command\n");
1135       print_strings (r);
1136       return -1;
1137     }
1138     {
1139       char expected[] = "b";
1140       if (strcmp (r[1], expected) != 0) {
1141         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1142         return -1;
1143       }
1144     }
1145     if (!r[2]) {
1146       fprintf (stderr, "test_find_1: short list returned from command\n");
1147       print_strings (r);
1148       return -1;
1149     }
1150     {
1151       char expected[] = "b/c";
1152       if (strcmp (r[2], expected) != 0) {
1153         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1154         return -1;
1155       }
1156     }
1157     if (!r[3]) {
1158       fprintf (stderr, "test_find_1: short list returned from command\n");
1159       print_strings (r);
1160       return -1;
1161     }
1162     {
1163       char expected[] = "lost+found";
1164       if (strcmp (r[3], expected) != 0) {
1165         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1166         return -1;
1167       }
1168     }
1169     if (r[4] != NULL) {
1170       fprintf (stderr, "test_find_1: extra elements returned from command\n");
1171       print_strings (r);
1172       return -1;
1173     }
1174     for (i = 0; r[i] != NULL; ++i)
1175       free (r[i]);
1176     free (r);
1177   }
1178   return 0;
1179 }
1180
1181 static int test_find_2_skip (void)
1182 {
1183   const char *str;
1184
1185   str = getenv ("SKIP_TEST_FIND_2");
1186   if (str && strcmp (str, "1") == 0) return 1;
1187   str = getenv ("SKIP_TEST_FIND");
1188   if (str && strcmp (str, "1") == 0) return 1;
1189   return 0;
1190 }
1191
1192 static int test_find_2 (void)
1193 {
1194   if (test_find_2_skip ()) {
1195     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
1196     return 0;
1197   }
1198
1199   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
1200   {
1201     char device[] = "/dev/sda";
1202     int r;
1203     suppress_error = 0;
1204     r = guestfs_blockdev_setrw (g, device);
1205     if (r == -1)
1206       return -1;
1207   }
1208   {
1209     int r;
1210     suppress_error = 0;
1211     r = guestfs_umount_all (g);
1212     if (r == -1)
1213       return -1;
1214   }
1215   {
1216     int r;
1217     suppress_error = 0;
1218     r = guestfs_lvm_remove_all (g);
1219     if (r == -1)
1220       return -1;
1221   }
1222   {
1223     char device[] = "/dev/sda";
1224     char lines_0[] = ",";
1225     char *lines[] = {
1226       lines_0,
1227       NULL
1228     };
1229     int r;
1230     suppress_error = 0;
1231     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1232     if (r == -1)
1233       return -1;
1234   }
1235   {
1236     char fstype[] = "ext2";
1237     char device[] = "/dev/sda1";
1238     int r;
1239     suppress_error = 0;
1240     r = guestfs_mkfs (g, fstype, device);
1241     if (r == -1)
1242       return -1;
1243   }
1244   {
1245     char device[] = "/dev/sda1";
1246     char mountpoint[] = "/";
1247     int r;
1248     suppress_error = 0;
1249     r = guestfs_mount (g, device, mountpoint);
1250     if (r == -1)
1251       return -1;
1252   }
1253   /* TestOutputList for find (2) */
1254   {
1255     char path[] = "/a/b/c";
1256     int r;
1257     suppress_error = 0;
1258     r = guestfs_mkdir_p (g, path);
1259     if (r == -1)
1260       return -1;
1261   }
1262   {
1263     char path[] = "/a/b/c/d";
1264     int r;
1265     suppress_error = 0;
1266     r = guestfs_touch (g, path);
1267     if (r == -1)
1268       return -1;
1269   }
1270   {
1271     char directory[] = "/a/b/";
1272     char **r;
1273     int i;
1274     suppress_error = 0;
1275     r = guestfs_find (g, directory);
1276     if (r == NULL)
1277       return -1;
1278     if (!r[0]) {
1279       fprintf (stderr, "test_find_2: short list returned from command\n");
1280       print_strings (r);
1281       return -1;
1282     }
1283     {
1284       char expected[] = "c";
1285       if (strcmp (r[0], expected) != 0) {
1286         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1287         return -1;
1288       }
1289     }
1290     if (!r[1]) {
1291       fprintf (stderr, "test_find_2: short list returned from command\n");
1292       print_strings (r);
1293       return -1;
1294     }
1295     {
1296       char expected[] = "c/d";
1297       if (strcmp (r[1], expected) != 0) {
1298         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1299         return -1;
1300       }
1301     }
1302     if (r[2] != NULL) {
1303       fprintf (stderr, "test_find_2: extra elements returned from command\n");
1304       print_strings (r);
1305       return -1;
1306     }
1307     for (i = 0; r[i] != NULL; ++i)
1308       free (r[i]);
1309     free (r);
1310   }
1311   return 0;
1312 }
1313
1314 static int test_lvresize_0_skip (void)
1315 {
1316   const char *str;
1317
1318   str = getenv ("SKIP_TEST_LVRESIZE_0");
1319   if (str && strcmp (str, "1") == 0) return 1;
1320   str = getenv ("SKIP_TEST_LVRESIZE");
1321   if (str && strcmp (str, "1") == 0) return 1;
1322   return 0;
1323 }
1324
1325 static int test_lvresize_0 (void)
1326 {
1327   if (test_lvresize_0_skip ()) {
1328     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
1329     return 0;
1330   }
1331
1332   /* InitNone|InitEmpty for test_lvresize_0 */
1333   {
1334     char device[] = "/dev/sda";
1335     int r;
1336     suppress_error = 0;
1337     r = guestfs_blockdev_setrw (g, device);
1338     if (r == -1)
1339       return -1;
1340   }
1341   {
1342     int r;
1343     suppress_error = 0;
1344     r = guestfs_umount_all (g);
1345     if (r == -1)
1346       return -1;
1347   }
1348   {
1349     int r;
1350     suppress_error = 0;
1351     r = guestfs_lvm_remove_all (g);
1352     if (r == -1)
1353       return -1;
1354   }
1355   /* TestOutput for lvresize (0) */
1356   char expected[] = "test content";
1357   {
1358     char device[] = "/dev/sda";
1359     char lines_0[] = ",";
1360     char *lines[] = {
1361       lines_0,
1362       NULL
1363     };
1364     int r;
1365     suppress_error = 0;
1366     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1367     if (r == -1)
1368       return -1;
1369   }
1370   {
1371     char device[] = "/dev/sda1";
1372     int r;
1373     suppress_error = 0;
1374     r = guestfs_pvcreate (g, device);
1375     if (r == -1)
1376       return -1;
1377   }
1378   {
1379     char volgroup[] = "VG";
1380     char physvols_0[] = "/dev/sda1";
1381     char *physvols[] = {
1382       physvols_0,
1383       NULL
1384     };
1385     int r;
1386     suppress_error = 0;
1387     r = guestfs_vgcreate (g, volgroup, physvols);
1388     if (r == -1)
1389       return -1;
1390   }
1391   {
1392     char logvol[] = "LV";
1393     char volgroup[] = "VG";
1394     int r;
1395     suppress_error = 0;
1396     r = guestfs_lvcreate (g, logvol, volgroup, 10);
1397     if (r == -1)
1398       return -1;
1399   }
1400   {
1401     char fstype[] = "ext2";
1402     char device[] = "/dev/VG/LV";
1403     int r;
1404     suppress_error = 0;
1405     r = guestfs_mkfs (g, fstype, device);
1406     if (r == -1)
1407       return -1;
1408   }
1409   {
1410     char device[] = "/dev/VG/LV";
1411     char mountpoint[] = "/";
1412     int r;
1413     suppress_error = 0;
1414     r = guestfs_mount (g, device, mountpoint);
1415     if (r == -1)
1416       return -1;
1417   }
1418   {
1419     char path[] = "/new";
1420     char content[] = "test content";
1421     int r;
1422     suppress_error = 0;
1423     r = guestfs_write_file (g, path, content, 0);
1424     if (r == -1)
1425       return -1;
1426   }
1427   {
1428     char pathordevice[] = "/";
1429     int r;
1430     suppress_error = 0;
1431     r = guestfs_umount (g, pathordevice);
1432     if (r == -1)
1433       return -1;
1434   }
1435   {
1436     char device[] = "/dev/VG/LV";
1437     int r;
1438     suppress_error = 0;
1439     r = guestfs_lvresize (g, device, 20);
1440     if (r == -1)
1441       return -1;
1442   }
1443   {
1444     char device[] = "/dev/VG/LV";
1445     int r;
1446     suppress_error = 0;
1447     r = guestfs_e2fsck_f (g, device);
1448     if (r == -1)
1449       return -1;
1450   }
1451   {
1452     char device[] = "/dev/VG/LV";
1453     int r;
1454     suppress_error = 0;
1455     r = guestfs_resize2fs (g, device);
1456     if (r == -1)
1457       return -1;
1458   }
1459   {
1460     char device[] = "/dev/VG/LV";
1461     char mountpoint[] = "/";
1462     int r;
1463     suppress_error = 0;
1464     r = guestfs_mount (g, device, mountpoint);
1465     if (r == -1)
1466       return -1;
1467   }
1468   {
1469     char path[] = "/new";
1470     char *r;
1471     suppress_error = 0;
1472     r = guestfs_cat (g, path);
1473     if (r == NULL)
1474       return -1;
1475     if (strcmp (r, expected) != 0) {
1476       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
1477       return -1;
1478     }
1479     free (r);
1480   }
1481   return 0;
1482 }
1483
1484 static int test_zerofree_0_skip (void)
1485 {
1486   const char *str;
1487
1488   str = getenv ("SKIP_TEST_ZEROFREE_0");
1489   if (str && strcmp (str, "1") == 0) return 1;
1490   str = getenv ("SKIP_TEST_ZEROFREE");
1491   if (str && strcmp (str, "1") == 0) return 1;
1492   return 0;
1493 }
1494
1495 static int test_zerofree_0 (void)
1496 {
1497   if (test_zerofree_0_skip ()) {
1498     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
1499     return 0;
1500   }
1501
1502   /* InitNone|InitEmpty for test_zerofree_0 */
1503   {
1504     char device[] = "/dev/sda";
1505     int r;
1506     suppress_error = 0;
1507     r = guestfs_blockdev_setrw (g, device);
1508     if (r == -1)
1509       return -1;
1510   }
1511   {
1512     int r;
1513     suppress_error = 0;
1514     r = guestfs_umount_all (g);
1515     if (r == -1)
1516       return -1;
1517   }
1518   {
1519     int r;
1520     suppress_error = 0;
1521     r = guestfs_lvm_remove_all (g);
1522     if (r == -1)
1523       return -1;
1524   }
1525   /* TestOutput for zerofree (0) */
1526   char expected[] = "test file";
1527   {
1528     char device[] = "/dev/sda";
1529     char lines_0[] = ",";
1530     char *lines[] = {
1531       lines_0,
1532       NULL
1533     };
1534     int r;
1535     suppress_error = 0;
1536     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1537     if (r == -1)
1538       return -1;
1539   }
1540   {
1541     char fstype[] = "ext3";
1542     char device[] = "/dev/sda1";
1543     int r;
1544     suppress_error = 0;
1545     r = guestfs_mkfs (g, fstype, device);
1546     if (r == -1)
1547       return -1;
1548   }
1549   {
1550     char device[] = "/dev/sda1";
1551     char mountpoint[] = "/";
1552     int r;
1553     suppress_error = 0;
1554     r = guestfs_mount (g, device, mountpoint);
1555     if (r == -1)
1556       return -1;
1557   }
1558   {
1559     char path[] = "/new";
1560     char content[] = "test file";
1561     int r;
1562     suppress_error = 0;
1563     r = guestfs_write_file (g, path, content, 0);
1564     if (r == -1)
1565       return -1;
1566   }
1567   {
1568     char pathordevice[] = "/dev/sda1";
1569     int r;
1570     suppress_error = 0;
1571     r = guestfs_umount (g, pathordevice);
1572     if (r == -1)
1573       return -1;
1574   }
1575   {
1576     char device[] = "/dev/sda1";
1577     int r;
1578     suppress_error = 0;
1579     r = guestfs_zerofree (g, device);
1580     if (r == -1)
1581       return -1;
1582   }
1583   {
1584     char device[] = "/dev/sda1";
1585     char mountpoint[] = "/";
1586     int r;
1587     suppress_error = 0;
1588     r = guestfs_mount (g, device, mountpoint);
1589     if (r == -1)
1590       return -1;
1591   }
1592   {
1593     char path[] = "/new";
1594     char *r;
1595     suppress_error = 0;
1596     r = guestfs_cat (g, path);
1597     if (r == NULL)
1598       return -1;
1599     if (strcmp (r, expected) != 0) {
1600       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1601       return -1;
1602     }
1603     free (r);
1604   }
1605   return 0;
1606 }
1607
1608 static int test_hexdump_0_skip (void)
1609 {
1610   const char *str;
1611
1612   str = getenv ("SKIP_TEST_HEXDUMP_0");
1613   if (str && strcmp (str, "1") == 0) return 1;
1614   str = getenv ("SKIP_TEST_HEXDUMP");
1615   if (str && strcmp (str, "1") == 0) return 1;
1616   return 0;
1617 }
1618
1619 static int test_hexdump_0 (void)
1620 {
1621   if (test_hexdump_0_skip ()) {
1622     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1623     return 0;
1624   }
1625
1626   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1627   {
1628     char device[] = "/dev/sda";
1629     int r;
1630     suppress_error = 0;
1631     r = guestfs_blockdev_setrw (g, device);
1632     if (r == -1)
1633       return -1;
1634   }
1635   {
1636     int r;
1637     suppress_error = 0;
1638     r = guestfs_umount_all (g);
1639     if (r == -1)
1640       return -1;
1641   }
1642   {
1643     int r;
1644     suppress_error = 0;
1645     r = guestfs_lvm_remove_all (g);
1646     if (r == -1)
1647       return -1;
1648   }
1649   {
1650     char device[] = "/dev/sda";
1651     char lines_0[] = ",";
1652     char *lines[] = {
1653       lines_0,
1654       NULL
1655     };
1656     int r;
1657     suppress_error = 0;
1658     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1659     if (r == -1)
1660       return -1;
1661   }
1662   {
1663     char fstype[] = "ext2";
1664     char device[] = "/dev/sda1";
1665     int r;
1666     suppress_error = 0;
1667     r = guestfs_mkfs (g, fstype, device);
1668     if (r == -1)
1669       return -1;
1670   }
1671   {
1672     char device[] = "/dev/sda1";
1673     char mountpoint[] = "/";
1674     int r;
1675     suppress_error = 0;
1676     r = guestfs_mount (g, device, mountpoint);
1677     if (r == -1)
1678       return -1;
1679   }
1680   /* TestOutput for hexdump (0) */
1681   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
1682   {
1683     char path[] = "/new";
1684     char content[] = "hello\nworld\n";
1685     int r;
1686     suppress_error = 0;
1687     r = guestfs_write_file (g, path, content, 12);
1688     if (r == -1)
1689       return -1;
1690   }
1691   {
1692     char path[] = "/new";
1693     char *r;
1694     suppress_error = 0;
1695     r = guestfs_hexdump (g, path);
1696     if (r == NULL)
1697       return -1;
1698     if (strcmp (r, expected) != 0) {
1699       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1700       return -1;
1701     }
1702     free (r);
1703   }
1704   return 0;
1705 }
1706
1707 static int test_strings_e_0_skip (void)
1708 {
1709   const char *str;
1710
1711   str = getenv ("SKIP_TEST_STRINGS_E_0");
1712   if (str && strcmp (str, "1") == 0) return 1;
1713   str = getenv ("SKIP_TEST_STRINGS_E");
1714   if (str && strcmp (str, "1") == 0) return 1;
1715   return 0;
1716 }
1717
1718 static int test_strings_e_0 (void)
1719 {
1720   if (test_strings_e_0_skip ()) {
1721     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1722     return 0;
1723   }
1724
1725   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1726   {
1727     char device[] = "/dev/sda";
1728     int r;
1729     suppress_error = 0;
1730     r = guestfs_blockdev_setrw (g, device);
1731     if (r == -1)
1732       return -1;
1733   }
1734   {
1735     int r;
1736     suppress_error = 0;
1737     r = guestfs_umount_all (g);
1738     if (r == -1)
1739       return -1;
1740   }
1741   {
1742     int r;
1743     suppress_error = 0;
1744     r = guestfs_lvm_remove_all (g);
1745     if (r == -1)
1746       return -1;
1747   }
1748   {
1749     char device[] = "/dev/sda";
1750     char lines_0[] = ",";
1751     char *lines[] = {
1752       lines_0,
1753       NULL
1754     };
1755     int r;
1756     suppress_error = 0;
1757     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1758     if (r == -1)
1759       return -1;
1760   }
1761   {
1762     char fstype[] = "ext2";
1763     char device[] = "/dev/sda1";
1764     int r;
1765     suppress_error = 0;
1766     r = guestfs_mkfs (g, fstype, device);
1767     if (r == -1)
1768       return -1;
1769   }
1770   {
1771     char device[] = "/dev/sda1";
1772     char mountpoint[] = "/";
1773     int r;
1774     suppress_error = 0;
1775     r = guestfs_mount (g, device, mountpoint);
1776     if (r == -1)
1777       return -1;
1778   }
1779   /* TestOutputList for strings_e (0) */
1780   {
1781     char path[] = "/new";
1782     char content[] = "hello\nworld\n";
1783     int r;
1784     suppress_error = 0;
1785     r = guestfs_write_file (g, path, content, 0);
1786     if (r == -1)
1787       return -1;
1788   }
1789   {
1790     char encoding[] = "b";
1791     char path[] = "/new";
1792     char **r;
1793     int i;
1794     suppress_error = 0;
1795     r = guestfs_strings_e (g, encoding, path);
1796     if (r == NULL)
1797       return -1;
1798     if (r[0] != NULL) {
1799       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1800       print_strings (r);
1801       return -1;
1802     }
1803     for (i = 0; r[i] != NULL; ++i)
1804       free (r[i]);
1805     free (r);
1806   }
1807   return 0;
1808 }
1809
1810 static int test_strings_e_1_skip (void)
1811 {
1812   const char *str;
1813
1814   str = getenv ("SKIP_TEST_STRINGS_E_1");
1815   if (str && strcmp (str, "1") == 0) return 1;
1816   str = getenv ("SKIP_TEST_STRINGS_E");
1817   if (str && strcmp (str, "1") == 0) return 1;
1818   return 0;
1819 }
1820
1821 static int test_strings_e_1 (void)
1822 {
1823   if (test_strings_e_1_skip ()) {
1824     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1825     return 0;
1826   }
1827
1828   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1829   return 0;
1830 }
1831
1832 static int test_strings_0_skip (void)
1833 {
1834   const char *str;
1835
1836   str = getenv ("SKIP_TEST_STRINGS_0");
1837   if (str && strcmp (str, "1") == 0) return 1;
1838   str = getenv ("SKIP_TEST_STRINGS");
1839   if (str && strcmp (str, "1") == 0) return 1;
1840   return 0;
1841 }
1842
1843 static int test_strings_0 (void)
1844 {
1845   if (test_strings_0_skip ()) {
1846     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1847     return 0;
1848   }
1849
1850   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1851   {
1852     char device[] = "/dev/sda";
1853     int r;
1854     suppress_error = 0;
1855     r = guestfs_blockdev_setrw (g, device);
1856     if (r == -1)
1857       return -1;
1858   }
1859   {
1860     int r;
1861     suppress_error = 0;
1862     r = guestfs_umount_all (g);
1863     if (r == -1)
1864       return -1;
1865   }
1866   {
1867     int r;
1868     suppress_error = 0;
1869     r = guestfs_lvm_remove_all (g);
1870     if (r == -1)
1871       return -1;
1872   }
1873   {
1874     char device[] = "/dev/sda";
1875     char lines_0[] = ",";
1876     char *lines[] = {
1877       lines_0,
1878       NULL
1879     };
1880     int r;
1881     suppress_error = 0;
1882     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1883     if (r == -1)
1884       return -1;
1885   }
1886   {
1887     char fstype[] = "ext2";
1888     char device[] = "/dev/sda1";
1889     int r;
1890     suppress_error = 0;
1891     r = guestfs_mkfs (g, fstype, device);
1892     if (r == -1)
1893       return -1;
1894   }
1895   {
1896     char device[] = "/dev/sda1";
1897     char mountpoint[] = "/";
1898     int r;
1899     suppress_error = 0;
1900     r = guestfs_mount (g, device, mountpoint);
1901     if (r == -1)
1902       return -1;
1903   }
1904   /* TestOutputList for strings (0) */
1905   {
1906     char path[] = "/new";
1907     char content[] = "hello\nworld\n";
1908     int r;
1909     suppress_error = 0;
1910     r = guestfs_write_file (g, path, content, 0);
1911     if (r == -1)
1912       return -1;
1913   }
1914   {
1915     char path[] = "/new";
1916     char **r;
1917     int i;
1918     suppress_error = 0;
1919     r = guestfs_strings (g, path);
1920     if (r == NULL)
1921       return -1;
1922     if (!r[0]) {
1923       fprintf (stderr, "test_strings_0: short list returned from command\n");
1924       print_strings (r);
1925       return -1;
1926     }
1927     {
1928       char expected[] = "hello";
1929       if (strcmp (r[0], expected) != 0) {
1930         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1931         return -1;
1932       }
1933     }
1934     if (!r[1]) {
1935       fprintf (stderr, "test_strings_0: short list returned from command\n");
1936       print_strings (r);
1937       return -1;
1938     }
1939     {
1940       char expected[] = "world";
1941       if (strcmp (r[1], expected) != 0) {
1942         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1943         return -1;
1944       }
1945     }
1946     if (r[2] != NULL) {
1947       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1948       print_strings (r);
1949       return -1;
1950     }
1951     for (i = 0; r[i] != NULL; ++i)
1952       free (r[i]);
1953     free (r);
1954   }
1955   return 0;
1956 }
1957
1958 static int test_strings_1_skip (void)
1959 {
1960   const char *str;
1961
1962   str = getenv ("SKIP_TEST_STRINGS_1");
1963   if (str && strcmp (str, "1") == 0) return 1;
1964   str = getenv ("SKIP_TEST_STRINGS");
1965   if (str && strcmp (str, "1") == 0) return 1;
1966   return 0;
1967 }
1968
1969 static int test_strings_1 (void)
1970 {
1971   if (test_strings_1_skip ()) {
1972     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1973     return 0;
1974   }
1975
1976   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1977   {
1978     char device[] = "/dev/sda";
1979     int r;
1980     suppress_error = 0;
1981     r = guestfs_blockdev_setrw (g, device);
1982     if (r == -1)
1983       return -1;
1984   }
1985   {
1986     int r;
1987     suppress_error = 0;
1988     r = guestfs_umount_all (g);
1989     if (r == -1)
1990       return -1;
1991   }
1992   {
1993     int r;
1994     suppress_error = 0;
1995     r = guestfs_lvm_remove_all (g);
1996     if (r == -1)
1997       return -1;
1998   }
1999   {
2000     char device[] = "/dev/sda";
2001     char lines_0[] = ",";
2002     char *lines[] = {
2003       lines_0,
2004       NULL
2005     };
2006     int r;
2007     suppress_error = 0;
2008     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2009     if (r == -1)
2010       return -1;
2011   }
2012   {
2013     char fstype[] = "ext2";
2014     char device[] = "/dev/sda1";
2015     int r;
2016     suppress_error = 0;
2017     r = guestfs_mkfs (g, fstype, device);
2018     if (r == -1)
2019       return -1;
2020   }
2021   {
2022     char device[] = "/dev/sda1";
2023     char mountpoint[] = "/";
2024     int r;
2025     suppress_error = 0;
2026     r = guestfs_mount (g, device, mountpoint);
2027     if (r == -1)
2028       return -1;
2029   }
2030   /* TestOutputList for strings (1) */
2031   {
2032     char path[] = "/new";
2033     int r;
2034     suppress_error = 0;
2035     r = guestfs_touch (g, path);
2036     if (r == -1)
2037       return -1;
2038   }
2039   {
2040     char path[] = "/new";
2041     char **r;
2042     int i;
2043     suppress_error = 0;
2044     r = guestfs_strings (g, path);
2045     if (r == NULL)
2046       return -1;
2047     if (r[0] != NULL) {
2048       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
2049       print_strings (r);
2050       return -1;
2051     }
2052     for (i = 0; r[i] != NULL; ++i)
2053       free (r[i]);
2054     free (r);
2055   }
2056   return 0;
2057 }
2058
2059 static int test_equal_0_skip (void)
2060 {
2061   const char *str;
2062
2063   str = getenv ("SKIP_TEST_EQUAL_0");
2064   if (str && strcmp (str, "1") == 0) return 1;
2065   str = getenv ("SKIP_TEST_EQUAL");
2066   if (str && strcmp (str, "1") == 0) return 1;
2067   return 0;
2068 }
2069
2070 static int test_equal_0 (void)
2071 {
2072   if (test_equal_0_skip ()) {
2073     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
2074     return 0;
2075   }
2076
2077   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
2078   {
2079     char device[] = "/dev/sda";
2080     int r;
2081     suppress_error = 0;
2082     r = guestfs_blockdev_setrw (g, device);
2083     if (r == -1)
2084       return -1;
2085   }
2086   {
2087     int r;
2088     suppress_error = 0;
2089     r = guestfs_umount_all (g);
2090     if (r == -1)
2091       return -1;
2092   }
2093   {
2094     int r;
2095     suppress_error = 0;
2096     r = guestfs_lvm_remove_all (g);
2097     if (r == -1)
2098       return -1;
2099   }
2100   {
2101     char device[] = "/dev/sda";
2102     char lines_0[] = ",";
2103     char *lines[] = {
2104       lines_0,
2105       NULL
2106     };
2107     int r;
2108     suppress_error = 0;
2109     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2110     if (r == -1)
2111       return -1;
2112   }
2113   {
2114     char fstype[] = "ext2";
2115     char device[] = "/dev/sda1";
2116     int r;
2117     suppress_error = 0;
2118     r = guestfs_mkfs (g, fstype, device);
2119     if (r == -1)
2120       return -1;
2121   }
2122   {
2123     char device[] = "/dev/sda1";
2124     char mountpoint[] = "/";
2125     int r;
2126     suppress_error = 0;
2127     r = guestfs_mount (g, device, mountpoint);
2128     if (r == -1)
2129       return -1;
2130   }
2131   /* TestOutputTrue for equal (0) */
2132   {
2133     char path[] = "/file1";
2134     char content[] = "contents of a file";
2135     int r;
2136     suppress_error = 0;
2137     r = guestfs_write_file (g, path, content, 0);
2138     if (r == -1)
2139       return -1;
2140   }
2141   {
2142     char src[] = "/file1";
2143     char dest[] = "/file2";
2144     int r;
2145     suppress_error = 0;
2146     r = guestfs_cp (g, src, dest);
2147     if (r == -1)
2148       return -1;
2149   }
2150   {
2151     char file1[] = "/file1";
2152     char file2[] = "/file2";
2153     int r;
2154     suppress_error = 0;
2155     r = guestfs_equal (g, file1, file2);
2156     if (r == -1)
2157       return -1;
2158     if (!r) {
2159       fprintf (stderr, "test_equal_0: expected true, got false\n");
2160       return -1;
2161     }
2162   }
2163   return 0;
2164 }
2165
2166 static int test_equal_1_skip (void)
2167 {
2168   const char *str;
2169
2170   str = getenv ("SKIP_TEST_EQUAL_1");
2171   if (str && strcmp (str, "1") == 0) return 1;
2172   str = getenv ("SKIP_TEST_EQUAL");
2173   if (str && strcmp (str, "1") == 0) return 1;
2174   return 0;
2175 }
2176
2177 static int test_equal_1 (void)
2178 {
2179   if (test_equal_1_skip ()) {
2180     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
2181     return 0;
2182   }
2183
2184   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2185   {
2186     char device[] = "/dev/sda";
2187     int r;
2188     suppress_error = 0;
2189     r = guestfs_blockdev_setrw (g, device);
2190     if (r == -1)
2191       return -1;
2192   }
2193   {
2194     int r;
2195     suppress_error = 0;
2196     r = guestfs_umount_all (g);
2197     if (r == -1)
2198       return -1;
2199   }
2200   {
2201     int r;
2202     suppress_error = 0;
2203     r = guestfs_lvm_remove_all (g);
2204     if (r == -1)
2205       return -1;
2206   }
2207   {
2208     char device[] = "/dev/sda";
2209     char lines_0[] = ",";
2210     char *lines[] = {
2211       lines_0,
2212       NULL
2213     };
2214     int r;
2215     suppress_error = 0;
2216     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2217     if (r == -1)
2218       return -1;
2219   }
2220   {
2221     char fstype[] = "ext2";
2222     char device[] = "/dev/sda1";
2223     int r;
2224     suppress_error = 0;
2225     r = guestfs_mkfs (g, fstype, device);
2226     if (r == -1)
2227       return -1;
2228   }
2229   {
2230     char device[] = "/dev/sda1";
2231     char mountpoint[] = "/";
2232     int r;
2233     suppress_error = 0;
2234     r = guestfs_mount (g, device, mountpoint);
2235     if (r == -1)
2236       return -1;
2237   }
2238   /* TestOutputFalse for equal (1) */
2239   {
2240     char path[] = "/file1";
2241     char content[] = "contents of a file";
2242     int r;
2243     suppress_error = 0;
2244     r = guestfs_write_file (g, path, content, 0);
2245     if (r == -1)
2246       return -1;
2247   }
2248   {
2249     char path[] = "/file2";
2250     char content[] = "contents of another file";
2251     int r;
2252     suppress_error = 0;
2253     r = guestfs_write_file (g, path, content, 0);
2254     if (r == -1)
2255       return -1;
2256   }
2257   {
2258     char file1[] = "/file1";
2259     char file2[] = "/file2";
2260     int r;
2261     suppress_error = 0;
2262     r = guestfs_equal (g, file1, file2);
2263     if (r == -1)
2264       return -1;
2265     if (r) {
2266       fprintf (stderr, "test_equal_1: expected false, got true\n");
2267       return -1;
2268     }
2269   }
2270   return 0;
2271 }
2272
2273 static int test_equal_2_skip (void)
2274 {
2275   const char *str;
2276
2277   str = getenv ("SKIP_TEST_EQUAL_2");
2278   if (str && strcmp (str, "1") == 0) return 1;
2279   str = getenv ("SKIP_TEST_EQUAL");
2280   if (str && strcmp (str, "1") == 0) return 1;
2281   return 0;
2282 }
2283
2284 static int test_equal_2 (void)
2285 {
2286   if (test_equal_2_skip ()) {
2287     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
2288     return 0;
2289   }
2290
2291   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
2292   {
2293     char device[] = "/dev/sda";
2294     int r;
2295     suppress_error = 0;
2296     r = guestfs_blockdev_setrw (g, device);
2297     if (r == -1)
2298       return -1;
2299   }
2300   {
2301     int r;
2302     suppress_error = 0;
2303     r = guestfs_umount_all (g);
2304     if (r == -1)
2305       return -1;
2306   }
2307   {
2308     int r;
2309     suppress_error = 0;
2310     r = guestfs_lvm_remove_all (g);
2311     if (r == -1)
2312       return -1;
2313   }
2314   {
2315     char device[] = "/dev/sda";
2316     char lines_0[] = ",";
2317     char *lines[] = {
2318       lines_0,
2319       NULL
2320     };
2321     int r;
2322     suppress_error = 0;
2323     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2324     if (r == -1)
2325       return -1;
2326   }
2327   {
2328     char fstype[] = "ext2";
2329     char device[] = "/dev/sda1";
2330     int r;
2331     suppress_error = 0;
2332     r = guestfs_mkfs (g, fstype, device);
2333     if (r == -1)
2334       return -1;
2335   }
2336   {
2337     char device[] = "/dev/sda1";
2338     char mountpoint[] = "/";
2339     int r;
2340     suppress_error = 0;
2341     r = guestfs_mount (g, device, mountpoint);
2342     if (r == -1)
2343       return -1;
2344   }
2345   /* TestLastFail for equal (2) */
2346   {
2347     char file1[] = "/file1";
2348     char file2[] = "/file2";
2349     int r;
2350     suppress_error = 1;
2351     r = guestfs_equal (g, file1, file2);
2352     if (r != -1)
2353       return -1;
2354   }
2355   return 0;
2356 }
2357
2358 static int test_ping_daemon_0_skip (void)
2359 {
2360   const char *str;
2361
2362   str = getenv ("SKIP_TEST_PING_DAEMON_0");
2363   if (str && strcmp (str, "1") == 0) return 1;
2364   str = getenv ("SKIP_TEST_PING_DAEMON");
2365   if (str && strcmp (str, "1") == 0) return 1;
2366   return 0;
2367 }
2368
2369 static int test_ping_daemon_0 (void)
2370 {
2371   if (test_ping_daemon_0_skip ()) {
2372     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
2373     return 0;
2374   }
2375
2376   /* InitNone|InitEmpty for test_ping_daemon_0 */
2377   {
2378     char device[] = "/dev/sda";
2379     int r;
2380     suppress_error = 0;
2381     r = guestfs_blockdev_setrw (g, device);
2382     if (r == -1)
2383       return -1;
2384   }
2385   {
2386     int r;
2387     suppress_error = 0;
2388     r = guestfs_umount_all (g);
2389     if (r == -1)
2390       return -1;
2391   }
2392   {
2393     int r;
2394     suppress_error = 0;
2395     r = guestfs_lvm_remove_all (g);
2396     if (r == -1)
2397       return -1;
2398   }
2399   /* TestRun for ping_daemon (0) */
2400   {
2401     int r;
2402     suppress_error = 0;
2403     r = guestfs_ping_daemon (g);
2404     if (r == -1)
2405       return -1;
2406   }
2407   return 0;
2408 }
2409
2410 static int test_dmesg_0_skip (void)
2411 {
2412   const char *str;
2413
2414   str = getenv ("SKIP_TEST_DMESG_0");
2415   if (str && strcmp (str, "1") == 0) return 1;
2416   str = getenv ("SKIP_TEST_DMESG");
2417   if (str && strcmp (str, "1") == 0) return 1;
2418   return 0;
2419 }
2420
2421 static int test_dmesg_0 (void)
2422 {
2423   if (test_dmesg_0_skip ()) {
2424     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
2425     return 0;
2426   }
2427
2428   /* InitNone|InitEmpty for test_dmesg_0 */
2429   {
2430     char device[] = "/dev/sda";
2431     int r;
2432     suppress_error = 0;
2433     r = guestfs_blockdev_setrw (g, device);
2434     if (r == -1)
2435       return -1;
2436   }
2437   {
2438     int r;
2439     suppress_error = 0;
2440     r = guestfs_umount_all (g);
2441     if (r == -1)
2442       return -1;
2443   }
2444   {
2445     int r;
2446     suppress_error = 0;
2447     r = guestfs_lvm_remove_all (g);
2448     if (r == -1)
2449       return -1;
2450   }
2451   /* TestRun for dmesg (0) */
2452   {
2453     char *r;
2454     suppress_error = 0;
2455     r = guestfs_dmesg (g);
2456     if (r == NULL)
2457       return -1;
2458     free (r);
2459   }
2460   return 0;
2461 }
2462
2463 static int test_drop_caches_0_skip (void)
2464 {
2465   const char *str;
2466
2467   str = getenv ("SKIP_TEST_DROP_CACHES_0");
2468   if (str && strcmp (str, "1") == 0) return 1;
2469   str = getenv ("SKIP_TEST_DROP_CACHES");
2470   if (str && strcmp (str, "1") == 0) return 1;
2471   return 0;
2472 }
2473
2474 static int test_drop_caches_0 (void)
2475 {
2476   if (test_drop_caches_0_skip ()) {
2477     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
2478     return 0;
2479   }
2480
2481   /* InitNone|InitEmpty for test_drop_caches_0 */
2482   {
2483     char device[] = "/dev/sda";
2484     int r;
2485     suppress_error = 0;
2486     r = guestfs_blockdev_setrw (g, device);
2487     if (r == -1)
2488       return -1;
2489   }
2490   {
2491     int r;
2492     suppress_error = 0;
2493     r = guestfs_umount_all (g);
2494     if (r == -1)
2495       return -1;
2496   }
2497   {
2498     int r;
2499     suppress_error = 0;
2500     r = guestfs_lvm_remove_all (g);
2501     if (r == -1)
2502       return -1;
2503   }
2504   /* TestRun for drop_caches (0) */
2505   {
2506     int r;
2507     suppress_error = 0;
2508     r = guestfs_drop_caches (g, 3);
2509     if (r == -1)
2510       return -1;
2511   }
2512   return 0;
2513 }
2514
2515 static int test_mv_0_skip (void)
2516 {
2517   const char *str;
2518
2519   str = getenv ("SKIP_TEST_MV_0");
2520   if (str && strcmp (str, "1") == 0) return 1;
2521   str = getenv ("SKIP_TEST_MV");
2522   if (str && strcmp (str, "1") == 0) return 1;
2523   return 0;
2524 }
2525
2526 static int test_mv_0 (void)
2527 {
2528   if (test_mv_0_skip ()) {
2529     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2530     return 0;
2531   }
2532
2533   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2534   {
2535     char device[] = "/dev/sda";
2536     int r;
2537     suppress_error = 0;
2538     r = guestfs_blockdev_setrw (g, device);
2539     if (r == -1)
2540       return -1;
2541   }
2542   {
2543     int r;
2544     suppress_error = 0;
2545     r = guestfs_umount_all (g);
2546     if (r == -1)
2547       return -1;
2548   }
2549   {
2550     int r;
2551     suppress_error = 0;
2552     r = guestfs_lvm_remove_all (g);
2553     if (r == -1)
2554       return -1;
2555   }
2556   {
2557     char device[] = "/dev/sda";
2558     char lines_0[] = ",";
2559     char *lines[] = {
2560       lines_0,
2561       NULL
2562     };
2563     int r;
2564     suppress_error = 0;
2565     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2566     if (r == -1)
2567       return -1;
2568   }
2569   {
2570     char fstype[] = "ext2";
2571     char device[] = "/dev/sda1";
2572     int r;
2573     suppress_error = 0;
2574     r = guestfs_mkfs (g, fstype, device);
2575     if (r == -1)
2576       return -1;
2577   }
2578   {
2579     char device[] = "/dev/sda1";
2580     char mountpoint[] = "/";
2581     int r;
2582     suppress_error = 0;
2583     r = guestfs_mount (g, device, mountpoint);
2584     if (r == -1)
2585       return -1;
2586   }
2587   /* TestOutput for mv (0) */
2588   char expected[] = "file content";
2589   {
2590     char path[] = "/old";
2591     char content[] = "file content";
2592     int r;
2593     suppress_error = 0;
2594     r = guestfs_write_file (g, path, content, 0);
2595     if (r == -1)
2596       return -1;
2597   }
2598   {
2599     char src[] = "/old";
2600     char dest[] = "/new";
2601     int r;
2602     suppress_error = 0;
2603     r = guestfs_mv (g, src, dest);
2604     if (r == -1)
2605       return -1;
2606   }
2607   {
2608     char path[] = "/new";
2609     char *r;
2610     suppress_error = 0;
2611     r = guestfs_cat (g, path);
2612     if (r == NULL)
2613       return -1;
2614     if (strcmp (r, expected) != 0) {
2615       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2616       return -1;
2617     }
2618     free (r);
2619   }
2620   return 0;
2621 }
2622
2623 static int test_mv_1_skip (void)
2624 {
2625   const char *str;
2626
2627   str = getenv ("SKIP_TEST_MV_1");
2628   if (str && strcmp (str, "1") == 0) return 1;
2629   str = getenv ("SKIP_TEST_MV");
2630   if (str && strcmp (str, "1") == 0) return 1;
2631   return 0;
2632 }
2633
2634 static int test_mv_1 (void)
2635 {
2636   if (test_mv_1_skip ()) {
2637     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2638     return 0;
2639   }
2640
2641   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2642   {
2643     char device[] = "/dev/sda";
2644     int r;
2645     suppress_error = 0;
2646     r = guestfs_blockdev_setrw (g, device);
2647     if (r == -1)
2648       return -1;
2649   }
2650   {
2651     int r;
2652     suppress_error = 0;
2653     r = guestfs_umount_all (g);
2654     if (r == -1)
2655       return -1;
2656   }
2657   {
2658     int r;
2659     suppress_error = 0;
2660     r = guestfs_lvm_remove_all (g);
2661     if (r == -1)
2662       return -1;
2663   }
2664   {
2665     char device[] = "/dev/sda";
2666     char lines_0[] = ",";
2667     char *lines[] = {
2668       lines_0,
2669       NULL
2670     };
2671     int r;
2672     suppress_error = 0;
2673     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2674     if (r == -1)
2675       return -1;
2676   }
2677   {
2678     char fstype[] = "ext2";
2679     char device[] = "/dev/sda1";
2680     int r;
2681     suppress_error = 0;
2682     r = guestfs_mkfs (g, fstype, device);
2683     if (r == -1)
2684       return -1;
2685   }
2686   {
2687     char device[] = "/dev/sda1";
2688     char mountpoint[] = "/";
2689     int r;
2690     suppress_error = 0;
2691     r = guestfs_mount (g, device, mountpoint);
2692     if (r == -1)
2693       return -1;
2694   }
2695   /* TestOutputFalse for mv (1) */
2696   {
2697     char path[] = "/old";
2698     char content[] = "file content";
2699     int r;
2700     suppress_error = 0;
2701     r = guestfs_write_file (g, path, content, 0);
2702     if (r == -1)
2703       return -1;
2704   }
2705   {
2706     char src[] = "/old";
2707     char dest[] = "/new";
2708     int r;
2709     suppress_error = 0;
2710     r = guestfs_mv (g, src, dest);
2711     if (r == -1)
2712       return -1;
2713   }
2714   {
2715     char path[] = "/old";
2716     int r;
2717     suppress_error = 0;
2718     r = guestfs_is_file (g, path);
2719     if (r == -1)
2720       return -1;
2721     if (r) {
2722       fprintf (stderr, "test_mv_1: expected false, got true\n");
2723       return -1;
2724     }
2725   }
2726   return 0;
2727 }
2728
2729 static int test_cp_a_0_skip (void)
2730 {
2731   const char *str;
2732
2733   str = getenv ("SKIP_TEST_CP_A_0");
2734   if (str && strcmp (str, "1") == 0) return 1;
2735   str = getenv ("SKIP_TEST_CP_A");
2736   if (str && strcmp (str, "1") == 0) return 1;
2737   return 0;
2738 }
2739
2740 static int test_cp_a_0 (void)
2741 {
2742   if (test_cp_a_0_skip ()) {
2743     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2744     return 0;
2745   }
2746
2747   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2748   {
2749     char device[] = "/dev/sda";
2750     int r;
2751     suppress_error = 0;
2752     r = guestfs_blockdev_setrw (g, device);
2753     if (r == -1)
2754       return -1;
2755   }
2756   {
2757     int r;
2758     suppress_error = 0;
2759     r = guestfs_umount_all (g);
2760     if (r == -1)
2761       return -1;
2762   }
2763   {
2764     int r;
2765     suppress_error = 0;
2766     r = guestfs_lvm_remove_all (g);
2767     if (r == -1)
2768       return -1;
2769   }
2770   {
2771     char device[] = "/dev/sda";
2772     char lines_0[] = ",";
2773     char *lines[] = {
2774       lines_0,
2775       NULL
2776     };
2777     int r;
2778     suppress_error = 0;
2779     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2780     if (r == -1)
2781       return -1;
2782   }
2783   {
2784     char fstype[] = "ext2";
2785     char device[] = "/dev/sda1";
2786     int r;
2787     suppress_error = 0;
2788     r = guestfs_mkfs (g, fstype, device);
2789     if (r == -1)
2790       return -1;
2791   }
2792   {
2793     char device[] = "/dev/sda1";
2794     char mountpoint[] = "/";
2795     int r;
2796     suppress_error = 0;
2797     r = guestfs_mount (g, device, mountpoint);
2798     if (r == -1)
2799       return -1;
2800   }
2801   /* TestOutput for cp_a (0) */
2802   char expected[] = "file content";
2803   {
2804     char path[] = "/olddir";
2805     int r;
2806     suppress_error = 0;
2807     r = guestfs_mkdir (g, path);
2808     if (r == -1)
2809       return -1;
2810   }
2811   {
2812     char path[] = "/newdir";
2813     int r;
2814     suppress_error = 0;
2815     r = guestfs_mkdir (g, path);
2816     if (r == -1)
2817       return -1;
2818   }
2819   {
2820     char path[] = "/olddir/file";
2821     char content[] = "file content";
2822     int r;
2823     suppress_error = 0;
2824     r = guestfs_write_file (g, path, content, 0);
2825     if (r == -1)
2826       return -1;
2827   }
2828   {
2829     char src[] = "/olddir";
2830     char dest[] = "/newdir";
2831     int r;
2832     suppress_error = 0;
2833     r = guestfs_cp_a (g, src, dest);
2834     if (r == -1)
2835       return -1;
2836   }
2837   {
2838     char path[] = "/newdir/olddir/file";
2839     char *r;
2840     suppress_error = 0;
2841     r = guestfs_cat (g, path);
2842     if (r == NULL)
2843       return -1;
2844     if (strcmp (r, expected) != 0) {
2845       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2846       return -1;
2847     }
2848     free (r);
2849   }
2850   return 0;
2851 }
2852
2853 static int test_cp_0_skip (void)
2854 {
2855   const char *str;
2856
2857   str = getenv ("SKIP_TEST_CP_0");
2858   if (str && strcmp (str, "1") == 0) return 1;
2859   str = getenv ("SKIP_TEST_CP");
2860   if (str && strcmp (str, "1") == 0) return 1;
2861   return 0;
2862 }
2863
2864 static int test_cp_0 (void)
2865 {
2866   if (test_cp_0_skip ()) {
2867     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2868     return 0;
2869   }
2870
2871   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2872   {
2873     char device[] = "/dev/sda";
2874     int r;
2875     suppress_error = 0;
2876     r = guestfs_blockdev_setrw (g, device);
2877     if (r == -1)
2878       return -1;
2879   }
2880   {
2881     int r;
2882     suppress_error = 0;
2883     r = guestfs_umount_all (g);
2884     if (r == -1)
2885       return -1;
2886   }
2887   {
2888     int r;
2889     suppress_error = 0;
2890     r = guestfs_lvm_remove_all (g);
2891     if (r == -1)
2892       return -1;
2893   }
2894   {
2895     char device[] = "/dev/sda";
2896     char lines_0[] = ",";
2897     char *lines[] = {
2898       lines_0,
2899       NULL
2900     };
2901     int r;
2902     suppress_error = 0;
2903     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2904     if (r == -1)
2905       return -1;
2906   }
2907   {
2908     char fstype[] = "ext2";
2909     char device[] = "/dev/sda1";
2910     int r;
2911     suppress_error = 0;
2912     r = guestfs_mkfs (g, fstype, device);
2913     if (r == -1)
2914       return -1;
2915   }
2916   {
2917     char device[] = "/dev/sda1";
2918     char mountpoint[] = "/";
2919     int r;
2920     suppress_error = 0;
2921     r = guestfs_mount (g, device, mountpoint);
2922     if (r == -1)
2923       return -1;
2924   }
2925   /* TestOutput for cp (0) */
2926   char expected[] = "file content";
2927   {
2928     char path[] = "/old";
2929     char content[] = "file content";
2930     int r;
2931     suppress_error = 0;
2932     r = guestfs_write_file (g, path, content, 0);
2933     if (r == -1)
2934       return -1;
2935   }
2936   {
2937     char src[] = "/old";
2938     char dest[] = "/new";
2939     int r;
2940     suppress_error = 0;
2941     r = guestfs_cp (g, src, dest);
2942     if (r == -1)
2943       return -1;
2944   }
2945   {
2946     char path[] = "/new";
2947     char *r;
2948     suppress_error = 0;
2949     r = guestfs_cat (g, path);
2950     if (r == NULL)
2951       return -1;
2952     if (strcmp (r, expected) != 0) {
2953       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2954       return -1;
2955     }
2956     free (r);
2957   }
2958   return 0;
2959 }
2960
2961 static int test_cp_1_skip (void)
2962 {
2963   const char *str;
2964
2965   str = getenv ("SKIP_TEST_CP_1");
2966   if (str && strcmp (str, "1") == 0) return 1;
2967   str = getenv ("SKIP_TEST_CP");
2968   if (str && strcmp (str, "1") == 0) return 1;
2969   return 0;
2970 }
2971
2972 static int test_cp_1 (void)
2973 {
2974   if (test_cp_1_skip ()) {
2975     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2976     return 0;
2977   }
2978
2979   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2980   {
2981     char device[] = "/dev/sda";
2982     int r;
2983     suppress_error = 0;
2984     r = guestfs_blockdev_setrw (g, device);
2985     if (r == -1)
2986       return -1;
2987   }
2988   {
2989     int r;
2990     suppress_error = 0;
2991     r = guestfs_umount_all (g);
2992     if (r == -1)
2993       return -1;
2994   }
2995   {
2996     int r;
2997     suppress_error = 0;
2998     r = guestfs_lvm_remove_all (g);
2999     if (r == -1)
3000       return -1;
3001   }
3002   {
3003     char device[] = "/dev/sda";
3004     char lines_0[] = ",";
3005     char *lines[] = {
3006       lines_0,
3007       NULL
3008     };
3009     int r;
3010     suppress_error = 0;
3011     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3012     if (r == -1)
3013       return -1;
3014   }
3015   {
3016     char fstype[] = "ext2";
3017     char device[] = "/dev/sda1";
3018     int r;
3019     suppress_error = 0;
3020     r = guestfs_mkfs (g, fstype, device);
3021     if (r == -1)
3022       return -1;
3023   }
3024   {
3025     char device[] = "/dev/sda1";
3026     char mountpoint[] = "/";
3027     int r;
3028     suppress_error = 0;
3029     r = guestfs_mount (g, device, mountpoint);
3030     if (r == -1)
3031       return -1;
3032   }
3033   /* TestOutputTrue for cp (1) */
3034   {
3035     char path[] = "/old";
3036     char content[] = "file content";
3037     int r;
3038     suppress_error = 0;
3039     r = guestfs_write_file (g, path, content, 0);
3040     if (r == -1)
3041       return -1;
3042   }
3043   {
3044     char src[] = "/old";
3045     char dest[] = "/new";
3046     int r;
3047     suppress_error = 0;
3048     r = guestfs_cp (g, src, dest);
3049     if (r == -1)
3050       return -1;
3051   }
3052   {
3053     char path[] = "/old";
3054     int r;
3055     suppress_error = 0;
3056     r = guestfs_is_file (g, path);
3057     if (r == -1)
3058       return -1;
3059     if (!r) {
3060       fprintf (stderr, "test_cp_1: expected true, got false\n");
3061       return -1;
3062     }
3063   }
3064   return 0;
3065 }
3066
3067 static int test_cp_2_skip (void)
3068 {
3069   const char *str;
3070
3071   str = getenv ("SKIP_TEST_CP_2");
3072   if (str && strcmp (str, "1") == 0) return 1;
3073   str = getenv ("SKIP_TEST_CP");
3074   if (str && strcmp (str, "1") == 0) return 1;
3075   return 0;
3076 }
3077
3078 static int test_cp_2 (void)
3079 {
3080   if (test_cp_2_skip ()) {
3081     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
3082     return 0;
3083   }
3084
3085   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
3086   {
3087     char device[] = "/dev/sda";
3088     int r;
3089     suppress_error = 0;
3090     r = guestfs_blockdev_setrw (g, device);
3091     if (r == -1)
3092       return -1;
3093   }
3094   {
3095     int r;
3096     suppress_error = 0;
3097     r = guestfs_umount_all (g);
3098     if (r == -1)
3099       return -1;
3100   }
3101   {
3102     int r;
3103     suppress_error = 0;
3104     r = guestfs_lvm_remove_all (g);
3105     if (r == -1)
3106       return -1;
3107   }
3108   {
3109     char device[] = "/dev/sda";
3110     char lines_0[] = ",";
3111     char *lines[] = {
3112       lines_0,
3113       NULL
3114     };
3115     int r;
3116     suppress_error = 0;
3117     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3118     if (r == -1)
3119       return -1;
3120   }
3121   {
3122     char fstype[] = "ext2";
3123     char device[] = "/dev/sda1";
3124     int r;
3125     suppress_error = 0;
3126     r = guestfs_mkfs (g, fstype, device);
3127     if (r == -1)
3128       return -1;
3129   }
3130   {
3131     char device[] = "/dev/sda1";
3132     char mountpoint[] = "/";
3133     int r;
3134     suppress_error = 0;
3135     r = guestfs_mount (g, device, mountpoint);
3136     if (r == -1)
3137       return -1;
3138   }
3139   /* TestOutput for cp (2) */
3140   char expected[] = "file content";
3141   {
3142     char path[] = "/old";
3143     char content[] = "file content";
3144     int r;
3145     suppress_error = 0;
3146     r = guestfs_write_file (g, path, content, 0);
3147     if (r == -1)
3148       return -1;
3149   }
3150   {
3151     char path[] = "/dir";
3152     int r;
3153     suppress_error = 0;
3154     r = guestfs_mkdir (g, path);
3155     if (r == -1)
3156       return -1;
3157   }
3158   {
3159     char src[] = "/old";
3160     char dest[] = "/dir/new";
3161     int r;
3162     suppress_error = 0;
3163     r = guestfs_cp (g, src, dest);
3164     if (r == -1)
3165       return -1;
3166   }
3167   {
3168     char path[] = "/dir/new";
3169     char *r;
3170     suppress_error = 0;
3171     r = guestfs_cat (g, path);
3172     if (r == NULL)
3173       return -1;
3174     if (strcmp (r, expected) != 0) {
3175       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3176       return -1;
3177     }
3178     free (r);
3179   }
3180   return 0;
3181 }
3182
3183 static int test_grub_install_0_skip (void)
3184 {
3185   const char *str;
3186
3187   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3188   if (str && strcmp (str, "1") == 0) return 1;
3189   str = getenv ("SKIP_TEST_GRUB_INSTALL");
3190   if (str && strcmp (str, "1") == 0) return 1;
3191   return 0;
3192 }
3193
3194 static int test_grub_install_0 (void)
3195 {
3196   if (test_grub_install_0_skip ()) {
3197     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
3198     return 0;
3199   }
3200
3201   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3202   {
3203     char device[] = "/dev/sda";
3204     int r;
3205     suppress_error = 0;
3206     r = guestfs_blockdev_setrw (g, device);
3207     if (r == -1)
3208       return -1;
3209   }
3210   {
3211     int r;
3212     suppress_error = 0;
3213     r = guestfs_umount_all (g);
3214     if (r == -1)
3215       return -1;
3216   }
3217   {
3218     int r;
3219     suppress_error = 0;
3220     r = guestfs_lvm_remove_all (g);
3221     if (r == -1)
3222       return -1;
3223   }
3224   {
3225     char device[] = "/dev/sda";
3226     char lines_0[] = ",";
3227     char *lines[] = {
3228       lines_0,
3229       NULL
3230     };
3231     int r;
3232     suppress_error = 0;
3233     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3234     if (r == -1)
3235       return -1;
3236   }
3237   {
3238     char fstype[] = "ext2";
3239     char device[] = "/dev/sda1";
3240     int r;
3241     suppress_error = 0;
3242     r = guestfs_mkfs (g, fstype, device);
3243     if (r == -1)
3244       return -1;
3245   }
3246   {
3247     char device[] = "/dev/sda1";
3248     char mountpoint[] = "/";
3249     int r;
3250     suppress_error = 0;
3251     r = guestfs_mount (g, device, mountpoint);
3252     if (r == -1)
3253       return -1;
3254   }
3255   /* TestOutputTrue for grub_install (0) */
3256   {
3257     char root[] = "/";
3258     char device[] = "/dev/sda1";
3259     int r;
3260     suppress_error = 0;
3261     r = guestfs_grub_install (g, root, device);
3262     if (r == -1)
3263       return -1;
3264   }
3265   {
3266     char path[] = "/boot";
3267     int r;
3268     suppress_error = 0;
3269     r = guestfs_is_dir (g, path);
3270     if (r == -1)
3271       return -1;
3272     if (!r) {
3273       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3274       return -1;
3275     }
3276   }
3277   return 0;
3278 }
3279
3280 static int test_zero_0_skip (void)
3281 {
3282   const char *str;
3283
3284   str = getenv ("SKIP_TEST_ZERO_0");
3285   if (str && strcmp (str, "1") == 0) return 1;
3286   str = getenv ("SKIP_TEST_ZERO");
3287   if (str && strcmp (str, "1") == 0) return 1;
3288   return 0;
3289 }
3290
3291 static int test_zero_0 (void)
3292 {
3293   if (test_zero_0_skip ()) {
3294     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
3295     return 0;
3296   }
3297
3298   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3299   {
3300     char device[] = "/dev/sda";
3301     int r;
3302     suppress_error = 0;
3303     r = guestfs_blockdev_setrw (g, device);
3304     if (r == -1)
3305       return -1;
3306   }
3307   {
3308     int r;
3309     suppress_error = 0;
3310     r = guestfs_umount_all (g);
3311     if (r == -1)
3312       return -1;
3313   }
3314   {
3315     int r;
3316     suppress_error = 0;
3317     r = guestfs_lvm_remove_all (g);
3318     if (r == -1)
3319       return -1;
3320   }
3321   {
3322     char device[] = "/dev/sda";
3323     char lines_0[] = ",";
3324     char *lines[] = {
3325       lines_0,
3326       NULL
3327     };
3328     int r;
3329     suppress_error = 0;
3330     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3331     if (r == -1)
3332       return -1;
3333   }
3334   {
3335     char fstype[] = "ext2";
3336     char device[] = "/dev/sda1";
3337     int r;
3338     suppress_error = 0;
3339     r = guestfs_mkfs (g, fstype, device);
3340     if (r == -1)
3341       return -1;
3342   }
3343   {
3344     char device[] = "/dev/sda1";
3345     char mountpoint[] = "/";
3346     int r;
3347     suppress_error = 0;
3348     r = guestfs_mount (g, device, mountpoint);
3349     if (r == -1)
3350       return -1;
3351   }
3352   /* TestOutput for zero (0) */
3353   char expected[] = "data";
3354   {
3355     char pathordevice[] = "/dev/sda1";
3356     int r;
3357     suppress_error = 0;
3358     r = guestfs_umount (g, pathordevice);
3359     if (r == -1)
3360       return -1;
3361   }
3362   {
3363     char device[] = "/dev/sda1";
3364     int r;
3365     suppress_error = 0;
3366     r = guestfs_zero (g, device);
3367     if (r == -1)
3368       return -1;
3369   }
3370   {
3371     char path[] = "/dev/sda1";
3372     char *r;
3373     suppress_error = 0;
3374     r = guestfs_file (g, path);
3375     if (r == NULL)
3376       return -1;
3377     if (strcmp (r, expected) != 0) {
3378       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3379       return -1;
3380     }
3381     free (r);
3382   }
3383   return 0;
3384 }
3385
3386 static int test_fsck_0_skip (void)
3387 {
3388   const char *str;
3389
3390   str = getenv ("SKIP_TEST_FSCK_0");
3391   if (str && strcmp (str, "1") == 0) return 1;
3392   str = getenv ("SKIP_TEST_FSCK");
3393   if (str && strcmp (str, "1") == 0) return 1;
3394   return 0;
3395 }
3396
3397 static int test_fsck_0 (void)
3398 {
3399   if (test_fsck_0_skip ()) {
3400     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
3401     return 0;
3402   }
3403
3404   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
3405   {
3406     char device[] = "/dev/sda";
3407     int r;
3408     suppress_error = 0;
3409     r = guestfs_blockdev_setrw (g, device);
3410     if (r == -1)
3411       return -1;
3412   }
3413   {
3414     int r;
3415     suppress_error = 0;
3416     r = guestfs_umount_all (g);
3417     if (r == -1)
3418       return -1;
3419   }
3420   {
3421     int r;
3422     suppress_error = 0;
3423     r = guestfs_lvm_remove_all (g);
3424     if (r == -1)
3425       return -1;
3426   }
3427   {
3428     char device[] = "/dev/sda";
3429     char lines_0[] = ",";
3430     char *lines[] = {
3431       lines_0,
3432       NULL
3433     };
3434     int r;
3435     suppress_error = 0;
3436     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3437     if (r == -1)
3438       return -1;
3439   }
3440   {
3441     char fstype[] = "ext2";
3442     char device[] = "/dev/sda1";
3443     int r;
3444     suppress_error = 0;
3445     r = guestfs_mkfs (g, fstype, device);
3446     if (r == -1)
3447       return -1;
3448   }
3449   {
3450     char device[] = "/dev/sda1";
3451     char mountpoint[] = "/";
3452     int r;
3453     suppress_error = 0;
3454     r = guestfs_mount (g, device, mountpoint);
3455     if (r == -1)
3456       return -1;
3457   }
3458   /* TestOutputInt for fsck (0) */
3459   {
3460     char pathordevice[] = "/dev/sda1";
3461     int r;
3462     suppress_error = 0;
3463     r = guestfs_umount (g, pathordevice);
3464     if (r == -1)
3465       return -1;
3466   }
3467   {
3468     char fstype[] = "ext2";
3469     char device[] = "/dev/sda1";
3470     int r;
3471     suppress_error = 0;
3472     r = guestfs_fsck (g, fstype, device);
3473     if (r == -1)
3474       return -1;
3475     if (r != 0) {
3476       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
3477       return -1;
3478     }
3479   }
3480   return 0;
3481 }
3482
3483 static int test_fsck_1_skip (void)
3484 {
3485   const char *str;
3486
3487   str = getenv ("SKIP_TEST_FSCK_1");
3488   if (str && strcmp (str, "1") == 0) return 1;
3489   str = getenv ("SKIP_TEST_FSCK");
3490   if (str && strcmp (str, "1") == 0) return 1;
3491   return 0;
3492 }
3493
3494 static int test_fsck_1 (void)
3495 {
3496   if (test_fsck_1_skip ()) {
3497     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3498     return 0;
3499   }
3500
3501   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3502   {
3503     char device[] = "/dev/sda";
3504     int r;
3505     suppress_error = 0;
3506     r = guestfs_blockdev_setrw (g, device);
3507     if (r == -1)
3508       return -1;
3509   }
3510   {
3511     int r;
3512     suppress_error = 0;
3513     r = guestfs_umount_all (g);
3514     if (r == -1)
3515       return -1;
3516   }
3517   {
3518     int r;
3519     suppress_error = 0;
3520     r = guestfs_lvm_remove_all (g);
3521     if (r == -1)
3522       return -1;
3523   }
3524   {
3525     char device[] = "/dev/sda";
3526     char lines_0[] = ",";
3527     char *lines[] = {
3528       lines_0,
3529       NULL
3530     };
3531     int r;
3532     suppress_error = 0;
3533     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3534     if (r == -1)
3535       return -1;
3536   }
3537   {
3538     char fstype[] = "ext2";
3539     char device[] = "/dev/sda1";
3540     int r;
3541     suppress_error = 0;
3542     r = guestfs_mkfs (g, fstype, device);
3543     if (r == -1)
3544       return -1;
3545   }
3546   {
3547     char device[] = "/dev/sda1";
3548     char mountpoint[] = "/";
3549     int r;
3550     suppress_error = 0;
3551     r = guestfs_mount (g, device, mountpoint);
3552     if (r == -1)
3553       return -1;
3554   }
3555   /* TestOutputInt for fsck (1) */
3556   {
3557     char pathordevice[] = "/dev/sda1";
3558     int r;
3559     suppress_error = 0;
3560     r = guestfs_umount (g, pathordevice);
3561     if (r == -1)
3562       return -1;
3563   }
3564   {
3565     char device[] = "/dev/sda1";
3566     int r;
3567     suppress_error = 0;
3568     r = guestfs_zero (g, device);
3569     if (r == -1)
3570       return -1;
3571   }
3572   {
3573     char fstype[] = "ext2";
3574     char device[] = "/dev/sda1";
3575     int r;
3576     suppress_error = 0;
3577     r = guestfs_fsck (g, fstype, device);
3578     if (r == -1)
3579       return -1;
3580     if (r != 8) {
3581       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
3582       return -1;
3583     }
3584   }
3585   return 0;
3586 }
3587
3588 static int test_set_e2uuid_0_skip (void)
3589 {
3590   const char *str;
3591
3592   str = getenv ("SKIP_TEST_SET_E2UUID_0");
3593   if (str && strcmp (str, "1") == 0) return 1;
3594   str = getenv ("SKIP_TEST_SET_E2UUID");
3595   if (str && strcmp (str, "1") == 0) return 1;
3596   return 0;
3597 }
3598
3599 static int test_set_e2uuid_0 (void)
3600 {
3601   if (test_set_e2uuid_0_skip ()) {
3602     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3603     return 0;
3604   }
3605
3606   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3607   {
3608     char device[] = "/dev/sda";
3609     int r;
3610     suppress_error = 0;
3611     r = guestfs_blockdev_setrw (g, device);
3612     if (r == -1)
3613       return -1;
3614   }
3615   {
3616     int r;
3617     suppress_error = 0;
3618     r = guestfs_umount_all (g);
3619     if (r == -1)
3620       return -1;
3621   }
3622   {
3623     int r;
3624     suppress_error = 0;
3625     r = guestfs_lvm_remove_all (g);
3626     if (r == -1)
3627       return -1;
3628   }
3629   {
3630     char device[] = "/dev/sda";
3631     char lines_0[] = ",";
3632     char *lines[] = {
3633       lines_0,
3634       NULL
3635     };
3636     int r;
3637     suppress_error = 0;
3638     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3639     if (r == -1)
3640       return -1;
3641   }
3642   {
3643     char fstype[] = "ext2";
3644     char device[] = "/dev/sda1";
3645     int r;
3646     suppress_error = 0;
3647     r = guestfs_mkfs (g, fstype, device);
3648     if (r == -1)
3649       return -1;
3650   }
3651   {
3652     char device[] = "/dev/sda1";
3653     char mountpoint[] = "/";
3654     int r;
3655     suppress_error = 0;
3656     r = guestfs_mount (g, device, mountpoint);
3657     if (r == -1)
3658       return -1;
3659   }
3660   /* TestOutput for set_e2uuid (0) */
3661   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3662   {
3663     char device[] = "/dev/sda1";
3664     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3665     int r;
3666     suppress_error = 0;
3667     r = guestfs_set_e2uuid (g, device, uuid);
3668     if (r == -1)
3669       return -1;
3670   }
3671   {
3672     char device[] = "/dev/sda1";
3673     char *r;
3674     suppress_error = 0;
3675     r = guestfs_get_e2uuid (g, device);
3676     if (r == NULL)
3677       return -1;
3678     if (strcmp (r, expected) != 0) {
3679       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3680       return -1;
3681     }
3682     free (r);
3683   }
3684   return 0;
3685 }
3686
3687 static int test_set_e2uuid_1_skip (void)
3688 {
3689   const char *str;
3690
3691   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3692   if (str && strcmp (str, "1") == 0) return 1;
3693   str = getenv ("SKIP_TEST_SET_E2UUID");
3694   if (str && strcmp (str, "1") == 0) return 1;
3695   return 0;
3696 }
3697
3698 static int test_set_e2uuid_1 (void)
3699 {
3700   if (test_set_e2uuid_1_skip ()) {
3701     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3702     return 0;
3703   }
3704
3705   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3706   {
3707     char device[] = "/dev/sda";
3708     int r;
3709     suppress_error = 0;
3710     r = guestfs_blockdev_setrw (g, device);
3711     if (r == -1)
3712       return -1;
3713   }
3714   {
3715     int r;
3716     suppress_error = 0;
3717     r = guestfs_umount_all (g);
3718     if (r == -1)
3719       return -1;
3720   }
3721   {
3722     int r;
3723     suppress_error = 0;
3724     r = guestfs_lvm_remove_all (g);
3725     if (r == -1)
3726       return -1;
3727   }
3728   {
3729     char device[] = "/dev/sda";
3730     char lines_0[] = ",";
3731     char *lines[] = {
3732       lines_0,
3733       NULL
3734     };
3735     int r;
3736     suppress_error = 0;
3737     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3738     if (r == -1)
3739       return -1;
3740   }
3741   {
3742     char fstype[] = "ext2";
3743     char device[] = "/dev/sda1";
3744     int r;
3745     suppress_error = 0;
3746     r = guestfs_mkfs (g, fstype, device);
3747     if (r == -1)
3748       return -1;
3749   }
3750   {
3751     char device[] = "/dev/sda1";
3752     char mountpoint[] = "/";
3753     int r;
3754     suppress_error = 0;
3755     r = guestfs_mount (g, device, mountpoint);
3756     if (r == -1)
3757       return -1;
3758   }
3759   /* TestOutput for set_e2uuid (1) */
3760   char expected[] = "";
3761   {
3762     char device[] = "/dev/sda1";
3763     char uuid[] = "clear";
3764     int r;
3765     suppress_error = 0;
3766     r = guestfs_set_e2uuid (g, device, uuid);
3767     if (r == -1)
3768       return -1;
3769   }
3770   {
3771     char device[] = "/dev/sda1";
3772     char *r;
3773     suppress_error = 0;
3774     r = guestfs_get_e2uuid (g, device);
3775     if (r == NULL)
3776       return -1;
3777     if (strcmp (r, expected) != 0) {
3778       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3779       return -1;
3780     }
3781     free (r);
3782   }
3783   return 0;
3784 }
3785
3786 static int test_set_e2uuid_2_skip (void)
3787 {
3788   const char *str;
3789
3790   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3791   if (str && strcmp (str, "1") == 0) return 1;
3792   str = getenv ("SKIP_TEST_SET_E2UUID");
3793   if (str && strcmp (str, "1") == 0) return 1;
3794   return 0;
3795 }
3796
3797 static int test_set_e2uuid_2 (void)
3798 {
3799   if (test_set_e2uuid_2_skip ()) {
3800     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3801     return 0;
3802   }
3803
3804   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3805   {
3806     char device[] = "/dev/sda";
3807     int r;
3808     suppress_error = 0;
3809     r = guestfs_blockdev_setrw (g, device);
3810     if (r == -1)
3811       return -1;
3812   }
3813   {
3814     int r;
3815     suppress_error = 0;
3816     r = guestfs_umount_all (g);
3817     if (r == -1)
3818       return -1;
3819   }
3820   {
3821     int r;
3822     suppress_error = 0;
3823     r = guestfs_lvm_remove_all (g);
3824     if (r == -1)
3825       return -1;
3826   }
3827   {
3828     char device[] = "/dev/sda";
3829     char lines_0[] = ",";
3830     char *lines[] = {
3831       lines_0,
3832       NULL
3833     };
3834     int r;
3835     suppress_error = 0;
3836     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3837     if (r == -1)
3838       return -1;
3839   }
3840   {
3841     char fstype[] = "ext2";
3842     char device[] = "/dev/sda1";
3843     int r;
3844     suppress_error = 0;
3845     r = guestfs_mkfs (g, fstype, device);
3846     if (r == -1)
3847       return -1;
3848   }
3849   {
3850     char device[] = "/dev/sda1";
3851     char mountpoint[] = "/";
3852     int r;
3853     suppress_error = 0;
3854     r = guestfs_mount (g, device, mountpoint);
3855     if (r == -1)
3856       return -1;
3857   }
3858   /* TestRun for set_e2uuid (2) */
3859   {
3860     char device[] = "/dev/sda1";
3861     char uuid[] = "random";
3862     int r;
3863     suppress_error = 0;
3864     r = guestfs_set_e2uuid (g, device, uuid);
3865     if (r == -1)
3866       return -1;
3867   }
3868   return 0;
3869 }
3870
3871 static int test_set_e2uuid_3_skip (void)
3872 {
3873   const char *str;
3874
3875   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3876   if (str && strcmp (str, "1") == 0) return 1;
3877   str = getenv ("SKIP_TEST_SET_E2UUID");
3878   if (str && strcmp (str, "1") == 0) return 1;
3879   return 0;
3880 }
3881
3882 static int test_set_e2uuid_3 (void)
3883 {
3884   if (test_set_e2uuid_3_skip ()) {
3885     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3886     return 0;
3887   }
3888
3889   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3890   {
3891     char device[] = "/dev/sda";
3892     int r;
3893     suppress_error = 0;
3894     r = guestfs_blockdev_setrw (g, device);
3895     if (r == -1)
3896       return -1;
3897   }
3898   {
3899     int r;
3900     suppress_error = 0;
3901     r = guestfs_umount_all (g);
3902     if (r == -1)
3903       return -1;
3904   }
3905   {
3906     int r;
3907     suppress_error = 0;
3908     r = guestfs_lvm_remove_all (g);
3909     if (r == -1)
3910       return -1;
3911   }
3912   {
3913     char device[] = "/dev/sda";
3914     char lines_0[] = ",";
3915     char *lines[] = {
3916       lines_0,
3917       NULL
3918     };
3919     int r;
3920     suppress_error = 0;
3921     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3922     if (r == -1)
3923       return -1;
3924   }
3925   {
3926     char fstype[] = "ext2";
3927     char device[] = "/dev/sda1";
3928     int r;
3929     suppress_error = 0;
3930     r = guestfs_mkfs (g, fstype, device);
3931     if (r == -1)
3932       return -1;
3933   }
3934   {
3935     char device[] = "/dev/sda1";
3936     char mountpoint[] = "/";
3937     int r;
3938     suppress_error = 0;
3939     r = guestfs_mount (g, device, mountpoint);
3940     if (r == -1)
3941       return -1;
3942   }
3943   /* TestRun for set_e2uuid (3) */
3944   {
3945     char device[] = "/dev/sda1";
3946     char uuid[] = "time";
3947     int r;
3948     suppress_error = 0;
3949     r = guestfs_set_e2uuid (g, device, uuid);
3950     if (r == -1)
3951       return -1;
3952   }
3953   return 0;
3954 }
3955
3956 static int test_set_e2label_0_skip (void)
3957 {
3958   const char *str;
3959
3960   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3961   if (str && strcmp (str, "1") == 0) return 1;
3962   str = getenv ("SKIP_TEST_SET_E2LABEL");
3963   if (str && strcmp (str, "1") == 0) return 1;
3964   return 0;
3965 }
3966
3967 static int test_set_e2label_0 (void)
3968 {
3969   if (test_set_e2label_0_skip ()) {
3970     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3971     return 0;
3972   }
3973
3974   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3975   {
3976     char device[] = "/dev/sda";
3977     int r;
3978     suppress_error = 0;
3979     r = guestfs_blockdev_setrw (g, device);
3980     if (r == -1)
3981       return -1;
3982   }
3983   {
3984     int r;
3985     suppress_error = 0;
3986     r = guestfs_umount_all (g);
3987     if (r == -1)
3988       return -1;
3989   }
3990   {
3991     int r;
3992     suppress_error = 0;
3993     r = guestfs_lvm_remove_all (g);
3994     if (r == -1)
3995       return -1;
3996   }
3997   {
3998     char device[] = "/dev/sda";
3999     char lines_0[] = ",";
4000     char *lines[] = {
4001       lines_0,
4002       NULL
4003     };
4004     int r;
4005     suppress_error = 0;
4006     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4007     if (r == -1)
4008       return -1;
4009   }
4010   {
4011     char fstype[] = "ext2";
4012     char device[] = "/dev/sda1";
4013     int r;
4014     suppress_error = 0;
4015     r = guestfs_mkfs (g, fstype, device);
4016     if (r == -1)
4017       return -1;
4018   }
4019   {
4020     char device[] = "/dev/sda1";
4021     char mountpoint[] = "/";
4022     int r;
4023     suppress_error = 0;
4024     r = guestfs_mount (g, device, mountpoint);
4025     if (r == -1)
4026       return -1;
4027   }
4028   /* TestOutput for set_e2label (0) */
4029   char expected[] = "testlabel";
4030   {
4031     char device[] = "/dev/sda1";
4032     char label[] = "testlabel";
4033     int r;
4034     suppress_error = 0;
4035     r = guestfs_set_e2label (g, device, label);
4036     if (r == -1)
4037       return -1;
4038   }
4039   {
4040     char device[] = "/dev/sda1";
4041     char *r;
4042     suppress_error = 0;
4043     r = guestfs_get_e2label (g, device);
4044     if (r == NULL)
4045       return -1;
4046     if (strcmp (r, expected) != 0) {
4047       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
4048       return -1;
4049     }
4050     free (r);
4051   }
4052   return 0;
4053 }
4054
4055 static int test_pvremove_0_skip (void)
4056 {
4057   const char *str;
4058
4059   str = getenv ("SKIP_TEST_PVREMOVE_0");
4060   if (str && strcmp (str, "1") == 0) return 1;
4061   str = getenv ("SKIP_TEST_PVREMOVE");
4062   if (str && strcmp (str, "1") == 0) return 1;
4063   return 0;
4064 }
4065
4066 static int test_pvremove_0 (void)
4067 {
4068   if (test_pvremove_0_skip ()) {
4069     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
4070     return 0;
4071   }
4072
4073   /* InitNone|InitEmpty for test_pvremove_0 */
4074   {
4075     char device[] = "/dev/sda";
4076     int r;
4077     suppress_error = 0;
4078     r = guestfs_blockdev_setrw (g, device);
4079     if (r == -1)
4080       return -1;
4081   }
4082   {
4083     int r;
4084     suppress_error = 0;
4085     r = guestfs_umount_all (g);
4086     if (r == -1)
4087       return -1;
4088   }
4089   {
4090     int r;
4091     suppress_error = 0;
4092     r = guestfs_lvm_remove_all (g);
4093     if (r == -1)
4094       return -1;
4095   }
4096   /* TestOutputListOfDevices for pvremove (0) */
4097   {
4098     char device[] = "/dev/sda";
4099     char lines_0[] = ",";
4100     char *lines[] = {
4101       lines_0,
4102       NULL
4103     };
4104     int r;
4105     suppress_error = 0;
4106     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4107     if (r == -1)
4108       return -1;
4109   }
4110   {
4111     char device[] = "/dev/sda1";
4112     int r;
4113     suppress_error = 0;
4114     r = guestfs_pvcreate (g, device);
4115     if (r == -1)
4116       return -1;
4117   }
4118   {
4119     char volgroup[] = "VG";
4120     char physvols_0[] = "/dev/sda1";
4121     char *physvols[] = {
4122       physvols_0,
4123       NULL
4124     };
4125     int r;
4126     suppress_error = 0;
4127     r = guestfs_vgcreate (g, volgroup, physvols);
4128     if (r == -1)
4129       return -1;
4130   }
4131   {
4132     char logvol[] = "LV1";
4133     char volgroup[] = "VG";
4134     int r;
4135     suppress_error = 0;
4136     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4137     if (r == -1)
4138       return -1;
4139   }
4140   {
4141     char logvol[] = "LV2";
4142     char volgroup[] = "VG";
4143     int r;
4144     suppress_error = 0;
4145     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4146     if (r == -1)
4147       return -1;
4148   }
4149   {
4150     char vgname[] = "VG";
4151     int r;
4152     suppress_error = 0;
4153     r = guestfs_vgremove (g, vgname);
4154     if (r == -1)
4155       return -1;
4156   }
4157   {
4158     char device[] = "/dev/sda1";
4159     int r;
4160     suppress_error = 0;
4161     r = guestfs_pvremove (g, device);
4162     if (r == -1)
4163       return -1;
4164   }
4165   {
4166     char **r;
4167     int i;
4168     suppress_error = 0;
4169     r = guestfs_lvs (g);
4170     if (r == NULL)
4171       return -1;
4172     if (r[0] != NULL) {
4173       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
4174       print_strings (r);
4175       return -1;
4176     }
4177     for (i = 0; r[i] != NULL; ++i)
4178       free (r[i]);
4179     free (r);
4180   }
4181   return 0;
4182 }
4183
4184 static int test_pvremove_1_skip (void)
4185 {
4186   const char *str;
4187
4188   str = getenv ("SKIP_TEST_PVREMOVE_1");
4189   if (str && strcmp (str, "1") == 0) return 1;
4190   str = getenv ("SKIP_TEST_PVREMOVE");
4191   if (str && strcmp (str, "1") == 0) return 1;
4192   return 0;
4193 }
4194
4195 static int test_pvremove_1 (void)
4196 {
4197   if (test_pvremove_1_skip ()) {
4198     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
4199     return 0;
4200   }
4201
4202   /* InitNone|InitEmpty for test_pvremove_1 */
4203   {
4204     char device[] = "/dev/sda";
4205     int r;
4206     suppress_error = 0;
4207     r = guestfs_blockdev_setrw (g, device);
4208     if (r == -1)
4209       return -1;
4210   }
4211   {
4212     int r;
4213     suppress_error = 0;
4214     r = guestfs_umount_all (g);
4215     if (r == -1)
4216       return -1;
4217   }
4218   {
4219     int r;
4220     suppress_error = 0;
4221     r = guestfs_lvm_remove_all (g);
4222     if (r == -1)
4223       return -1;
4224   }
4225   /* TestOutputListOfDevices for pvremove (1) */
4226   {
4227     char device[] = "/dev/sda";
4228     char lines_0[] = ",";
4229     char *lines[] = {
4230       lines_0,
4231       NULL
4232     };
4233     int r;
4234     suppress_error = 0;
4235     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4236     if (r == -1)
4237       return -1;
4238   }
4239   {
4240     char device[] = "/dev/sda1";
4241     int r;
4242     suppress_error = 0;
4243     r = guestfs_pvcreate (g, device);
4244     if (r == -1)
4245       return -1;
4246   }
4247   {
4248     char volgroup[] = "VG";
4249     char physvols_0[] = "/dev/sda1";
4250     char *physvols[] = {
4251       physvols_0,
4252       NULL
4253     };
4254     int r;
4255     suppress_error = 0;
4256     r = guestfs_vgcreate (g, volgroup, physvols);
4257     if (r == -1)
4258       return -1;
4259   }
4260   {
4261     char logvol[] = "LV1";
4262     char volgroup[] = "VG";
4263     int r;
4264     suppress_error = 0;
4265     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4266     if (r == -1)
4267       return -1;
4268   }
4269   {
4270     char logvol[] = "LV2";
4271     char volgroup[] = "VG";
4272     int r;
4273     suppress_error = 0;
4274     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4275     if (r == -1)
4276       return -1;
4277   }
4278   {
4279     char vgname[] = "VG";
4280     int r;
4281     suppress_error = 0;
4282     r = guestfs_vgremove (g, vgname);
4283     if (r == -1)
4284       return -1;
4285   }
4286   {
4287     char device[] = "/dev/sda1";
4288     int r;
4289     suppress_error = 0;
4290     r = guestfs_pvremove (g, device);
4291     if (r == -1)
4292       return -1;
4293   }
4294   {
4295     char **r;
4296     int i;
4297     suppress_error = 0;
4298     r = guestfs_vgs (g);
4299     if (r == NULL)
4300       return -1;
4301     if (r[0] != NULL) {
4302       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
4303       print_strings (r);
4304       return -1;
4305     }
4306     for (i = 0; r[i] != NULL; ++i)
4307       free (r[i]);
4308     free (r);
4309   }
4310   return 0;
4311 }
4312
4313 static int test_pvremove_2_skip (void)
4314 {
4315   const char *str;
4316
4317   str = getenv ("SKIP_TEST_PVREMOVE_2");
4318   if (str && strcmp (str, "1") == 0) return 1;
4319   str = getenv ("SKIP_TEST_PVREMOVE");
4320   if (str && strcmp (str, "1") == 0) return 1;
4321   return 0;
4322 }
4323
4324 static int test_pvremove_2 (void)
4325 {
4326   if (test_pvremove_2_skip ()) {
4327     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
4328     return 0;
4329   }
4330
4331   /* InitNone|InitEmpty for test_pvremove_2 */
4332   {
4333     char device[] = "/dev/sda";
4334     int r;
4335     suppress_error = 0;
4336     r = guestfs_blockdev_setrw (g, device);
4337     if (r == -1)
4338       return -1;
4339   }
4340   {
4341     int r;
4342     suppress_error = 0;
4343     r = guestfs_umount_all (g);
4344     if (r == -1)
4345       return -1;
4346   }
4347   {
4348     int r;
4349     suppress_error = 0;
4350     r = guestfs_lvm_remove_all (g);
4351     if (r == -1)
4352       return -1;
4353   }
4354   /* TestOutputListOfDevices for pvremove (2) */
4355   {
4356     char device[] = "/dev/sda";
4357     char lines_0[] = ",";
4358     char *lines[] = {
4359       lines_0,
4360       NULL
4361     };
4362     int r;
4363     suppress_error = 0;
4364     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4365     if (r == -1)
4366       return -1;
4367   }
4368   {
4369     char device[] = "/dev/sda1";
4370     int r;
4371     suppress_error = 0;
4372     r = guestfs_pvcreate (g, device);
4373     if (r == -1)
4374       return -1;
4375   }
4376   {
4377     char volgroup[] = "VG";
4378     char physvols_0[] = "/dev/sda1";
4379     char *physvols[] = {
4380       physvols_0,
4381       NULL
4382     };
4383     int r;
4384     suppress_error = 0;
4385     r = guestfs_vgcreate (g, volgroup, physvols);
4386     if (r == -1)
4387       return -1;
4388   }
4389   {
4390     char logvol[] = "LV1";
4391     char volgroup[] = "VG";
4392     int r;
4393     suppress_error = 0;
4394     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4395     if (r == -1)
4396       return -1;
4397   }
4398   {
4399     char logvol[] = "LV2";
4400     char volgroup[] = "VG";
4401     int r;
4402     suppress_error = 0;
4403     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4404     if (r == -1)
4405       return -1;
4406   }
4407   {
4408     char vgname[] = "VG";
4409     int r;
4410     suppress_error = 0;
4411     r = guestfs_vgremove (g, vgname);
4412     if (r == -1)
4413       return -1;
4414   }
4415   {
4416     char device[] = "/dev/sda1";
4417     int r;
4418     suppress_error = 0;
4419     r = guestfs_pvremove (g, device);
4420     if (r == -1)
4421       return -1;
4422   }
4423   {
4424     char **r;
4425     int i;
4426     suppress_error = 0;
4427     r = guestfs_pvs (g);
4428     if (r == NULL)
4429       return -1;
4430     if (r[0] != NULL) {
4431       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
4432       print_strings (r);
4433       return -1;
4434     }
4435     for (i = 0; r[i] != NULL; ++i)
4436       free (r[i]);
4437     free (r);
4438   }
4439   return 0;
4440 }
4441
4442 static int test_vgremove_0_skip (void)
4443 {
4444   const char *str;
4445
4446   str = getenv ("SKIP_TEST_VGREMOVE_0");
4447   if (str && strcmp (str, "1") == 0) return 1;
4448   str = getenv ("SKIP_TEST_VGREMOVE");
4449   if (str && strcmp (str, "1") == 0) return 1;
4450   return 0;
4451 }
4452
4453 static int test_vgremove_0 (void)
4454 {
4455   if (test_vgremove_0_skip ()) {
4456     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
4457     return 0;
4458   }
4459
4460   /* InitNone|InitEmpty for test_vgremove_0 */
4461   {
4462     char device[] = "/dev/sda";
4463     int r;
4464     suppress_error = 0;
4465     r = guestfs_blockdev_setrw (g, device);
4466     if (r == -1)
4467       return -1;
4468   }
4469   {
4470     int r;
4471     suppress_error = 0;
4472     r = guestfs_umount_all (g);
4473     if (r == -1)
4474       return -1;
4475   }
4476   {
4477     int r;
4478     suppress_error = 0;
4479     r = guestfs_lvm_remove_all (g);
4480     if (r == -1)
4481       return -1;
4482   }
4483   /* TestOutputList for vgremove (0) */
4484   {
4485     char device[] = "/dev/sda";
4486     char lines_0[] = ",";
4487     char *lines[] = {
4488       lines_0,
4489       NULL
4490     };
4491     int r;
4492     suppress_error = 0;
4493     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4494     if (r == -1)
4495       return -1;
4496   }
4497   {
4498     char device[] = "/dev/sda1";
4499     int r;
4500     suppress_error = 0;
4501     r = guestfs_pvcreate (g, device);
4502     if (r == -1)
4503       return -1;
4504   }
4505   {
4506     char volgroup[] = "VG";
4507     char physvols_0[] = "/dev/sda1";
4508     char *physvols[] = {
4509       physvols_0,
4510       NULL
4511     };
4512     int r;
4513     suppress_error = 0;
4514     r = guestfs_vgcreate (g, volgroup, physvols);
4515     if (r == -1)
4516       return -1;
4517   }
4518   {
4519     char logvol[] = "LV1";
4520     char volgroup[] = "VG";
4521     int r;
4522     suppress_error = 0;
4523     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4524     if (r == -1)
4525       return -1;
4526   }
4527   {
4528     char logvol[] = "LV2";
4529     char volgroup[] = "VG";
4530     int r;
4531     suppress_error = 0;
4532     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4533     if (r == -1)
4534       return -1;
4535   }
4536   {
4537     char vgname[] = "VG";
4538     int r;
4539     suppress_error = 0;
4540     r = guestfs_vgremove (g, vgname);
4541     if (r == -1)
4542       return -1;
4543   }
4544   {
4545     char **r;
4546     int i;
4547     suppress_error = 0;
4548     r = guestfs_lvs (g);
4549     if (r == NULL)
4550       return -1;
4551     if (r[0] != NULL) {
4552       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4553       print_strings (r);
4554       return -1;
4555     }
4556     for (i = 0; r[i] != NULL; ++i)
4557       free (r[i]);
4558     free (r);
4559   }
4560   return 0;
4561 }
4562
4563 static int test_vgremove_1_skip (void)
4564 {
4565   const char *str;
4566
4567   str = getenv ("SKIP_TEST_VGREMOVE_1");
4568   if (str && strcmp (str, "1") == 0) return 1;
4569   str = getenv ("SKIP_TEST_VGREMOVE");
4570   if (str && strcmp (str, "1") == 0) return 1;
4571   return 0;
4572 }
4573
4574 static int test_vgremove_1 (void)
4575 {
4576   if (test_vgremove_1_skip ()) {
4577     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4578     return 0;
4579   }
4580
4581   /* InitNone|InitEmpty for test_vgremove_1 */
4582   {
4583     char device[] = "/dev/sda";
4584     int r;
4585     suppress_error = 0;
4586     r = guestfs_blockdev_setrw (g, device);
4587     if (r == -1)
4588       return -1;
4589   }
4590   {
4591     int r;
4592     suppress_error = 0;
4593     r = guestfs_umount_all (g);
4594     if (r == -1)
4595       return -1;
4596   }
4597   {
4598     int r;
4599     suppress_error = 0;
4600     r = guestfs_lvm_remove_all (g);
4601     if (r == -1)
4602       return -1;
4603   }
4604   /* TestOutputList for vgremove (1) */
4605   {
4606     char device[] = "/dev/sda";
4607     char lines_0[] = ",";
4608     char *lines[] = {
4609       lines_0,
4610       NULL
4611     };
4612     int r;
4613     suppress_error = 0;
4614     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4615     if (r == -1)
4616       return -1;
4617   }
4618   {
4619     char device[] = "/dev/sda1";
4620     int r;
4621     suppress_error = 0;
4622     r = guestfs_pvcreate (g, device);
4623     if (r == -1)
4624       return -1;
4625   }
4626   {
4627     char volgroup[] = "VG";
4628     char physvols_0[] = "/dev/sda1";
4629     char *physvols[] = {
4630       physvols_0,
4631       NULL
4632     };
4633     int r;
4634     suppress_error = 0;
4635     r = guestfs_vgcreate (g, volgroup, physvols);
4636     if (r == -1)
4637       return -1;
4638   }
4639   {
4640     char logvol[] = "LV1";
4641     char volgroup[] = "VG";
4642     int r;
4643     suppress_error = 0;
4644     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4645     if (r == -1)
4646       return -1;
4647   }
4648   {
4649     char logvol[] = "LV2";
4650     char volgroup[] = "VG";
4651     int r;
4652     suppress_error = 0;
4653     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4654     if (r == -1)
4655       return -1;
4656   }
4657   {
4658     char vgname[] = "VG";
4659     int r;
4660     suppress_error = 0;
4661     r = guestfs_vgremove (g, vgname);
4662     if (r == -1)
4663       return -1;
4664   }
4665   {
4666     char **r;
4667     int i;
4668     suppress_error = 0;
4669     r = guestfs_vgs (g);
4670     if (r == NULL)
4671       return -1;
4672     if (r[0] != NULL) {
4673       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4674       print_strings (r);
4675       return -1;
4676     }
4677     for (i = 0; r[i] != NULL; ++i)
4678       free (r[i]);
4679     free (r);
4680   }
4681   return 0;
4682 }
4683
4684 static int test_lvremove_0_skip (void)
4685 {
4686   const char *str;
4687
4688   str = getenv ("SKIP_TEST_LVREMOVE_0");
4689   if (str && strcmp (str, "1") == 0) return 1;
4690   str = getenv ("SKIP_TEST_LVREMOVE");
4691   if (str && strcmp (str, "1") == 0) return 1;
4692   return 0;
4693 }
4694
4695 static int test_lvremove_0 (void)
4696 {
4697   if (test_lvremove_0_skip ()) {
4698     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4699     return 0;
4700   }
4701
4702   /* InitNone|InitEmpty for test_lvremove_0 */
4703   {
4704     char device[] = "/dev/sda";
4705     int r;
4706     suppress_error = 0;
4707     r = guestfs_blockdev_setrw (g, device);
4708     if (r == -1)
4709       return -1;
4710   }
4711   {
4712     int r;
4713     suppress_error = 0;
4714     r = guestfs_umount_all (g);
4715     if (r == -1)
4716       return -1;
4717   }
4718   {
4719     int r;
4720     suppress_error = 0;
4721     r = guestfs_lvm_remove_all (g);
4722     if (r == -1)
4723       return -1;
4724   }
4725   /* TestOutputList for lvremove (0) */
4726   {
4727     char device[] = "/dev/sda";
4728     char lines_0[] = ",";
4729     char *lines[] = {
4730       lines_0,
4731       NULL
4732     };
4733     int r;
4734     suppress_error = 0;
4735     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4736     if (r == -1)
4737       return -1;
4738   }
4739   {
4740     char device[] = "/dev/sda1";
4741     int r;
4742     suppress_error = 0;
4743     r = guestfs_pvcreate (g, device);
4744     if (r == -1)
4745       return -1;
4746   }
4747   {
4748     char volgroup[] = "VG";
4749     char physvols_0[] = "/dev/sda1";
4750     char *physvols[] = {
4751       physvols_0,
4752       NULL
4753     };
4754     int r;
4755     suppress_error = 0;
4756     r = guestfs_vgcreate (g, volgroup, physvols);
4757     if (r == -1)
4758       return -1;
4759   }
4760   {
4761     char logvol[] = "LV1";
4762     char volgroup[] = "VG";
4763     int r;
4764     suppress_error = 0;
4765     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4766     if (r == -1)
4767       return -1;
4768   }
4769   {
4770     char logvol[] = "LV2";
4771     char volgroup[] = "VG";
4772     int r;
4773     suppress_error = 0;
4774     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4775     if (r == -1)
4776       return -1;
4777   }
4778   {
4779     char device[] = "/dev/VG/LV1";
4780     int r;
4781     suppress_error = 0;
4782     r = guestfs_lvremove (g, device);
4783     if (r == -1)
4784       return -1;
4785   }
4786   {
4787     char **r;
4788     int i;
4789     suppress_error = 0;
4790     r = guestfs_lvs (g);
4791     if (r == NULL)
4792       return -1;
4793     if (!r[0]) {
4794       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4795       print_strings (r);
4796       return -1;
4797     }
4798     {
4799       char expected[] = "/dev/VG/LV2";
4800       if (strcmp (r[0], expected) != 0) {
4801         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4802         return -1;
4803       }
4804     }
4805     if (r[1] != NULL) {
4806       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4807       print_strings (r);
4808       return -1;
4809     }
4810     for (i = 0; r[i] != NULL; ++i)
4811       free (r[i]);
4812     free (r);
4813   }
4814   return 0;
4815 }
4816
4817 static int test_lvremove_1_skip (void)
4818 {
4819   const char *str;
4820
4821   str = getenv ("SKIP_TEST_LVREMOVE_1");
4822   if (str && strcmp (str, "1") == 0) return 1;
4823   str = getenv ("SKIP_TEST_LVREMOVE");
4824   if (str && strcmp (str, "1") == 0) return 1;
4825   return 0;
4826 }
4827
4828 static int test_lvremove_1 (void)
4829 {
4830   if (test_lvremove_1_skip ()) {
4831     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4832     return 0;
4833   }
4834
4835   /* InitNone|InitEmpty for test_lvremove_1 */
4836   {
4837     char device[] = "/dev/sda";
4838     int r;
4839     suppress_error = 0;
4840     r = guestfs_blockdev_setrw (g, device);
4841     if (r == -1)
4842       return -1;
4843   }
4844   {
4845     int r;
4846     suppress_error = 0;
4847     r = guestfs_umount_all (g);
4848     if (r == -1)
4849       return -1;
4850   }
4851   {
4852     int r;
4853     suppress_error = 0;
4854     r = guestfs_lvm_remove_all (g);
4855     if (r == -1)
4856       return -1;
4857   }
4858   /* TestOutputList for lvremove (1) */
4859   {
4860     char device[] = "/dev/sda";
4861     char lines_0[] = ",";
4862     char *lines[] = {
4863       lines_0,
4864       NULL
4865     };
4866     int r;
4867     suppress_error = 0;
4868     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4869     if (r == -1)
4870       return -1;
4871   }
4872   {
4873     char device[] = "/dev/sda1";
4874     int r;
4875     suppress_error = 0;
4876     r = guestfs_pvcreate (g, device);
4877     if (r == -1)
4878       return -1;
4879   }
4880   {
4881     char volgroup[] = "VG";
4882     char physvols_0[] = "/dev/sda1";
4883     char *physvols[] = {
4884       physvols_0,
4885       NULL
4886     };
4887     int r;
4888     suppress_error = 0;
4889     r = guestfs_vgcreate (g, volgroup, physvols);
4890     if (r == -1)
4891       return -1;
4892   }
4893   {
4894     char logvol[] = "LV1";
4895     char volgroup[] = "VG";
4896     int r;
4897     suppress_error = 0;
4898     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4899     if (r == -1)
4900       return -1;
4901   }
4902   {
4903     char logvol[] = "LV2";
4904     char volgroup[] = "VG";
4905     int r;
4906     suppress_error = 0;
4907     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4908     if (r == -1)
4909       return -1;
4910   }
4911   {
4912     char device[] = "/dev/VG";
4913     int r;
4914     suppress_error = 0;
4915     r = guestfs_lvremove (g, device);
4916     if (r == -1)
4917       return -1;
4918   }
4919   {
4920     char **r;
4921     int i;
4922     suppress_error = 0;
4923     r = guestfs_lvs (g);
4924     if (r == NULL)
4925       return -1;
4926     if (r[0] != NULL) {
4927       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4928       print_strings (r);
4929       return -1;
4930     }
4931     for (i = 0; r[i] != NULL; ++i)
4932       free (r[i]);
4933     free (r);
4934   }
4935   return 0;
4936 }
4937
4938 static int test_lvremove_2_skip (void)
4939 {
4940   const char *str;
4941
4942   str = getenv ("SKIP_TEST_LVREMOVE_2");
4943   if (str && strcmp (str, "1") == 0) return 1;
4944   str = getenv ("SKIP_TEST_LVREMOVE");
4945   if (str && strcmp (str, "1") == 0) return 1;
4946   return 0;
4947 }
4948
4949 static int test_lvremove_2 (void)
4950 {
4951   if (test_lvremove_2_skip ()) {
4952     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4953     return 0;
4954   }
4955
4956   /* InitNone|InitEmpty for test_lvremove_2 */
4957   {
4958     char device[] = "/dev/sda";
4959     int r;
4960     suppress_error = 0;
4961     r = guestfs_blockdev_setrw (g, device);
4962     if (r == -1)
4963       return -1;
4964   }
4965   {
4966     int r;
4967     suppress_error = 0;
4968     r = guestfs_umount_all (g);
4969     if (r == -1)
4970       return -1;
4971   }
4972   {
4973     int r;
4974     suppress_error = 0;
4975     r = guestfs_lvm_remove_all (g);
4976     if (r == -1)
4977       return -1;
4978   }
4979   /* TestOutputList for lvremove (2) */
4980   {
4981     char device[] = "/dev/sda";
4982     char lines_0[] = ",";
4983     char *lines[] = {
4984       lines_0,
4985       NULL
4986     };
4987     int r;
4988     suppress_error = 0;
4989     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4990     if (r == -1)
4991       return -1;
4992   }
4993   {
4994     char device[] = "/dev/sda1";
4995     int r;
4996     suppress_error = 0;
4997     r = guestfs_pvcreate (g, device);
4998     if (r == -1)
4999       return -1;
5000   }
5001   {
5002     char volgroup[] = "VG";
5003     char physvols_0[] = "/dev/sda1";
5004     char *physvols[] = {
5005       physvols_0,
5006       NULL
5007     };
5008     int r;
5009     suppress_error = 0;
5010     r = guestfs_vgcreate (g, volgroup, physvols);
5011     if (r == -1)
5012       return -1;
5013   }
5014   {
5015     char logvol[] = "LV1";
5016     char volgroup[] = "VG";
5017     int r;
5018     suppress_error = 0;
5019     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5020     if (r == -1)
5021       return -1;
5022   }
5023   {
5024     char logvol[] = "LV2";
5025     char volgroup[] = "VG";
5026     int r;
5027     suppress_error = 0;
5028     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5029     if (r == -1)
5030       return -1;
5031   }
5032   {
5033     char device[] = "/dev/VG";
5034     int r;
5035     suppress_error = 0;
5036     r = guestfs_lvremove (g, device);
5037     if (r == -1)
5038       return -1;
5039   }
5040   {
5041     char **r;
5042     int i;
5043     suppress_error = 0;
5044     r = guestfs_vgs (g);
5045     if (r == NULL)
5046       return -1;
5047     if (!r[0]) {
5048       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
5049       print_strings (r);
5050       return -1;
5051     }
5052     {
5053       char expected[] = "VG";
5054       if (strcmp (r[0], expected) != 0) {
5055         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5056         return -1;
5057       }
5058     }
5059     if (r[1] != NULL) {
5060       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
5061       print_strings (r);
5062       return -1;
5063     }
5064     for (i = 0; r[i] != NULL; ++i)
5065       free (r[i]);
5066     free (r);
5067   }
5068   return 0;
5069 }
5070
5071 static int test_mount_ro_0_skip (void)
5072 {
5073   const char *str;
5074
5075   str = getenv ("SKIP_TEST_MOUNT_RO_0");
5076   if (str && strcmp (str, "1") == 0) return 1;
5077   str = getenv ("SKIP_TEST_MOUNT_RO");
5078   if (str && strcmp (str, "1") == 0) return 1;
5079   return 0;
5080 }
5081
5082 static int test_mount_ro_0 (void)
5083 {
5084   if (test_mount_ro_0_skip ()) {
5085     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
5086     return 0;
5087   }
5088
5089   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
5090   {
5091     char device[] = "/dev/sda";
5092     int r;
5093     suppress_error = 0;
5094     r = guestfs_blockdev_setrw (g, device);
5095     if (r == -1)
5096       return -1;
5097   }
5098   {
5099     int r;
5100     suppress_error = 0;
5101     r = guestfs_umount_all (g);
5102     if (r == -1)
5103       return -1;
5104   }
5105   {
5106     int r;
5107     suppress_error = 0;
5108     r = guestfs_lvm_remove_all (g);
5109     if (r == -1)
5110       return -1;
5111   }
5112   {
5113     char device[] = "/dev/sda";
5114     char lines_0[] = ",";
5115     char *lines[] = {
5116       lines_0,
5117       NULL
5118     };
5119     int r;
5120     suppress_error = 0;
5121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5122     if (r == -1)
5123       return -1;
5124   }
5125   {
5126     char fstype[] = "ext2";
5127     char device[] = "/dev/sda1";
5128     int r;
5129     suppress_error = 0;
5130     r = guestfs_mkfs (g, fstype, device);
5131     if (r == -1)
5132       return -1;
5133   }
5134   {
5135     char device[] = "/dev/sda1";
5136     char mountpoint[] = "/";
5137     int r;
5138     suppress_error = 0;
5139     r = guestfs_mount (g, device, mountpoint);
5140     if (r == -1)
5141       return -1;
5142   }
5143   /* TestLastFail for mount_ro (0) */
5144   {
5145     char pathordevice[] = "/";
5146     int r;
5147     suppress_error = 0;
5148     r = guestfs_umount (g, pathordevice);
5149     if (r == -1)
5150       return -1;
5151   }
5152   {
5153     char device[] = "/dev/sda1";
5154     char mountpoint[] = "/";
5155     int r;
5156     suppress_error = 0;
5157     r = guestfs_mount_ro (g, device, mountpoint);
5158     if (r == -1)
5159       return -1;
5160   }
5161   {
5162     char path[] = "/new";
5163     int r;
5164     suppress_error = 1;
5165     r = guestfs_touch (g, path);
5166     if (r != -1)
5167       return -1;
5168   }
5169   return 0;
5170 }
5171
5172 static int test_mount_ro_1_skip (void)
5173 {
5174   const char *str;
5175
5176   str = getenv ("SKIP_TEST_MOUNT_RO_1");
5177   if (str && strcmp (str, "1") == 0) return 1;
5178   str = getenv ("SKIP_TEST_MOUNT_RO");
5179   if (str && strcmp (str, "1") == 0) return 1;
5180   return 0;
5181 }
5182
5183 static int test_mount_ro_1 (void)
5184 {
5185   if (test_mount_ro_1_skip ()) {
5186     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
5187     return 0;
5188   }
5189
5190   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5191   {
5192     char device[] = "/dev/sda";
5193     int r;
5194     suppress_error = 0;
5195     r = guestfs_blockdev_setrw (g, device);
5196     if (r == -1)
5197       return -1;
5198   }
5199   {
5200     int r;
5201     suppress_error = 0;
5202     r = guestfs_umount_all (g);
5203     if (r == -1)
5204       return -1;
5205   }
5206   {
5207     int r;
5208     suppress_error = 0;
5209     r = guestfs_lvm_remove_all (g);
5210     if (r == -1)
5211       return -1;
5212   }
5213   {
5214     char device[] = "/dev/sda";
5215     char lines_0[] = ",";
5216     char *lines[] = {
5217       lines_0,
5218       NULL
5219     };
5220     int r;
5221     suppress_error = 0;
5222     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5223     if (r == -1)
5224       return -1;
5225   }
5226   {
5227     char fstype[] = "ext2";
5228     char device[] = "/dev/sda1";
5229     int r;
5230     suppress_error = 0;
5231     r = guestfs_mkfs (g, fstype, device);
5232     if (r == -1)
5233       return -1;
5234   }
5235   {
5236     char device[] = "/dev/sda1";
5237     char mountpoint[] = "/";
5238     int r;
5239     suppress_error = 0;
5240     r = guestfs_mount (g, device, mountpoint);
5241     if (r == -1)
5242       return -1;
5243   }
5244   /* TestOutput for mount_ro (1) */
5245   char expected[] = "data";
5246   {
5247     char path[] = "/new";
5248     char content[] = "data";
5249     int r;
5250     suppress_error = 0;
5251     r = guestfs_write_file (g, path, content, 0);
5252     if (r == -1)
5253       return -1;
5254   }
5255   {
5256     char pathordevice[] = "/";
5257     int r;
5258     suppress_error = 0;
5259     r = guestfs_umount (g, pathordevice);
5260     if (r == -1)
5261       return -1;
5262   }
5263   {
5264     char device[] = "/dev/sda1";
5265     char mountpoint[] = "/";
5266     int r;
5267     suppress_error = 0;
5268     r = guestfs_mount_ro (g, device, mountpoint);
5269     if (r == -1)
5270       return -1;
5271   }
5272   {
5273     char path[] = "/new";
5274     char *r;
5275     suppress_error = 0;
5276     r = guestfs_cat (g, path);
5277     if (r == NULL)
5278       return -1;
5279     if (strcmp (r, expected) != 0) {
5280       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5281       return -1;
5282     }
5283     free (r);
5284   }
5285   return 0;
5286 }
5287
5288 static int test_tgz_in_0_skip (void)
5289 {
5290   const char *str;
5291
5292   str = getenv ("SKIP_TEST_TGZ_IN_0");
5293   if (str && strcmp (str, "1") == 0) return 1;
5294   str = getenv ("SKIP_TEST_TGZ_IN");
5295   if (str && strcmp (str, "1") == 0) return 1;
5296   return 0;
5297 }
5298
5299 static int test_tgz_in_0 (void)
5300 {
5301   if (test_tgz_in_0_skip ()) {
5302     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
5303     return 0;
5304   }
5305
5306   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5307   {
5308     char device[] = "/dev/sda";
5309     int r;
5310     suppress_error = 0;
5311     r = guestfs_blockdev_setrw (g, device);
5312     if (r == -1)
5313       return -1;
5314   }
5315   {
5316     int r;
5317     suppress_error = 0;
5318     r = guestfs_umount_all (g);
5319     if (r == -1)
5320       return -1;
5321   }
5322   {
5323     int r;
5324     suppress_error = 0;
5325     r = guestfs_lvm_remove_all (g);
5326     if (r == -1)
5327       return -1;
5328   }
5329   {
5330     char device[] = "/dev/sda";
5331     char lines_0[] = ",";
5332     char *lines[] = {
5333       lines_0,
5334       NULL
5335     };
5336     int r;
5337     suppress_error = 0;
5338     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5339     if (r == -1)
5340       return -1;
5341   }
5342   {
5343     char fstype[] = "ext2";
5344     char device[] = "/dev/sda1";
5345     int r;
5346     suppress_error = 0;
5347     r = guestfs_mkfs (g, fstype, device);
5348     if (r == -1)
5349       return -1;
5350   }
5351   {
5352     char device[] = "/dev/sda1";
5353     char mountpoint[] = "/";
5354     int r;
5355     suppress_error = 0;
5356     r = guestfs_mount (g, device, mountpoint);
5357     if (r == -1)
5358       return -1;
5359   }
5360   /* TestOutput for tgz_in (0) */
5361   char expected[] = "hello\n";
5362   {
5363     char directory[] = "/";
5364     int r;
5365     suppress_error = 0;
5366     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5367     if (r == -1)
5368       return -1;
5369   }
5370   {
5371     char path[] = "/hello";
5372     char *r;
5373     suppress_error = 0;
5374     r = guestfs_cat (g, path);
5375     if (r == NULL)
5376       return -1;
5377     if (strcmp (r, expected) != 0) {
5378       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5379       return -1;
5380     }
5381     free (r);
5382   }
5383   return 0;
5384 }
5385
5386 static int test_tar_in_0_skip (void)
5387 {
5388   const char *str;
5389
5390   str = getenv ("SKIP_TEST_TAR_IN_0");
5391   if (str && strcmp (str, "1") == 0) return 1;
5392   str = getenv ("SKIP_TEST_TAR_IN");
5393   if (str && strcmp (str, "1") == 0) return 1;
5394   return 0;
5395 }
5396
5397 static int test_tar_in_0 (void)
5398 {
5399   if (test_tar_in_0_skip ()) {
5400     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5401     return 0;
5402   }
5403
5404   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5405   {
5406     char device[] = "/dev/sda";
5407     int r;
5408     suppress_error = 0;
5409     r = guestfs_blockdev_setrw (g, device);
5410     if (r == -1)
5411       return -1;
5412   }
5413   {
5414     int r;
5415     suppress_error = 0;
5416     r = guestfs_umount_all (g);
5417     if (r == -1)
5418       return -1;
5419   }
5420   {
5421     int r;
5422     suppress_error = 0;
5423     r = guestfs_lvm_remove_all (g);
5424     if (r == -1)
5425       return -1;
5426   }
5427   {
5428     char device[] = "/dev/sda";
5429     char lines_0[] = ",";
5430     char *lines[] = {
5431       lines_0,
5432       NULL
5433     };
5434     int r;
5435     suppress_error = 0;
5436     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5437     if (r == -1)
5438       return -1;
5439   }
5440   {
5441     char fstype[] = "ext2";
5442     char device[] = "/dev/sda1";
5443     int r;
5444     suppress_error = 0;
5445     r = guestfs_mkfs (g, fstype, device);
5446     if (r == -1)
5447       return -1;
5448   }
5449   {
5450     char device[] = "/dev/sda1";
5451     char mountpoint[] = "/";
5452     int r;
5453     suppress_error = 0;
5454     r = guestfs_mount (g, device, mountpoint);
5455     if (r == -1)
5456       return -1;
5457   }
5458   /* TestOutput for tar_in (0) */
5459   char expected[] = "hello\n";
5460   {
5461     char directory[] = "/";
5462     int r;
5463     suppress_error = 0;
5464     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5465     if (r == -1)
5466       return -1;
5467   }
5468   {
5469     char path[] = "/hello";
5470     char *r;
5471     suppress_error = 0;
5472     r = guestfs_cat (g, path);
5473     if (r == NULL)
5474       return -1;
5475     if (strcmp (r, expected) != 0) {
5476       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5477       return -1;
5478     }
5479     free (r);
5480   }
5481   return 0;
5482 }
5483
5484 static int test_checksum_0_skip (void)
5485 {
5486   const char *str;
5487
5488   str = getenv ("SKIP_TEST_CHECKSUM_0");
5489   if (str && strcmp (str, "1") == 0) return 1;
5490   str = getenv ("SKIP_TEST_CHECKSUM");
5491   if (str && strcmp (str, "1") == 0) return 1;
5492   return 0;
5493 }
5494
5495 static int test_checksum_0 (void)
5496 {
5497   if (test_checksum_0_skip ()) {
5498     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5499     return 0;
5500   }
5501
5502   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5503   {
5504     char device[] = "/dev/sda";
5505     int r;
5506     suppress_error = 0;
5507     r = guestfs_blockdev_setrw (g, device);
5508     if (r == -1)
5509       return -1;
5510   }
5511   {
5512     int r;
5513     suppress_error = 0;
5514     r = guestfs_umount_all (g);
5515     if (r == -1)
5516       return -1;
5517   }
5518   {
5519     int r;
5520     suppress_error = 0;
5521     r = guestfs_lvm_remove_all (g);
5522     if (r == -1)
5523       return -1;
5524   }
5525   {
5526     char device[] = "/dev/sda";
5527     char lines_0[] = ",";
5528     char *lines[] = {
5529       lines_0,
5530       NULL
5531     };
5532     int r;
5533     suppress_error = 0;
5534     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5535     if (r == -1)
5536       return -1;
5537   }
5538   {
5539     char fstype[] = "ext2";
5540     char device[] = "/dev/sda1";
5541     int r;
5542     suppress_error = 0;
5543     r = guestfs_mkfs (g, fstype, device);
5544     if (r == -1)
5545       return -1;
5546   }
5547   {
5548     char device[] = "/dev/sda1";
5549     char mountpoint[] = "/";
5550     int r;
5551     suppress_error = 0;
5552     r = guestfs_mount (g, device, mountpoint);
5553     if (r == -1)
5554       return -1;
5555   }
5556   /* TestOutput for checksum (0) */
5557   char expected[] = "935282863";
5558   {
5559     char path[] = "/new";
5560     char content[] = "test\n";
5561     int r;
5562     suppress_error = 0;
5563     r = guestfs_write_file (g, path, content, 0);
5564     if (r == -1)
5565       return -1;
5566   }
5567   {
5568     char csumtype[] = "crc";
5569     char path[] = "/new";
5570     char *r;
5571     suppress_error = 0;
5572     r = guestfs_checksum (g, csumtype, path);
5573     if (r == NULL)
5574       return -1;
5575     if (strcmp (r, expected) != 0) {
5576       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5577       return -1;
5578     }
5579     free (r);
5580   }
5581   return 0;
5582 }
5583
5584 static int test_checksum_1_skip (void)
5585 {
5586   const char *str;
5587
5588   str = getenv ("SKIP_TEST_CHECKSUM_1");
5589   if (str && strcmp (str, "1") == 0) return 1;
5590   str = getenv ("SKIP_TEST_CHECKSUM");
5591   if (str && strcmp (str, "1") == 0) return 1;
5592   return 0;
5593 }
5594
5595 static int test_checksum_1 (void)
5596 {
5597   if (test_checksum_1_skip ()) {
5598     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5599     return 0;
5600   }
5601
5602   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5603   {
5604     char device[] = "/dev/sda";
5605     int r;
5606     suppress_error = 0;
5607     r = guestfs_blockdev_setrw (g, device);
5608     if (r == -1)
5609       return -1;
5610   }
5611   {
5612     int r;
5613     suppress_error = 0;
5614     r = guestfs_umount_all (g);
5615     if (r == -1)
5616       return -1;
5617   }
5618   {
5619     int r;
5620     suppress_error = 0;
5621     r = guestfs_lvm_remove_all (g);
5622     if (r == -1)
5623       return -1;
5624   }
5625   {
5626     char device[] = "/dev/sda";
5627     char lines_0[] = ",";
5628     char *lines[] = {
5629       lines_0,
5630       NULL
5631     };
5632     int r;
5633     suppress_error = 0;
5634     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5635     if (r == -1)
5636       return -1;
5637   }
5638   {
5639     char fstype[] = "ext2";
5640     char device[] = "/dev/sda1";
5641     int r;
5642     suppress_error = 0;
5643     r = guestfs_mkfs (g, fstype, device);
5644     if (r == -1)
5645       return -1;
5646   }
5647   {
5648     char device[] = "/dev/sda1";
5649     char mountpoint[] = "/";
5650     int r;
5651     suppress_error = 0;
5652     r = guestfs_mount (g, device, mountpoint);
5653     if (r == -1)
5654       return -1;
5655   }
5656   /* TestLastFail for checksum (1) */
5657   {
5658     char csumtype[] = "crc";
5659     char path[] = "/new";
5660     char *r;
5661     suppress_error = 1;
5662     r = guestfs_checksum (g, csumtype, path);
5663     if (r != NULL)
5664       return -1;
5665     free (r);
5666   }
5667   return 0;
5668 }
5669
5670 static int test_checksum_2_skip (void)
5671 {
5672   const char *str;
5673
5674   str = getenv ("SKIP_TEST_CHECKSUM_2");
5675   if (str && strcmp (str, "1") == 0) return 1;
5676   str = getenv ("SKIP_TEST_CHECKSUM");
5677   if (str && strcmp (str, "1") == 0) return 1;
5678   return 0;
5679 }
5680
5681 static int test_checksum_2 (void)
5682 {
5683   if (test_checksum_2_skip ()) {
5684     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5685     return 0;
5686   }
5687
5688   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5689   {
5690     char device[] = "/dev/sda";
5691     int r;
5692     suppress_error = 0;
5693     r = guestfs_blockdev_setrw (g, device);
5694     if (r == -1)
5695       return -1;
5696   }
5697   {
5698     int r;
5699     suppress_error = 0;
5700     r = guestfs_umount_all (g);
5701     if (r == -1)
5702       return -1;
5703   }
5704   {
5705     int r;
5706     suppress_error = 0;
5707     r = guestfs_lvm_remove_all (g);
5708     if (r == -1)
5709       return -1;
5710   }
5711   {
5712     char device[] = "/dev/sda";
5713     char lines_0[] = ",";
5714     char *lines[] = {
5715       lines_0,
5716       NULL
5717     };
5718     int r;
5719     suppress_error = 0;
5720     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5721     if (r == -1)
5722       return -1;
5723   }
5724   {
5725     char fstype[] = "ext2";
5726     char device[] = "/dev/sda1";
5727     int r;
5728     suppress_error = 0;
5729     r = guestfs_mkfs (g, fstype, device);
5730     if (r == -1)
5731       return -1;
5732   }
5733   {
5734     char device[] = "/dev/sda1";
5735     char mountpoint[] = "/";
5736     int r;
5737     suppress_error = 0;
5738     r = guestfs_mount (g, device, mountpoint);
5739     if (r == -1)
5740       return -1;
5741   }
5742   /* TestOutput for checksum (2) */
5743   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5744   {
5745     char path[] = "/new";
5746     char content[] = "test\n";
5747     int r;
5748     suppress_error = 0;
5749     r = guestfs_write_file (g, path, content, 0);
5750     if (r == -1)
5751       return -1;
5752   }
5753   {
5754     char csumtype[] = "md5";
5755     char path[] = "/new";
5756     char *r;
5757     suppress_error = 0;
5758     r = guestfs_checksum (g, csumtype, path);
5759     if (r == NULL)
5760       return -1;
5761     if (strcmp (r, expected) != 0) {
5762       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5763       return -1;
5764     }
5765     free (r);
5766   }
5767   return 0;
5768 }
5769
5770 static int test_checksum_3_skip (void)
5771 {
5772   const char *str;
5773
5774   str = getenv ("SKIP_TEST_CHECKSUM_3");
5775   if (str && strcmp (str, "1") == 0) return 1;
5776   str = getenv ("SKIP_TEST_CHECKSUM");
5777   if (str && strcmp (str, "1") == 0) return 1;
5778   return 0;
5779 }
5780
5781 static int test_checksum_3 (void)
5782 {
5783   if (test_checksum_3_skip ()) {
5784     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5785     return 0;
5786   }
5787
5788   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5789   {
5790     char device[] = "/dev/sda";
5791     int r;
5792     suppress_error = 0;
5793     r = guestfs_blockdev_setrw (g, device);
5794     if (r == -1)
5795       return -1;
5796   }
5797   {
5798     int r;
5799     suppress_error = 0;
5800     r = guestfs_umount_all (g);
5801     if (r == -1)
5802       return -1;
5803   }
5804   {
5805     int r;
5806     suppress_error = 0;
5807     r = guestfs_lvm_remove_all (g);
5808     if (r == -1)
5809       return -1;
5810   }
5811   {
5812     char device[] = "/dev/sda";
5813     char lines_0[] = ",";
5814     char *lines[] = {
5815       lines_0,
5816       NULL
5817     };
5818     int r;
5819     suppress_error = 0;
5820     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5821     if (r == -1)
5822       return -1;
5823   }
5824   {
5825     char fstype[] = "ext2";
5826     char device[] = "/dev/sda1";
5827     int r;
5828     suppress_error = 0;
5829     r = guestfs_mkfs (g, fstype, device);
5830     if (r == -1)
5831       return -1;
5832   }
5833   {
5834     char device[] = "/dev/sda1";
5835     char mountpoint[] = "/";
5836     int r;
5837     suppress_error = 0;
5838     r = guestfs_mount (g, device, mountpoint);
5839     if (r == -1)
5840       return -1;
5841   }
5842   /* TestOutput for checksum (3) */
5843   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5844   {
5845     char path[] = "/new";
5846     char content[] = "test\n";
5847     int r;
5848     suppress_error = 0;
5849     r = guestfs_write_file (g, path, content, 0);
5850     if (r == -1)
5851       return -1;
5852   }
5853   {
5854     char csumtype[] = "sha1";
5855     char path[] = "/new";
5856     char *r;
5857     suppress_error = 0;
5858     r = guestfs_checksum (g, csumtype, path);
5859     if (r == NULL)
5860       return -1;
5861     if (strcmp (r, expected) != 0) {
5862       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5863       return -1;
5864     }
5865     free (r);
5866   }
5867   return 0;
5868 }
5869
5870 static int test_checksum_4_skip (void)
5871 {
5872   const char *str;
5873
5874   str = getenv ("SKIP_TEST_CHECKSUM_4");
5875   if (str && strcmp (str, "1") == 0) return 1;
5876   str = getenv ("SKIP_TEST_CHECKSUM");
5877   if (str && strcmp (str, "1") == 0) return 1;
5878   return 0;
5879 }
5880
5881 static int test_checksum_4 (void)
5882 {
5883   if (test_checksum_4_skip ()) {
5884     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5885     return 0;
5886   }
5887
5888   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5889   {
5890     char device[] = "/dev/sda";
5891     int r;
5892     suppress_error = 0;
5893     r = guestfs_blockdev_setrw (g, device);
5894     if (r == -1)
5895       return -1;
5896   }
5897   {
5898     int r;
5899     suppress_error = 0;
5900     r = guestfs_umount_all (g);
5901     if (r == -1)
5902       return -1;
5903   }
5904   {
5905     int r;
5906     suppress_error = 0;
5907     r = guestfs_lvm_remove_all (g);
5908     if (r == -1)
5909       return -1;
5910   }
5911   {
5912     char device[] = "/dev/sda";
5913     char lines_0[] = ",";
5914     char *lines[] = {
5915       lines_0,
5916       NULL
5917     };
5918     int r;
5919     suppress_error = 0;
5920     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5921     if (r == -1)
5922       return -1;
5923   }
5924   {
5925     char fstype[] = "ext2";
5926     char device[] = "/dev/sda1";
5927     int r;
5928     suppress_error = 0;
5929     r = guestfs_mkfs (g, fstype, device);
5930     if (r == -1)
5931       return -1;
5932   }
5933   {
5934     char device[] = "/dev/sda1";
5935     char mountpoint[] = "/";
5936     int r;
5937     suppress_error = 0;
5938     r = guestfs_mount (g, device, mountpoint);
5939     if (r == -1)
5940       return -1;
5941   }
5942   /* TestOutput for checksum (4) */
5943   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5944   {
5945     char path[] = "/new";
5946     char content[] = "test\n";
5947     int r;
5948     suppress_error = 0;
5949     r = guestfs_write_file (g, path, content, 0);
5950     if (r == -1)
5951       return -1;
5952   }
5953   {
5954     char csumtype[] = "sha224";
5955     char path[] = "/new";
5956     char *r;
5957     suppress_error = 0;
5958     r = guestfs_checksum (g, csumtype, path);
5959     if (r == NULL)
5960       return -1;
5961     if (strcmp (r, expected) != 0) {
5962       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5963       return -1;
5964     }
5965     free (r);
5966   }
5967   return 0;
5968 }
5969
5970 static int test_checksum_5_skip (void)
5971 {
5972   const char *str;
5973
5974   str = getenv ("SKIP_TEST_CHECKSUM_5");
5975   if (str && strcmp (str, "1") == 0) return 1;
5976   str = getenv ("SKIP_TEST_CHECKSUM");
5977   if (str && strcmp (str, "1") == 0) return 1;
5978   return 0;
5979 }
5980
5981 static int test_checksum_5 (void)
5982 {
5983   if (test_checksum_5_skip ()) {
5984     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5985     return 0;
5986   }
5987
5988   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5989   {
5990     char device[] = "/dev/sda";
5991     int r;
5992     suppress_error = 0;
5993     r = guestfs_blockdev_setrw (g, device);
5994     if (r == -1)
5995       return -1;
5996   }
5997   {
5998     int r;
5999     suppress_error = 0;
6000     r = guestfs_umount_all (g);
6001     if (r == -1)
6002       return -1;
6003   }
6004   {
6005     int r;
6006     suppress_error = 0;
6007     r = guestfs_lvm_remove_all (g);
6008     if (r == -1)
6009       return -1;
6010   }
6011   {
6012     char device[] = "/dev/sda";
6013     char lines_0[] = ",";
6014     char *lines[] = {
6015       lines_0,
6016       NULL
6017     };
6018     int r;
6019     suppress_error = 0;
6020     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6021     if (r == -1)
6022       return -1;
6023   }
6024   {
6025     char fstype[] = "ext2";
6026     char device[] = "/dev/sda1";
6027     int r;
6028     suppress_error = 0;
6029     r = guestfs_mkfs (g, fstype, device);
6030     if (r == -1)
6031       return -1;
6032   }
6033   {
6034     char device[] = "/dev/sda1";
6035     char mountpoint[] = "/";
6036     int r;
6037     suppress_error = 0;
6038     r = guestfs_mount (g, device, mountpoint);
6039     if (r == -1)
6040       return -1;
6041   }
6042   /* TestOutput for checksum (5) */
6043   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
6044   {
6045     char path[] = "/new";
6046     char content[] = "test\n";
6047     int r;
6048     suppress_error = 0;
6049     r = guestfs_write_file (g, path, content, 0);
6050     if (r == -1)
6051       return -1;
6052   }
6053   {
6054     char csumtype[] = "sha256";
6055     char path[] = "/new";
6056     char *r;
6057     suppress_error = 0;
6058     r = guestfs_checksum (g, csumtype, path);
6059     if (r == NULL)
6060       return -1;
6061     if (strcmp (r, expected) != 0) {
6062       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
6063       return -1;
6064     }
6065     free (r);
6066   }
6067   return 0;
6068 }
6069
6070 static int test_checksum_6_skip (void)
6071 {
6072   const char *str;
6073
6074   str = getenv ("SKIP_TEST_CHECKSUM_6");
6075   if (str && strcmp (str, "1") == 0) return 1;
6076   str = getenv ("SKIP_TEST_CHECKSUM");
6077   if (str && strcmp (str, "1") == 0) return 1;
6078   return 0;
6079 }
6080
6081 static int test_checksum_6 (void)
6082 {
6083   if (test_checksum_6_skip ()) {
6084     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
6085     return 0;
6086   }
6087
6088   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
6089   {
6090     char device[] = "/dev/sda";
6091     int r;
6092     suppress_error = 0;
6093     r = guestfs_blockdev_setrw (g, device);
6094     if (r == -1)
6095       return -1;
6096   }
6097   {
6098     int r;
6099     suppress_error = 0;
6100     r = guestfs_umount_all (g);
6101     if (r == -1)
6102       return -1;
6103   }
6104   {
6105     int r;
6106     suppress_error = 0;
6107     r = guestfs_lvm_remove_all (g);
6108     if (r == -1)
6109       return -1;
6110   }
6111   {
6112     char device[] = "/dev/sda";
6113     char lines_0[] = ",";
6114     char *lines[] = {
6115       lines_0,
6116       NULL
6117     };
6118     int r;
6119     suppress_error = 0;
6120     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6121     if (r == -1)
6122       return -1;
6123   }
6124   {
6125     char fstype[] = "ext2";
6126     char device[] = "/dev/sda1";
6127     int r;
6128     suppress_error = 0;
6129     r = guestfs_mkfs (g, fstype, device);
6130     if (r == -1)
6131       return -1;
6132   }
6133   {
6134     char device[] = "/dev/sda1";
6135     char mountpoint[] = "/";
6136     int r;
6137     suppress_error = 0;
6138     r = guestfs_mount (g, device, mountpoint);
6139     if (r == -1)
6140       return -1;
6141   }
6142   /* TestOutput for checksum (6) */
6143   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
6144   {
6145     char path[] = "/new";
6146     char content[] = "test\n";
6147     int r;
6148     suppress_error = 0;
6149     r = guestfs_write_file (g, path, content, 0);
6150     if (r == -1)
6151       return -1;
6152   }
6153   {
6154     char csumtype[] = "sha384";
6155     char path[] = "/new";
6156     char *r;
6157     suppress_error = 0;
6158     r = guestfs_checksum (g, csumtype, path);
6159     if (r == NULL)
6160       return -1;
6161     if (strcmp (r, expected) != 0) {
6162       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6163       return -1;
6164     }
6165     free (r);
6166   }
6167   return 0;
6168 }
6169
6170 static int test_checksum_7_skip (void)
6171 {
6172   const char *str;
6173
6174   str = getenv ("SKIP_TEST_CHECKSUM_7");
6175   if (str && strcmp (str, "1") == 0) return 1;
6176   str = getenv ("SKIP_TEST_CHECKSUM");
6177   if (str && strcmp (str, "1") == 0) return 1;
6178   return 0;
6179 }
6180
6181 static int test_checksum_7 (void)
6182 {
6183   if (test_checksum_7_skip ()) {
6184     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
6185     return 0;
6186   }
6187
6188   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6189   {
6190     char device[] = "/dev/sda";
6191     int r;
6192     suppress_error = 0;
6193     r = guestfs_blockdev_setrw (g, device);
6194     if (r == -1)
6195       return -1;
6196   }
6197   {
6198     int r;
6199     suppress_error = 0;
6200     r = guestfs_umount_all (g);
6201     if (r == -1)
6202       return -1;
6203   }
6204   {
6205     int r;
6206     suppress_error = 0;
6207     r = guestfs_lvm_remove_all (g);
6208     if (r == -1)
6209       return -1;
6210   }
6211   {
6212     char device[] = "/dev/sda";
6213     char lines_0[] = ",";
6214     char *lines[] = {
6215       lines_0,
6216       NULL
6217     };
6218     int r;
6219     suppress_error = 0;
6220     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6221     if (r == -1)
6222       return -1;
6223   }
6224   {
6225     char fstype[] = "ext2";
6226     char device[] = "/dev/sda1";
6227     int r;
6228     suppress_error = 0;
6229     r = guestfs_mkfs (g, fstype, device);
6230     if (r == -1)
6231       return -1;
6232   }
6233   {
6234     char device[] = "/dev/sda1";
6235     char mountpoint[] = "/";
6236     int r;
6237     suppress_error = 0;
6238     r = guestfs_mount (g, device, mountpoint);
6239     if (r == -1)
6240       return -1;
6241   }
6242   /* TestOutput for checksum (7) */
6243   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6244   {
6245     char path[] = "/new";
6246     char content[] = "test\n";
6247     int r;
6248     suppress_error = 0;
6249     r = guestfs_write_file (g, path, content, 0);
6250     if (r == -1)
6251       return -1;
6252   }
6253   {
6254     char csumtype[] = "sha512";
6255     char path[] = "/new";
6256     char *r;
6257     suppress_error = 0;
6258     r = guestfs_checksum (g, csumtype, path);
6259     if (r == NULL)
6260       return -1;
6261     if (strcmp (r, expected) != 0) {
6262       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6263       return -1;
6264     }
6265     free (r);
6266   }
6267   return 0;
6268 }
6269
6270 static int test_checksum_8_skip (void)
6271 {
6272   const char *str;
6273
6274   str = getenv ("SKIP_TEST_CHECKSUM_8");
6275   if (str && strcmp (str, "1") == 0) return 1;
6276   str = getenv ("SKIP_TEST_CHECKSUM");
6277   if (str && strcmp (str, "1") == 0) return 1;
6278   return 0;
6279 }
6280
6281 static int test_checksum_8 (void)
6282 {
6283   if (test_checksum_8_skip ()) {
6284     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
6285     return 0;
6286   }
6287
6288   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6289   {
6290     char device[] = "/dev/sda";
6291     int r;
6292     suppress_error = 0;
6293     r = guestfs_blockdev_setrw (g, device);
6294     if (r == -1)
6295       return -1;
6296   }
6297   {
6298     int r;
6299     suppress_error = 0;
6300     r = guestfs_umount_all (g);
6301     if (r == -1)
6302       return -1;
6303   }
6304   {
6305     int r;
6306     suppress_error = 0;
6307     r = guestfs_lvm_remove_all (g);
6308     if (r == -1)
6309       return -1;
6310   }
6311   {
6312     char device[] = "/dev/sda";
6313     char lines_0[] = ",";
6314     char *lines[] = {
6315       lines_0,
6316       NULL
6317     };
6318     int r;
6319     suppress_error = 0;
6320     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6321     if (r == -1)
6322       return -1;
6323   }
6324   {
6325     char fstype[] = "ext2";
6326     char device[] = "/dev/sda1";
6327     int r;
6328     suppress_error = 0;
6329     r = guestfs_mkfs (g, fstype, device);
6330     if (r == -1)
6331       return -1;
6332   }
6333   {
6334     char device[] = "/dev/sda1";
6335     char mountpoint[] = "/";
6336     int r;
6337     suppress_error = 0;
6338     r = guestfs_mount (g, device, mountpoint);
6339     if (r == -1)
6340       return -1;
6341   }
6342   /* TestOutput for checksum (8) */
6343   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6344   {
6345     char options[] = "ro";
6346     char vfstype[] = "squashfs";
6347     char device[] = "/dev/sdd";
6348     char mountpoint[] = "/";
6349     int r;
6350     suppress_error = 0;
6351     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
6352     if (r == -1)
6353       return -1;
6354   }
6355   {
6356     char csumtype[] = "md5";
6357     char path[] = "/known-3";
6358     char *r;
6359     suppress_error = 0;
6360     r = guestfs_checksum (g, csumtype, path);
6361     if (r == NULL)
6362       return -1;
6363     if (strcmp (r, expected) != 0) {
6364       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6365       return -1;
6366     }
6367     free (r);
6368   }
6369   return 0;
6370 }
6371
6372 static int test_download_0_skip (void)
6373 {
6374   const char *str;
6375
6376   str = getenv ("SKIP_TEST_DOWNLOAD_0");
6377   if (str && strcmp (str, "1") == 0) return 1;
6378   str = getenv ("SKIP_TEST_DOWNLOAD");
6379   if (str && strcmp (str, "1") == 0) return 1;
6380   return 0;
6381 }
6382
6383 static int test_download_0 (void)
6384 {
6385   if (test_download_0_skip ()) {
6386     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6387     return 0;
6388   }
6389
6390   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
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   {
6414     char device[] = "/dev/sda";
6415     char lines_0[] = ",";
6416     char *lines[] = {
6417       lines_0,
6418       NULL
6419     };
6420     int r;
6421     suppress_error = 0;
6422     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6423     if (r == -1)
6424       return -1;
6425   }
6426   {
6427     char fstype[] = "ext2";
6428     char device[] = "/dev/sda1";
6429     int r;
6430     suppress_error = 0;
6431     r = guestfs_mkfs (g, fstype, device);
6432     if (r == -1)
6433       return -1;
6434   }
6435   {
6436     char device[] = "/dev/sda1";
6437     char mountpoint[] = "/";
6438     int r;
6439     suppress_error = 0;
6440     r = guestfs_mount (g, device, mountpoint);
6441     if (r == -1)
6442       return -1;
6443   }
6444   /* TestOutput for download (0) */
6445   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6446   {
6447     char remotefilename[] = "/COPYING.LIB";
6448     int r;
6449     suppress_error = 0;
6450     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6451     if (r == -1)
6452       return -1;
6453   }
6454   {
6455     char remotefilename[] = "/COPYING.LIB";
6456     int r;
6457     suppress_error = 0;
6458     r = guestfs_download (g, remotefilename, "testdownload.tmp");
6459     if (r == -1)
6460       return -1;
6461   }
6462   {
6463     char remotefilename[] = "/upload";
6464     int r;
6465     suppress_error = 0;
6466     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6467     if (r == -1)
6468       return -1;
6469   }
6470   {
6471     char csumtype[] = "md5";
6472     char path[] = "/upload";
6473     char *r;
6474     suppress_error = 0;
6475     r = guestfs_checksum (g, csumtype, path);
6476     if (r == NULL)
6477       return -1;
6478     if (strcmp (r, expected) != 0) {
6479       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6480       return -1;
6481     }
6482     free (r);
6483   }
6484   return 0;
6485 }
6486
6487 static int test_upload_0_skip (void)
6488 {
6489   const char *str;
6490
6491   str = getenv ("SKIP_TEST_UPLOAD_0");
6492   if (str && strcmp (str, "1") == 0) return 1;
6493   str = getenv ("SKIP_TEST_UPLOAD");
6494   if (str && strcmp (str, "1") == 0) return 1;
6495   return 0;
6496 }
6497
6498 static int test_upload_0 (void)
6499 {
6500   if (test_upload_0_skip ()) {
6501     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6502     return 0;
6503   }
6504
6505   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6506   {
6507     char device[] = "/dev/sda";
6508     int r;
6509     suppress_error = 0;
6510     r = guestfs_blockdev_setrw (g, device);
6511     if (r == -1)
6512       return -1;
6513   }
6514   {
6515     int r;
6516     suppress_error = 0;
6517     r = guestfs_umount_all (g);
6518     if (r == -1)
6519       return -1;
6520   }
6521   {
6522     int r;
6523     suppress_error = 0;
6524     r = guestfs_lvm_remove_all (g);
6525     if (r == -1)
6526       return -1;
6527   }
6528   {
6529     char device[] = "/dev/sda";
6530     char lines_0[] = ",";
6531     char *lines[] = {
6532       lines_0,
6533       NULL
6534     };
6535     int r;
6536     suppress_error = 0;
6537     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6538     if (r == -1)
6539       return -1;
6540   }
6541   {
6542     char fstype[] = "ext2";
6543     char device[] = "/dev/sda1";
6544     int r;
6545     suppress_error = 0;
6546     r = guestfs_mkfs (g, fstype, device);
6547     if (r == -1)
6548       return -1;
6549   }
6550   {
6551     char device[] = "/dev/sda1";
6552     char mountpoint[] = "/";
6553     int r;
6554     suppress_error = 0;
6555     r = guestfs_mount (g, device, mountpoint);
6556     if (r == -1)
6557       return -1;
6558   }
6559   /* TestOutput for upload (0) */
6560   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6561   {
6562     char remotefilename[] = "/COPYING.LIB";
6563     int r;
6564     suppress_error = 0;
6565     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6566     if (r == -1)
6567       return -1;
6568   }
6569   {
6570     char csumtype[] = "md5";
6571     char path[] = "/COPYING.LIB";
6572     char *r;
6573     suppress_error = 0;
6574     r = guestfs_checksum (g, csumtype, path);
6575     if (r == NULL)
6576       return -1;
6577     if (strcmp (r, expected) != 0) {
6578       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6579       return -1;
6580     }
6581     free (r);
6582   }
6583   return 0;
6584 }
6585
6586 static int test_blockdev_rereadpt_0_skip (void)
6587 {
6588   const char *str;
6589
6590   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6591   if (str && strcmp (str, "1") == 0) return 1;
6592   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6593   if (str && strcmp (str, "1") == 0) return 1;
6594   return 0;
6595 }
6596
6597 static int test_blockdev_rereadpt_0 (void)
6598 {
6599   if (test_blockdev_rereadpt_0_skip ()) {
6600     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6601     return 0;
6602   }
6603
6604   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6605   {
6606     char device[] = "/dev/sda";
6607     int r;
6608     suppress_error = 0;
6609     r = guestfs_blockdev_setrw (g, device);
6610     if (r == -1)
6611       return -1;
6612   }
6613   {
6614     int r;
6615     suppress_error = 0;
6616     r = guestfs_umount_all (g);
6617     if (r == -1)
6618       return -1;
6619   }
6620   {
6621     int r;
6622     suppress_error = 0;
6623     r = guestfs_lvm_remove_all (g);
6624     if (r == -1)
6625       return -1;
6626   }
6627   /* TestRun for blockdev_rereadpt (0) */
6628   {
6629     char device[] = "/dev/sda";
6630     int r;
6631     suppress_error = 0;
6632     r = guestfs_blockdev_rereadpt (g, device);
6633     if (r == -1)
6634       return -1;
6635   }
6636   return 0;
6637 }
6638
6639 static int test_blockdev_flushbufs_0_skip (void)
6640 {
6641   const char *str;
6642
6643   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6644   if (str && strcmp (str, "1") == 0) return 1;
6645   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6646   if (str && strcmp (str, "1") == 0) return 1;
6647   return 0;
6648 }
6649
6650 static int test_blockdev_flushbufs_0 (void)
6651 {
6652   if (test_blockdev_flushbufs_0_skip ()) {
6653     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6654     return 0;
6655   }
6656
6657   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6658   {
6659     char device[] = "/dev/sda";
6660     int r;
6661     suppress_error = 0;
6662     r = guestfs_blockdev_setrw (g, device);
6663     if (r == -1)
6664       return -1;
6665   }
6666   {
6667     int r;
6668     suppress_error = 0;
6669     r = guestfs_umount_all (g);
6670     if (r == -1)
6671       return -1;
6672   }
6673   {
6674     int r;
6675     suppress_error = 0;
6676     r = guestfs_lvm_remove_all (g);
6677     if (r == -1)
6678       return -1;
6679   }
6680   /* TestRun for blockdev_flushbufs (0) */
6681   {
6682     char device[] = "/dev/sda";
6683     int r;
6684     suppress_error = 0;
6685     r = guestfs_blockdev_flushbufs (g, device);
6686     if (r == -1)
6687       return -1;
6688   }
6689   return 0;
6690 }
6691
6692 static int test_blockdev_getsize64_0_skip (void)
6693 {
6694   const char *str;
6695
6696   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6697   if (str && strcmp (str, "1") == 0) return 1;
6698   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6699   if (str && strcmp (str, "1") == 0) return 1;
6700   return 0;
6701 }
6702
6703 static int test_blockdev_getsize64_0 (void)
6704 {
6705   if (test_blockdev_getsize64_0_skip ()) {
6706     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6707     return 0;
6708   }
6709
6710   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6711   {
6712     char device[] = "/dev/sda";
6713     int r;
6714     suppress_error = 0;
6715     r = guestfs_blockdev_setrw (g, device);
6716     if (r == -1)
6717       return -1;
6718   }
6719   {
6720     int r;
6721     suppress_error = 0;
6722     r = guestfs_umount_all (g);
6723     if (r == -1)
6724       return -1;
6725   }
6726   {
6727     int r;
6728     suppress_error = 0;
6729     r = guestfs_lvm_remove_all (g);
6730     if (r == -1)
6731       return -1;
6732   }
6733   /* TestOutputInt for blockdev_getsize64 (0) */
6734   {
6735     char device[] = "/dev/sda";
6736     int64_t r;
6737     suppress_error = 0;
6738     r = guestfs_blockdev_getsize64 (g, device);
6739     if (r == -1)
6740       return -1;
6741     if (r != 524288000) {
6742       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6743       return -1;
6744     }
6745   }
6746   return 0;
6747 }
6748
6749 static int test_blockdev_getsz_0_skip (void)
6750 {
6751   const char *str;
6752
6753   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6754   if (str && strcmp (str, "1") == 0) return 1;
6755   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6756   if (str && strcmp (str, "1") == 0) return 1;
6757   return 0;
6758 }
6759
6760 static int test_blockdev_getsz_0 (void)
6761 {
6762   if (test_blockdev_getsz_0_skip ()) {
6763     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6764     return 0;
6765   }
6766
6767   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6768   {
6769     char device[] = "/dev/sda";
6770     int r;
6771     suppress_error = 0;
6772     r = guestfs_blockdev_setrw (g, device);
6773     if (r == -1)
6774       return -1;
6775   }
6776   {
6777     int r;
6778     suppress_error = 0;
6779     r = guestfs_umount_all (g);
6780     if (r == -1)
6781       return -1;
6782   }
6783   {
6784     int r;
6785     suppress_error = 0;
6786     r = guestfs_lvm_remove_all (g);
6787     if (r == -1)
6788       return -1;
6789   }
6790   /* TestOutputInt for blockdev_getsz (0) */
6791   {
6792     char device[] = "/dev/sda";
6793     int64_t r;
6794     suppress_error = 0;
6795     r = guestfs_blockdev_getsz (g, device);
6796     if (r == -1)
6797       return -1;
6798     if (r != 1024000) {
6799       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6800       return -1;
6801     }
6802   }
6803   return 0;
6804 }
6805
6806 static int test_blockdev_getbsz_0_skip (void)
6807 {
6808   const char *str;
6809
6810   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6811   if (str && strcmp (str, "1") == 0) return 1;
6812   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6813   if (str && strcmp (str, "1") == 0) return 1;
6814   return 0;
6815 }
6816
6817 static int test_blockdev_getbsz_0 (void)
6818 {
6819   if (test_blockdev_getbsz_0_skip ()) {
6820     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6821     return 0;
6822   }
6823
6824   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6825   {
6826     char device[] = "/dev/sda";
6827     int r;
6828     suppress_error = 0;
6829     r = guestfs_blockdev_setrw (g, device);
6830     if (r == -1)
6831       return -1;
6832   }
6833   {
6834     int r;
6835     suppress_error = 0;
6836     r = guestfs_umount_all (g);
6837     if (r == -1)
6838       return -1;
6839   }
6840   {
6841     int r;
6842     suppress_error = 0;
6843     r = guestfs_lvm_remove_all (g);
6844     if (r == -1)
6845       return -1;
6846   }
6847   /* TestOutputInt for blockdev_getbsz (0) */
6848   {
6849     char device[] = "/dev/sda";
6850     int r;
6851     suppress_error = 0;
6852     r = guestfs_blockdev_getbsz (g, device);
6853     if (r == -1)
6854       return -1;
6855     if (r != 4096) {
6856       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6857       return -1;
6858     }
6859   }
6860   return 0;
6861 }
6862
6863 static int test_blockdev_getss_0_skip (void)
6864 {
6865   const char *str;
6866
6867   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6868   if (str && strcmp (str, "1") == 0) return 1;
6869   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6870   if (str && strcmp (str, "1") == 0) return 1;
6871   return 0;
6872 }
6873
6874 static int test_blockdev_getss_0 (void)
6875 {
6876   if (test_blockdev_getss_0_skip ()) {
6877     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6878     return 0;
6879   }
6880
6881   /* InitNone|InitEmpty for test_blockdev_getss_0 */
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   /* TestOutputInt for blockdev_getss (0) */
6905   {
6906     char device[] = "/dev/sda";
6907     int r;
6908     suppress_error = 0;
6909     r = guestfs_blockdev_getss (g, device);
6910     if (r == -1)
6911       return -1;
6912     if (r != 512) {
6913       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6914       return -1;
6915     }
6916   }
6917   return 0;
6918 }
6919
6920 static int test_blockdev_getro_0_skip (void)
6921 {
6922   const char *str;
6923
6924   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6925   if (str && strcmp (str, "1") == 0) return 1;
6926   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6927   if (str && strcmp (str, "1") == 0) return 1;
6928   return 0;
6929 }
6930
6931 static int test_blockdev_getro_0 (void)
6932 {
6933   if (test_blockdev_getro_0_skip ()) {
6934     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6935     return 0;
6936   }
6937
6938   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6939   {
6940     char device[] = "/dev/sda";
6941     int r;
6942     suppress_error = 0;
6943     r = guestfs_blockdev_setrw (g, device);
6944     if (r == -1)
6945       return -1;
6946   }
6947   {
6948     int r;
6949     suppress_error = 0;
6950     r = guestfs_umount_all (g);
6951     if (r == -1)
6952       return -1;
6953   }
6954   {
6955     int r;
6956     suppress_error = 0;
6957     r = guestfs_lvm_remove_all (g);
6958     if (r == -1)
6959       return -1;
6960   }
6961   /* TestOutputTrue for blockdev_getro (0) */
6962   {
6963     char device[] = "/dev/sda";
6964     int r;
6965     suppress_error = 0;
6966     r = guestfs_blockdev_setro (g, device);
6967     if (r == -1)
6968       return -1;
6969   }
6970   {
6971     char device[] = "/dev/sda";
6972     int r;
6973     suppress_error = 0;
6974     r = guestfs_blockdev_getro (g, device);
6975     if (r == -1)
6976       return -1;
6977     if (!r) {
6978       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6979       return -1;
6980     }
6981   }
6982   return 0;
6983 }
6984
6985 static int test_blockdev_setrw_0_skip (void)
6986 {
6987   const char *str;
6988
6989   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6990   if (str && strcmp (str, "1") == 0) return 1;
6991   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6992   if (str && strcmp (str, "1") == 0) return 1;
6993   return 0;
6994 }
6995
6996 static int test_blockdev_setrw_0 (void)
6997 {
6998   if (test_blockdev_setrw_0_skip ()) {
6999     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
7000     return 0;
7001   }
7002
7003   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
7004   {
7005     char device[] = "/dev/sda";
7006     int r;
7007     suppress_error = 0;
7008     r = guestfs_blockdev_setrw (g, device);
7009     if (r == -1)
7010       return -1;
7011   }
7012   {
7013     int r;
7014     suppress_error = 0;
7015     r = guestfs_umount_all (g);
7016     if (r == -1)
7017       return -1;
7018   }
7019   {
7020     int r;
7021     suppress_error = 0;
7022     r = guestfs_lvm_remove_all (g);
7023     if (r == -1)
7024       return -1;
7025   }
7026   /* TestOutputFalse for blockdev_setrw (0) */
7027   {
7028     char device[] = "/dev/sda";
7029     int r;
7030     suppress_error = 0;
7031     r = guestfs_blockdev_setrw (g, device);
7032     if (r == -1)
7033       return -1;
7034   }
7035   {
7036     char device[] = "/dev/sda";
7037     int r;
7038     suppress_error = 0;
7039     r = guestfs_blockdev_getro (g, device);
7040     if (r == -1)
7041       return -1;
7042     if (r) {
7043       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
7044       return -1;
7045     }
7046   }
7047   return 0;
7048 }
7049
7050 static int test_blockdev_setro_0_skip (void)
7051 {
7052   const char *str;
7053
7054   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
7055   if (str && strcmp (str, "1") == 0) return 1;
7056   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
7057   if (str && strcmp (str, "1") == 0) return 1;
7058   return 0;
7059 }
7060
7061 static int test_blockdev_setro_0 (void)
7062 {
7063   if (test_blockdev_setro_0_skip ()) {
7064     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
7065     return 0;
7066   }
7067
7068   /* InitNone|InitEmpty for test_blockdev_setro_0 */
7069   {
7070     char device[] = "/dev/sda";
7071     int r;
7072     suppress_error = 0;
7073     r = guestfs_blockdev_setrw (g, device);
7074     if (r == -1)
7075       return -1;
7076   }
7077   {
7078     int r;
7079     suppress_error = 0;
7080     r = guestfs_umount_all (g);
7081     if (r == -1)
7082       return -1;
7083   }
7084   {
7085     int r;
7086     suppress_error = 0;
7087     r = guestfs_lvm_remove_all (g);
7088     if (r == -1)
7089       return -1;
7090   }
7091   /* TestOutputTrue for blockdev_setro (0) */
7092   {
7093     char device[] = "/dev/sda";
7094     int r;
7095     suppress_error = 0;
7096     r = guestfs_blockdev_setro (g, device);
7097     if (r == -1)
7098       return -1;
7099   }
7100   {
7101     char device[] = "/dev/sda";
7102     int r;
7103     suppress_error = 0;
7104     r = guestfs_blockdev_getro (g, device);
7105     if (r == -1)
7106       return -1;
7107     if (!r) {
7108       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
7109       return -1;
7110     }
7111   }
7112   return 0;
7113 }
7114
7115 static int test_statvfs_0_skip (void)
7116 {
7117   const char *str;
7118
7119   str = getenv ("SKIP_TEST_STATVFS_0");
7120   if (str && strcmp (str, "1") == 0) return 1;
7121   str = getenv ("SKIP_TEST_STATVFS");
7122   if (str && strcmp (str, "1") == 0) return 1;
7123   return 0;
7124 }
7125
7126 static int test_statvfs_0 (void)
7127 {
7128   if (test_statvfs_0_skip ()) {
7129     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
7130     return 0;
7131   }
7132
7133   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
7134   {
7135     char device[] = "/dev/sda";
7136     int r;
7137     suppress_error = 0;
7138     r = guestfs_blockdev_setrw (g, device);
7139     if (r == -1)
7140       return -1;
7141   }
7142   {
7143     int r;
7144     suppress_error = 0;
7145     r = guestfs_umount_all (g);
7146     if (r == -1)
7147       return -1;
7148   }
7149   {
7150     int r;
7151     suppress_error = 0;
7152     r = guestfs_lvm_remove_all (g);
7153     if (r == -1)
7154       return -1;
7155   }
7156   {
7157     char device[] = "/dev/sda";
7158     char lines_0[] = ",";
7159     char *lines[] = {
7160       lines_0,
7161       NULL
7162     };
7163     int r;
7164     suppress_error = 0;
7165     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7166     if (r == -1)
7167       return -1;
7168   }
7169   {
7170     char fstype[] = "ext2";
7171     char device[] = "/dev/sda1";
7172     int r;
7173     suppress_error = 0;
7174     r = guestfs_mkfs (g, fstype, device);
7175     if (r == -1)
7176       return -1;
7177   }
7178   {
7179     char device[] = "/dev/sda1";
7180     char mountpoint[] = "/";
7181     int r;
7182     suppress_error = 0;
7183     r = guestfs_mount (g, device, mountpoint);
7184     if (r == -1)
7185       return -1;
7186   }
7187   /* TestOutputStruct for statvfs (0) */
7188   {
7189     char path[] = "/";
7190     struct guestfs_statvfs *r;
7191     suppress_error = 0;
7192     r = guestfs_statvfs (g, path);
7193     if (r == NULL)
7194       return -1;
7195     if (r->bfree != 487702) {
7196       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7197                (int) r->bfree);
7198       return -1;
7199     }
7200     if (r->blocks != 490020) {
7201       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7202                (int) r->blocks);
7203       return -1;
7204     }
7205     if (r->bsize != 1024) {
7206       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7207                (int) r->bsize);
7208       return -1;
7209     }
7210     free (r);
7211   }
7212   return 0;
7213 }
7214
7215 static int test_lstat_0_skip (void)
7216 {
7217   const char *str;
7218
7219   str = getenv ("SKIP_TEST_LSTAT_0");
7220   if (str && strcmp (str, "1") == 0) return 1;
7221   str = getenv ("SKIP_TEST_LSTAT");
7222   if (str && strcmp (str, "1") == 0) return 1;
7223   return 0;
7224 }
7225
7226 static int test_lstat_0 (void)
7227 {
7228   if (test_lstat_0_skip ()) {
7229     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
7230     return 0;
7231   }
7232
7233   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7234   {
7235     char device[] = "/dev/sda";
7236     int r;
7237     suppress_error = 0;
7238     r = guestfs_blockdev_setrw (g, device);
7239     if (r == -1)
7240       return -1;
7241   }
7242   {
7243     int r;
7244     suppress_error = 0;
7245     r = guestfs_umount_all (g);
7246     if (r == -1)
7247       return -1;
7248   }
7249   {
7250     int r;
7251     suppress_error = 0;
7252     r = guestfs_lvm_remove_all (g);
7253     if (r == -1)
7254       return -1;
7255   }
7256   {
7257     char device[] = "/dev/sda";
7258     char lines_0[] = ",";
7259     char *lines[] = {
7260       lines_0,
7261       NULL
7262     };
7263     int r;
7264     suppress_error = 0;
7265     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7266     if (r == -1)
7267       return -1;
7268   }
7269   {
7270     char fstype[] = "ext2";
7271     char device[] = "/dev/sda1";
7272     int r;
7273     suppress_error = 0;
7274     r = guestfs_mkfs (g, fstype, device);
7275     if (r == -1)
7276       return -1;
7277   }
7278   {
7279     char device[] = "/dev/sda1";
7280     char mountpoint[] = "/";
7281     int r;
7282     suppress_error = 0;
7283     r = guestfs_mount (g, device, mountpoint);
7284     if (r == -1)
7285       return -1;
7286   }
7287   /* TestOutputStruct for lstat (0) */
7288   {
7289     char path[] = "/new";
7290     int r;
7291     suppress_error = 0;
7292     r = guestfs_touch (g, path);
7293     if (r == -1)
7294       return -1;
7295   }
7296   {
7297     char path[] = "/new";
7298     struct guestfs_stat *r;
7299     suppress_error = 0;
7300     r = guestfs_lstat (g, path);
7301     if (r == NULL)
7302       return -1;
7303     if (r->size != 0) {
7304       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7305                (int) r->size);
7306       return -1;
7307     }
7308     free (r);
7309   }
7310   return 0;
7311 }
7312
7313 static int test_stat_0_skip (void)
7314 {
7315   const char *str;
7316
7317   str = getenv ("SKIP_TEST_STAT_0");
7318   if (str && strcmp (str, "1") == 0) return 1;
7319   str = getenv ("SKIP_TEST_STAT");
7320   if (str && strcmp (str, "1") == 0) return 1;
7321   return 0;
7322 }
7323
7324 static int test_stat_0 (void)
7325 {
7326   if (test_stat_0_skip ()) {
7327     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7328     return 0;
7329   }
7330
7331   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7332   {
7333     char device[] = "/dev/sda";
7334     int r;
7335     suppress_error = 0;
7336     r = guestfs_blockdev_setrw (g, device);
7337     if (r == -1)
7338       return -1;
7339   }
7340   {
7341     int r;
7342     suppress_error = 0;
7343     r = guestfs_umount_all (g);
7344     if (r == -1)
7345       return -1;
7346   }
7347   {
7348     int r;
7349     suppress_error = 0;
7350     r = guestfs_lvm_remove_all (g);
7351     if (r == -1)
7352       return -1;
7353   }
7354   {
7355     char device[] = "/dev/sda";
7356     char lines_0[] = ",";
7357     char *lines[] = {
7358       lines_0,
7359       NULL
7360     };
7361     int r;
7362     suppress_error = 0;
7363     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7364     if (r == -1)
7365       return -1;
7366   }
7367   {
7368     char fstype[] = "ext2";
7369     char device[] = "/dev/sda1";
7370     int r;
7371     suppress_error = 0;
7372     r = guestfs_mkfs (g, fstype, device);
7373     if (r == -1)
7374       return -1;
7375   }
7376   {
7377     char device[] = "/dev/sda1";
7378     char mountpoint[] = "/";
7379     int r;
7380     suppress_error = 0;
7381     r = guestfs_mount (g, device, mountpoint);
7382     if (r == -1)
7383       return -1;
7384   }
7385   /* TestOutputStruct for stat (0) */
7386   {
7387     char path[] = "/new";
7388     int r;
7389     suppress_error = 0;
7390     r = guestfs_touch (g, path);
7391     if (r == -1)
7392       return -1;
7393   }
7394   {
7395     char path[] = "/new";
7396     struct guestfs_stat *r;
7397     suppress_error = 0;
7398     r = guestfs_stat (g, path);
7399     if (r == NULL)
7400       return -1;
7401     if (r->size != 0) {
7402       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7403                (int) r->size);
7404       return -1;
7405     }
7406     free (r);
7407   }
7408   return 0;
7409 }
7410
7411 static int test_command_lines_0_skip (void)
7412 {
7413   const char *str;
7414
7415   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7416   if (str && strcmp (str, "1") == 0) return 1;
7417   str = getenv ("SKIP_TEST_COMMAND_LINES");
7418   if (str && strcmp (str, "1") == 0) return 1;
7419   return 0;
7420 }
7421
7422 static int test_command_lines_0 (void)
7423 {
7424   if (test_command_lines_0_skip ()) {
7425     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7426     return 0;
7427   }
7428
7429   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7430   {
7431     char device[] = "/dev/sda";
7432     int r;
7433     suppress_error = 0;
7434     r = guestfs_blockdev_setrw (g, device);
7435     if (r == -1)
7436       return -1;
7437   }
7438   {
7439     int r;
7440     suppress_error = 0;
7441     r = guestfs_umount_all (g);
7442     if (r == -1)
7443       return -1;
7444   }
7445   {
7446     int r;
7447     suppress_error = 0;
7448     r = guestfs_lvm_remove_all (g);
7449     if (r == -1)
7450       return -1;
7451   }
7452   {
7453     char device[] = "/dev/sda";
7454     char lines_0[] = ",";
7455     char *lines[] = {
7456       lines_0,
7457       NULL
7458     };
7459     int r;
7460     suppress_error = 0;
7461     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7462     if (r == -1)
7463       return -1;
7464   }
7465   {
7466     char fstype[] = "ext2";
7467     char device[] = "/dev/sda1";
7468     int r;
7469     suppress_error = 0;
7470     r = guestfs_mkfs (g, fstype, device);
7471     if (r == -1)
7472       return -1;
7473   }
7474   {
7475     char device[] = "/dev/sda1";
7476     char mountpoint[] = "/";
7477     int r;
7478     suppress_error = 0;
7479     r = guestfs_mount (g, device, mountpoint);
7480     if (r == -1)
7481       return -1;
7482   }
7483   /* TestOutputList for command_lines (0) */
7484   {
7485     char remotefilename[] = "/test-command";
7486     int r;
7487     suppress_error = 0;
7488     r = guestfs_upload (g, "test-command", remotefilename);
7489     if (r == -1)
7490       return -1;
7491   }
7492   {
7493     char path[] = "/test-command";
7494     int r;
7495     suppress_error = 0;
7496     r = guestfs_chmod (g, 493, path);
7497     if (r == -1)
7498       return -1;
7499   }
7500   {
7501     char arguments_0[] = "/test-command";
7502     char arguments_1[] = "1";
7503     char *arguments[] = {
7504       arguments_0,
7505       arguments_1,
7506       NULL
7507     };
7508     char **r;
7509     int i;
7510     suppress_error = 0;
7511     r = guestfs_command_lines (g, arguments);
7512     if (r == NULL)
7513       return -1;
7514     if (!r[0]) {
7515       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7516       print_strings (r);
7517       return -1;
7518     }
7519     {
7520       char expected[] = "Result1";
7521       if (strcmp (r[0], expected) != 0) {
7522         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7523         return -1;
7524       }
7525     }
7526     if (r[1] != NULL) {
7527       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7528       print_strings (r);
7529       return -1;
7530     }
7531     for (i = 0; r[i] != NULL; ++i)
7532       free (r[i]);
7533     free (r);
7534   }
7535   return 0;
7536 }
7537
7538 static int test_command_lines_1_skip (void)
7539 {
7540   const char *str;
7541
7542   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7543   if (str && strcmp (str, "1") == 0) return 1;
7544   str = getenv ("SKIP_TEST_COMMAND_LINES");
7545   if (str && strcmp (str, "1") == 0) return 1;
7546   return 0;
7547 }
7548
7549 static int test_command_lines_1 (void)
7550 {
7551   if (test_command_lines_1_skip ()) {
7552     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7553     return 0;
7554   }
7555
7556   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7557   {
7558     char device[] = "/dev/sda";
7559     int r;
7560     suppress_error = 0;
7561     r = guestfs_blockdev_setrw (g, device);
7562     if (r == -1)
7563       return -1;
7564   }
7565   {
7566     int r;
7567     suppress_error = 0;
7568     r = guestfs_umount_all (g);
7569     if (r == -1)
7570       return -1;
7571   }
7572   {
7573     int r;
7574     suppress_error = 0;
7575     r = guestfs_lvm_remove_all (g);
7576     if (r == -1)
7577       return -1;
7578   }
7579   {
7580     char device[] = "/dev/sda";
7581     char lines_0[] = ",";
7582     char *lines[] = {
7583       lines_0,
7584       NULL
7585     };
7586     int r;
7587     suppress_error = 0;
7588     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7589     if (r == -1)
7590       return -1;
7591   }
7592   {
7593     char fstype[] = "ext2";
7594     char device[] = "/dev/sda1";
7595     int r;
7596     suppress_error = 0;
7597     r = guestfs_mkfs (g, fstype, device);
7598     if (r == -1)
7599       return -1;
7600   }
7601   {
7602     char device[] = "/dev/sda1";
7603     char mountpoint[] = "/";
7604     int r;
7605     suppress_error = 0;
7606     r = guestfs_mount (g, device, mountpoint);
7607     if (r == -1)
7608       return -1;
7609   }
7610   /* TestOutputList for command_lines (1) */
7611   {
7612     char remotefilename[] = "/test-command";
7613     int r;
7614     suppress_error = 0;
7615     r = guestfs_upload (g, "test-command", remotefilename);
7616     if (r == -1)
7617       return -1;
7618   }
7619   {
7620     char path[] = "/test-command";
7621     int r;
7622     suppress_error = 0;
7623     r = guestfs_chmod (g, 493, path);
7624     if (r == -1)
7625       return -1;
7626   }
7627   {
7628     char arguments_0[] = "/test-command";
7629     char arguments_1[] = "2";
7630     char *arguments[] = {
7631       arguments_0,
7632       arguments_1,
7633       NULL
7634     };
7635     char **r;
7636     int i;
7637     suppress_error = 0;
7638     r = guestfs_command_lines (g, arguments);
7639     if (r == NULL)
7640       return -1;
7641     if (!r[0]) {
7642       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7643       print_strings (r);
7644       return -1;
7645     }
7646     {
7647       char expected[] = "Result2";
7648       if (strcmp (r[0], expected) != 0) {
7649         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7650         return -1;
7651       }
7652     }
7653     if (r[1] != NULL) {
7654       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7655       print_strings (r);
7656       return -1;
7657     }
7658     for (i = 0; r[i] != NULL; ++i)
7659       free (r[i]);
7660     free (r);
7661   }
7662   return 0;
7663 }
7664
7665 static int test_command_lines_2_skip (void)
7666 {
7667   const char *str;
7668
7669   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7670   if (str && strcmp (str, "1") == 0) return 1;
7671   str = getenv ("SKIP_TEST_COMMAND_LINES");
7672   if (str && strcmp (str, "1") == 0) return 1;
7673   return 0;
7674 }
7675
7676 static int test_command_lines_2 (void)
7677 {
7678   if (test_command_lines_2_skip ()) {
7679     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7680     return 0;
7681   }
7682
7683   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7684   {
7685     char device[] = "/dev/sda";
7686     int r;
7687     suppress_error = 0;
7688     r = guestfs_blockdev_setrw (g, device);
7689     if (r == -1)
7690       return -1;
7691   }
7692   {
7693     int r;
7694     suppress_error = 0;
7695     r = guestfs_umount_all (g);
7696     if (r == -1)
7697       return -1;
7698   }
7699   {
7700     int r;
7701     suppress_error = 0;
7702     r = guestfs_lvm_remove_all (g);
7703     if (r == -1)
7704       return -1;
7705   }
7706   {
7707     char device[] = "/dev/sda";
7708     char lines_0[] = ",";
7709     char *lines[] = {
7710       lines_0,
7711       NULL
7712     };
7713     int r;
7714     suppress_error = 0;
7715     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7716     if (r == -1)
7717       return -1;
7718   }
7719   {
7720     char fstype[] = "ext2";
7721     char device[] = "/dev/sda1";
7722     int r;
7723     suppress_error = 0;
7724     r = guestfs_mkfs (g, fstype, device);
7725     if (r == -1)
7726       return -1;
7727   }
7728   {
7729     char device[] = "/dev/sda1";
7730     char mountpoint[] = "/";
7731     int r;
7732     suppress_error = 0;
7733     r = guestfs_mount (g, device, mountpoint);
7734     if (r == -1)
7735       return -1;
7736   }
7737   /* TestOutputList for command_lines (2) */
7738   {
7739     char remotefilename[] = "/test-command";
7740     int r;
7741     suppress_error = 0;
7742     r = guestfs_upload (g, "test-command", remotefilename);
7743     if (r == -1)
7744       return -1;
7745   }
7746   {
7747     char path[] = "/test-command";
7748     int r;
7749     suppress_error = 0;
7750     r = guestfs_chmod (g, 493, path);
7751     if (r == -1)
7752       return -1;
7753   }
7754   {
7755     char arguments_0[] = "/test-command";
7756     char arguments_1[] = "3";
7757     char *arguments[] = {
7758       arguments_0,
7759       arguments_1,
7760       NULL
7761     };
7762     char **r;
7763     int i;
7764     suppress_error = 0;
7765     r = guestfs_command_lines (g, arguments);
7766     if (r == NULL)
7767       return -1;
7768     if (!r[0]) {
7769       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7770       print_strings (r);
7771       return -1;
7772     }
7773     {
7774       char expected[] = "";
7775       if (strcmp (r[0], expected) != 0) {
7776         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7777         return -1;
7778       }
7779     }
7780     if (!r[1]) {
7781       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7782       print_strings (r);
7783       return -1;
7784     }
7785     {
7786       char expected[] = "Result3";
7787       if (strcmp (r[1], expected) != 0) {
7788         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7789         return -1;
7790       }
7791     }
7792     if (r[2] != NULL) {
7793       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7794       print_strings (r);
7795       return -1;
7796     }
7797     for (i = 0; r[i] != NULL; ++i)
7798       free (r[i]);
7799     free (r);
7800   }
7801   return 0;
7802 }
7803
7804 static int test_command_lines_3_skip (void)
7805 {
7806   const char *str;
7807
7808   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7809   if (str && strcmp (str, "1") == 0) return 1;
7810   str = getenv ("SKIP_TEST_COMMAND_LINES");
7811   if (str && strcmp (str, "1") == 0) return 1;
7812   return 0;
7813 }
7814
7815 static int test_command_lines_3 (void)
7816 {
7817   if (test_command_lines_3_skip ()) {
7818     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7819     return 0;
7820   }
7821
7822   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7823   {
7824     char device[] = "/dev/sda";
7825     int r;
7826     suppress_error = 0;
7827     r = guestfs_blockdev_setrw (g, device);
7828     if (r == -1)
7829       return -1;
7830   }
7831   {
7832     int r;
7833     suppress_error = 0;
7834     r = guestfs_umount_all (g);
7835     if (r == -1)
7836       return -1;
7837   }
7838   {
7839     int r;
7840     suppress_error = 0;
7841     r = guestfs_lvm_remove_all (g);
7842     if (r == -1)
7843       return -1;
7844   }
7845   {
7846     char device[] = "/dev/sda";
7847     char lines_0[] = ",";
7848     char *lines[] = {
7849       lines_0,
7850       NULL
7851     };
7852     int r;
7853     suppress_error = 0;
7854     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7855     if (r == -1)
7856       return -1;
7857   }
7858   {
7859     char fstype[] = "ext2";
7860     char device[] = "/dev/sda1";
7861     int r;
7862     suppress_error = 0;
7863     r = guestfs_mkfs (g, fstype, device);
7864     if (r == -1)
7865       return -1;
7866   }
7867   {
7868     char device[] = "/dev/sda1";
7869     char mountpoint[] = "/";
7870     int r;
7871     suppress_error = 0;
7872     r = guestfs_mount (g, device, mountpoint);
7873     if (r == -1)
7874       return -1;
7875   }
7876   /* TestOutputList for command_lines (3) */
7877   {
7878     char remotefilename[] = "/test-command";
7879     int r;
7880     suppress_error = 0;
7881     r = guestfs_upload (g, "test-command", remotefilename);
7882     if (r == -1)
7883       return -1;
7884   }
7885   {
7886     char path[] = "/test-command";
7887     int r;
7888     suppress_error = 0;
7889     r = guestfs_chmod (g, 493, path);
7890     if (r == -1)
7891       return -1;
7892   }
7893   {
7894     char arguments_0[] = "/test-command";
7895     char arguments_1[] = "4";
7896     char *arguments[] = {
7897       arguments_0,
7898       arguments_1,
7899       NULL
7900     };
7901     char **r;
7902     int i;
7903     suppress_error = 0;
7904     r = guestfs_command_lines (g, arguments);
7905     if (r == NULL)
7906       return -1;
7907     if (!r[0]) {
7908       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7909       print_strings (r);
7910       return -1;
7911     }
7912     {
7913       char expected[] = "";
7914       if (strcmp (r[0], expected) != 0) {
7915         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7916         return -1;
7917       }
7918     }
7919     if (!r[1]) {
7920       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7921       print_strings (r);
7922       return -1;
7923     }
7924     {
7925       char expected[] = "Result4";
7926       if (strcmp (r[1], expected) != 0) {
7927         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7928         return -1;
7929       }
7930     }
7931     if (r[2] != NULL) {
7932       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7933       print_strings (r);
7934       return -1;
7935     }
7936     for (i = 0; r[i] != NULL; ++i)
7937       free (r[i]);
7938     free (r);
7939   }
7940   return 0;
7941 }
7942
7943 static int test_command_lines_4_skip (void)
7944 {
7945   const char *str;
7946
7947   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7948   if (str && strcmp (str, "1") == 0) return 1;
7949   str = getenv ("SKIP_TEST_COMMAND_LINES");
7950   if (str && strcmp (str, "1") == 0) return 1;
7951   return 0;
7952 }
7953
7954 static int test_command_lines_4 (void)
7955 {
7956   if (test_command_lines_4_skip ()) {
7957     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7958     return 0;
7959   }
7960
7961   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7962   {
7963     char device[] = "/dev/sda";
7964     int r;
7965     suppress_error = 0;
7966     r = guestfs_blockdev_setrw (g, device);
7967     if (r == -1)
7968       return -1;
7969   }
7970   {
7971     int r;
7972     suppress_error = 0;
7973     r = guestfs_umount_all (g);
7974     if (r == -1)
7975       return -1;
7976   }
7977   {
7978     int r;
7979     suppress_error = 0;
7980     r = guestfs_lvm_remove_all (g);
7981     if (r == -1)
7982       return -1;
7983   }
7984   {
7985     char device[] = "/dev/sda";
7986     char lines_0[] = ",";
7987     char *lines[] = {
7988       lines_0,
7989       NULL
7990     };
7991     int r;
7992     suppress_error = 0;
7993     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7994     if (r == -1)
7995       return -1;
7996   }
7997   {
7998     char fstype[] = "ext2";
7999     char device[] = "/dev/sda1";
8000     int r;
8001     suppress_error = 0;
8002     r = guestfs_mkfs (g, fstype, device);
8003     if (r == -1)
8004       return -1;
8005   }
8006   {
8007     char device[] = "/dev/sda1";
8008     char mountpoint[] = "/";
8009     int r;
8010     suppress_error = 0;
8011     r = guestfs_mount (g, device, mountpoint);
8012     if (r == -1)
8013       return -1;
8014   }
8015   /* TestOutputList for command_lines (4) */
8016   {
8017     char remotefilename[] = "/test-command";
8018     int r;
8019     suppress_error = 0;
8020     r = guestfs_upload (g, "test-command", remotefilename);
8021     if (r == -1)
8022       return -1;
8023   }
8024   {
8025     char path[] = "/test-command";
8026     int r;
8027     suppress_error = 0;
8028     r = guestfs_chmod (g, 493, path);
8029     if (r == -1)
8030       return -1;
8031   }
8032   {
8033     char arguments_0[] = "/test-command";
8034     char arguments_1[] = "5";
8035     char *arguments[] = {
8036       arguments_0,
8037       arguments_1,
8038       NULL
8039     };
8040     char **r;
8041     int i;
8042     suppress_error = 0;
8043     r = guestfs_command_lines (g, arguments);
8044     if (r == NULL)
8045       return -1;
8046     if (!r[0]) {
8047       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8048       print_strings (r);
8049       return -1;
8050     }
8051     {
8052       char expected[] = "";
8053       if (strcmp (r[0], expected) != 0) {
8054         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8055         return -1;
8056       }
8057     }
8058     if (!r[1]) {
8059       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8060       print_strings (r);
8061       return -1;
8062     }
8063     {
8064       char expected[] = "Result5";
8065       if (strcmp (r[1], expected) != 0) {
8066         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8067         return -1;
8068       }
8069     }
8070     if (!r[2]) {
8071       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8072       print_strings (r);
8073       return -1;
8074     }
8075     {
8076       char expected[] = "";
8077       if (strcmp (r[2], expected) != 0) {
8078         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8079         return -1;
8080       }
8081     }
8082     if (r[3] != NULL) {
8083       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
8084       print_strings (r);
8085       return -1;
8086     }
8087     for (i = 0; r[i] != NULL; ++i)
8088       free (r[i]);
8089     free (r);
8090   }
8091   return 0;
8092 }
8093
8094 static int test_command_lines_5_skip (void)
8095 {
8096   const char *str;
8097
8098   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
8099   if (str && strcmp (str, "1") == 0) return 1;
8100   str = getenv ("SKIP_TEST_COMMAND_LINES");
8101   if (str && strcmp (str, "1") == 0) return 1;
8102   return 0;
8103 }
8104
8105 static int test_command_lines_5 (void)
8106 {
8107   if (test_command_lines_5_skip ()) {
8108     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
8109     return 0;
8110   }
8111
8112   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
8113   {
8114     char device[] = "/dev/sda";
8115     int r;
8116     suppress_error = 0;
8117     r = guestfs_blockdev_setrw (g, device);
8118     if (r == -1)
8119       return -1;
8120   }
8121   {
8122     int r;
8123     suppress_error = 0;
8124     r = guestfs_umount_all (g);
8125     if (r == -1)
8126       return -1;
8127   }
8128   {
8129     int r;
8130     suppress_error = 0;
8131     r = guestfs_lvm_remove_all (g);
8132     if (r == -1)
8133       return -1;
8134   }
8135   {
8136     char device[] = "/dev/sda";
8137     char lines_0[] = ",";
8138     char *lines[] = {
8139       lines_0,
8140       NULL
8141     };
8142     int r;
8143     suppress_error = 0;
8144     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8145     if (r == -1)
8146       return -1;
8147   }
8148   {
8149     char fstype[] = "ext2";
8150     char device[] = "/dev/sda1";
8151     int r;
8152     suppress_error = 0;
8153     r = guestfs_mkfs (g, fstype, device);
8154     if (r == -1)
8155       return -1;
8156   }
8157   {
8158     char device[] = "/dev/sda1";
8159     char mountpoint[] = "/";
8160     int r;
8161     suppress_error = 0;
8162     r = guestfs_mount (g, device, mountpoint);
8163     if (r == -1)
8164       return -1;
8165   }
8166   /* TestOutputList for command_lines (5) */
8167   {
8168     char remotefilename[] = "/test-command";
8169     int r;
8170     suppress_error = 0;
8171     r = guestfs_upload (g, "test-command", remotefilename);
8172     if (r == -1)
8173       return -1;
8174   }
8175   {
8176     char path[] = "/test-command";
8177     int r;
8178     suppress_error = 0;
8179     r = guestfs_chmod (g, 493, path);
8180     if (r == -1)
8181       return -1;
8182   }
8183   {
8184     char arguments_0[] = "/test-command";
8185     char arguments_1[] = "6";
8186     char *arguments[] = {
8187       arguments_0,
8188       arguments_1,
8189       NULL
8190     };
8191     char **r;
8192     int i;
8193     suppress_error = 0;
8194     r = guestfs_command_lines (g, arguments);
8195     if (r == NULL)
8196       return -1;
8197     if (!r[0]) {
8198       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8199       print_strings (r);
8200       return -1;
8201     }
8202     {
8203       char expected[] = "";
8204       if (strcmp (r[0], expected) != 0) {
8205         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8206         return -1;
8207       }
8208     }
8209     if (!r[1]) {
8210       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8211       print_strings (r);
8212       return -1;
8213     }
8214     {
8215       char expected[] = "";
8216       if (strcmp (r[1], expected) != 0) {
8217         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8218         return -1;
8219       }
8220     }
8221     if (!r[2]) {
8222       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8223       print_strings (r);
8224       return -1;
8225     }
8226     {
8227       char expected[] = "Result6";
8228       if (strcmp (r[2], expected) != 0) {
8229         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8230         return -1;
8231       }
8232     }
8233     if (!r[3]) {
8234       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8235       print_strings (r);
8236       return -1;
8237     }
8238     {
8239       char expected[] = "";
8240       if (strcmp (r[3], expected) != 0) {
8241         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8242         return -1;
8243       }
8244     }
8245     if (r[4] != NULL) {
8246       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8247       print_strings (r);
8248       return -1;
8249     }
8250     for (i = 0; r[i] != NULL; ++i)
8251       free (r[i]);
8252     free (r);
8253   }
8254   return 0;
8255 }
8256
8257 static int test_command_lines_6_skip (void)
8258 {
8259   const char *str;
8260
8261   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8262   if (str && strcmp (str, "1") == 0) return 1;
8263   str = getenv ("SKIP_TEST_COMMAND_LINES");
8264   if (str && strcmp (str, "1") == 0) return 1;
8265   return 0;
8266 }
8267
8268 static int test_command_lines_6 (void)
8269 {
8270   if (test_command_lines_6_skip ()) {
8271     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8272     return 0;
8273   }
8274
8275   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8276   {
8277     char device[] = "/dev/sda";
8278     int r;
8279     suppress_error = 0;
8280     r = guestfs_blockdev_setrw (g, device);
8281     if (r == -1)
8282       return -1;
8283   }
8284   {
8285     int r;
8286     suppress_error = 0;
8287     r = guestfs_umount_all (g);
8288     if (r == -1)
8289       return -1;
8290   }
8291   {
8292     int r;
8293     suppress_error = 0;
8294     r = guestfs_lvm_remove_all (g);
8295     if (r == -1)
8296       return -1;
8297   }
8298   {
8299     char device[] = "/dev/sda";
8300     char lines_0[] = ",";
8301     char *lines[] = {
8302       lines_0,
8303       NULL
8304     };
8305     int r;
8306     suppress_error = 0;
8307     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8308     if (r == -1)
8309       return -1;
8310   }
8311   {
8312     char fstype[] = "ext2";
8313     char device[] = "/dev/sda1";
8314     int r;
8315     suppress_error = 0;
8316     r = guestfs_mkfs (g, fstype, device);
8317     if (r == -1)
8318       return -1;
8319   }
8320   {
8321     char device[] = "/dev/sda1";
8322     char mountpoint[] = "/";
8323     int r;
8324     suppress_error = 0;
8325     r = guestfs_mount (g, device, mountpoint);
8326     if (r == -1)
8327       return -1;
8328   }
8329   /* TestOutputList for command_lines (6) */
8330   {
8331     char remotefilename[] = "/test-command";
8332     int r;
8333     suppress_error = 0;
8334     r = guestfs_upload (g, "test-command", remotefilename);
8335     if (r == -1)
8336       return -1;
8337   }
8338   {
8339     char path[] = "/test-command";
8340     int r;
8341     suppress_error = 0;
8342     r = guestfs_chmod (g, 493, path);
8343     if (r == -1)
8344       return -1;
8345   }
8346   {
8347     char arguments_0[] = "/test-command";
8348     char arguments_1[] = "7";
8349     char *arguments[] = {
8350       arguments_0,
8351       arguments_1,
8352       NULL
8353     };
8354     char **r;
8355     int i;
8356     suppress_error = 0;
8357     r = guestfs_command_lines (g, arguments);
8358     if (r == NULL)
8359       return -1;
8360     if (r[0] != NULL) {
8361       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8362       print_strings (r);
8363       return -1;
8364     }
8365     for (i = 0; r[i] != NULL; ++i)
8366       free (r[i]);
8367     free (r);
8368   }
8369   return 0;
8370 }
8371
8372 static int test_command_lines_7_skip (void)
8373 {
8374   const char *str;
8375
8376   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8377   if (str && strcmp (str, "1") == 0) return 1;
8378   str = getenv ("SKIP_TEST_COMMAND_LINES");
8379   if (str && strcmp (str, "1") == 0) return 1;
8380   return 0;
8381 }
8382
8383 static int test_command_lines_7 (void)
8384 {
8385   if (test_command_lines_7_skip ()) {
8386     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8387     return 0;
8388   }
8389
8390   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8391   {
8392     char device[] = "/dev/sda";
8393     int r;
8394     suppress_error = 0;
8395     r = guestfs_blockdev_setrw (g, device);
8396     if (r == -1)
8397       return -1;
8398   }
8399   {
8400     int r;
8401     suppress_error = 0;
8402     r = guestfs_umount_all (g);
8403     if (r == -1)
8404       return -1;
8405   }
8406   {
8407     int r;
8408     suppress_error = 0;
8409     r = guestfs_lvm_remove_all (g);
8410     if (r == -1)
8411       return -1;
8412   }
8413   {
8414     char device[] = "/dev/sda";
8415     char lines_0[] = ",";
8416     char *lines[] = {
8417       lines_0,
8418       NULL
8419     };
8420     int r;
8421     suppress_error = 0;
8422     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8423     if (r == -1)
8424       return -1;
8425   }
8426   {
8427     char fstype[] = "ext2";
8428     char device[] = "/dev/sda1";
8429     int r;
8430     suppress_error = 0;
8431     r = guestfs_mkfs (g, fstype, device);
8432     if (r == -1)
8433       return -1;
8434   }
8435   {
8436     char device[] = "/dev/sda1";
8437     char mountpoint[] = "/";
8438     int r;
8439     suppress_error = 0;
8440     r = guestfs_mount (g, device, mountpoint);
8441     if (r == -1)
8442       return -1;
8443   }
8444   /* TestOutputList for command_lines (7) */
8445   {
8446     char remotefilename[] = "/test-command";
8447     int r;
8448     suppress_error = 0;
8449     r = guestfs_upload (g, "test-command", remotefilename);
8450     if (r == -1)
8451       return -1;
8452   }
8453   {
8454     char path[] = "/test-command";
8455     int r;
8456     suppress_error = 0;
8457     r = guestfs_chmod (g, 493, path);
8458     if (r == -1)
8459       return -1;
8460   }
8461   {
8462     char arguments_0[] = "/test-command";
8463     char arguments_1[] = "8";
8464     char *arguments[] = {
8465       arguments_0,
8466       arguments_1,
8467       NULL
8468     };
8469     char **r;
8470     int i;
8471     suppress_error = 0;
8472     r = guestfs_command_lines (g, arguments);
8473     if (r == NULL)
8474       return -1;
8475     if (!r[0]) {
8476       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8477       print_strings (r);
8478       return -1;
8479     }
8480     {
8481       char expected[] = "";
8482       if (strcmp (r[0], expected) != 0) {
8483         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8484         return -1;
8485       }
8486     }
8487     if (r[1] != NULL) {
8488       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8489       print_strings (r);
8490       return -1;
8491     }
8492     for (i = 0; r[i] != NULL; ++i)
8493       free (r[i]);
8494     free (r);
8495   }
8496   return 0;
8497 }
8498
8499 static int test_command_lines_8_skip (void)
8500 {
8501   const char *str;
8502
8503   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8504   if (str && strcmp (str, "1") == 0) return 1;
8505   str = getenv ("SKIP_TEST_COMMAND_LINES");
8506   if (str && strcmp (str, "1") == 0) return 1;
8507   return 0;
8508 }
8509
8510 static int test_command_lines_8 (void)
8511 {
8512   if (test_command_lines_8_skip ()) {
8513     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8514     return 0;
8515   }
8516
8517   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8518   {
8519     char device[] = "/dev/sda";
8520     int r;
8521     suppress_error = 0;
8522     r = guestfs_blockdev_setrw (g, device);
8523     if (r == -1)
8524       return -1;
8525   }
8526   {
8527     int r;
8528     suppress_error = 0;
8529     r = guestfs_umount_all (g);
8530     if (r == -1)
8531       return -1;
8532   }
8533   {
8534     int r;
8535     suppress_error = 0;
8536     r = guestfs_lvm_remove_all (g);
8537     if (r == -1)
8538       return -1;
8539   }
8540   {
8541     char device[] = "/dev/sda";
8542     char lines_0[] = ",";
8543     char *lines[] = {
8544       lines_0,
8545       NULL
8546     };
8547     int r;
8548     suppress_error = 0;
8549     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8550     if (r == -1)
8551       return -1;
8552   }
8553   {
8554     char fstype[] = "ext2";
8555     char device[] = "/dev/sda1";
8556     int r;
8557     suppress_error = 0;
8558     r = guestfs_mkfs (g, fstype, device);
8559     if (r == -1)
8560       return -1;
8561   }
8562   {
8563     char device[] = "/dev/sda1";
8564     char mountpoint[] = "/";
8565     int r;
8566     suppress_error = 0;
8567     r = guestfs_mount (g, device, mountpoint);
8568     if (r == -1)
8569       return -1;
8570   }
8571   /* TestOutputList for command_lines (8) */
8572   {
8573     char remotefilename[] = "/test-command";
8574     int r;
8575     suppress_error = 0;
8576     r = guestfs_upload (g, "test-command", remotefilename);
8577     if (r == -1)
8578       return -1;
8579   }
8580   {
8581     char path[] = "/test-command";
8582     int r;
8583     suppress_error = 0;
8584     r = guestfs_chmod (g, 493, path);
8585     if (r == -1)
8586       return -1;
8587   }
8588   {
8589     char arguments_0[] = "/test-command";
8590     char arguments_1[] = "9";
8591     char *arguments[] = {
8592       arguments_0,
8593       arguments_1,
8594       NULL
8595     };
8596     char **r;
8597     int i;
8598     suppress_error = 0;
8599     r = guestfs_command_lines (g, arguments);
8600     if (r == NULL)
8601       return -1;
8602     if (!r[0]) {
8603       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8604       print_strings (r);
8605       return -1;
8606     }
8607     {
8608       char expected[] = "";
8609       if (strcmp (r[0], expected) != 0) {
8610         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8611         return -1;
8612       }
8613     }
8614     if (!r[1]) {
8615       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8616       print_strings (r);
8617       return -1;
8618     }
8619     {
8620       char expected[] = "";
8621       if (strcmp (r[1], expected) != 0) {
8622         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8623         return -1;
8624       }
8625     }
8626     if (r[2] != NULL) {
8627       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8628       print_strings (r);
8629       return -1;
8630     }
8631     for (i = 0; r[i] != NULL; ++i)
8632       free (r[i]);
8633     free (r);
8634   }
8635   return 0;
8636 }
8637
8638 static int test_command_lines_9_skip (void)
8639 {
8640   const char *str;
8641
8642   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8643   if (str && strcmp (str, "1") == 0) return 1;
8644   str = getenv ("SKIP_TEST_COMMAND_LINES");
8645   if (str && strcmp (str, "1") == 0) return 1;
8646   return 0;
8647 }
8648
8649 static int test_command_lines_9 (void)
8650 {
8651   if (test_command_lines_9_skip ()) {
8652     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8653     return 0;
8654   }
8655
8656   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8657   {
8658     char device[] = "/dev/sda";
8659     int r;
8660     suppress_error = 0;
8661     r = guestfs_blockdev_setrw (g, device);
8662     if (r == -1)
8663       return -1;
8664   }
8665   {
8666     int r;
8667     suppress_error = 0;
8668     r = guestfs_umount_all (g);
8669     if (r == -1)
8670       return -1;
8671   }
8672   {
8673     int r;
8674     suppress_error = 0;
8675     r = guestfs_lvm_remove_all (g);
8676     if (r == -1)
8677       return -1;
8678   }
8679   {
8680     char device[] = "/dev/sda";
8681     char lines_0[] = ",";
8682     char *lines[] = {
8683       lines_0,
8684       NULL
8685     };
8686     int r;
8687     suppress_error = 0;
8688     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8689     if (r == -1)
8690       return -1;
8691   }
8692   {
8693     char fstype[] = "ext2";
8694     char device[] = "/dev/sda1";
8695     int r;
8696     suppress_error = 0;
8697     r = guestfs_mkfs (g, fstype, device);
8698     if (r == -1)
8699       return -1;
8700   }
8701   {
8702     char device[] = "/dev/sda1";
8703     char mountpoint[] = "/";
8704     int r;
8705     suppress_error = 0;
8706     r = guestfs_mount (g, device, mountpoint);
8707     if (r == -1)
8708       return -1;
8709   }
8710   /* TestOutputList for command_lines (9) */
8711   {
8712     char remotefilename[] = "/test-command";
8713     int r;
8714     suppress_error = 0;
8715     r = guestfs_upload (g, "test-command", remotefilename);
8716     if (r == -1)
8717       return -1;
8718   }
8719   {
8720     char path[] = "/test-command";
8721     int r;
8722     suppress_error = 0;
8723     r = guestfs_chmod (g, 493, path);
8724     if (r == -1)
8725       return -1;
8726   }
8727   {
8728     char arguments_0[] = "/test-command";
8729     char arguments_1[] = "10";
8730     char *arguments[] = {
8731       arguments_0,
8732       arguments_1,
8733       NULL
8734     };
8735     char **r;
8736     int i;
8737     suppress_error = 0;
8738     r = guestfs_command_lines (g, arguments);
8739     if (r == NULL)
8740       return -1;
8741     if (!r[0]) {
8742       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8743       print_strings (r);
8744       return -1;
8745     }
8746     {
8747       char expected[] = "Result10-1";
8748       if (strcmp (r[0], expected) != 0) {
8749         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8750         return -1;
8751       }
8752     }
8753     if (!r[1]) {
8754       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8755       print_strings (r);
8756       return -1;
8757     }
8758     {
8759       char expected[] = "Result10-2";
8760       if (strcmp (r[1], expected) != 0) {
8761         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8762         return -1;
8763       }
8764     }
8765     if (r[2] != NULL) {
8766       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8767       print_strings (r);
8768       return -1;
8769     }
8770     for (i = 0; r[i] != NULL; ++i)
8771       free (r[i]);
8772     free (r);
8773   }
8774   return 0;
8775 }
8776
8777 static int test_command_lines_10_skip (void)
8778 {
8779   const char *str;
8780
8781   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8782   if (str && strcmp (str, "1") == 0) return 1;
8783   str = getenv ("SKIP_TEST_COMMAND_LINES");
8784   if (str && strcmp (str, "1") == 0) return 1;
8785   return 0;
8786 }
8787
8788 static int test_command_lines_10 (void)
8789 {
8790   if (test_command_lines_10_skip ()) {
8791     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8792     return 0;
8793   }
8794
8795   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8796   {
8797     char device[] = "/dev/sda";
8798     int r;
8799     suppress_error = 0;
8800     r = guestfs_blockdev_setrw (g, device);
8801     if (r == -1)
8802       return -1;
8803   }
8804   {
8805     int r;
8806     suppress_error = 0;
8807     r = guestfs_umount_all (g);
8808     if (r == -1)
8809       return -1;
8810   }
8811   {
8812     int r;
8813     suppress_error = 0;
8814     r = guestfs_lvm_remove_all (g);
8815     if (r == -1)
8816       return -1;
8817   }
8818   {
8819     char device[] = "/dev/sda";
8820     char lines_0[] = ",";
8821     char *lines[] = {
8822       lines_0,
8823       NULL
8824     };
8825     int r;
8826     suppress_error = 0;
8827     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8828     if (r == -1)
8829       return -1;
8830   }
8831   {
8832     char fstype[] = "ext2";
8833     char device[] = "/dev/sda1";
8834     int r;
8835     suppress_error = 0;
8836     r = guestfs_mkfs (g, fstype, device);
8837     if (r == -1)
8838       return -1;
8839   }
8840   {
8841     char device[] = "/dev/sda1";
8842     char mountpoint[] = "/";
8843     int r;
8844     suppress_error = 0;
8845     r = guestfs_mount (g, device, mountpoint);
8846     if (r == -1)
8847       return -1;
8848   }
8849   /* TestOutputList for command_lines (10) */
8850   {
8851     char remotefilename[] = "/test-command";
8852     int r;
8853     suppress_error = 0;
8854     r = guestfs_upload (g, "test-command", remotefilename);
8855     if (r == -1)
8856       return -1;
8857   }
8858   {
8859     char path[] = "/test-command";
8860     int r;
8861     suppress_error = 0;
8862     r = guestfs_chmod (g, 493, path);
8863     if (r == -1)
8864       return -1;
8865   }
8866   {
8867     char arguments_0[] = "/test-command";
8868     char arguments_1[] = "11";
8869     char *arguments[] = {
8870       arguments_0,
8871       arguments_1,
8872       NULL
8873     };
8874     char **r;
8875     int i;
8876     suppress_error = 0;
8877     r = guestfs_command_lines (g, arguments);
8878     if (r == NULL)
8879       return -1;
8880     if (!r[0]) {
8881       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8882       print_strings (r);
8883       return -1;
8884     }
8885     {
8886       char expected[] = "Result11-1";
8887       if (strcmp (r[0], expected) != 0) {
8888         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8889         return -1;
8890       }
8891     }
8892     if (!r[1]) {
8893       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8894       print_strings (r);
8895       return -1;
8896     }
8897     {
8898       char expected[] = "Result11-2";
8899       if (strcmp (r[1], expected) != 0) {
8900         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8901         return -1;
8902       }
8903     }
8904     if (r[2] != NULL) {
8905       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8906       print_strings (r);
8907       return -1;
8908     }
8909     for (i = 0; r[i] != NULL; ++i)
8910       free (r[i]);
8911     free (r);
8912   }
8913   return 0;
8914 }
8915
8916 static int test_command_0_skip (void)
8917 {
8918   const char *str;
8919
8920   str = getenv ("SKIP_TEST_COMMAND_0");
8921   if (str && strcmp (str, "1") == 0) return 1;
8922   str = getenv ("SKIP_TEST_COMMAND");
8923   if (str && strcmp (str, "1") == 0) return 1;
8924   return 0;
8925 }
8926
8927 static int test_command_0 (void)
8928 {
8929   if (test_command_0_skip ()) {
8930     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8931     return 0;
8932   }
8933
8934   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8935   {
8936     char device[] = "/dev/sda";
8937     int r;
8938     suppress_error = 0;
8939     r = guestfs_blockdev_setrw (g, device);
8940     if (r == -1)
8941       return -1;
8942   }
8943   {
8944     int r;
8945     suppress_error = 0;
8946     r = guestfs_umount_all (g);
8947     if (r == -1)
8948       return -1;
8949   }
8950   {
8951     int r;
8952     suppress_error = 0;
8953     r = guestfs_lvm_remove_all (g);
8954     if (r == -1)
8955       return -1;
8956   }
8957   {
8958     char device[] = "/dev/sda";
8959     char lines_0[] = ",";
8960     char *lines[] = {
8961       lines_0,
8962       NULL
8963     };
8964     int r;
8965     suppress_error = 0;
8966     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8967     if (r == -1)
8968       return -1;
8969   }
8970   {
8971     char fstype[] = "ext2";
8972     char device[] = "/dev/sda1";
8973     int r;
8974     suppress_error = 0;
8975     r = guestfs_mkfs (g, fstype, device);
8976     if (r == -1)
8977       return -1;
8978   }
8979   {
8980     char device[] = "/dev/sda1";
8981     char mountpoint[] = "/";
8982     int r;
8983     suppress_error = 0;
8984     r = guestfs_mount (g, device, mountpoint);
8985     if (r == -1)
8986       return -1;
8987   }
8988   /* TestOutput for command (0) */
8989   char expected[] = "Result1";
8990   {
8991     char remotefilename[] = "/test-command";
8992     int r;
8993     suppress_error = 0;
8994     r = guestfs_upload (g, "test-command", remotefilename);
8995     if (r == -1)
8996       return -1;
8997   }
8998   {
8999     char path[] = "/test-command";
9000     int r;
9001     suppress_error = 0;
9002     r = guestfs_chmod (g, 493, path);
9003     if (r == -1)
9004       return -1;
9005   }
9006   {
9007     char arguments_0[] = "/test-command";
9008     char arguments_1[] = "1";
9009     char *arguments[] = {
9010       arguments_0,
9011       arguments_1,
9012       NULL
9013     };
9014     char *r;
9015     suppress_error = 0;
9016     r = guestfs_command (g, arguments);
9017     if (r == NULL)
9018       return -1;
9019     if (strcmp (r, expected) != 0) {
9020       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
9021       return -1;
9022     }
9023     free (r);
9024   }
9025   return 0;
9026 }
9027
9028 static int test_command_1_skip (void)
9029 {
9030   const char *str;
9031
9032   str = getenv ("SKIP_TEST_COMMAND_1");
9033   if (str && strcmp (str, "1") == 0) return 1;
9034   str = getenv ("SKIP_TEST_COMMAND");
9035   if (str && strcmp (str, "1") == 0) return 1;
9036   return 0;
9037 }
9038
9039 static int test_command_1 (void)
9040 {
9041   if (test_command_1_skip ()) {
9042     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
9043     return 0;
9044   }
9045
9046   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
9047   {
9048     char device[] = "/dev/sda";
9049     int r;
9050     suppress_error = 0;
9051     r = guestfs_blockdev_setrw (g, device);
9052     if (r == -1)
9053       return -1;
9054   }
9055   {
9056     int r;
9057     suppress_error = 0;
9058     r = guestfs_umount_all (g);
9059     if (r == -1)
9060       return -1;
9061   }
9062   {
9063     int r;
9064     suppress_error = 0;
9065     r = guestfs_lvm_remove_all (g);
9066     if (r == -1)
9067       return -1;
9068   }
9069   {
9070     char device[] = "/dev/sda";
9071     char lines_0[] = ",";
9072     char *lines[] = {
9073       lines_0,
9074       NULL
9075     };
9076     int r;
9077     suppress_error = 0;
9078     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9079     if (r == -1)
9080       return -1;
9081   }
9082   {
9083     char fstype[] = "ext2";
9084     char device[] = "/dev/sda1";
9085     int r;
9086     suppress_error = 0;
9087     r = guestfs_mkfs (g, fstype, device);
9088     if (r == -1)
9089       return -1;
9090   }
9091   {
9092     char device[] = "/dev/sda1";
9093     char mountpoint[] = "/";
9094     int r;
9095     suppress_error = 0;
9096     r = guestfs_mount (g, device, mountpoint);
9097     if (r == -1)
9098       return -1;
9099   }
9100   /* TestOutput for command (1) */
9101   char expected[] = "Result2\n";
9102   {
9103     char remotefilename[] = "/test-command";
9104     int r;
9105     suppress_error = 0;
9106     r = guestfs_upload (g, "test-command", remotefilename);
9107     if (r == -1)
9108       return -1;
9109   }
9110   {
9111     char path[] = "/test-command";
9112     int r;
9113     suppress_error = 0;
9114     r = guestfs_chmod (g, 493, path);
9115     if (r == -1)
9116       return -1;
9117   }
9118   {
9119     char arguments_0[] = "/test-command";
9120     char arguments_1[] = "2";
9121     char *arguments[] = {
9122       arguments_0,
9123       arguments_1,
9124       NULL
9125     };
9126     char *r;
9127     suppress_error = 0;
9128     r = guestfs_command (g, arguments);
9129     if (r == NULL)
9130       return -1;
9131     if (strcmp (r, expected) != 0) {
9132       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
9133       return -1;
9134     }
9135     free (r);
9136   }
9137   return 0;
9138 }
9139
9140 static int test_command_2_skip (void)
9141 {
9142   const char *str;
9143
9144   str = getenv ("SKIP_TEST_COMMAND_2");
9145   if (str && strcmp (str, "1") == 0) return 1;
9146   str = getenv ("SKIP_TEST_COMMAND");
9147   if (str && strcmp (str, "1") == 0) return 1;
9148   return 0;
9149 }
9150
9151 static int test_command_2 (void)
9152 {
9153   if (test_command_2_skip ()) {
9154     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
9155     return 0;
9156   }
9157
9158   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9159   {
9160     char device[] = "/dev/sda";
9161     int r;
9162     suppress_error = 0;
9163     r = guestfs_blockdev_setrw (g, device);
9164     if (r == -1)
9165       return -1;
9166   }
9167   {
9168     int r;
9169     suppress_error = 0;
9170     r = guestfs_umount_all (g);
9171     if (r == -1)
9172       return -1;
9173   }
9174   {
9175     int r;
9176     suppress_error = 0;
9177     r = guestfs_lvm_remove_all (g);
9178     if (r == -1)
9179       return -1;
9180   }
9181   {
9182     char device[] = "/dev/sda";
9183     char lines_0[] = ",";
9184     char *lines[] = {
9185       lines_0,
9186       NULL
9187     };
9188     int r;
9189     suppress_error = 0;
9190     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9191     if (r == -1)
9192       return -1;
9193   }
9194   {
9195     char fstype[] = "ext2";
9196     char device[] = "/dev/sda1";
9197     int r;
9198     suppress_error = 0;
9199     r = guestfs_mkfs (g, fstype, device);
9200     if (r == -1)
9201       return -1;
9202   }
9203   {
9204     char device[] = "/dev/sda1";
9205     char mountpoint[] = "/";
9206     int r;
9207     suppress_error = 0;
9208     r = guestfs_mount (g, device, mountpoint);
9209     if (r == -1)
9210       return -1;
9211   }
9212   /* TestOutput for command (2) */
9213   char expected[] = "\nResult3";
9214   {
9215     char remotefilename[] = "/test-command";
9216     int r;
9217     suppress_error = 0;
9218     r = guestfs_upload (g, "test-command", remotefilename);
9219     if (r == -1)
9220       return -1;
9221   }
9222   {
9223     char path[] = "/test-command";
9224     int r;
9225     suppress_error = 0;
9226     r = guestfs_chmod (g, 493, path);
9227     if (r == -1)
9228       return -1;
9229   }
9230   {
9231     char arguments_0[] = "/test-command";
9232     char arguments_1[] = "3";
9233     char *arguments[] = {
9234       arguments_0,
9235       arguments_1,
9236       NULL
9237     };
9238     char *r;
9239     suppress_error = 0;
9240     r = guestfs_command (g, arguments);
9241     if (r == NULL)
9242       return -1;
9243     if (strcmp (r, expected) != 0) {
9244       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9245       return -1;
9246     }
9247     free (r);
9248   }
9249   return 0;
9250 }
9251
9252 static int test_command_3_skip (void)
9253 {
9254   const char *str;
9255
9256   str = getenv ("SKIP_TEST_COMMAND_3");
9257   if (str && strcmp (str, "1") == 0) return 1;
9258   str = getenv ("SKIP_TEST_COMMAND");
9259   if (str && strcmp (str, "1") == 0) return 1;
9260   return 0;
9261 }
9262
9263 static int test_command_3 (void)
9264 {
9265   if (test_command_3_skip ()) {
9266     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9267     return 0;
9268   }
9269
9270   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9271   {
9272     char device[] = "/dev/sda";
9273     int r;
9274     suppress_error = 0;
9275     r = guestfs_blockdev_setrw (g, device);
9276     if (r == -1)
9277       return -1;
9278   }
9279   {
9280     int r;
9281     suppress_error = 0;
9282     r = guestfs_umount_all (g);
9283     if (r == -1)
9284       return -1;
9285   }
9286   {
9287     int r;
9288     suppress_error = 0;
9289     r = guestfs_lvm_remove_all (g);
9290     if (r == -1)
9291       return -1;
9292   }
9293   {
9294     char device[] = "/dev/sda";
9295     char lines_0[] = ",";
9296     char *lines[] = {
9297       lines_0,
9298       NULL
9299     };
9300     int r;
9301     suppress_error = 0;
9302     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9303     if (r == -1)
9304       return -1;
9305   }
9306   {
9307     char fstype[] = "ext2";
9308     char device[] = "/dev/sda1";
9309     int r;
9310     suppress_error = 0;
9311     r = guestfs_mkfs (g, fstype, device);
9312     if (r == -1)
9313       return -1;
9314   }
9315   {
9316     char device[] = "/dev/sda1";
9317     char mountpoint[] = "/";
9318     int r;
9319     suppress_error = 0;
9320     r = guestfs_mount (g, device, mountpoint);
9321     if (r == -1)
9322       return -1;
9323   }
9324   /* TestOutput for command (3) */
9325   char expected[] = "\nResult4\n";
9326   {
9327     char remotefilename[] = "/test-command";
9328     int r;
9329     suppress_error = 0;
9330     r = guestfs_upload (g, "test-command", remotefilename);
9331     if (r == -1)
9332       return -1;
9333   }
9334   {
9335     char path[] = "/test-command";
9336     int r;
9337     suppress_error = 0;
9338     r = guestfs_chmod (g, 493, path);
9339     if (r == -1)
9340       return -1;
9341   }
9342   {
9343     char arguments_0[] = "/test-command";
9344     char arguments_1[] = "4";
9345     char *arguments[] = {
9346       arguments_0,
9347       arguments_1,
9348       NULL
9349     };
9350     char *r;
9351     suppress_error = 0;
9352     r = guestfs_command (g, arguments);
9353     if (r == NULL)
9354       return -1;
9355     if (strcmp (r, expected) != 0) {
9356       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9357       return -1;
9358     }
9359     free (r);
9360   }
9361   return 0;
9362 }
9363
9364 static int test_command_4_skip (void)
9365 {
9366   const char *str;
9367
9368   str = getenv ("SKIP_TEST_COMMAND_4");
9369   if (str && strcmp (str, "1") == 0) return 1;
9370   str = getenv ("SKIP_TEST_COMMAND");
9371   if (str && strcmp (str, "1") == 0) return 1;
9372   return 0;
9373 }
9374
9375 static int test_command_4 (void)
9376 {
9377   if (test_command_4_skip ()) {
9378     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9379     return 0;
9380   }
9381
9382   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9383   {
9384     char device[] = "/dev/sda";
9385     int r;
9386     suppress_error = 0;
9387     r = guestfs_blockdev_setrw (g, device);
9388     if (r == -1)
9389       return -1;
9390   }
9391   {
9392     int r;
9393     suppress_error = 0;
9394     r = guestfs_umount_all (g);
9395     if (r == -1)
9396       return -1;
9397   }
9398   {
9399     int r;
9400     suppress_error = 0;
9401     r = guestfs_lvm_remove_all (g);
9402     if (r == -1)
9403       return -1;
9404   }
9405   {
9406     char device[] = "/dev/sda";
9407     char lines_0[] = ",";
9408     char *lines[] = {
9409       lines_0,
9410       NULL
9411     };
9412     int r;
9413     suppress_error = 0;
9414     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9415     if (r == -1)
9416       return -1;
9417   }
9418   {
9419     char fstype[] = "ext2";
9420     char device[] = "/dev/sda1";
9421     int r;
9422     suppress_error = 0;
9423     r = guestfs_mkfs (g, fstype, device);
9424     if (r == -1)
9425       return -1;
9426   }
9427   {
9428     char device[] = "/dev/sda1";
9429     char mountpoint[] = "/";
9430     int r;
9431     suppress_error = 0;
9432     r = guestfs_mount (g, device, mountpoint);
9433     if (r == -1)
9434       return -1;
9435   }
9436   /* TestOutput for command (4) */
9437   char expected[] = "\nResult5\n\n";
9438   {
9439     char remotefilename[] = "/test-command";
9440     int r;
9441     suppress_error = 0;
9442     r = guestfs_upload (g, "test-command", remotefilename);
9443     if (r == -1)
9444       return -1;
9445   }
9446   {
9447     char path[] = "/test-command";
9448     int r;
9449     suppress_error = 0;
9450     r = guestfs_chmod (g, 493, path);
9451     if (r == -1)
9452       return -1;
9453   }
9454   {
9455     char arguments_0[] = "/test-command";
9456     char arguments_1[] = "5";
9457     char *arguments[] = {
9458       arguments_0,
9459       arguments_1,
9460       NULL
9461     };
9462     char *r;
9463     suppress_error = 0;
9464     r = guestfs_command (g, arguments);
9465     if (r == NULL)
9466       return -1;
9467     if (strcmp (r, expected) != 0) {
9468       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9469       return -1;
9470     }
9471     free (r);
9472   }
9473   return 0;
9474 }
9475
9476 static int test_command_5_skip (void)
9477 {
9478   const char *str;
9479
9480   str = getenv ("SKIP_TEST_COMMAND_5");
9481   if (str && strcmp (str, "1") == 0) return 1;
9482   str = getenv ("SKIP_TEST_COMMAND");
9483   if (str && strcmp (str, "1") == 0) return 1;
9484   return 0;
9485 }
9486
9487 static int test_command_5 (void)
9488 {
9489   if (test_command_5_skip ()) {
9490     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9491     return 0;
9492   }
9493
9494   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9495   {
9496     char device[] = "/dev/sda";
9497     int r;
9498     suppress_error = 0;
9499     r = guestfs_blockdev_setrw (g, device);
9500     if (r == -1)
9501       return -1;
9502   }
9503   {
9504     int r;
9505     suppress_error = 0;
9506     r = guestfs_umount_all (g);
9507     if (r == -1)
9508       return -1;
9509   }
9510   {
9511     int r;
9512     suppress_error = 0;
9513     r = guestfs_lvm_remove_all (g);
9514     if (r == -1)
9515       return -1;
9516   }
9517   {
9518     char device[] = "/dev/sda";
9519     char lines_0[] = ",";
9520     char *lines[] = {
9521       lines_0,
9522       NULL
9523     };
9524     int r;
9525     suppress_error = 0;
9526     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9527     if (r == -1)
9528       return -1;
9529   }
9530   {
9531     char fstype[] = "ext2";
9532     char device[] = "/dev/sda1";
9533     int r;
9534     suppress_error = 0;
9535     r = guestfs_mkfs (g, fstype, device);
9536     if (r == -1)
9537       return -1;
9538   }
9539   {
9540     char device[] = "/dev/sda1";
9541     char mountpoint[] = "/";
9542     int r;
9543     suppress_error = 0;
9544     r = guestfs_mount (g, device, mountpoint);
9545     if (r == -1)
9546       return -1;
9547   }
9548   /* TestOutput for command (5) */
9549   char expected[] = "\n\nResult6\n\n";
9550   {
9551     char remotefilename[] = "/test-command";
9552     int r;
9553     suppress_error = 0;
9554     r = guestfs_upload (g, "test-command", remotefilename);
9555     if (r == -1)
9556       return -1;
9557   }
9558   {
9559     char path[] = "/test-command";
9560     int r;
9561     suppress_error = 0;
9562     r = guestfs_chmod (g, 493, path);
9563     if (r == -1)
9564       return -1;
9565   }
9566   {
9567     char arguments_0[] = "/test-command";
9568     char arguments_1[] = "6";
9569     char *arguments[] = {
9570       arguments_0,
9571       arguments_1,
9572       NULL
9573     };
9574     char *r;
9575     suppress_error = 0;
9576     r = guestfs_command (g, arguments);
9577     if (r == NULL)
9578       return -1;
9579     if (strcmp (r, expected) != 0) {
9580       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9581       return -1;
9582     }
9583     free (r);
9584   }
9585   return 0;
9586 }
9587
9588 static int test_command_6_skip (void)
9589 {
9590   const char *str;
9591
9592   str = getenv ("SKIP_TEST_COMMAND_6");
9593   if (str && strcmp (str, "1") == 0) return 1;
9594   str = getenv ("SKIP_TEST_COMMAND");
9595   if (str && strcmp (str, "1") == 0) return 1;
9596   return 0;
9597 }
9598
9599 static int test_command_6 (void)
9600 {
9601   if (test_command_6_skip ()) {
9602     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9603     return 0;
9604   }
9605
9606   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9607   {
9608     char device[] = "/dev/sda";
9609     int r;
9610     suppress_error = 0;
9611     r = guestfs_blockdev_setrw (g, device);
9612     if (r == -1)
9613       return -1;
9614   }
9615   {
9616     int r;
9617     suppress_error = 0;
9618     r = guestfs_umount_all (g);
9619     if (r == -1)
9620       return -1;
9621   }
9622   {
9623     int r;
9624     suppress_error = 0;
9625     r = guestfs_lvm_remove_all (g);
9626     if (r == -1)
9627       return -1;
9628   }
9629   {
9630     char device[] = "/dev/sda";
9631     char lines_0[] = ",";
9632     char *lines[] = {
9633       lines_0,
9634       NULL
9635     };
9636     int r;
9637     suppress_error = 0;
9638     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9639     if (r == -1)
9640       return -1;
9641   }
9642   {
9643     char fstype[] = "ext2";
9644     char device[] = "/dev/sda1";
9645     int r;
9646     suppress_error = 0;
9647     r = guestfs_mkfs (g, fstype, device);
9648     if (r == -1)
9649       return -1;
9650   }
9651   {
9652     char device[] = "/dev/sda1";
9653     char mountpoint[] = "/";
9654     int r;
9655     suppress_error = 0;
9656     r = guestfs_mount (g, device, mountpoint);
9657     if (r == -1)
9658       return -1;
9659   }
9660   /* TestOutput for command (6) */
9661   char expected[] = "";
9662   {
9663     char remotefilename[] = "/test-command";
9664     int r;
9665     suppress_error = 0;
9666     r = guestfs_upload (g, "test-command", remotefilename);
9667     if (r == -1)
9668       return -1;
9669   }
9670   {
9671     char path[] = "/test-command";
9672     int r;
9673     suppress_error = 0;
9674     r = guestfs_chmod (g, 493, path);
9675     if (r == -1)
9676       return -1;
9677   }
9678   {
9679     char arguments_0[] = "/test-command";
9680     char arguments_1[] = "7";
9681     char *arguments[] = {
9682       arguments_0,
9683       arguments_1,
9684       NULL
9685     };
9686     char *r;
9687     suppress_error = 0;
9688     r = guestfs_command (g, arguments);
9689     if (r == NULL)
9690       return -1;
9691     if (strcmp (r, expected) != 0) {
9692       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9693       return -1;
9694     }
9695     free (r);
9696   }
9697   return 0;
9698 }
9699
9700 static int test_command_7_skip (void)
9701 {
9702   const char *str;
9703
9704   str = getenv ("SKIP_TEST_COMMAND_7");
9705   if (str && strcmp (str, "1") == 0) return 1;
9706   str = getenv ("SKIP_TEST_COMMAND");
9707   if (str && strcmp (str, "1") == 0) return 1;
9708   return 0;
9709 }
9710
9711 static int test_command_7 (void)
9712 {
9713   if (test_command_7_skip ()) {
9714     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9715     return 0;
9716   }
9717
9718   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9719   {
9720     char device[] = "/dev/sda";
9721     int r;
9722     suppress_error = 0;
9723     r = guestfs_blockdev_setrw (g, device);
9724     if (r == -1)
9725       return -1;
9726   }
9727   {
9728     int r;
9729     suppress_error = 0;
9730     r = guestfs_umount_all (g);
9731     if (r == -1)
9732       return -1;
9733   }
9734   {
9735     int r;
9736     suppress_error = 0;
9737     r = guestfs_lvm_remove_all (g);
9738     if (r == -1)
9739       return -1;
9740   }
9741   {
9742     char device[] = "/dev/sda";
9743     char lines_0[] = ",";
9744     char *lines[] = {
9745       lines_0,
9746       NULL
9747     };
9748     int r;
9749     suppress_error = 0;
9750     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9751     if (r == -1)
9752       return -1;
9753   }
9754   {
9755     char fstype[] = "ext2";
9756     char device[] = "/dev/sda1";
9757     int r;
9758     suppress_error = 0;
9759     r = guestfs_mkfs (g, fstype, device);
9760     if (r == -1)
9761       return -1;
9762   }
9763   {
9764     char device[] = "/dev/sda1";
9765     char mountpoint[] = "/";
9766     int r;
9767     suppress_error = 0;
9768     r = guestfs_mount (g, device, mountpoint);
9769     if (r == -1)
9770       return -1;
9771   }
9772   /* TestOutput for command (7) */
9773   char expected[] = "\n";
9774   {
9775     char remotefilename[] = "/test-command";
9776     int r;
9777     suppress_error = 0;
9778     r = guestfs_upload (g, "test-command", remotefilename);
9779     if (r == -1)
9780       return -1;
9781   }
9782   {
9783     char path[] = "/test-command";
9784     int r;
9785     suppress_error = 0;
9786     r = guestfs_chmod (g, 493, path);
9787     if (r == -1)
9788       return -1;
9789   }
9790   {
9791     char arguments_0[] = "/test-command";
9792     char arguments_1[] = "8";
9793     char *arguments[] = {
9794       arguments_0,
9795       arguments_1,
9796       NULL
9797     };
9798     char *r;
9799     suppress_error = 0;
9800     r = guestfs_command (g, arguments);
9801     if (r == NULL)
9802       return -1;
9803     if (strcmp (r, expected) != 0) {
9804       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9805       return -1;
9806     }
9807     free (r);
9808   }
9809   return 0;
9810 }
9811
9812 static int test_command_8_skip (void)
9813 {
9814   const char *str;
9815
9816   str = getenv ("SKIP_TEST_COMMAND_8");
9817   if (str && strcmp (str, "1") == 0) return 1;
9818   str = getenv ("SKIP_TEST_COMMAND");
9819   if (str && strcmp (str, "1") == 0) return 1;
9820   return 0;
9821 }
9822
9823 static int test_command_8 (void)
9824 {
9825   if (test_command_8_skip ()) {
9826     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9827     return 0;
9828   }
9829
9830   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9831   {
9832     char device[] = "/dev/sda";
9833     int r;
9834     suppress_error = 0;
9835     r = guestfs_blockdev_setrw (g, device);
9836     if (r == -1)
9837       return -1;
9838   }
9839   {
9840     int r;
9841     suppress_error = 0;
9842     r = guestfs_umount_all (g);
9843     if (r == -1)
9844       return -1;
9845   }
9846   {
9847     int r;
9848     suppress_error = 0;
9849     r = guestfs_lvm_remove_all (g);
9850     if (r == -1)
9851       return -1;
9852   }
9853   {
9854     char device[] = "/dev/sda";
9855     char lines_0[] = ",";
9856     char *lines[] = {
9857       lines_0,
9858       NULL
9859     };
9860     int r;
9861     suppress_error = 0;
9862     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9863     if (r == -1)
9864       return -1;
9865   }
9866   {
9867     char fstype[] = "ext2";
9868     char device[] = "/dev/sda1";
9869     int r;
9870     suppress_error = 0;
9871     r = guestfs_mkfs (g, fstype, device);
9872     if (r == -1)
9873       return -1;
9874   }
9875   {
9876     char device[] = "/dev/sda1";
9877     char mountpoint[] = "/";
9878     int r;
9879     suppress_error = 0;
9880     r = guestfs_mount (g, device, mountpoint);
9881     if (r == -1)
9882       return -1;
9883   }
9884   /* TestOutput for command (8) */
9885   char expected[] = "\n\n";
9886   {
9887     char remotefilename[] = "/test-command";
9888     int r;
9889     suppress_error = 0;
9890     r = guestfs_upload (g, "test-command", remotefilename);
9891     if (r == -1)
9892       return -1;
9893   }
9894   {
9895     char path[] = "/test-command";
9896     int r;
9897     suppress_error = 0;
9898     r = guestfs_chmod (g, 493, path);
9899     if (r == -1)
9900       return -1;
9901   }
9902   {
9903     char arguments_0[] = "/test-command";
9904     char arguments_1[] = "9";
9905     char *arguments[] = {
9906       arguments_0,
9907       arguments_1,
9908       NULL
9909     };
9910     char *r;
9911     suppress_error = 0;
9912     r = guestfs_command (g, arguments);
9913     if (r == NULL)
9914       return -1;
9915     if (strcmp (r, expected) != 0) {
9916       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9917       return -1;
9918     }
9919     free (r);
9920   }
9921   return 0;
9922 }
9923
9924 static int test_command_9_skip (void)
9925 {
9926   const char *str;
9927
9928   str = getenv ("SKIP_TEST_COMMAND_9");
9929   if (str && strcmp (str, "1") == 0) return 1;
9930   str = getenv ("SKIP_TEST_COMMAND");
9931   if (str && strcmp (str, "1") == 0) return 1;
9932   return 0;
9933 }
9934
9935 static int test_command_9 (void)
9936 {
9937   if (test_command_9_skip ()) {
9938     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9939     return 0;
9940   }
9941
9942   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9943   {
9944     char device[] = "/dev/sda";
9945     int r;
9946     suppress_error = 0;
9947     r = guestfs_blockdev_setrw (g, device);
9948     if (r == -1)
9949       return -1;
9950   }
9951   {
9952     int r;
9953     suppress_error = 0;
9954     r = guestfs_umount_all (g);
9955     if (r == -1)
9956       return -1;
9957   }
9958   {
9959     int r;
9960     suppress_error = 0;
9961     r = guestfs_lvm_remove_all (g);
9962     if (r == -1)
9963       return -1;
9964   }
9965   {
9966     char device[] = "/dev/sda";
9967     char lines_0[] = ",";
9968     char *lines[] = {
9969       lines_0,
9970       NULL
9971     };
9972     int r;
9973     suppress_error = 0;
9974     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9975     if (r == -1)
9976       return -1;
9977   }
9978   {
9979     char fstype[] = "ext2";
9980     char device[] = "/dev/sda1";
9981     int r;
9982     suppress_error = 0;
9983     r = guestfs_mkfs (g, fstype, device);
9984     if (r == -1)
9985       return -1;
9986   }
9987   {
9988     char device[] = "/dev/sda1";
9989     char mountpoint[] = "/";
9990     int r;
9991     suppress_error = 0;
9992     r = guestfs_mount (g, device, mountpoint);
9993     if (r == -1)
9994       return -1;
9995   }
9996   /* TestOutput for command (9) */
9997   char expected[] = "Result10-1\nResult10-2\n";
9998   {
9999     char remotefilename[] = "/test-command";
10000     int r;
10001     suppress_error = 0;
10002     r = guestfs_upload (g, "test-command", remotefilename);
10003     if (r == -1)
10004       return -1;
10005   }
10006   {
10007     char path[] = "/test-command";
10008     int r;
10009     suppress_error = 0;
10010     r = guestfs_chmod (g, 493, path);
10011     if (r == -1)
10012       return -1;
10013   }
10014   {
10015     char arguments_0[] = "/test-command";
10016     char arguments_1[] = "10";
10017     char *arguments[] = {
10018       arguments_0,
10019       arguments_1,
10020       NULL
10021     };
10022     char *r;
10023     suppress_error = 0;
10024     r = guestfs_command (g, arguments);
10025     if (r == NULL)
10026       return -1;
10027     if (strcmp (r, expected) != 0) {
10028       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
10029       return -1;
10030     }
10031     free (r);
10032   }
10033   return 0;
10034 }
10035
10036 static int test_command_10_skip (void)
10037 {
10038   const char *str;
10039
10040   str = getenv ("SKIP_TEST_COMMAND_10");
10041   if (str && strcmp (str, "1") == 0) return 1;
10042   str = getenv ("SKIP_TEST_COMMAND");
10043   if (str && strcmp (str, "1") == 0) return 1;
10044   return 0;
10045 }
10046
10047 static int test_command_10 (void)
10048 {
10049   if (test_command_10_skip ()) {
10050     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
10051     return 0;
10052   }
10053
10054   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
10055   {
10056     char device[] = "/dev/sda";
10057     int r;
10058     suppress_error = 0;
10059     r = guestfs_blockdev_setrw (g, device);
10060     if (r == -1)
10061       return -1;
10062   }
10063   {
10064     int r;
10065     suppress_error = 0;
10066     r = guestfs_umount_all (g);
10067     if (r == -1)
10068       return -1;
10069   }
10070   {
10071     int r;
10072     suppress_error = 0;
10073     r = guestfs_lvm_remove_all (g);
10074     if (r == -1)
10075       return -1;
10076   }
10077   {
10078     char device[] = "/dev/sda";
10079     char lines_0[] = ",";
10080     char *lines[] = {
10081       lines_0,
10082       NULL
10083     };
10084     int r;
10085     suppress_error = 0;
10086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10087     if (r == -1)
10088       return -1;
10089   }
10090   {
10091     char fstype[] = "ext2";
10092     char device[] = "/dev/sda1";
10093     int r;
10094     suppress_error = 0;
10095     r = guestfs_mkfs (g, fstype, device);
10096     if (r == -1)
10097       return -1;
10098   }
10099   {
10100     char device[] = "/dev/sda1";
10101     char mountpoint[] = "/";
10102     int r;
10103     suppress_error = 0;
10104     r = guestfs_mount (g, device, mountpoint);
10105     if (r == -1)
10106       return -1;
10107   }
10108   /* TestOutput for command (10) */
10109   char expected[] = "Result11-1\nResult11-2";
10110   {
10111     char remotefilename[] = "/test-command";
10112     int r;
10113     suppress_error = 0;
10114     r = guestfs_upload (g, "test-command", remotefilename);
10115     if (r == -1)
10116       return -1;
10117   }
10118   {
10119     char path[] = "/test-command";
10120     int r;
10121     suppress_error = 0;
10122     r = guestfs_chmod (g, 493, path);
10123     if (r == -1)
10124       return -1;
10125   }
10126   {
10127     char arguments_0[] = "/test-command";
10128     char arguments_1[] = "11";
10129     char *arguments[] = {
10130       arguments_0,
10131       arguments_1,
10132       NULL
10133     };
10134     char *r;
10135     suppress_error = 0;
10136     r = guestfs_command (g, arguments);
10137     if (r == NULL)
10138       return -1;
10139     if (strcmp (r, expected) != 0) {
10140       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
10141       return -1;
10142     }
10143     free (r);
10144   }
10145   return 0;
10146 }
10147
10148 static int test_command_11_skip (void)
10149 {
10150   const char *str;
10151
10152   str = getenv ("SKIP_TEST_COMMAND_11");
10153   if (str && strcmp (str, "1") == 0) return 1;
10154   str = getenv ("SKIP_TEST_COMMAND");
10155   if (str && strcmp (str, "1") == 0) return 1;
10156   return 0;
10157 }
10158
10159 static int test_command_11 (void)
10160 {
10161   if (test_command_11_skip ()) {
10162     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
10163     return 0;
10164   }
10165
10166   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10167   {
10168     char device[] = "/dev/sda";
10169     int r;
10170     suppress_error = 0;
10171     r = guestfs_blockdev_setrw (g, device);
10172     if (r == -1)
10173       return -1;
10174   }
10175   {
10176     int r;
10177     suppress_error = 0;
10178     r = guestfs_umount_all (g);
10179     if (r == -1)
10180       return -1;
10181   }
10182   {
10183     int r;
10184     suppress_error = 0;
10185     r = guestfs_lvm_remove_all (g);
10186     if (r == -1)
10187       return -1;
10188   }
10189   {
10190     char device[] = "/dev/sda";
10191     char lines_0[] = ",";
10192     char *lines[] = {
10193       lines_0,
10194       NULL
10195     };
10196     int r;
10197     suppress_error = 0;
10198     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10199     if (r == -1)
10200       return -1;
10201   }
10202   {
10203     char fstype[] = "ext2";
10204     char device[] = "/dev/sda1";
10205     int r;
10206     suppress_error = 0;
10207     r = guestfs_mkfs (g, fstype, device);
10208     if (r == -1)
10209       return -1;
10210   }
10211   {
10212     char device[] = "/dev/sda1";
10213     char mountpoint[] = "/";
10214     int r;
10215     suppress_error = 0;
10216     r = guestfs_mount (g, device, mountpoint);
10217     if (r == -1)
10218       return -1;
10219   }
10220   /* TestLastFail for command (11) */
10221   {
10222     char remotefilename[] = "/test-command";
10223     int r;
10224     suppress_error = 0;
10225     r = guestfs_upload (g, "test-command", remotefilename);
10226     if (r == -1)
10227       return -1;
10228   }
10229   {
10230     char path[] = "/test-command";
10231     int r;
10232     suppress_error = 0;
10233     r = guestfs_chmod (g, 493, path);
10234     if (r == -1)
10235       return -1;
10236   }
10237   {
10238     char arguments_0[] = "/test-command";
10239     char *arguments[] = {
10240       arguments_0,
10241       NULL
10242     };
10243     char *r;
10244     suppress_error = 1;
10245     r = guestfs_command (g, arguments);
10246     if (r != NULL)
10247       return -1;
10248     free (r);
10249   }
10250   return 0;
10251 }
10252
10253 static int test_file_0_skip (void)
10254 {
10255   const char *str;
10256
10257   str = getenv ("SKIP_TEST_FILE_0");
10258   if (str && strcmp (str, "1") == 0) return 1;
10259   str = getenv ("SKIP_TEST_FILE");
10260   if (str && strcmp (str, "1") == 0) return 1;
10261   return 0;
10262 }
10263
10264 static int test_file_0 (void)
10265 {
10266   if (test_file_0_skip ()) {
10267     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10268     return 0;
10269   }
10270
10271   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10272   {
10273     char device[] = "/dev/sda";
10274     int r;
10275     suppress_error = 0;
10276     r = guestfs_blockdev_setrw (g, device);
10277     if (r == -1)
10278       return -1;
10279   }
10280   {
10281     int r;
10282     suppress_error = 0;
10283     r = guestfs_umount_all (g);
10284     if (r == -1)
10285       return -1;
10286   }
10287   {
10288     int r;
10289     suppress_error = 0;
10290     r = guestfs_lvm_remove_all (g);
10291     if (r == -1)
10292       return -1;
10293   }
10294   {
10295     char device[] = "/dev/sda";
10296     char lines_0[] = ",";
10297     char *lines[] = {
10298       lines_0,
10299       NULL
10300     };
10301     int r;
10302     suppress_error = 0;
10303     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10304     if (r == -1)
10305       return -1;
10306   }
10307   {
10308     char fstype[] = "ext2";
10309     char device[] = "/dev/sda1";
10310     int r;
10311     suppress_error = 0;
10312     r = guestfs_mkfs (g, fstype, device);
10313     if (r == -1)
10314       return -1;
10315   }
10316   {
10317     char device[] = "/dev/sda1";
10318     char mountpoint[] = "/";
10319     int r;
10320     suppress_error = 0;
10321     r = guestfs_mount (g, device, mountpoint);
10322     if (r == -1)
10323       return -1;
10324   }
10325   /* TestOutput for file (0) */
10326   char expected[] = "empty";
10327   {
10328     char path[] = "/new";
10329     int r;
10330     suppress_error = 0;
10331     r = guestfs_touch (g, path);
10332     if (r == -1)
10333       return -1;
10334   }
10335   {
10336     char path[] = "/new";
10337     char *r;
10338     suppress_error = 0;
10339     r = guestfs_file (g, path);
10340     if (r == NULL)
10341       return -1;
10342     if (strcmp (r, expected) != 0) {
10343       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10344       return -1;
10345     }
10346     free (r);
10347   }
10348   return 0;
10349 }
10350
10351 static int test_file_1_skip (void)
10352 {
10353   const char *str;
10354
10355   str = getenv ("SKIP_TEST_FILE_1");
10356   if (str && strcmp (str, "1") == 0) return 1;
10357   str = getenv ("SKIP_TEST_FILE");
10358   if (str && strcmp (str, "1") == 0) return 1;
10359   return 0;
10360 }
10361
10362 static int test_file_1 (void)
10363 {
10364   if (test_file_1_skip ()) {
10365     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10366     return 0;
10367   }
10368
10369   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10370   {
10371     char device[] = "/dev/sda";
10372     int r;
10373     suppress_error = 0;
10374     r = guestfs_blockdev_setrw (g, device);
10375     if (r == -1)
10376       return -1;
10377   }
10378   {
10379     int r;
10380     suppress_error = 0;
10381     r = guestfs_umount_all (g);
10382     if (r == -1)
10383       return -1;
10384   }
10385   {
10386     int r;
10387     suppress_error = 0;
10388     r = guestfs_lvm_remove_all (g);
10389     if (r == -1)
10390       return -1;
10391   }
10392   {
10393     char device[] = "/dev/sda";
10394     char lines_0[] = ",";
10395     char *lines[] = {
10396       lines_0,
10397       NULL
10398     };
10399     int r;
10400     suppress_error = 0;
10401     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10402     if (r == -1)
10403       return -1;
10404   }
10405   {
10406     char fstype[] = "ext2";
10407     char device[] = "/dev/sda1";
10408     int r;
10409     suppress_error = 0;
10410     r = guestfs_mkfs (g, fstype, device);
10411     if (r == -1)
10412       return -1;
10413   }
10414   {
10415     char device[] = "/dev/sda1";
10416     char mountpoint[] = "/";
10417     int r;
10418     suppress_error = 0;
10419     r = guestfs_mount (g, device, mountpoint);
10420     if (r == -1)
10421       return -1;
10422   }
10423   /* TestOutput for file (1) */
10424   char expected[] = "ASCII text";
10425   {
10426     char path[] = "/new";
10427     char content[] = "some content\n";
10428     int r;
10429     suppress_error = 0;
10430     r = guestfs_write_file (g, path, content, 0);
10431     if (r == -1)
10432       return -1;
10433   }
10434   {
10435     char path[] = "/new";
10436     char *r;
10437     suppress_error = 0;
10438     r = guestfs_file (g, path);
10439     if (r == NULL)
10440       return -1;
10441     if (strcmp (r, expected) != 0) {
10442       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10443       return -1;
10444     }
10445     free (r);
10446   }
10447   return 0;
10448 }
10449
10450 static int test_file_2_skip (void)
10451 {
10452   const char *str;
10453
10454   str = getenv ("SKIP_TEST_FILE_2");
10455   if (str && strcmp (str, "1") == 0) return 1;
10456   str = getenv ("SKIP_TEST_FILE");
10457   if (str && strcmp (str, "1") == 0) return 1;
10458   return 0;
10459 }
10460
10461 static int test_file_2 (void)
10462 {
10463   if (test_file_2_skip ()) {
10464     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10465     return 0;
10466   }
10467
10468   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10469   {
10470     char device[] = "/dev/sda";
10471     int r;
10472     suppress_error = 0;
10473     r = guestfs_blockdev_setrw (g, device);
10474     if (r == -1)
10475       return -1;
10476   }
10477   {
10478     int r;
10479     suppress_error = 0;
10480     r = guestfs_umount_all (g);
10481     if (r == -1)
10482       return -1;
10483   }
10484   {
10485     int r;
10486     suppress_error = 0;
10487     r = guestfs_lvm_remove_all (g);
10488     if (r == -1)
10489       return -1;
10490   }
10491   {
10492     char device[] = "/dev/sda";
10493     char lines_0[] = ",";
10494     char *lines[] = {
10495       lines_0,
10496       NULL
10497     };
10498     int r;
10499     suppress_error = 0;
10500     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10501     if (r == -1)
10502       return -1;
10503   }
10504   {
10505     char fstype[] = "ext2";
10506     char device[] = "/dev/sda1";
10507     int r;
10508     suppress_error = 0;
10509     r = guestfs_mkfs (g, fstype, device);
10510     if (r == -1)
10511       return -1;
10512   }
10513   {
10514     char device[] = "/dev/sda1";
10515     char mountpoint[] = "/";
10516     int r;
10517     suppress_error = 0;
10518     r = guestfs_mount (g, device, mountpoint);
10519     if (r == -1)
10520       return -1;
10521   }
10522   /* TestLastFail for file (2) */
10523   {
10524     char path[] = "/nofile";
10525     char *r;
10526     suppress_error = 1;
10527     r = guestfs_file (g, path);
10528     if (r != NULL)
10529       return -1;
10530     free (r);
10531   }
10532   return 0;
10533 }
10534
10535 static int test_umount_all_0_skip (void)
10536 {
10537   const char *str;
10538
10539   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10540   if (str && strcmp (str, "1") == 0) return 1;
10541   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10542   if (str && strcmp (str, "1") == 0) return 1;
10543   return 0;
10544 }
10545
10546 static int test_umount_all_0 (void)
10547 {
10548   if (test_umount_all_0_skip ()) {
10549     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10550     return 0;
10551   }
10552
10553   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10554   {
10555     char device[] = "/dev/sda";
10556     int r;
10557     suppress_error = 0;
10558     r = guestfs_blockdev_setrw (g, device);
10559     if (r == -1)
10560       return -1;
10561   }
10562   {
10563     int r;
10564     suppress_error = 0;
10565     r = guestfs_umount_all (g);
10566     if (r == -1)
10567       return -1;
10568   }
10569   {
10570     int r;
10571     suppress_error = 0;
10572     r = guestfs_lvm_remove_all (g);
10573     if (r == -1)
10574       return -1;
10575   }
10576   {
10577     char device[] = "/dev/sda";
10578     char lines_0[] = ",";
10579     char *lines[] = {
10580       lines_0,
10581       NULL
10582     };
10583     int r;
10584     suppress_error = 0;
10585     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10586     if (r == -1)
10587       return -1;
10588   }
10589   {
10590     char fstype[] = "ext2";
10591     char device[] = "/dev/sda1";
10592     int r;
10593     suppress_error = 0;
10594     r = guestfs_mkfs (g, fstype, device);
10595     if (r == -1)
10596       return -1;
10597   }
10598   {
10599     char device[] = "/dev/sda1";
10600     char mountpoint[] = "/";
10601     int r;
10602     suppress_error = 0;
10603     r = guestfs_mount (g, device, mountpoint);
10604     if (r == -1)
10605       return -1;
10606   }
10607   /* TestOutputList for umount_all (0) */
10608   {
10609     int r;
10610     suppress_error = 0;
10611     r = guestfs_umount_all (g);
10612     if (r == -1)
10613       return -1;
10614   }
10615   {
10616     char **r;
10617     int i;
10618     suppress_error = 0;
10619     r = guestfs_mounts (g);
10620     if (r == NULL)
10621       return -1;
10622     if (r[0] != NULL) {
10623       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10624       print_strings (r);
10625       return -1;
10626     }
10627     for (i = 0; r[i] != NULL; ++i)
10628       free (r[i]);
10629     free (r);
10630   }
10631   return 0;
10632 }
10633
10634 static int test_umount_all_1_skip (void)
10635 {
10636   const char *str;
10637
10638   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10639   if (str && strcmp (str, "1") == 0) return 1;
10640   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10641   if (str && strcmp (str, "1") == 0) return 1;
10642   return 0;
10643 }
10644
10645 static int test_umount_all_1 (void)
10646 {
10647   if (test_umount_all_1_skip ()) {
10648     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10649     return 0;
10650   }
10651
10652   /* InitNone|InitEmpty for test_umount_all_1 */
10653   {
10654     char device[] = "/dev/sda";
10655     int r;
10656     suppress_error = 0;
10657     r = guestfs_blockdev_setrw (g, device);
10658     if (r == -1)
10659       return -1;
10660   }
10661   {
10662     int r;
10663     suppress_error = 0;
10664     r = guestfs_umount_all (g);
10665     if (r == -1)
10666       return -1;
10667   }
10668   {
10669     int r;
10670     suppress_error = 0;
10671     r = guestfs_lvm_remove_all (g);
10672     if (r == -1)
10673       return -1;
10674   }
10675   /* TestOutputList for umount_all (1) */
10676   {
10677     char device[] = "/dev/sda";
10678     char lines_0[] = ",10";
10679     char lines_1[] = ",20";
10680     char lines_2[] = ",";
10681     char *lines[] = {
10682       lines_0,
10683       lines_1,
10684       lines_2,
10685       NULL
10686     };
10687     int r;
10688     suppress_error = 0;
10689     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10690     if (r == -1)
10691       return -1;
10692   }
10693   {
10694     char fstype[] = "ext2";
10695     char device[] = "/dev/sda1";
10696     int r;
10697     suppress_error = 0;
10698     r = guestfs_mkfs (g, fstype, device);
10699     if (r == -1)
10700       return -1;
10701   }
10702   {
10703     char fstype[] = "ext2";
10704     char device[] = "/dev/sda2";
10705     int r;
10706     suppress_error = 0;
10707     r = guestfs_mkfs (g, fstype, device);
10708     if (r == -1)
10709       return -1;
10710   }
10711   {
10712     char fstype[] = "ext2";
10713     char device[] = "/dev/sda3";
10714     int r;
10715     suppress_error = 0;
10716     r = guestfs_mkfs (g, fstype, device);
10717     if (r == -1)
10718       return -1;
10719   }
10720   {
10721     char device[] = "/dev/sda1";
10722     char mountpoint[] = "/";
10723     int r;
10724     suppress_error = 0;
10725     r = guestfs_mount (g, device, mountpoint);
10726     if (r == -1)
10727       return -1;
10728   }
10729   {
10730     char path[] = "/mp1";
10731     int r;
10732     suppress_error = 0;
10733     r = guestfs_mkdir (g, path);
10734     if (r == -1)
10735       return -1;
10736   }
10737   {
10738     char device[] = "/dev/sda2";
10739     char mountpoint[] = "/mp1";
10740     int r;
10741     suppress_error = 0;
10742     r = guestfs_mount (g, device, mountpoint);
10743     if (r == -1)
10744       return -1;
10745   }
10746   {
10747     char path[] = "/mp1/mp2";
10748     int r;
10749     suppress_error = 0;
10750     r = guestfs_mkdir (g, path);
10751     if (r == -1)
10752       return -1;
10753   }
10754   {
10755     char device[] = "/dev/sda3";
10756     char mountpoint[] = "/mp1/mp2";
10757     int r;
10758     suppress_error = 0;
10759     r = guestfs_mount (g, device, mountpoint);
10760     if (r == -1)
10761       return -1;
10762   }
10763   {
10764     char path[] = "/mp1/mp2/mp3";
10765     int r;
10766     suppress_error = 0;
10767     r = guestfs_mkdir (g, path);
10768     if (r == -1)
10769       return -1;
10770   }
10771   {
10772     int r;
10773     suppress_error = 0;
10774     r = guestfs_umount_all (g);
10775     if (r == -1)
10776       return -1;
10777   }
10778   {
10779     char **r;
10780     int i;
10781     suppress_error = 0;
10782     r = guestfs_mounts (g);
10783     if (r == NULL)
10784       return -1;
10785     if (r[0] != NULL) {
10786       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10787       print_strings (r);
10788       return -1;
10789     }
10790     for (i = 0; r[i] != NULL; ++i)
10791       free (r[i]);
10792     free (r);
10793   }
10794   return 0;
10795 }
10796
10797 static int test_mounts_0_skip (void)
10798 {
10799   const char *str;
10800
10801   str = getenv ("SKIP_TEST_MOUNTS_0");
10802   if (str && strcmp (str, "1") == 0) return 1;
10803   str = getenv ("SKIP_TEST_MOUNTS");
10804   if (str && strcmp (str, "1") == 0) return 1;
10805   return 0;
10806 }
10807
10808 static int test_mounts_0 (void)
10809 {
10810   if (test_mounts_0_skip ()) {
10811     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10812     return 0;
10813   }
10814
10815   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10816   {
10817     char device[] = "/dev/sda";
10818     int r;
10819     suppress_error = 0;
10820     r = guestfs_blockdev_setrw (g, device);
10821     if (r == -1)
10822       return -1;
10823   }
10824   {
10825     int r;
10826     suppress_error = 0;
10827     r = guestfs_umount_all (g);
10828     if (r == -1)
10829       return -1;
10830   }
10831   {
10832     int r;
10833     suppress_error = 0;
10834     r = guestfs_lvm_remove_all (g);
10835     if (r == -1)
10836       return -1;
10837   }
10838   {
10839     char device[] = "/dev/sda";
10840     char lines_0[] = ",";
10841     char *lines[] = {
10842       lines_0,
10843       NULL
10844     };
10845     int r;
10846     suppress_error = 0;
10847     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10848     if (r == -1)
10849       return -1;
10850   }
10851   {
10852     char fstype[] = "ext2";
10853     char device[] = "/dev/sda1";
10854     int r;
10855     suppress_error = 0;
10856     r = guestfs_mkfs (g, fstype, device);
10857     if (r == -1)
10858       return -1;
10859   }
10860   {
10861     char device[] = "/dev/sda1";
10862     char mountpoint[] = "/";
10863     int r;
10864     suppress_error = 0;
10865     r = guestfs_mount (g, device, mountpoint);
10866     if (r == -1)
10867       return -1;
10868   }
10869   /* TestOutputListOfDevices for mounts (0) */
10870   {
10871     char **r;
10872     int i;
10873     suppress_error = 0;
10874     r = guestfs_mounts (g);
10875     if (r == NULL)
10876       return -1;
10877     if (!r[0]) {
10878       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10879       print_strings (r);
10880       return -1;
10881     }
10882     {
10883       char expected[] = "/dev/sda1";
10884       r[0][5] = 's';
10885       if (strcmp (r[0], expected) != 0) {
10886         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10887         return -1;
10888       }
10889     }
10890     if (r[1] != NULL) {
10891       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10892       print_strings (r);
10893       return -1;
10894     }
10895     for (i = 0; r[i] != NULL; ++i)
10896       free (r[i]);
10897     free (r);
10898   }
10899   return 0;
10900 }
10901
10902 static int test_umount_0_skip (void)
10903 {
10904   const char *str;
10905
10906   str = getenv ("SKIP_TEST_UMOUNT_0");
10907   if (str && strcmp (str, "1") == 0) return 1;
10908   str = getenv ("SKIP_TEST_UMOUNT");
10909   if (str && strcmp (str, "1") == 0) return 1;
10910   return 0;
10911 }
10912
10913 static int test_umount_0 (void)
10914 {
10915   if (test_umount_0_skip ()) {
10916     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10917     return 0;
10918   }
10919
10920   /* InitNone|InitEmpty for test_umount_0 */
10921   {
10922     char device[] = "/dev/sda";
10923     int r;
10924     suppress_error = 0;
10925     r = guestfs_blockdev_setrw (g, device);
10926     if (r == -1)
10927       return -1;
10928   }
10929   {
10930     int r;
10931     suppress_error = 0;
10932     r = guestfs_umount_all (g);
10933     if (r == -1)
10934       return -1;
10935   }
10936   {
10937     int r;
10938     suppress_error = 0;
10939     r = guestfs_lvm_remove_all (g);
10940     if (r == -1)
10941       return -1;
10942   }
10943   /* TestOutputListOfDevices for umount (0) */
10944   {
10945     char device[] = "/dev/sda";
10946     char lines_0[] = ",";
10947     char *lines[] = {
10948       lines_0,
10949       NULL
10950     };
10951     int r;
10952     suppress_error = 0;
10953     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10954     if (r == -1)
10955       return -1;
10956   }
10957   {
10958     char fstype[] = "ext2";
10959     char device[] = "/dev/sda1";
10960     int r;
10961     suppress_error = 0;
10962     r = guestfs_mkfs (g, fstype, device);
10963     if (r == -1)
10964       return -1;
10965   }
10966   {
10967     char device[] = "/dev/sda1";
10968     char mountpoint[] = "/";
10969     int r;
10970     suppress_error = 0;
10971     r = guestfs_mount (g, device, mountpoint);
10972     if (r == -1)
10973       return -1;
10974   }
10975   {
10976     char **r;
10977     int i;
10978     suppress_error = 0;
10979     r = guestfs_mounts (g);
10980     if (r == NULL)
10981       return -1;
10982     if (!r[0]) {
10983       fprintf (stderr, "test_umount_0: short list returned from command\n");
10984       print_strings (r);
10985       return -1;
10986     }
10987     {
10988       char expected[] = "/dev/sda1";
10989       r[0][5] = 's';
10990       if (strcmp (r[0], expected) != 0) {
10991         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10992         return -1;
10993       }
10994     }
10995     if (r[1] != NULL) {
10996       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10997       print_strings (r);
10998       return -1;
10999     }
11000     for (i = 0; r[i] != NULL; ++i)
11001       free (r[i]);
11002     free (r);
11003   }
11004   return 0;
11005 }
11006
11007 static int test_umount_1_skip (void)
11008 {
11009   const char *str;
11010
11011   str = getenv ("SKIP_TEST_UMOUNT_1");
11012   if (str && strcmp (str, "1") == 0) return 1;
11013   str = getenv ("SKIP_TEST_UMOUNT");
11014   if (str && strcmp (str, "1") == 0) return 1;
11015   return 0;
11016 }
11017
11018 static int test_umount_1 (void)
11019 {
11020   if (test_umount_1_skip ()) {
11021     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
11022     return 0;
11023   }
11024
11025   /* InitNone|InitEmpty for test_umount_1 */
11026   {
11027     char device[] = "/dev/sda";
11028     int r;
11029     suppress_error = 0;
11030     r = guestfs_blockdev_setrw (g, device);
11031     if (r == -1)
11032       return -1;
11033   }
11034   {
11035     int r;
11036     suppress_error = 0;
11037     r = guestfs_umount_all (g);
11038     if (r == -1)
11039       return -1;
11040   }
11041   {
11042     int r;
11043     suppress_error = 0;
11044     r = guestfs_lvm_remove_all (g);
11045     if (r == -1)
11046       return -1;
11047   }
11048   /* TestOutputList for umount (1) */
11049   {
11050     char device[] = "/dev/sda";
11051     char lines_0[] = ",";
11052     char *lines[] = {
11053       lines_0,
11054       NULL
11055     };
11056     int r;
11057     suppress_error = 0;
11058     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11059     if (r == -1)
11060       return -1;
11061   }
11062   {
11063     char fstype[] = "ext2";
11064     char device[] = "/dev/sda1";
11065     int r;
11066     suppress_error = 0;
11067     r = guestfs_mkfs (g, fstype, device);
11068     if (r == -1)
11069       return -1;
11070   }
11071   {
11072     char device[] = "/dev/sda1";
11073     char mountpoint[] = "/";
11074     int r;
11075     suppress_error = 0;
11076     r = guestfs_mount (g, device, mountpoint);
11077     if (r == -1)
11078       return -1;
11079   }
11080   {
11081     char pathordevice[] = "/";
11082     int r;
11083     suppress_error = 0;
11084     r = guestfs_umount (g, pathordevice);
11085     if (r == -1)
11086       return -1;
11087   }
11088   {
11089     char **r;
11090     int i;
11091     suppress_error = 0;
11092     r = guestfs_mounts (g);
11093     if (r == NULL)
11094       return -1;
11095     if (r[0] != NULL) {
11096       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
11097       print_strings (r);
11098       return -1;
11099     }
11100     for (i = 0; r[i] != NULL; ++i)
11101       free (r[i]);
11102     free (r);
11103   }
11104   return 0;
11105 }
11106
11107 static int test_write_file_0_skip (void)
11108 {
11109   const char *str;
11110
11111   str = getenv ("SKIP_TEST_WRITE_FILE_0");
11112   if (str && strcmp (str, "1") == 0) return 1;
11113   str = getenv ("SKIP_TEST_WRITE_FILE");
11114   if (str && strcmp (str, "1") == 0) return 1;
11115   return 0;
11116 }
11117
11118 static int test_write_file_0 (void)
11119 {
11120   if (test_write_file_0_skip ()) {
11121     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
11122     return 0;
11123   }
11124
11125   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
11126   {
11127     char device[] = "/dev/sda";
11128     int r;
11129     suppress_error = 0;
11130     r = guestfs_blockdev_setrw (g, device);
11131     if (r == -1)
11132       return -1;
11133   }
11134   {
11135     int r;
11136     suppress_error = 0;
11137     r = guestfs_umount_all (g);
11138     if (r == -1)
11139       return -1;
11140   }
11141   {
11142     int r;
11143     suppress_error = 0;
11144     r = guestfs_lvm_remove_all (g);
11145     if (r == -1)
11146       return -1;
11147   }
11148   {
11149     char device[] = "/dev/sda";
11150     char lines_0[] = ",";
11151     char *lines[] = {
11152       lines_0,
11153       NULL
11154     };
11155     int r;
11156     suppress_error = 0;
11157     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11158     if (r == -1)
11159       return -1;
11160   }
11161   {
11162     char fstype[] = "ext2";
11163     char device[] = "/dev/sda1";
11164     int r;
11165     suppress_error = 0;
11166     r = guestfs_mkfs (g, fstype, device);
11167     if (r == -1)
11168       return -1;
11169   }
11170   {
11171     char device[] = "/dev/sda1";
11172     char mountpoint[] = "/";
11173     int r;
11174     suppress_error = 0;
11175     r = guestfs_mount (g, device, mountpoint);
11176     if (r == -1)
11177       return -1;
11178   }
11179   /* TestOutput for write_file (0) */
11180   char expected[] = "new file contents";
11181   {
11182     char path[] = "/new";
11183     char content[] = "new file contents";
11184     int r;
11185     suppress_error = 0;
11186     r = guestfs_write_file (g, path, content, 0);
11187     if (r == -1)
11188       return -1;
11189   }
11190   {
11191     char path[] = "/new";
11192     char *r;
11193     suppress_error = 0;
11194     r = guestfs_cat (g, path);
11195     if (r == NULL)
11196       return -1;
11197     if (strcmp (r, expected) != 0) {
11198       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11199       return -1;
11200     }
11201     free (r);
11202   }
11203   return 0;
11204 }
11205
11206 static int test_write_file_1_skip (void)
11207 {
11208   const char *str;
11209
11210   str = getenv ("SKIP_TEST_WRITE_FILE_1");
11211   if (str && strcmp (str, "1") == 0) return 1;
11212   str = getenv ("SKIP_TEST_WRITE_FILE");
11213   if (str && strcmp (str, "1") == 0) return 1;
11214   return 0;
11215 }
11216
11217 static int test_write_file_1 (void)
11218 {
11219   if (test_write_file_1_skip ()) {
11220     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11221     return 0;
11222   }
11223
11224   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11225   {
11226     char device[] = "/dev/sda";
11227     int r;
11228     suppress_error = 0;
11229     r = guestfs_blockdev_setrw (g, device);
11230     if (r == -1)
11231       return -1;
11232   }
11233   {
11234     int r;
11235     suppress_error = 0;
11236     r = guestfs_umount_all (g);
11237     if (r == -1)
11238       return -1;
11239   }
11240   {
11241     int r;
11242     suppress_error = 0;
11243     r = guestfs_lvm_remove_all (g);
11244     if (r == -1)
11245       return -1;
11246   }
11247   {
11248     char device[] = "/dev/sda";
11249     char lines_0[] = ",";
11250     char *lines[] = {
11251       lines_0,
11252       NULL
11253     };
11254     int r;
11255     suppress_error = 0;
11256     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11257     if (r == -1)
11258       return -1;
11259   }
11260   {
11261     char fstype[] = "ext2";
11262     char device[] = "/dev/sda1";
11263     int r;
11264     suppress_error = 0;
11265     r = guestfs_mkfs (g, fstype, device);
11266     if (r == -1)
11267       return -1;
11268   }
11269   {
11270     char device[] = "/dev/sda1";
11271     char mountpoint[] = "/";
11272     int r;
11273     suppress_error = 0;
11274     r = guestfs_mount (g, device, mountpoint);
11275     if (r == -1)
11276       return -1;
11277   }
11278   /* TestOutput for write_file (1) */
11279   char expected[] = "\nnew file contents\n";
11280   {
11281     char path[] = "/new";
11282     char content[] = "\nnew file contents\n";
11283     int r;
11284     suppress_error = 0;
11285     r = guestfs_write_file (g, path, content, 0);
11286     if (r == -1)
11287       return -1;
11288   }
11289   {
11290     char path[] = "/new";
11291     char *r;
11292     suppress_error = 0;
11293     r = guestfs_cat (g, path);
11294     if (r == NULL)
11295       return -1;
11296     if (strcmp (r, expected) != 0) {
11297       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11298       return -1;
11299     }
11300     free (r);
11301   }
11302   return 0;
11303 }
11304
11305 static int test_write_file_2_skip (void)
11306 {
11307   const char *str;
11308
11309   str = getenv ("SKIP_TEST_WRITE_FILE_2");
11310   if (str && strcmp (str, "1") == 0) return 1;
11311   str = getenv ("SKIP_TEST_WRITE_FILE");
11312   if (str && strcmp (str, "1") == 0) return 1;
11313   return 0;
11314 }
11315
11316 static int test_write_file_2 (void)
11317 {
11318   if (test_write_file_2_skip ()) {
11319     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11320     return 0;
11321   }
11322
11323   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11324   {
11325     char device[] = "/dev/sda";
11326     int r;
11327     suppress_error = 0;
11328     r = guestfs_blockdev_setrw (g, device);
11329     if (r == -1)
11330       return -1;
11331   }
11332   {
11333     int r;
11334     suppress_error = 0;
11335     r = guestfs_umount_all (g);
11336     if (r == -1)
11337       return -1;
11338   }
11339   {
11340     int r;
11341     suppress_error = 0;
11342     r = guestfs_lvm_remove_all (g);
11343     if (r == -1)
11344       return -1;
11345   }
11346   {
11347     char device[] = "/dev/sda";
11348     char lines_0[] = ",";
11349     char *lines[] = {
11350       lines_0,
11351       NULL
11352     };
11353     int r;
11354     suppress_error = 0;
11355     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11356     if (r == -1)
11357       return -1;
11358   }
11359   {
11360     char fstype[] = "ext2";
11361     char device[] = "/dev/sda1";
11362     int r;
11363     suppress_error = 0;
11364     r = guestfs_mkfs (g, fstype, device);
11365     if (r == -1)
11366       return -1;
11367   }
11368   {
11369     char device[] = "/dev/sda1";
11370     char mountpoint[] = "/";
11371     int r;
11372     suppress_error = 0;
11373     r = guestfs_mount (g, device, mountpoint);
11374     if (r == -1)
11375       return -1;
11376   }
11377   /* TestOutput for write_file (2) */
11378   char expected[] = "\n\n";
11379   {
11380     char path[] = "/new";
11381     char content[] = "\n\n";
11382     int r;
11383     suppress_error = 0;
11384     r = guestfs_write_file (g, path, content, 0);
11385     if (r == -1)
11386       return -1;
11387   }
11388   {
11389     char path[] = "/new";
11390     char *r;
11391     suppress_error = 0;
11392     r = guestfs_cat (g, path);
11393     if (r == NULL)
11394       return -1;
11395     if (strcmp (r, expected) != 0) {
11396       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11397       return -1;
11398     }
11399     free (r);
11400   }
11401   return 0;
11402 }
11403
11404 static int test_write_file_3_skip (void)
11405 {
11406   const char *str;
11407
11408   str = getenv ("SKIP_TEST_WRITE_FILE_3");
11409   if (str && strcmp (str, "1") == 0) return 1;
11410   str = getenv ("SKIP_TEST_WRITE_FILE");
11411   if (str && strcmp (str, "1") == 0) return 1;
11412   return 0;
11413 }
11414
11415 static int test_write_file_3 (void)
11416 {
11417   if (test_write_file_3_skip ()) {
11418     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11419     return 0;
11420   }
11421
11422   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11423   {
11424     char device[] = "/dev/sda";
11425     int r;
11426     suppress_error = 0;
11427     r = guestfs_blockdev_setrw (g, device);
11428     if (r == -1)
11429       return -1;
11430   }
11431   {
11432     int r;
11433     suppress_error = 0;
11434     r = guestfs_umount_all (g);
11435     if (r == -1)
11436       return -1;
11437   }
11438   {
11439     int r;
11440     suppress_error = 0;
11441     r = guestfs_lvm_remove_all (g);
11442     if (r == -1)
11443       return -1;
11444   }
11445   {
11446     char device[] = "/dev/sda";
11447     char lines_0[] = ",";
11448     char *lines[] = {
11449       lines_0,
11450       NULL
11451     };
11452     int r;
11453     suppress_error = 0;
11454     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11455     if (r == -1)
11456       return -1;
11457   }
11458   {
11459     char fstype[] = "ext2";
11460     char device[] = "/dev/sda1";
11461     int r;
11462     suppress_error = 0;
11463     r = guestfs_mkfs (g, fstype, device);
11464     if (r == -1)
11465       return -1;
11466   }
11467   {
11468     char device[] = "/dev/sda1";
11469     char mountpoint[] = "/";
11470     int r;
11471     suppress_error = 0;
11472     r = guestfs_mount (g, device, mountpoint);
11473     if (r == -1)
11474       return -1;
11475   }
11476   /* TestOutput for write_file (3) */
11477   char expected[] = "";
11478   {
11479     char path[] = "/new";
11480     char content[] = "";
11481     int r;
11482     suppress_error = 0;
11483     r = guestfs_write_file (g, path, content, 0);
11484     if (r == -1)
11485       return -1;
11486   }
11487   {
11488     char path[] = "/new";
11489     char *r;
11490     suppress_error = 0;
11491     r = guestfs_cat (g, path);
11492     if (r == NULL)
11493       return -1;
11494     if (strcmp (r, expected) != 0) {
11495       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11496       return -1;
11497     }
11498     free (r);
11499   }
11500   return 0;
11501 }
11502
11503 static int test_write_file_4_skip (void)
11504 {
11505   const char *str;
11506
11507   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11508   if (str && strcmp (str, "1") == 0) return 1;
11509   str = getenv ("SKIP_TEST_WRITE_FILE");
11510   if (str && strcmp (str, "1") == 0) return 1;
11511   return 0;
11512 }
11513
11514 static int test_write_file_4 (void)
11515 {
11516   if (test_write_file_4_skip ()) {
11517     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11518     return 0;
11519   }
11520
11521   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11522   {
11523     char device[] = "/dev/sda";
11524     int r;
11525     suppress_error = 0;
11526     r = guestfs_blockdev_setrw (g, device);
11527     if (r == -1)
11528       return -1;
11529   }
11530   {
11531     int r;
11532     suppress_error = 0;
11533     r = guestfs_umount_all (g);
11534     if (r == -1)
11535       return -1;
11536   }
11537   {
11538     int r;
11539     suppress_error = 0;
11540     r = guestfs_lvm_remove_all (g);
11541     if (r == -1)
11542       return -1;
11543   }
11544   {
11545     char device[] = "/dev/sda";
11546     char lines_0[] = ",";
11547     char *lines[] = {
11548       lines_0,
11549       NULL
11550     };
11551     int r;
11552     suppress_error = 0;
11553     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11554     if (r == -1)
11555       return -1;
11556   }
11557   {
11558     char fstype[] = "ext2";
11559     char device[] = "/dev/sda1";
11560     int r;
11561     suppress_error = 0;
11562     r = guestfs_mkfs (g, fstype, device);
11563     if (r == -1)
11564       return -1;
11565   }
11566   {
11567     char device[] = "/dev/sda1";
11568     char mountpoint[] = "/";
11569     int r;
11570     suppress_error = 0;
11571     r = guestfs_mount (g, device, mountpoint);
11572     if (r == -1)
11573       return -1;
11574   }
11575   /* TestOutput for write_file (4) */
11576   char expected[] = "\n\n\n";
11577   {
11578     char path[] = "/new";
11579     char content[] = "\n\n\n";
11580     int r;
11581     suppress_error = 0;
11582     r = guestfs_write_file (g, path, content, 0);
11583     if (r == -1)
11584       return -1;
11585   }
11586   {
11587     char path[] = "/new";
11588     char *r;
11589     suppress_error = 0;
11590     r = guestfs_cat (g, path);
11591     if (r == NULL)
11592       return -1;
11593     if (strcmp (r, expected) != 0) {
11594       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11595       return -1;
11596     }
11597     free (r);
11598   }
11599   return 0;
11600 }
11601
11602 static int test_write_file_5_skip (void)
11603 {
11604   const char *str;
11605
11606   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11607   if (str && strcmp (str, "1") == 0) return 1;
11608   str = getenv ("SKIP_TEST_WRITE_FILE");
11609   if (str && strcmp (str, "1") == 0) return 1;
11610   return 0;
11611 }
11612
11613 static int test_write_file_5 (void)
11614 {
11615   if (test_write_file_5_skip ()) {
11616     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11617     return 0;
11618   }
11619
11620   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11621   {
11622     char device[] = "/dev/sda";
11623     int r;
11624     suppress_error = 0;
11625     r = guestfs_blockdev_setrw (g, device);
11626     if (r == -1)
11627       return -1;
11628   }
11629   {
11630     int r;
11631     suppress_error = 0;
11632     r = guestfs_umount_all (g);
11633     if (r == -1)
11634       return -1;
11635   }
11636   {
11637     int r;
11638     suppress_error = 0;
11639     r = guestfs_lvm_remove_all (g);
11640     if (r == -1)
11641       return -1;
11642   }
11643   {
11644     char device[] = "/dev/sda";
11645     char lines_0[] = ",";
11646     char *lines[] = {
11647       lines_0,
11648       NULL
11649     };
11650     int r;
11651     suppress_error = 0;
11652     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11653     if (r == -1)
11654       return -1;
11655   }
11656   {
11657     char fstype[] = "ext2";
11658     char device[] = "/dev/sda1";
11659     int r;
11660     suppress_error = 0;
11661     r = guestfs_mkfs (g, fstype, device);
11662     if (r == -1)
11663       return -1;
11664   }
11665   {
11666     char device[] = "/dev/sda1";
11667     char mountpoint[] = "/";
11668     int r;
11669     suppress_error = 0;
11670     r = guestfs_mount (g, device, mountpoint);
11671     if (r == -1)
11672       return -1;
11673   }
11674   /* TestOutput for write_file (5) */
11675   char expected[] = "\n";
11676   {
11677     char path[] = "/new";
11678     char content[] = "\n";
11679     int r;
11680     suppress_error = 0;
11681     r = guestfs_write_file (g, path, content, 0);
11682     if (r == -1)
11683       return -1;
11684   }
11685   {
11686     char path[] = "/new";
11687     char *r;
11688     suppress_error = 0;
11689     r = guestfs_cat (g, path);
11690     if (r == NULL)
11691       return -1;
11692     if (strcmp (r, expected) != 0) {
11693       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11694       return -1;
11695     }
11696     free (r);
11697   }
11698   return 0;
11699 }
11700
11701 static int test_mkfs_0_skip (void)
11702 {
11703   const char *str;
11704
11705   str = getenv ("SKIP_TEST_MKFS_0");
11706   if (str && strcmp (str, "1") == 0) return 1;
11707   str = getenv ("SKIP_TEST_MKFS");
11708   if (str && strcmp (str, "1") == 0) return 1;
11709   return 0;
11710 }
11711
11712 static int test_mkfs_0 (void)
11713 {
11714   if (test_mkfs_0_skip ()) {
11715     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11716     return 0;
11717   }
11718
11719   /* InitNone|InitEmpty for test_mkfs_0 */
11720   {
11721     char device[] = "/dev/sda";
11722     int r;
11723     suppress_error = 0;
11724     r = guestfs_blockdev_setrw (g, device);
11725     if (r == -1)
11726       return -1;
11727   }
11728   {
11729     int r;
11730     suppress_error = 0;
11731     r = guestfs_umount_all (g);
11732     if (r == -1)
11733       return -1;
11734   }
11735   {
11736     int r;
11737     suppress_error = 0;
11738     r = guestfs_lvm_remove_all (g);
11739     if (r == -1)
11740       return -1;
11741   }
11742   /* TestOutput for mkfs (0) */
11743   char expected[] = "new file contents";
11744   {
11745     char device[] = "/dev/sda";
11746     char lines_0[] = ",";
11747     char *lines[] = {
11748       lines_0,
11749       NULL
11750     };
11751     int r;
11752     suppress_error = 0;
11753     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11754     if (r == -1)
11755       return -1;
11756   }
11757   {
11758     char fstype[] = "ext2";
11759     char device[] = "/dev/sda1";
11760     int r;
11761     suppress_error = 0;
11762     r = guestfs_mkfs (g, fstype, device);
11763     if (r == -1)
11764       return -1;
11765   }
11766   {
11767     char device[] = "/dev/sda1";
11768     char mountpoint[] = "/";
11769     int r;
11770     suppress_error = 0;
11771     r = guestfs_mount (g, device, mountpoint);
11772     if (r == -1)
11773       return -1;
11774   }
11775   {
11776     char path[] = "/new";
11777     char content[] = "new file contents";
11778     int r;
11779     suppress_error = 0;
11780     r = guestfs_write_file (g, path, content, 0);
11781     if (r == -1)
11782       return -1;
11783   }
11784   {
11785     char path[] = "/new";
11786     char *r;
11787     suppress_error = 0;
11788     r = guestfs_cat (g, path);
11789     if (r == NULL)
11790       return -1;
11791     if (strcmp (r, expected) != 0) {
11792       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11793       return -1;
11794     }
11795     free (r);
11796   }
11797   return 0;
11798 }
11799
11800 static int test_lvcreate_0_skip (void)
11801 {
11802   const char *str;
11803
11804   str = getenv ("SKIP_TEST_LVCREATE_0");
11805   if (str && strcmp (str, "1") == 0) return 1;
11806   str = getenv ("SKIP_TEST_LVCREATE");
11807   if (str && strcmp (str, "1") == 0) return 1;
11808   return 0;
11809 }
11810
11811 static int test_lvcreate_0 (void)
11812 {
11813   if (test_lvcreate_0_skip ()) {
11814     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11815     return 0;
11816   }
11817
11818   /* InitNone|InitEmpty for test_lvcreate_0 */
11819   {
11820     char device[] = "/dev/sda";
11821     int r;
11822     suppress_error = 0;
11823     r = guestfs_blockdev_setrw (g, device);
11824     if (r == -1)
11825       return -1;
11826   }
11827   {
11828     int r;
11829     suppress_error = 0;
11830     r = guestfs_umount_all (g);
11831     if (r == -1)
11832       return -1;
11833   }
11834   {
11835     int r;
11836     suppress_error = 0;
11837     r = guestfs_lvm_remove_all (g);
11838     if (r == -1)
11839       return -1;
11840   }
11841   /* TestOutputList for lvcreate (0) */
11842   {
11843     char device[] = "/dev/sda";
11844     char lines_0[] = ",10";
11845     char lines_1[] = ",20";
11846     char lines_2[] = ",";
11847     char *lines[] = {
11848       lines_0,
11849       lines_1,
11850       lines_2,
11851       NULL
11852     };
11853     int r;
11854     suppress_error = 0;
11855     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11856     if (r == -1)
11857       return -1;
11858   }
11859   {
11860     char device[] = "/dev/sda1";
11861     int r;
11862     suppress_error = 0;
11863     r = guestfs_pvcreate (g, device);
11864     if (r == -1)
11865       return -1;
11866   }
11867   {
11868     char device[] = "/dev/sda2";
11869     int r;
11870     suppress_error = 0;
11871     r = guestfs_pvcreate (g, device);
11872     if (r == -1)
11873       return -1;
11874   }
11875   {
11876     char device[] = "/dev/sda3";
11877     int r;
11878     suppress_error = 0;
11879     r = guestfs_pvcreate (g, device);
11880     if (r == -1)
11881       return -1;
11882   }
11883   {
11884     char volgroup[] = "VG1";
11885     char physvols_0[] = "/dev/sda1";
11886     char physvols_1[] = "/dev/sda2";
11887     char *physvols[] = {
11888       physvols_0,
11889       physvols_1,
11890       NULL
11891     };
11892     int r;
11893     suppress_error = 0;
11894     r = guestfs_vgcreate (g, volgroup, physvols);
11895     if (r == -1)
11896       return -1;
11897   }
11898   {
11899     char volgroup[] = "VG2";
11900     char physvols_0[] = "/dev/sda3";
11901     char *physvols[] = {
11902       physvols_0,
11903       NULL
11904     };
11905     int r;
11906     suppress_error = 0;
11907     r = guestfs_vgcreate (g, volgroup, physvols);
11908     if (r == -1)
11909       return -1;
11910   }
11911   {
11912     char logvol[] = "LV1";
11913     char volgroup[] = "VG1";
11914     int r;
11915     suppress_error = 0;
11916     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11917     if (r == -1)
11918       return -1;
11919   }
11920   {
11921     char logvol[] = "LV2";
11922     char volgroup[] = "VG1";
11923     int r;
11924     suppress_error = 0;
11925     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11926     if (r == -1)
11927       return -1;
11928   }
11929   {
11930     char logvol[] = "LV3";
11931     char volgroup[] = "VG2";
11932     int r;
11933     suppress_error = 0;
11934     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11935     if (r == -1)
11936       return -1;
11937   }
11938   {
11939     char logvol[] = "LV4";
11940     char volgroup[] = "VG2";
11941     int r;
11942     suppress_error = 0;
11943     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11944     if (r == -1)
11945       return -1;
11946   }
11947   {
11948     char logvol[] = "LV5";
11949     char volgroup[] = "VG2";
11950     int r;
11951     suppress_error = 0;
11952     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11953     if (r == -1)
11954       return -1;
11955   }
11956   {
11957     char **r;
11958     int i;
11959     suppress_error = 0;
11960     r = guestfs_lvs (g);
11961     if (r == NULL)
11962       return -1;
11963     if (!r[0]) {
11964       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11965       print_strings (r);
11966       return -1;
11967     }
11968     {
11969       char expected[] = "/dev/VG1/LV1";
11970       if (strcmp (r[0], expected) != 0) {
11971         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11972         return -1;
11973       }
11974     }
11975     if (!r[1]) {
11976       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11977       print_strings (r);
11978       return -1;
11979     }
11980     {
11981       char expected[] = "/dev/VG1/LV2";
11982       if (strcmp (r[1], expected) != 0) {
11983         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11984         return -1;
11985       }
11986     }
11987     if (!r[2]) {
11988       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11989       print_strings (r);
11990       return -1;
11991     }
11992     {
11993       char expected[] = "/dev/VG2/LV3";
11994       if (strcmp (r[2], expected) != 0) {
11995         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11996         return -1;
11997       }
11998     }
11999     if (!r[3]) {
12000       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12001       print_strings (r);
12002       return -1;
12003     }
12004     {
12005       char expected[] = "/dev/VG2/LV4";
12006       if (strcmp (r[3], expected) != 0) {
12007         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12008         return -1;
12009       }
12010     }
12011     if (!r[4]) {
12012       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12013       print_strings (r);
12014       return -1;
12015     }
12016     {
12017       char expected[] = "/dev/VG2/LV5";
12018       if (strcmp (r[4], expected) != 0) {
12019         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
12020         return -1;
12021       }
12022     }
12023     if (r[5] != NULL) {
12024       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
12025       print_strings (r);
12026       return -1;
12027     }
12028     for (i = 0; r[i] != NULL; ++i)
12029       free (r[i]);
12030     free (r);
12031   }
12032   return 0;
12033 }
12034
12035 static int test_vgcreate_0_skip (void)
12036 {
12037   const char *str;
12038
12039   str = getenv ("SKIP_TEST_VGCREATE_0");
12040   if (str && strcmp (str, "1") == 0) return 1;
12041   str = getenv ("SKIP_TEST_VGCREATE");
12042   if (str && strcmp (str, "1") == 0) return 1;
12043   return 0;
12044 }
12045
12046 static int test_vgcreate_0 (void)
12047 {
12048   if (test_vgcreate_0_skip ()) {
12049     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
12050     return 0;
12051   }
12052
12053   /* InitNone|InitEmpty for test_vgcreate_0 */
12054   {
12055     char device[] = "/dev/sda";
12056     int r;
12057     suppress_error = 0;
12058     r = guestfs_blockdev_setrw (g, device);
12059     if (r == -1)
12060       return -1;
12061   }
12062   {
12063     int r;
12064     suppress_error = 0;
12065     r = guestfs_umount_all (g);
12066     if (r == -1)
12067       return -1;
12068   }
12069   {
12070     int r;
12071     suppress_error = 0;
12072     r = guestfs_lvm_remove_all (g);
12073     if (r == -1)
12074       return -1;
12075   }
12076   /* TestOutputList for vgcreate (0) */
12077   {
12078     char device[] = "/dev/sda";
12079     char lines_0[] = ",10";
12080     char lines_1[] = ",20";
12081     char lines_2[] = ",";
12082     char *lines[] = {
12083       lines_0,
12084       lines_1,
12085       lines_2,
12086       NULL
12087     };
12088     int r;
12089     suppress_error = 0;
12090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12091     if (r == -1)
12092       return -1;
12093   }
12094   {
12095     char device[] = "/dev/sda1";
12096     int r;
12097     suppress_error = 0;
12098     r = guestfs_pvcreate (g, device);
12099     if (r == -1)
12100       return -1;
12101   }
12102   {
12103     char device[] = "/dev/sda2";
12104     int r;
12105     suppress_error = 0;
12106     r = guestfs_pvcreate (g, device);
12107     if (r == -1)
12108       return -1;
12109   }
12110   {
12111     char device[] = "/dev/sda3";
12112     int r;
12113     suppress_error = 0;
12114     r = guestfs_pvcreate (g, device);
12115     if (r == -1)
12116       return -1;
12117   }
12118   {
12119     char volgroup[] = "VG1";
12120     char physvols_0[] = "/dev/sda1";
12121     char physvols_1[] = "/dev/sda2";
12122     char *physvols[] = {
12123       physvols_0,
12124       physvols_1,
12125       NULL
12126     };
12127     int r;
12128     suppress_error = 0;
12129     r = guestfs_vgcreate (g, volgroup, physvols);
12130     if (r == -1)
12131       return -1;
12132   }
12133   {
12134     char volgroup[] = "VG2";
12135     char physvols_0[] = "/dev/sda3";
12136     char *physvols[] = {
12137       physvols_0,
12138       NULL
12139     };
12140     int r;
12141     suppress_error = 0;
12142     r = guestfs_vgcreate (g, volgroup, physvols);
12143     if (r == -1)
12144       return -1;
12145   }
12146   {
12147     char **r;
12148     int i;
12149     suppress_error = 0;
12150     r = guestfs_vgs (g);
12151     if (r == NULL)
12152       return -1;
12153     if (!r[0]) {
12154       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12155       print_strings (r);
12156       return -1;
12157     }
12158     {
12159       char expected[] = "VG1";
12160       if (strcmp (r[0], expected) != 0) {
12161         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12162         return -1;
12163       }
12164     }
12165     if (!r[1]) {
12166       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12167       print_strings (r);
12168       return -1;
12169     }
12170     {
12171       char expected[] = "VG2";
12172       if (strcmp (r[1], expected) != 0) {
12173         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12174         return -1;
12175       }
12176     }
12177     if (r[2] != NULL) {
12178       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12179       print_strings (r);
12180       return -1;
12181     }
12182     for (i = 0; r[i] != NULL; ++i)
12183       free (r[i]);
12184     free (r);
12185   }
12186   return 0;
12187 }
12188
12189 static int test_pvcreate_0_skip (void)
12190 {
12191   const char *str;
12192
12193   str = getenv ("SKIP_TEST_PVCREATE_0");
12194   if (str && strcmp (str, "1") == 0) return 1;
12195   str = getenv ("SKIP_TEST_PVCREATE");
12196   if (str && strcmp (str, "1") == 0) return 1;
12197   return 0;
12198 }
12199
12200 static int test_pvcreate_0 (void)
12201 {
12202   if (test_pvcreate_0_skip ()) {
12203     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12204     return 0;
12205   }
12206
12207   /* InitNone|InitEmpty for test_pvcreate_0 */
12208   {
12209     char device[] = "/dev/sda";
12210     int r;
12211     suppress_error = 0;
12212     r = guestfs_blockdev_setrw (g, device);
12213     if (r == -1)
12214       return -1;
12215   }
12216   {
12217     int r;
12218     suppress_error = 0;
12219     r = guestfs_umount_all (g);
12220     if (r == -1)
12221       return -1;
12222   }
12223   {
12224     int r;
12225     suppress_error = 0;
12226     r = guestfs_lvm_remove_all (g);
12227     if (r == -1)
12228       return -1;
12229   }
12230   /* TestOutputListOfDevices for pvcreate (0) */
12231   {
12232     char device[] = "/dev/sda";
12233     char lines_0[] = ",10";
12234     char lines_1[] = ",20";
12235     char lines_2[] = ",";
12236     char *lines[] = {
12237       lines_0,
12238       lines_1,
12239       lines_2,
12240       NULL
12241     };
12242     int r;
12243     suppress_error = 0;
12244     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12245     if (r == -1)
12246       return -1;
12247   }
12248   {
12249     char device[] = "/dev/sda1";
12250     int r;
12251     suppress_error = 0;
12252     r = guestfs_pvcreate (g, device);
12253     if (r == -1)
12254       return -1;
12255   }
12256   {
12257     char device[] = "/dev/sda2";
12258     int r;
12259     suppress_error = 0;
12260     r = guestfs_pvcreate (g, device);
12261     if (r == -1)
12262       return -1;
12263   }
12264   {
12265     char device[] = "/dev/sda3";
12266     int r;
12267     suppress_error = 0;
12268     r = guestfs_pvcreate (g, device);
12269     if (r == -1)
12270       return -1;
12271   }
12272   {
12273     char **r;
12274     int i;
12275     suppress_error = 0;
12276     r = guestfs_pvs (g);
12277     if (r == NULL)
12278       return -1;
12279     if (!r[0]) {
12280       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12281       print_strings (r);
12282       return -1;
12283     }
12284     {
12285       char expected[] = "/dev/sda1";
12286       r[0][5] = 's';
12287       if (strcmp (r[0], expected) != 0) {
12288         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12289         return -1;
12290       }
12291     }
12292     if (!r[1]) {
12293       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12294       print_strings (r);
12295       return -1;
12296     }
12297     {
12298       char expected[] = "/dev/sda2";
12299       r[1][5] = 's';
12300       if (strcmp (r[1], expected) != 0) {
12301         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12302         return -1;
12303       }
12304     }
12305     if (!r[2]) {
12306       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12307       print_strings (r);
12308       return -1;
12309     }
12310     {
12311       char expected[] = "/dev/sda3";
12312       r[2][5] = 's';
12313       if (strcmp (r[2], expected) != 0) {
12314         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12315         return -1;
12316       }
12317     }
12318     if (r[3] != NULL) {
12319       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12320       print_strings (r);
12321       return -1;
12322     }
12323     for (i = 0; r[i] != NULL; ++i)
12324       free (r[i]);
12325     free (r);
12326   }
12327   return 0;
12328 }
12329
12330 static int test_is_dir_0_skip (void)
12331 {
12332   const char *str;
12333
12334   str = getenv ("SKIP_TEST_IS_DIR_0");
12335   if (str && strcmp (str, "1") == 0) return 1;
12336   str = getenv ("SKIP_TEST_IS_DIR");
12337   if (str && strcmp (str, "1") == 0) return 1;
12338   return 0;
12339 }
12340
12341 static int test_is_dir_0 (void)
12342 {
12343   if (test_is_dir_0_skip ()) {
12344     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12345     return 0;
12346   }
12347
12348   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12349   {
12350     char device[] = "/dev/sda";
12351     int r;
12352     suppress_error = 0;
12353     r = guestfs_blockdev_setrw (g, device);
12354     if (r == -1)
12355       return -1;
12356   }
12357   {
12358     int r;
12359     suppress_error = 0;
12360     r = guestfs_umount_all (g);
12361     if (r == -1)
12362       return -1;
12363   }
12364   {
12365     int r;
12366     suppress_error = 0;
12367     r = guestfs_lvm_remove_all (g);
12368     if (r == -1)
12369       return -1;
12370   }
12371   {
12372     char device[] = "/dev/sda";
12373     char lines_0[] = ",";
12374     char *lines[] = {
12375       lines_0,
12376       NULL
12377     };
12378     int r;
12379     suppress_error = 0;
12380     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12381     if (r == -1)
12382       return -1;
12383   }
12384   {
12385     char fstype[] = "ext2";
12386     char device[] = "/dev/sda1";
12387     int r;
12388     suppress_error = 0;
12389     r = guestfs_mkfs (g, fstype, device);
12390     if (r == -1)
12391       return -1;
12392   }
12393   {
12394     char device[] = "/dev/sda1";
12395     char mountpoint[] = "/";
12396     int r;
12397     suppress_error = 0;
12398     r = guestfs_mount (g, device, mountpoint);
12399     if (r == -1)
12400       return -1;
12401   }
12402   /* TestOutputFalse for is_dir (0) */
12403   {
12404     char path[] = "/new";
12405     int r;
12406     suppress_error = 0;
12407     r = guestfs_touch (g, path);
12408     if (r == -1)
12409       return -1;
12410   }
12411   {
12412     char path[] = "/new";
12413     int r;
12414     suppress_error = 0;
12415     r = guestfs_is_dir (g, path);
12416     if (r == -1)
12417       return -1;
12418     if (r) {
12419       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12420       return -1;
12421     }
12422   }
12423   return 0;
12424 }
12425
12426 static int test_is_dir_1_skip (void)
12427 {
12428   const char *str;
12429
12430   str = getenv ("SKIP_TEST_IS_DIR_1");
12431   if (str && strcmp (str, "1") == 0) return 1;
12432   str = getenv ("SKIP_TEST_IS_DIR");
12433   if (str && strcmp (str, "1") == 0) return 1;
12434   return 0;
12435 }
12436
12437 static int test_is_dir_1 (void)
12438 {
12439   if (test_is_dir_1_skip ()) {
12440     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12441     return 0;
12442   }
12443
12444   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12445   {
12446     char device[] = "/dev/sda";
12447     int r;
12448     suppress_error = 0;
12449     r = guestfs_blockdev_setrw (g, device);
12450     if (r == -1)
12451       return -1;
12452   }
12453   {
12454     int r;
12455     suppress_error = 0;
12456     r = guestfs_umount_all (g);
12457     if (r == -1)
12458       return -1;
12459   }
12460   {
12461     int r;
12462     suppress_error = 0;
12463     r = guestfs_lvm_remove_all (g);
12464     if (r == -1)
12465       return -1;
12466   }
12467   {
12468     char device[] = "/dev/sda";
12469     char lines_0[] = ",";
12470     char *lines[] = {
12471       lines_0,
12472       NULL
12473     };
12474     int r;
12475     suppress_error = 0;
12476     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12477     if (r == -1)
12478       return -1;
12479   }
12480   {
12481     char fstype[] = "ext2";
12482     char device[] = "/dev/sda1";
12483     int r;
12484     suppress_error = 0;
12485     r = guestfs_mkfs (g, fstype, device);
12486     if (r == -1)
12487       return -1;
12488   }
12489   {
12490     char device[] = "/dev/sda1";
12491     char mountpoint[] = "/";
12492     int r;
12493     suppress_error = 0;
12494     r = guestfs_mount (g, device, mountpoint);
12495     if (r == -1)
12496       return -1;
12497   }
12498   /* TestOutputTrue for is_dir (1) */
12499   {
12500     char path[] = "/new";
12501     int r;
12502     suppress_error = 0;
12503     r = guestfs_mkdir (g, path);
12504     if (r == -1)
12505       return -1;
12506   }
12507   {
12508     char path[] = "/new";
12509     int r;
12510     suppress_error = 0;
12511     r = guestfs_is_dir (g, path);
12512     if (r == -1)
12513       return -1;
12514     if (!r) {
12515       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12516       return -1;
12517     }
12518   }
12519   return 0;
12520 }
12521
12522 static int test_is_file_0_skip (void)
12523 {
12524   const char *str;
12525
12526   str = getenv ("SKIP_TEST_IS_FILE_0");
12527   if (str && strcmp (str, "1") == 0) return 1;
12528   str = getenv ("SKIP_TEST_IS_FILE");
12529   if (str && strcmp (str, "1") == 0) return 1;
12530   return 0;
12531 }
12532
12533 static int test_is_file_0 (void)
12534 {
12535   if (test_is_file_0_skip ()) {
12536     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12537     return 0;
12538   }
12539
12540   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12541   {
12542     char device[] = "/dev/sda";
12543     int r;
12544     suppress_error = 0;
12545     r = guestfs_blockdev_setrw (g, device);
12546     if (r == -1)
12547       return -1;
12548   }
12549   {
12550     int r;
12551     suppress_error = 0;
12552     r = guestfs_umount_all (g);
12553     if (r == -1)
12554       return -1;
12555   }
12556   {
12557     int r;
12558     suppress_error = 0;
12559     r = guestfs_lvm_remove_all (g);
12560     if (r == -1)
12561       return -1;
12562   }
12563   {
12564     char device[] = "/dev/sda";
12565     char lines_0[] = ",";
12566     char *lines[] = {
12567       lines_0,
12568       NULL
12569     };
12570     int r;
12571     suppress_error = 0;
12572     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12573     if (r == -1)
12574       return -1;
12575   }
12576   {
12577     char fstype[] = "ext2";
12578     char device[] = "/dev/sda1";
12579     int r;
12580     suppress_error = 0;
12581     r = guestfs_mkfs (g, fstype, device);
12582     if (r == -1)
12583       return -1;
12584   }
12585   {
12586     char device[] = "/dev/sda1";
12587     char mountpoint[] = "/";
12588     int r;
12589     suppress_error = 0;
12590     r = guestfs_mount (g, device, mountpoint);
12591     if (r == -1)
12592       return -1;
12593   }
12594   /* TestOutputTrue for is_file (0) */
12595   {
12596     char path[] = "/new";
12597     int r;
12598     suppress_error = 0;
12599     r = guestfs_touch (g, path);
12600     if (r == -1)
12601       return -1;
12602   }
12603   {
12604     char path[] = "/new";
12605     int r;
12606     suppress_error = 0;
12607     r = guestfs_is_file (g, path);
12608     if (r == -1)
12609       return -1;
12610     if (!r) {
12611       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12612       return -1;
12613     }
12614   }
12615   return 0;
12616 }
12617
12618 static int test_is_file_1_skip (void)
12619 {
12620   const char *str;
12621
12622   str = getenv ("SKIP_TEST_IS_FILE_1");
12623   if (str && strcmp (str, "1") == 0) return 1;
12624   str = getenv ("SKIP_TEST_IS_FILE");
12625   if (str && strcmp (str, "1") == 0) return 1;
12626   return 0;
12627 }
12628
12629 static int test_is_file_1 (void)
12630 {
12631   if (test_is_file_1_skip ()) {
12632     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12633     return 0;
12634   }
12635
12636   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12637   {
12638     char device[] = "/dev/sda";
12639     int r;
12640     suppress_error = 0;
12641     r = guestfs_blockdev_setrw (g, device);
12642     if (r == -1)
12643       return -1;
12644   }
12645   {
12646     int r;
12647     suppress_error = 0;
12648     r = guestfs_umount_all (g);
12649     if (r == -1)
12650       return -1;
12651   }
12652   {
12653     int r;
12654     suppress_error = 0;
12655     r = guestfs_lvm_remove_all (g);
12656     if (r == -1)
12657       return -1;
12658   }
12659   {
12660     char device[] = "/dev/sda";
12661     char lines_0[] = ",";
12662     char *lines[] = {
12663       lines_0,
12664       NULL
12665     };
12666     int r;
12667     suppress_error = 0;
12668     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12669     if (r == -1)
12670       return -1;
12671   }
12672   {
12673     char fstype[] = "ext2";
12674     char device[] = "/dev/sda1";
12675     int r;
12676     suppress_error = 0;
12677     r = guestfs_mkfs (g, fstype, device);
12678     if (r == -1)
12679       return -1;
12680   }
12681   {
12682     char device[] = "/dev/sda1";
12683     char mountpoint[] = "/";
12684     int r;
12685     suppress_error = 0;
12686     r = guestfs_mount (g, device, mountpoint);
12687     if (r == -1)
12688       return -1;
12689   }
12690   /* TestOutputFalse for is_file (1) */
12691   {
12692     char path[] = "/new";
12693     int r;
12694     suppress_error = 0;
12695     r = guestfs_mkdir (g, path);
12696     if (r == -1)
12697       return -1;
12698   }
12699   {
12700     char path[] = "/new";
12701     int r;
12702     suppress_error = 0;
12703     r = guestfs_is_file (g, path);
12704     if (r == -1)
12705       return -1;
12706     if (r) {
12707       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12708       return -1;
12709     }
12710   }
12711   return 0;
12712 }
12713
12714 static int test_exists_0_skip (void)
12715 {
12716   const char *str;
12717
12718   str = getenv ("SKIP_TEST_EXISTS_0");
12719   if (str && strcmp (str, "1") == 0) return 1;
12720   str = getenv ("SKIP_TEST_EXISTS");
12721   if (str && strcmp (str, "1") == 0) return 1;
12722   return 0;
12723 }
12724
12725 static int test_exists_0 (void)
12726 {
12727   if (test_exists_0_skip ()) {
12728     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12729     return 0;
12730   }
12731
12732   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12733   {
12734     char device[] = "/dev/sda";
12735     int r;
12736     suppress_error = 0;
12737     r = guestfs_blockdev_setrw (g, device);
12738     if (r == -1)
12739       return -1;
12740   }
12741   {
12742     int r;
12743     suppress_error = 0;
12744     r = guestfs_umount_all (g);
12745     if (r == -1)
12746       return -1;
12747   }
12748   {
12749     int r;
12750     suppress_error = 0;
12751     r = guestfs_lvm_remove_all (g);
12752     if (r == -1)
12753       return -1;
12754   }
12755   {
12756     char device[] = "/dev/sda";
12757     char lines_0[] = ",";
12758     char *lines[] = {
12759       lines_0,
12760       NULL
12761     };
12762     int r;
12763     suppress_error = 0;
12764     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12765     if (r == -1)
12766       return -1;
12767   }
12768   {
12769     char fstype[] = "ext2";
12770     char device[] = "/dev/sda1";
12771     int r;
12772     suppress_error = 0;
12773     r = guestfs_mkfs (g, fstype, device);
12774     if (r == -1)
12775       return -1;
12776   }
12777   {
12778     char device[] = "/dev/sda1";
12779     char mountpoint[] = "/";
12780     int r;
12781     suppress_error = 0;
12782     r = guestfs_mount (g, device, mountpoint);
12783     if (r == -1)
12784       return -1;
12785   }
12786   /* TestOutputTrue for exists (0) */
12787   {
12788     char path[] = "/new";
12789     int r;
12790     suppress_error = 0;
12791     r = guestfs_touch (g, path);
12792     if (r == -1)
12793       return -1;
12794   }
12795   {
12796     char path[] = "/new";
12797     int r;
12798     suppress_error = 0;
12799     r = guestfs_exists (g, path);
12800     if (r == -1)
12801       return -1;
12802     if (!r) {
12803       fprintf (stderr, "test_exists_0: expected true, got false\n");
12804       return -1;
12805     }
12806   }
12807   return 0;
12808 }
12809
12810 static int test_exists_1_skip (void)
12811 {
12812   const char *str;
12813
12814   str = getenv ("SKIP_TEST_EXISTS_1");
12815   if (str && strcmp (str, "1") == 0) return 1;
12816   str = getenv ("SKIP_TEST_EXISTS");
12817   if (str && strcmp (str, "1") == 0) return 1;
12818   return 0;
12819 }
12820
12821 static int test_exists_1 (void)
12822 {
12823   if (test_exists_1_skip ()) {
12824     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12825     return 0;
12826   }
12827
12828   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12829   {
12830     char device[] = "/dev/sda";
12831     int r;
12832     suppress_error = 0;
12833     r = guestfs_blockdev_setrw (g, device);
12834     if (r == -1)
12835       return -1;
12836   }
12837   {
12838     int r;
12839     suppress_error = 0;
12840     r = guestfs_umount_all (g);
12841     if (r == -1)
12842       return -1;
12843   }
12844   {
12845     int r;
12846     suppress_error = 0;
12847     r = guestfs_lvm_remove_all (g);
12848     if (r == -1)
12849       return -1;
12850   }
12851   {
12852     char device[] = "/dev/sda";
12853     char lines_0[] = ",";
12854     char *lines[] = {
12855       lines_0,
12856       NULL
12857     };
12858     int r;
12859     suppress_error = 0;
12860     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12861     if (r == -1)
12862       return -1;
12863   }
12864   {
12865     char fstype[] = "ext2";
12866     char device[] = "/dev/sda1";
12867     int r;
12868     suppress_error = 0;
12869     r = guestfs_mkfs (g, fstype, device);
12870     if (r == -1)
12871       return -1;
12872   }
12873   {
12874     char device[] = "/dev/sda1";
12875     char mountpoint[] = "/";
12876     int r;
12877     suppress_error = 0;
12878     r = guestfs_mount (g, device, mountpoint);
12879     if (r == -1)
12880       return -1;
12881   }
12882   /* TestOutputTrue for exists (1) */
12883   {
12884     char path[] = "/new";
12885     int r;
12886     suppress_error = 0;
12887     r = guestfs_mkdir (g, path);
12888     if (r == -1)
12889       return -1;
12890   }
12891   {
12892     char path[] = "/new";
12893     int r;
12894     suppress_error = 0;
12895     r = guestfs_exists (g, path);
12896     if (r == -1)
12897       return -1;
12898     if (!r) {
12899       fprintf (stderr, "test_exists_1: expected true, got false\n");
12900       return -1;
12901     }
12902   }
12903   return 0;
12904 }
12905
12906 static int test_mkdir_p_0_skip (void)
12907 {
12908   const char *str;
12909
12910   str = getenv ("SKIP_TEST_MKDIR_P_0");
12911   if (str && strcmp (str, "1") == 0) return 1;
12912   str = getenv ("SKIP_TEST_MKDIR_P");
12913   if (str && strcmp (str, "1") == 0) return 1;
12914   return 0;
12915 }
12916
12917 static int test_mkdir_p_0 (void)
12918 {
12919   if (test_mkdir_p_0_skip ()) {
12920     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12921     return 0;
12922   }
12923
12924   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12925   {
12926     char device[] = "/dev/sda";
12927     int r;
12928     suppress_error = 0;
12929     r = guestfs_blockdev_setrw (g, device);
12930     if (r == -1)
12931       return -1;
12932   }
12933   {
12934     int r;
12935     suppress_error = 0;
12936     r = guestfs_umount_all (g);
12937     if (r == -1)
12938       return -1;
12939   }
12940   {
12941     int r;
12942     suppress_error = 0;
12943     r = guestfs_lvm_remove_all (g);
12944     if (r == -1)
12945       return -1;
12946   }
12947   {
12948     char device[] = "/dev/sda";
12949     char lines_0[] = ",";
12950     char *lines[] = {
12951       lines_0,
12952       NULL
12953     };
12954     int r;
12955     suppress_error = 0;
12956     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12957     if (r == -1)
12958       return -1;
12959   }
12960   {
12961     char fstype[] = "ext2";
12962     char device[] = "/dev/sda1";
12963     int r;
12964     suppress_error = 0;
12965     r = guestfs_mkfs (g, fstype, device);
12966     if (r == -1)
12967       return -1;
12968   }
12969   {
12970     char device[] = "/dev/sda1";
12971     char mountpoint[] = "/";
12972     int r;
12973     suppress_error = 0;
12974     r = guestfs_mount (g, device, mountpoint);
12975     if (r == -1)
12976       return -1;
12977   }
12978   /* TestOutputTrue for mkdir_p (0) */
12979   {
12980     char path[] = "/new/foo/bar";
12981     int r;
12982     suppress_error = 0;
12983     r = guestfs_mkdir_p (g, path);
12984     if (r == -1)
12985       return -1;
12986   }
12987   {
12988     char path[] = "/new/foo/bar";
12989     int r;
12990     suppress_error = 0;
12991     r = guestfs_is_dir (g, path);
12992     if (r == -1)
12993       return -1;
12994     if (!r) {
12995       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12996       return -1;
12997     }
12998   }
12999   return 0;
13000 }
13001
13002 static int test_mkdir_p_1_skip (void)
13003 {
13004   const char *str;
13005
13006   str = getenv ("SKIP_TEST_MKDIR_P_1");
13007   if (str && strcmp (str, "1") == 0) return 1;
13008   str = getenv ("SKIP_TEST_MKDIR_P");
13009   if (str && strcmp (str, "1") == 0) return 1;
13010   return 0;
13011 }
13012
13013 static int test_mkdir_p_1 (void)
13014 {
13015   if (test_mkdir_p_1_skip ()) {
13016     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
13017     return 0;
13018   }
13019
13020   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
13021   {
13022     char device[] = "/dev/sda";
13023     int r;
13024     suppress_error = 0;
13025     r = guestfs_blockdev_setrw (g, device);
13026     if (r == -1)
13027       return -1;
13028   }
13029   {
13030     int r;
13031     suppress_error = 0;
13032     r = guestfs_umount_all (g);
13033     if (r == -1)
13034       return -1;
13035   }
13036   {
13037     int r;
13038     suppress_error = 0;
13039     r = guestfs_lvm_remove_all (g);
13040     if (r == -1)
13041       return -1;
13042   }
13043   {
13044     char device[] = "/dev/sda";
13045     char lines_0[] = ",";
13046     char *lines[] = {
13047       lines_0,
13048       NULL
13049     };
13050     int r;
13051     suppress_error = 0;
13052     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13053     if (r == -1)
13054       return -1;
13055   }
13056   {
13057     char fstype[] = "ext2";
13058     char device[] = "/dev/sda1";
13059     int r;
13060     suppress_error = 0;
13061     r = guestfs_mkfs (g, fstype, device);
13062     if (r == -1)
13063       return -1;
13064   }
13065   {
13066     char device[] = "/dev/sda1";
13067     char mountpoint[] = "/";
13068     int r;
13069     suppress_error = 0;
13070     r = guestfs_mount (g, device, mountpoint);
13071     if (r == -1)
13072       return -1;
13073   }
13074   /* TestOutputTrue for mkdir_p (1) */
13075   {
13076     char path[] = "/new/foo/bar";
13077     int r;
13078     suppress_error = 0;
13079     r = guestfs_mkdir_p (g, path);
13080     if (r == -1)
13081       return -1;
13082   }
13083   {
13084     char path[] = "/new/foo";
13085     int r;
13086     suppress_error = 0;
13087     r = guestfs_is_dir (g, path);
13088     if (r == -1)
13089       return -1;
13090     if (!r) {
13091       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
13092       return -1;
13093     }
13094   }
13095   return 0;
13096 }
13097
13098 static int test_mkdir_p_2_skip (void)
13099 {
13100   const char *str;
13101
13102   str = getenv ("SKIP_TEST_MKDIR_P_2");
13103   if (str && strcmp (str, "1") == 0) return 1;
13104   str = getenv ("SKIP_TEST_MKDIR_P");
13105   if (str && strcmp (str, "1") == 0) return 1;
13106   return 0;
13107 }
13108
13109 static int test_mkdir_p_2 (void)
13110 {
13111   if (test_mkdir_p_2_skip ()) {
13112     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
13113     return 0;
13114   }
13115
13116   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
13117   {
13118     char device[] = "/dev/sda";
13119     int r;
13120     suppress_error = 0;
13121     r = guestfs_blockdev_setrw (g, device);
13122     if (r == -1)
13123       return -1;
13124   }
13125   {
13126     int r;
13127     suppress_error = 0;
13128     r = guestfs_umount_all (g);
13129     if (r == -1)
13130       return -1;
13131   }
13132   {
13133     int r;
13134     suppress_error = 0;
13135     r = guestfs_lvm_remove_all (g);
13136     if (r == -1)
13137       return -1;
13138   }
13139   {
13140     char device[] = "/dev/sda";
13141     char lines_0[] = ",";
13142     char *lines[] = {
13143       lines_0,
13144       NULL
13145     };
13146     int r;
13147     suppress_error = 0;
13148     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13149     if (r == -1)
13150       return -1;
13151   }
13152   {
13153     char fstype[] = "ext2";
13154     char device[] = "/dev/sda1";
13155     int r;
13156     suppress_error = 0;
13157     r = guestfs_mkfs (g, fstype, device);
13158     if (r == -1)
13159       return -1;
13160   }
13161   {
13162     char device[] = "/dev/sda1";
13163     char mountpoint[] = "/";
13164     int r;
13165     suppress_error = 0;
13166     r = guestfs_mount (g, device, mountpoint);
13167     if (r == -1)
13168       return -1;
13169   }
13170   /* TestOutputTrue for mkdir_p (2) */
13171   {
13172     char path[] = "/new/foo/bar";
13173     int r;
13174     suppress_error = 0;
13175     r = guestfs_mkdir_p (g, path);
13176     if (r == -1)
13177       return -1;
13178   }
13179   {
13180     char path[] = "/new";
13181     int r;
13182     suppress_error = 0;
13183     r = guestfs_is_dir (g, path);
13184     if (r == -1)
13185       return -1;
13186     if (!r) {
13187       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13188       return -1;
13189     }
13190   }
13191   return 0;
13192 }
13193
13194 static int test_mkdir_p_3_skip (void)
13195 {
13196   const char *str;
13197
13198   str = getenv ("SKIP_TEST_MKDIR_P_3");
13199   if (str && strcmp (str, "1") == 0) return 1;
13200   str = getenv ("SKIP_TEST_MKDIR_P");
13201   if (str && strcmp (str, "1") == 0) return 1;
13202   return 0;
13203 }
13204
13205 static int test_mkdir_p_3 (void)
13206 {
13207   if (test_mkdir_p_3_skip ()) {
13208     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13209     return 0;
13210   }
13211
13212   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13213   {
13214     char device[] = "/dev/sda";
13215     int r;
13216     suppress_error = 0;
13217     r = guestfs_blockdev_setrw (g, device);
13218     if (r == -1)
13219       return -1;
13220   }
13221   {
13222     int r;
13223     suppress_error = 0;
13224     r = guestfs_umount_all (g);
13225     if (r == -1)
13226       return -1;
13227   }
13228   {
13229     int r;
13230     suppress_error = 0;
13231     r = guestfs_lvm_remove_all (g);
13232     if (r == -1)
13233       return -1;
13234   }
13235   {
13236     char device[] = "/dev/sda";
13237     char lines_0[] = ",";
13238     char *lines[] = {
13239       lines_0,
13240       NULL
13241     };
13242     int r;
13243     suppress_error = 0;
13244     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13245     if (r == -1)
13246       return -1;
13247   }
13248   {
13249     char fstype[] = "ext2";
13250     char device[] = "/dev/sda1";
13251     int r;
13252     suppress_error = 0;
13253     r = guestfs_mkfs (g, fstype, device);
13254     if (r == -1)
13255       return -1;
13256   }
13257   {
13258     char device[] = "/dev/sda1";
13259     char mountpoint[] = "/";
13260     int r;
13261     suppress_error = 0;
13262     r = guestfs_mount (g, device, mountpoint);
13263     if (r == -1)
13264       return -1;
13265   }
13266   /* TestRun for mkdir_p (3) */
13267   {
13268     char path[] = "/new";
13269     int r;
13270     suppress_error = 0;
13271     r = guestfs_mkdir (g, path);
13272     if (r == -1)
13273       return -1;
13274   }
13275   {
13276     char path[] = "/new";
13277     int r;
13278     suppress_error = 0;
13279     r = guestfs_mkdir_p (g, path);
13280     if (r == -1)
13281       return -1;
13282   }
13283   return 0;
13284 }
13285
13286 static int test_mkdir_p_4_skip (void)
13287 {
13288   const char *str;
13289
13290   str = getenv ("SKIP_TEST_MKDIR_P_4");
13291   if (str && strcmp (str, "1") == 0) return 1;
13292   str = getenv ("SKIP_TEST_MKDIR_P");
13293   if (str && strcmp (str, "1") == 0) return 1;
13294   return 0;
13295 }
13296
13297 static int test_mkdir_p_4 (void)
13298 {
13299   if (test_mkdir_p_4_skip ()) {
13300     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13301     return 0;
13302   }
13303
13304   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13305   {
13306     char device[] = "/dev/sda";
13307     int r;
13308     suppress_error = 0;
13309     r = guestfs_blockdev_setrw (g, device);
13310     if (r == -1)
13311       return -1;
13312   }
13313   {
13314     int r;
13315     suppress_error = 0;
13316     r = guestfs_umount_all (g);
13317     if (r == -1)
13318       return -1;
13319   }
13320   {
13321     int r;
13322     suppress_error = 0;
13323     r = guestfs_lvm_remove_all (g);
13324     if (r == -1)
13325       return -1;
13326   }
13327   {
13328     char device[] = "/dev/sda";
13329     char lines_0[] = ",";
13330     char *lines[] = {
13331       lines_0,
13332       NULL
13333     };
13334     int r;
13335     suppress_error = 0;
13336     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13337     if (r == -1)
13338       return -1;
13339   }
13340   {
13341     char fstype[] = "ext2";
13342     char device[] = "/dev/sda1";
13343     int r;
13344     suppress_error = 0;
13345     r = guestfs_mkfs (g, fstype, device);
13346     if (r == -1)
13347       return -1;
13348   }
13349   {
13350     char device[] = "/dev/sda1";
13351     char mountpoint[] = "/";
13352     int r;
13353     suppress_error = 0;
13354     r = guestfs_mount (g, device, mountpoint);
13355     if (r == -1)
13356       return -1;
13357   }
13358   /* TestLastFail for mkdir_p (4) */
13359   {
13360     char path[] = "/new";
13361     int r;
13362     suppress_error = 0;
13363     r = guestfs_touch (g, path);
13364     if (r == -1)
13365       return -1;
13366   }
13367   {
13368     char path[] = "/new";
13369     int r;
13370     suppress_error = 1;
13371     r = guestfs_mkdir_p (g, path);
13372     if (r != -1)
13373       return -1;
13374   }
13375   return 0;
13376 }
13377
13378 static int test_mkdir_0_skip (void)
13379 {
13380   const char *str;
13381
13382   str = getenv ("SKIP_TEST_MKDIR_0");
13383   if (str && strcmp (str, "1") == 0) return 1;
13384   str = getenv ("SKIP_TEST_MKDIR");
13385   if (str && strcmp (str, "1") == 0) return 1;
13386   return 0;
13387 }
13388
13389 static int test_mkdir_0 (void)
13390 {
13391   if (test_mkdir_0_skip ()) {
13392     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13393     return 0;
13394   }
13395
13396   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13397   {
13398     char device[] = "/dev/sda";
13399     int r;
13400     suppress_error = 0;
13401     r = guestfs_blockdev_setrw (g, device);
13402     if (r == -1)
13403       return -1;
13404   }
13405   {
13406     int r;
13407     suppress_error = 0;
13408     r = guestfs_umount_all (g);
13409     if (r == -1)
13410       return -1;
13411   }
13412   {
13413     int r;
13414     suppress_error = 0;
13415     r = guestfs_lvm_remove_all (g);
13416     if (r == -1)
13417       return -1;
13418   }
13419   {
13420     char device[] = "/dev/sda";
13421     char lines_0[] = ",";
13422     char *lines[] = {
13423       lines_0,
13424       NULL
13425     };
13426     int r;
13427     suppress_error = 0;
13428     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13429     if (r == -1)
13430       return -1;
13431   }
13432   {
13433     char fstype[] = "ext2";
13434     char device[] = "/dev/sda1";
13435     int r;
13436     suppress_error = 0;
13437     r = guestfs_mkfs (g, fstype, device);
13438     if (r == -1)
13439       return -1;
13440   }
13441   {
13442     char device[] = "/dev/sda1";
13443     char mountpoint[] = "/";
13444     int r;
13445     suppress_error = 0;
13446     r = guestfs_mount (g, device, mountpoint);
13447     if (r == -1)
13448       return -1;
13449   }
13450   /* TestOutputTrue for mkdir (0) */
13451   {
13452     char path[] = "/new";
13453     int r;
13454     suppress_error = 0;
13455     r = guestfs_mkdir (g, path);
13456     if (r == -1)
13457       return -1;
13458   }
13459   {
13460     char path[] = "/new";
13461     int r;
13462     suppress_error = 0;
13463     r = guestfs_is_dir (g, path);
13464     if (r == -1)
13465       return -1;
13466     if (!r) {
13467       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13468       return -1;
13469     }
13470   }
13471   return 0;
13472 }
13473
13474 static int test_mkdir_1_skip (void)
13475 {
13476   const char *str;
13477
13478   str = getenv ("SKIP_TEST_MKDIR_1");
13479   if (str && strcmp (str, "1") == 0) return 1;
13480   str = getenv ("SKIP_TEST_MKDIR");
13481   if (str && strcmp (str, "1") == 0) return 1;
13482   return 0;
13483 }
13484
13485 static int test_mkdir_1 (void)
13486 {
13487   if (test_mkdir_1_skip ()) {
13488     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13489     return 0;
13490   }
13491
13492   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13493   {
13494     char device[] = "/dev/sda";
13495     int r;
13496     suppress_error = 0;
13497     r = guestfs_blockdev_setrw (g, device);
13498     if (r == -1)
13499       return -1;
13500   }
13501   {
13502     int r;
13503     suppress_error = 0;
13504     r = guestfs_umount_all (g);
13505     if (r == -1)
13506       return -1;
13507   }
13508   {
13509     int r;
13510     suppress_error = 0;
13511     r = guestfs_lvm_remove_all (g);
13512     if (r == -1)
13513       return -1;
13514   }
13515   {
13516     char device[] = "/dev/sda";
13517     char lines_0[] = ",";
13518     char *lines[] = {
13519       lines_0,
13520       NULL
13521     };
13522     int r;
13523     suppress_error = 0;
13524     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13525     if (r == -1)
13526       return -1;
13527   }
13528   {
13529     char fstype[] = "ext2";
13530     char device[] = "/dev/sda1";
13531     int r;
13532     suppress_error = 0;
13533     r = guestfs_mkfs (g, fstype, device);
13534     if (r == -1)
13535       return -1;
13536   }
13537   {
13538     char device[] = "/dev/sda1";
13539     char mountpoint[] = "/";
13540     int r;
13541     suppress_error = 0;
13542     r = guestfs_mount (g, device, mountpoint);
13543     if (r == -1)
13544       return -1;
13545   }
13546   /* TestLastFail for mkdir (1) */
13547   {
13548     char path[] = "/new/foo/bar";
13549     int r;
13550     suppress_error = 1;
13551     r = guestfs_mkdir (g, path);
13552     if (r != -1)
13553       return -1;
13554   }
13555   return 0;
13556 }
13557
13558 static int test_rm_rf_0_skip (void)
13559 {
13560   const char *str;
13561
13562   str = getenv ("SKIP_TEST_RM_RF_0");
13563   if (str && strcmp (str, "1") == 0) return 1;
13564   str = getenv ("SKIP_TEST_RM_RF");
13565   if (str && strcmp (str, "1") == 0) return 1;
13566   return 0;
13567 }
13568
13569 static int test_rm_rf_0 (void)
13570 {
13571   if (test_rm_rf_0_skip ()) {
13572     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13573     return 0;
13574   }
13575
13576   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13577   {
13578     char device[] = "/dev/sda";
13579     int r;
13580     suppress_error = 0;
13581     r = guestfs_blockdev_setrw (g, device);
13582     if (r == -1)
13583       return -1;
13584   }
13585   {
13586     int r;
13587     suppress_error = 0;
13588     r = guestfs_umount_all (g);
13589     if (r == -1)
13590       return -1;
13591   }
13592   {
13593     int r;
13594     suppress_error = 0;
13595     r = guestfs_lvm_remove_all (g);
13596     if (r == -1)
13597       return -1;
13598   }
13599   {
13600     char device[] = "/dev/sda";
13601     char lines_0[] = ",";
13602     char *lines[] = {
13603       lines_0,
13604       NULL
13605     };
13606     int r;
13607     suppress_error = 0;
13608     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13609     if (r == -1)
13610       return -1;
13611   }
13612   {
13613     char fstype[] = "ext2";
13614     char device[] = "/dev/sda1";
13615     int r;
13616     suppress_error = 0;
13617     r = guestfs_mkfs (g, fstype, device);
13618     if (r == -1)
13619       return -1;
13620   }
13621   {
13622     char device[] = "/dev/sda1";
13623     char mountpoint[] = "/";
13624     int r;
13625     suppress_error = 0;
13626     r = guestfs_mount (g, device, mountpoint);
13627     if (r == -1)
13628       return -1;
13629   }
13630   /* TestOutputFalse for rm_rf (0) */
13631   {
13632     char path[] = "/new";
13633     int r;
13634     suppress_error = 0;
13635     r = guestfs_mkdir (g, path);
13636     if (r == -1)
13637       return -1;
13638   }
13639   {
13640     char path[] = "/new/foo";
13641     int r;
13642     suppress_error = 0;
13643     r = guestfs_mkdir (g, path);
13644     if (r == -1)
13645       return -1;
13646   }
13647   {
13648     char path[] = "/new/foo/bar";
13649     int r;
13650     suppress_error = 0;
13651     r = guestfs_touch (g, path);
13652     if (r == -1)
13653       return -1;
13654   }
13655   {
13656     char path[] = "/new";
13657     int r;
13658     suppress_error = 0;
13659     r = guestfs_rm_rf (g, path);
13660     if (r == -1)
13661       return -1;
13662   }
13663   {
13664     char path[] = "/new";
13665     int r;
13666     suppress_error = 0;
13667     r = guestfs_exists (g, path);
13668     if (r == -1)
13669       return -1;
13670     if (r) {
13671       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13672       return -1;
13673     }
13674   }
13675   return 0;
13676 }
13677
13678 static int test_rmdir_0_skip (void)
13679 {
13680   const char *str;
13681
13682   str = getenv ("SKIP_TEST_RMDIR_0");
13683   if (str && strcmp (str, "1") == 0) return 1;
13684   str = getenv ("SKIP_TEST_RMDIR");
13685   if (str && strcmp (str, "1") == 0) return 1;
13686   return 0;
13687 }
13688
13689 static int test_rmdir_0 (void)
13690 {
13691   if (test_rmdir_0_skip ()) {
13692     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13693     return 0;
13694   }
13695
13696   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13697   {
13698     char device[] = "/dev/sda";
13699     int r;
13700     suppress_error = 0;
13701     r = guestfs_blockdev_setrw (g, device);
13702     if (r == -1)
13703       return -1;
13704   }
13705   {
13706     int r;
13707     suppress_error = 0;
13708     r = guestfs_umount_all (g);
13709     if (r == -1)
13710       return -1;
13711   }
13712   {
13713     int r;
13714     suppress_error = 0;
13715     r = guestfs_lvm_remove_all (g);
13716     if (r == -1)
13717       return -1;
13718   }
13719   {
13720     char device[] = "/dev/sda";
13721     char lines_0[] = ",";
13722     char *lines[] = {
13723       lines_0,
13724       NULL
13725     };
13726     int r;
13727     suppress_error = 0;
13728     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13729     if (r == -1)
13730       return -1;
13731   }
13732   {
13733     char fstype[] = "ext2";
13734     char device[] = "/dev/sda1";
13735     int r;
13736     suppress_error = 0;
13737     r = guestfs_mkfs (g, fstype, device);
13738     if (r == -1)
13739       return -1;
13740   }
13741   {
13742     char device[] = "/dev/sda1";
13743     char mountpoint[] = "/";
13744     int r;
13745     suppress_error = 0;
13746     r = guestfs_mount (g, device, mountpoint);
13747     if (r == -1)
13748       return -1;
13749   }
13750   /* TestRun for rmdir (0) */
13751   {
13752     char path[] = "/new";
13753     int r;
13754     suppress_error = 0;
13755     r = guestfs_mkdir (g, path);
13756     if (r == -1)
13757       return -1;
13758   }
13759   {
13760     char path[] = "/new";
13761     int r;
13762     suppress_error = 0;
13763     r = guestfs_rmdir (g, path);
13764     if (r == -1)
13765       return -1;
13766   }
13767   return 0;
13768 }
13769
13770 static int test_rmdir_1_skip (void)
13771 {
13772   const char *str;
13773
13774   str = getenv ("SKIP_TEST_RMDIR_1");
13775   if (str && strcmp (str, "1") == 0) return 1;
13776   str = getenv ("SKIP_TEST_RMDIR");
13777   if (str && strcmp (str, "1") == 0) return 1;
13778   return 0;
13779 }
13780
13781 static int test_rmdir_1 (void)
13782 {
13783   if (test_rmdir_1_skip ()) {
13784     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13785     return 0;
13786   }
13787
13788   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13789   {
13790     char device[] = "/dev/sda";
13791     int r;
13792     suppress_error = 0;
13793     r = guestfs_blockdev_setrw (g, device);
13794     if (r == -1)
13795       return -1;
13796   }
13797   {
13798     int r;
13799     suppress_error = 0;
13800     r = guestfs_umount_all (g);
13801     if (r == -1)
13802       return -1;
13803   }
13804   {
13805     int r;
13806     suppress_error = 0;
13807     r = guestfs_lvm_remove_all (g);
13808     if (r == -1)
13809       return -1;
13810   }
13811   {
13812     char device[] = "/dev/sda";
13813     char lines_0[] = ",";
13814     char *lines[] = {
13815       lines_0,
13816       NULL
13817     };
13818     int r;
13819     suppress_error = 0;
13820     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13821     if (r == -1)
13822       return -1;
13823   }
13824   {
13825     char fstype[] = "ext2";
13826     char device[] = "/dev/sda1";
13827     int r;
13828     suppress_error = 0;
13829     r = guestfs_mkfs (g, fstype, device);
13830     if (r == -1)
13831       return -1;
13832   }
13833   {
13834     char device[] = "/dev/sda1";
13835     char mountpoint[] = "/";
13836     int r;
13837     suppress_error = 0;
13838     r = guestfs_mount (g, device, mountpoint);
13839     if (r == -1)
13840       return -1;
13841   }
13842   /* TestLastFail for rmdir (1) */
13843   {
13844     char path[] = "/new";
13845     int r;
13846     suppress_error = 1;
13847     r = guestfs_rmdir (g, path);
13848     if (r != -1)
13849       return -1;
13850   }
13851   return 0;
13852 }
13853
13854 static int test_rmdir_2_skip (void)
13855 {
13856   const char *str;
13857
13858   str = getenv ("SKIP_TEST_RMDIR_2");
13859   if (str && strcmp (str, "1") == 0) return 1;
13860   str = getenv ("SKIP_TEST_RMDIR");
13861   if (str && strcmp (str, "1") == 0) return 1;
13862   return 0;
13863 }
13864
13865 static int test_rmdir_2 (void)
13866 {
13867   if (test_rmdir_2_skip ()) {
13868     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13869     return 0;
13870   }
13871
13872   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13873   {
13874     char device[] = "/dev/sda";
13875     int r;
13876     suppress_error = 0;
13877     r = guestfs_blockdev_setrw (g, device);
13878     if (r == -1)
13879       return -1;
13880   }
13881   {
13882     int r;
13883     suppress_error = 0;
13884     r = guestfs_umount_all (g);
13885     if (r == -1)
13886       return -1;
13887   }
13888   {
13889     int r;
13890     suppress_error = 0;
13891     r = guestfs_lvm_remove_all (g);
13892     if (r == -1)
13893       return -1;
13894   }
13895   {
13896     char device[] = "/dev/sda";
13897     char lines_0[] = ",";
13898     char *lines[] = {
13899       lines_0,
13900       NULL
13901     };
13902     int r;
13903     suppress_error = 0;
13904     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13905     if (r == -1)
13906       return -1;
13907   }
13908   {
13909     char fstype[] = "ext2";
13910     char device[] = "/dev/sda1";
13911     int r;
13912     suppress_error = 0;
13913     r = guestfs_mkfs (g, fstype, device);
13914     if (r == -1)
13915       return -1;
13916   }
13917   {
13918     char device[] = "/dev/sda1";
13919     char mountpoint[] = "/";
13920     int r;
13921     suppress_error = 0;
13922     r = guestfs_mount (g, device, mountpoint);
13923     if (r == -1)
13924       return -1;
13925   }
13926   /* TestLastFail for rmdir (2) */
13927   {
13928     char path[] = "/new";
13929     int r;
13930     suppress_error = 0;
13931     r = guestfs_touch (g, path);
13932     if (r == -1)
13933       return -1;
13934   }
13935   {
13936     char path[] = "/new";
13937     int r;
13938     suppress_error = 1;
13939     r = guestfs_rmdir (g, path);
13940     if (r != -1)
13941       return -1;
13942   }
13943   return 0;
13944 }
13945
13946 static int test_rm_0_skip (void)
13947 {
13948   const char *str;
13949
13950   str = getenv ("SKIP_TEST_RM_0");
13951   if (str && strcmp (str, "1") == 0) return 1;
13952   str = getenv ("SKIP_TEST_RM");
13953   if (str && strcmp (str, "1") == 0) return 1;
13954   return 0;
13955 }
13956
13957 static int test_rm_0 (void)
13958 {
13959   if (test_rm_0_skip ()) {
13960     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13961     return 0;
13962   }
13963
13964   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13965   {
13966     char device[] = "/dev/sda";
13967     int r;
13968     suppress_error = 0;
13969     r = guestfs_blockdev_setrw (g, device);
13970     if (r == -1)
13971       return -1;
13972   }
13973   {
13974     int r;
13975     suppress_error = 0;
13976     r = guestfs_umount_all (g);
13977     if (r == -1)
13978       return -1;
13979   }
13980   {
13981     int r;
13982     suppress_error = 0;
13983     r = guestfs_lvm_remove_all (g);
13984     if (r == -1)
13985       return -1;
13986   }
13987   {
13988     char device[] = "/dev/sda";
13989     char lines_0[] = ",";
13990     char *lines[] = {
13991       lines_0,
13992       NULL
13993     };
13994     int r;
13995     suppress_error = 0;
13996     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13997     if (r == -1)
13998       return -1;
13999   }
14000   {
14001     char fstype[] = "ext2";
14002     char device[] = "/dev/sda1";
14003     int r;
14004     suppress_error = 0;
14005     r = guestfs_mkfs (g, fstype, device);
14006     if (r == -1)
14007       return -1;
14008   }
14009   {
14010     char device[] = "/dev/sda1";
14011     char mountpoint[] = "/";
14012     int r;
14013     suppress_error = 0;
14014     r = guestfs_mount (g, device, mountpoint);
14015     if (r == -1)
14016       return -1;
14017   }
14018   /* TestRun for rm (0) */
14019   {
14020     char path[] = "/new";
14021     int r;
14022     suppress_error = 0;
14023     r = guestfs_touch (g, path);
14024     if (r == -1)
14025       return -1;
14026   }
14027   {
14028     char path[] = "/new";
14029     int r;
14030     suppress_error = 0;
14031     r = guestfs_rm (g, path);
14032     if (r == -1)
14033       return -1;
14034   }
14035   return 0;
14036 }
14037
14038 static int test_rm_1_skip (void)
14039 {
14040   const char *str;
14041
14042   str = getenv ("SKIP_TEST_RM_1");
14043   if (str && strcmp (str, "1") == 0) return 1;
14044   str = getenv ("SKIP_TEST_RM");
14045   if (str && strcmp (str, "1") == 0) return 1;
14046   return 0;
14047 }
14048
14049 static int test_rm_1 (void)
14050 {
14051   if (test_rm_1_skip ()) {
14052     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
14053     return 0;
14054   }
14055
14056   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14057   {
14058     char device[] = "/dev/sda";
14059     int r;
14060     suppress_error = 0;
14061     r = guestfs_blockdev_setrw (g, device);
14062     if (r == -1)
14063       return -1;
14064   }
14065   {
14066     int r;
14067     suppress_error = 0;
14068     r = guestfs_umount_all (g);
14069     if (r == -1)
14070       return -1;
14071   }
14072   {
14073     int r;
14074     suppress_error = 0;
14075     r = guestfs_lvm_remove_all (g);
14076     if (r == -1)
14077       return -1;
14078   }
14079   {
14080     char device[] = "/dev/sda";
14081     char lines_0[] = ",";
14082     char *lines[] = {
14083       lines_0,
14084       NULL
14085     };
14086     int r;
14087     suppress_error = 0;
14088     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14089     if (r == -1)
14090       return -1;
14091   }
14092   {
14093     char fstype[] = "ext2";
14094     char device[] = "/dev/sda1";
14095     int r;
14096     suppress_error = 0;
14097     r = guestfs_mkfs (g, fstype, device);
14098     if (r == -1)
14099       return -1;
14100   }
14101   {
14102     char device[] = "/dev/sda1";
14103     char mountpoint[] = "/";
14104     int r;
14105     suppress_error = 0;
14106     r = guestfs_mount (g, device, mountpoint);
14107     if (r == -1)
14108       return -1;
14109   }
14110   /* TestLastFail for rm (1) */
14111   {
14112     char path[] = "/new";
14113     int r;
14114     suppress_error = 1;
14115     r = guestfs_rm (g, path);
14116     if (r != -1)
14117       return -1;
14118   }
14119   return 0;
14120 }
14121
14122 static int test_rm_2_skip (void)
14123 {
14124   const char *str;
14125
14126   str = getenv ("SKIP_TEST_RM_2");
14127   if (str && strcmp (str, "1") == 0) return 1;
14128   str = getenv ("SKIP_TEST_RM");
14129   if (str && strcmp (str, "1") == 0) return 1;
14130   return 0;
14131 }
14132
14133 static int test_rm_2 (void)
14134 {
14135   if (test_rm_2_skip ()) {
14136     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
14137     return 0;
14138   }
14139
14140   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
14141   {
14142     char device[] = "/dev/sda";
14143     int r;
14144     suppress_error = 0;
14145     r = guestfs_blockdev_setrw (g, device);
14146     if (r == -1)
14147       return -1;
14148   }
14149   {
14150     int r;
14151     suppress_error = 0;
14152     r = guestfs_umount_all (g);
14153     if (r == -1)
14154       return -1;
14155   }
14156   {
14157     int r;
14158     suppress_error = 0;
14159     r = guestfs_lvm_remove_all (g);
14160     if (r == -1)
14161       return -1;
14162   }
14163   {
14164     char device[] = "/dev/sda";
14165     char lines_0[] = ",";
14166     char *lines[] = {
14167       lines_0,
14168       NULL
14169     };
14170     int r;
14171     suppress_error = 0;
14172     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14173     if (r == -1)
14174       return -1;
14175   }
14176   {
14177     char fstype[] = "ext2";
14178     char device[] = "/dev/sda1";
14179     int r;
14180     suppress_error = 0;
14181     r = guestfs_mkfs (g, fstype, device);
14182     if (r == -1)
14183       return -1;
14184   }
14185   {
14186     char device[] = "/dev/sda1";
14187     char mountpoint[] = "/";
14188     int r;
14189     suppress_error = 0;
14190     r = guestfs_mount (g, device, mountpoint);
14191     if (r == -1)
14192       return -1;
14193   }
14194   /* TestLastFail for rm (2) */
14195   {
14196     char path[] = "/new";
14197     int r;
14198     suppress_error = 0;
14199     r = guestfs_mkdir (g, path);
14200     if (r == -1)
14201       return -1;
14202   }
14203   {
14204     char path[] = "/new";
14205     int r;
14206     suppress_error = 1;
14207     r = guestfs_rm (g, path);
14208     if (r != -1)
14209       return -1;
14210   }
14211   return 0;
14212 }
14213
14214 static int test_read_lines_0_skip (void)
14215 {
14216   const char *str;
14217
14218   str = getenv ("SKIP_TEST_READ_LINES_0");
14219   if (str && strcmp (str, "1") == 0) return 1;
14220   str = getenv ("SKIP_TEST_READ_LINES");
14221   if (str && strcmp (str, "1") == 0) return 1;
14222   return 0;
14223 }
14224
14225 static int test_read_lines_0 (void)
14226 {
14227   if (test_read_lines_0_skip ()) {
14228     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14229     return 0;
14230   }
14231
14232   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14233   {
14234     char device[] = "/dev/sda";
14235     int r;
14236     suppress_error = 0;
14237     r = guestfs_blockdev_setrw (g, device);
14238     if (r == -1)
14239       return -1;
14240   }
14241   {
14242     int r;
14243     suppress_error = 0;
14244     r = guestfs_umount_all (g);
14245     if (r == -1)
14246       return -1;
14247   }
14248   {
14249     int r;
14250     suppress_error = 0;
14251     r = guestfs_lvm_remove_all (g);
14252     if (r == -1)
14253       return -1;
14254   }
14255   {
14256     char device[] = "/dev/sda";
14257     char lines_0[] = ",";
14258     char *lines[] = {
14259       lines_0,
14260       NULL
14261     };
14262     int r;
14263     suppress_error = 0;
14264     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14265     if (r == -1)
14266       return -1;
14267   }
14268   {
14269     char fstype[] = "ext2";
14270     char device[] = "/dev/sda1";
14271     int r;
14272     suppress_error = 0;
14273     r = guestfs_mkfs (g, fstype, device);
14274     if (r == -1)
14275       return -1;
14276   }
14277   {
14278     char device[] = "/dev/sda1";
14279     char mountpoint[] = "/";
14280     int r;
14281     suppress_error = 0;
14282     r = guestfs_mount (g, device, mountpoint);
14283     if (r == -1)
14284       return -1;
14285   }
14286   /* TestOutputList for read_lines (0) */
14287   {
14288     char path[] = "/new";
14289     char content[] = "line1\r\nline2\nline3";
14290     int r;
14291     suppress_error = 0;
14292     r = guestfs_write_file (g, path, content, 0);
14293     if (r == -1)
14294       return -1;
14295   }
14296   {
14297     char path[] = "/new";
14298     char **r;
14299     int i;
14300     suppress_error = 0;
14301     r = guestfs_read_lines (g, path);
14302     if (r == NULL)
14303       return -1;
14304     if (!r[0]) {
14305       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14306       print_strings (r);
14307       return -1;
14308     }
14309     {
14310       char expected[] = "line1";
14311       if (strcmp (r[0], expected) != 0) {
14312         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14313         return -1;
14314       }
14315     }
14316     if (!r[1]) {
14317       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14318       print_strings (r);
14319       return -1;
14320     }
14321     {
14322       char expected[] = "line2";
14323       if (strcmp (r[1], expected) != 0) {
14324         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14325         return -1;
14326       }
14327     }
14328     if (!r[2]) {
14329       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14330       print_strings (r);
14331       return -1;
14332     }
14333     {
14334       char expected[] = "line3";
14335       if (strcmp (r[2], expected) != 0) {
14336         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14337         return -1;
14338       }
14339     }
14340     if (r[3] != NULL) {
14341       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14342       print_strings (r);
14343       return -1;
14344     }
14345     for (i = 0; r[i] != NULL; ++i)
14346       free (r[i]);
14347     free (r);
14348   }
14349   return 0;
14350 }
14351
14352 static int test_read_lines_1_skip (void)
14353 {
14354   const char *str;
14355
14356   str = getenv ("SKIP_TEST_READ_LINES_1");
14357   if (str && strcmp (str, "1") == 0) return 1;
14358   str = getenv ("SKIP_TEST_READ_LINES");
14359   if (str && strcmp (str, "1") == 0) return 1;
14360   return 0;
14361 }
14362
14363 static int test_read_lines_1 (void)
14364 {
14365   if (test_read_lines_1_skip ()) {
14366     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14367     return 0;
14368   }
14369
14370   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14371   {
14372     char device[] = "/dev/sda";
14373     int r;
14374     suppress_error = 0;
14375     r = guestfs_blockdev_setrw (g, device);
14376     if (r == -1)
14377       return -1;
14378   }
14379   {
14380     int r;
14381     suppress_error = 0;
14382     r = guestfs_umount_all (g);
14383     if (r == -1)
14384       return -1;
14385   }
14386   {
14387     int r;
14388     suppress_error = 0;
14389     r = guestfs_lvm_remove_all (g);
14390     if (r == -1)
14391       return -1;
14392   }
14393   {
14394     char device[] = "/dev/sda";
14395     char lines_0[] = ",";
14396     char *lines[] = {
14397       lines_0,
14398       NULL
14399     };
14400     int r;
14401     suppress_error = 0;
14402     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14403     if (r == -1)
14404       return -1;
14405   }
14406   {
14407     char fstype[] = "ext2";
14408     char device[] = "/dev/sda1";
14409     int r;
14410     suppress_error = 0;
14411     r = guestfs_mkfs (g, fstype, device);
14412     if (r == -1)
14413       return -1;
14414   }
14415   {
14416     char device[] = "/dev/sda1";
14417     char mountpoint[] = "/";
14418     int r;
14419     suppress_error = 0;
14420     r = guestfs_mount (g, device, mountpoint);
14421     if (r == -1)
14422       return -1;
14423   }
14424   /* TestOutputList for read_lines (1) */
14425   {
14426     char path[] = "/new";
14427     char content[] = "";
14428     int r;
14429     suppress_error = 0;
14430     r = guestfs_write_file (g, path, content, 0);
14431     if (r == -1)
14432       return -1;
14433   }
14434   {
14435     char path[] = "/new";
14436     char **r;
14437     int i;
14438     suppress_error = 0;
14439     r = guestfs_read_lines (g, path);
14440     if (r == NULL)
14441       return -1;
14442     if (r[0] != NULL) {
14443       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14444       print_strings (r);
14445       return -1;
14446     }
14447     for (i = 0; r[i] != NULL; ++i)
14448       free (r[i]);
14449     free (r);
14450   }
14451   return 0;
14452 }
14453
14454 static int test_lvs_0_skip (void)
14455 {
14456   const char *str;
14457
14458   str = getenv ("SKIP_TEST_LVS_0");
14459   if (str && strcmp (str, "1") == 0) return 1;
14460   str = getenv ("SKIP_TEST_LVS");
14461   if (str && strcmp (str, "1") == 0) return 1;
14462   return 0;
14463 }
14464
14465 static int test_lvs_0 (void)
14466 {
14467   if (test_lvs_0_skip ()) {
14468     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14469     return 0;
14470   }
14471
14472   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14473   {
14474     char device[] = "/dev/sda";
14475     int r;
14476     suppress_error = 0;
14477     r = guestfs_blockdev_setrw (g, device);
14478     if (r == -1)
14479       return -1;
14480   }
14481   {
14482     int r;
14483     suppress_error = 0;
14484     r = guestfs_umount_all (g);
14485     if (r == -1)
14486       return -1;
14487   }
14488   {
14489     int r;
14490     suppress_error = 0;
14491     r = guestfs_lvm_remove_all (g);
14492     if (r == -1)
14493       return -1;
14494   }
14495   {
14496     char device[] = "/dev/sda";
14497     char lines_0[] = ",";
14498     char *lines[] = {
14499       lines_0,
14500       NULL
14501     };
14502     int r;
14503     suppress_error = 0;
14504     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14505     if (r == -1)
14506       return -1;
14507   }
14508   {
14509     char device[] = "/dev/sda1";
14510     int r;
14511     suppress_error = 0;
14512     r = guestfs_pvcreate (g, device);
14513     if (r == -1)
14514       return -1;
14515   }
14516   {
14517     char volgroup[] = "VG";
14518     char physvols_0[] = "/dev/sda1";
14519     char *physvols[] = {
14520       physvols_0,
14521       NULL
14522     };
14523     int r;
14524     suppress_error = 0;
14525     r = guestfs_vgcreate (g, volgroup, physvols);
14526     if (r == -1)
14527       return -1;
14528   }
14529   {
14530     char logvol[] = "LV";
14531     char volgroup[] = "VG";
14532     int r;
14533     suppress_error = 0;
14534     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14535     if (r == -1)
14536       return -1;
14537   }
14538   {
14539     char fstype[] = "ext2";
14540     char device[] = "/dev/VG/LV";
14541     int r;
14542     suppress_error = 0;
14543     r = guestfs_mkfs (g, fstype, device);
14544     if (r == -1)
14545       return -1;
14546   }
14547   {
14548     char device[] = "/dev/VG/LV";
14549     char mountpoint[] = "/";
14550     int r;
14551     suppress_error = 0;
14552     r = guestfs_mount (g, device, mountpoint);
14553     if (r == -1)
14554       return -1;
14555   }
14556   /* TestOutputList for lvs (0) */
14557   {
14558     char **r;
14559     int i;
14560     suppress_error = 0;
14561     r = guestfs_lvs (g);
14562     if (r == NULL)
14563       return -1;
14564     if (!r[0]) {
14565       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14566       print_strings (r);
14567       return -1;
14568     }
14569     {
14570       char expected[] = "/dev/VG/LV";
14571       if (strcmp (r[0], expected) != 0) {
14572         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14573         return -1;
14574       }
14575     }
14576     if (r[1] != NULL) {
14577       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14578       print_strings (r);
14579       return -1;
14580     }
14581     for (i = 0; r[i] != NULL; ++i)
14582       free (r[i]);
14583     free (r);
14584   }
14585   return 0;
14586 }
14587
14588 static int test_lvs_1_skip (void)
14589 {
14590   const char *str;
14591
14592   str = getenv ("SKIP_TEST_LVS_1");
14593   if (str && strcmp (str, "1") == 0) return 1;
14594   str = getenv ("SKIP_TEST_LVS");
14595   if (str && strcmp (str, "1") == 0) return 1;
14596   return 0;
14597 }
14598
14599 static int test_lvs_1 (void)
14600 {
14601   if (test_lvs_1_skip ()) {
14602     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14603     return 0;
14604   }
14605
14606   /* InitNone|InitEmpty for test_lvs_1 */
14607   {
14608     char device[] = "/dev/sda";
14609     int r;
14610     suppress_error = 0;
14611     r = guestfs_blockdev_setrw (g, device);
14612     if (r == -1)
14613       return -1;
14614   }
14615   {
14616     int r;
14617     suppress_error = 0;
14618     r = guestfs_umount_all (g);
14619     if (r == -1)
14620       return -1;
14621   }
14622   {
14623     int r;
14624     suppress_error = 0;
14625     r = guestfs_lvm_remove_all (g);
14626     if (r == -1)
14627       return -1;
14628   }
14629   /* TestOutputList for lvs (1) */
14630   {
14631     char device[] = "/dev/sda";
14632     char lines_0[] = ",10";
14633     char lines_1[] = ",20";
14634     char lines_2[] = ",";
14635     char *lines[] = {
14636       lines_0,
14637       lines_1,
14638       lines_2,
14639       NULL
14640     };
14641     int r;
14642     suppress_error = 0;
14643     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14644     if (r == -1)
14645       return -1;
14646   }
14647   {
14648     char device[] = "/dev/sda1";
14649     int r;
14650     suppress_error = 0;
14651     r = guestfs_pvcreate (g, device);
14652     if (r == -1)
14653       return -1;
14654   }
14655   {
14656     char device[] = "/dev/sda2";
14657     int r;
14658     suppress_error = 0;
14659     r = guestfs_pvcreate (g, device);
14660     if (r == -1)
14661       return -1;
14662   }
14663   {
14664     char device[] = "/dev/sda3";
14665     int r;
14666     suppress_error = 0;
14667     r = guestfs_pvcreate (g, device);
14668     if (r == -1)
14669       return -1;
14670   }
14671   {
14672     char volgroup[] = "VG1";
14673     char physvols_0[] = "/dev/sda1";
14674     char physvols_1[] = "/dev/sda2";
14675     char *physvols[] = {
14676       physvols_0,
14677       physvols_1,
14678       NULL
14679     };
14680     int r;
14681     suppress_error = 0;
14682     r = guestfs_vgcreate (g, volgroup, physvols);
14683     if (r == -1)
14684       return -1;
14685   }
14686   {
14687     char volgroup[] = "VG2";
14688     char physvols_0[] = "/dev/sda3";
14689     char *physvols[] = {
14690       physvols_0,
14691       NULL
14692     };
14693     int r;
14694     suppress_error = 0;
14695     r = guestfs_vgcreate (g, volgroup, physvols);
14696     if (r == -1)
14697       return -1;
14698   }
14699   {
14700     char logvol[] = "LV1";
14701     char volgroup[] = "VG1";
14702     int r;
14703     suppress_error = 0;
14704     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14705     if (r == -1)
14706       return -1;
14707   }
14708   {
14709     char logvol[] = "LV2";
14710     char volgroup[] = "VG1";
14711     int r;
14712     suppress_error = 0;
14713     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14714     if (r == -1)
14715       return -1;
14716   }
14717   {
14718     char logvol[] = "LV3";
14719     char volgroup[] = "VG2";
14720     int r;
14721     suppress_error = 0;
14722     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14723     if (r == -1)
14724       return -1;
14725   }
14726   {
14727     char **r;
14728     int i;
14729     suppress_error = 0;
14730     r = guestfs_lvs (g);
14731     if (r == NULL)
14732       return -1;
14733     if (!r[0]) {
14734       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14735       print_strings (r);
14736       return -1;
14737     }
14738     {
14739       char expected[] = "/dev/VG1/LV1";
14740       if (strcmp (r[0], expected) != 0) {
14741         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14742         return -1;
14743       }
14744     }
14745     if (!r[1]) {
14746       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14747       print_strings (r);
14748       return -1;
14749     }
14750     {
14751       char expected[] = "/dev/VG1/LV2";
14752       if (strcmp (r[1], expected) != 0) {
14753         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14754         return -1;
14755       }
14756     }
14757     if (!r[2]) {
14758       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14759       print_strings (r);
14760       return -1;
14761     }
14762     {
14763       char expected[] = "/dev/VG2/LV3";
14764       if (strcmp (r[2], expected) != 0) {
14765         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14766         return -1;
14767       }
14768     }
14769     if (r[3] != NULL) {
14770       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14771       print_strings (r);
14772       return -1;
14773     }
14774     for (i = 0; r[i] != NULL; ++i)
14775       free (r[i]);
14776     free (r);
14777   }
14778   return 0;
14779 }
14780
14781 static int test_vgs_0_skip (void)
14782 {
14783   const char *str;
14784
14785   str = getenv ("SKIP_TEST_VGS_0");
14786   if (str && strcmp (str, "1") == 0) return 1;
14787   str = getenv ("SKIP_TEST_VGS");
14788   if (str && strcmp (str, "1") == 0) return 1;
14789   return 0;
14790 }
14791
14792 static int test_vgs_0 (void)
14793 {
14794   if (test_vgs_0_skip ()) {
14795     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14796     return 0;
14797   }
14798
14799   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14800   {
14801     char device[] = "/dev/sda";
14802     int r;
14803     suppress_error = 0;
14804     r = guestfs_blockdev_setrw (g, device);
14805     if (r == -1)
14806       return -1;
14807   }
14808   {
14809     int r;
14810     suppress_error = 0;
14811     r = guestfs_umount_all (g);
14812     if (r == -1)
14813       return -1;
14814   }
14815   {
14816     int r;
14817     suppress_error = 0;
14818     r = guestfs_lvm_remove_all (g);
14819     if (r == -1)
14820       return -1;
14821   }
14822   {
14823     char device[] = "/dev/sda";
14824     char lines_0[] = ",";
14825     char *lines[] = {
14826       lines_0,
14827       NULL
14828     };
14829     int r;
14830     suppress_error = 0;
14831     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14832     if (r == -1)
14833       return -1;
14834   }
14835   {
14836     char device[] = "/dev/sda1";
14837     int r;
14838     suppress_error = 0;
14839     r = guestfs_pvcreate (g, device);
14840     if (r == -1)
14841       return -1;
14842   }
14843   {
14844     char volgroup[] = "VG";
14845     char physvols_0[] = "/dev/sda1";
14846     char *physvols[] = {
14847       physvols_0,
14848       NULL
14849     };
14850     int r;
14851     suppress_error = 0;
14852     r = guestfs_vgcreate (g, volgroup, physvols);
14853     if (r == -1)
14854       return -1;
14855   }
14856   {
14857     char logvol[] = "LV";
14858     char volgroup[] = "VG";
14859     int r;
14860     suppress_error = 0;
14861     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14862     if (r == -1)
14863       return -1;
14864   }
14865   {
14866     char fstype[] = "ext2";
14867     char device[] = "/dev/VG/LV";
14868     int r;
14869     suppress_error = 0;
14870     r = guestfs_mkfs (g, fstype, device);
14871     if (r == -1)
14872       return -1;
14873   }
14874   {
14875     char device[] = "/dev/VG/LV";
14876     char mountpoint[] = "/";
14877     int r;
14878     suppress_error = 0;
14879     r = guestfs_mount (g, device, mountpoint);
14880     if (r == -1)
14881       return -1;
14882   }
14883   /* TestOutputList for vgs (0) */
14884   {
14885     char **r;
14886     int i;
14887     suppress_error = 0;
14888     r = guestfs_vgs (g);
14889     if (r == NULL)
14890       return -1;
14891     if (!r[0]) {
14892       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14893       print_strings (r);
14894       return -1;
14895     }
14896     {
14897       char expected[] = "VG";
14898       if (strcmp (r[0], expected) != 0) {
14899         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14900         return -1;
14901       }
14902     }
14903     if (r[1] != NULL) {
14904       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14905       print_strings (r);
14906       return -1;
14907     }
14908     for (i = 0; r[i] != NULL; ++i)
14909       free (r[i]);
14910     free (r);
14911   }
14912   return 0;
14913 }
14914
14915 static int test_vgs_1_skip (void)
14916 {
14917   const char *str;
14918
14919   str = getenv ("SKIP_TEST_VGS_1");
14920   if (str && strcmp (str, "1") == 0) return 1;
14921   str = getenv ("SKIP_TEST_VGS");
14922   if (str && strcmp (str, "1") == 0) return 1;
14923   return 0;
14924 }
14925
14926 static int test_vgs_1 (void)
14927 {
14928   if (test_vgs_1_skip ()) {
14929     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14930     return 0;
14931   }
14932
14933   /* InitNone|InitEmpty for test_vgs_1 */
14934   {
14935     char device[] = "/dev/sda";
14936     int r;
14937     suppress_error = 0;
14938     r = guestfs_blockdev_setrw (g, device);
14939     if (r == -1)
14940       return -1;
14941   }
14942   {
14943     int r;
14944     suppress_error = 0;
14945     r = guestfs_umount_all (g);
14946     if (r == -1)
14947       return -1;
14948   }
14949   {
14950     int r;
14951     suppress_error = 0;
14952     r = guestfs_lvm_remove_all (g);
14953     if (r == -1)
14954       return -1;
14955   }
14956   /* TestOutputList for vgs (1) */
14957   {
14958     char device[] = "/dev/sda";
14959     char lines_0[] = ",10";
14960     char lines_1[] = ",20";
14961     char lines_2[] = ",";
14962     char *lines[] = {
14963       lines_0,
14964       lines_1,
14965       lines_2,
14966       NULL
14967     };
14968     int r;
14969     suppress_error = 0;
14970     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14971     if (r == -1)
14972       return -1;
14973   }
14974   {
14975     char device[] = "/dev/sda1";
14976     int r;
14977     suppress_error = 0;
14978     r = guestfs_pvcreate (g, device);
14979     if (r == -1)
14980       return -1;
14981   }
14982   {
14983     char device[] = "/dev/sda2";
14984     int r;
14985     suppress_error = 0;
14986     r = guestfs_pvcreate (g, device);
14987     if (r == -1)
14988       return -1;
14989   }
14990   {
14991     char device[] = "/dev/sda3";
14992     int r;
14993     suppress_error = 0;
14994     r = guestfs_pvcreate (g, device);
14995     if (r == -1)
14996       return -1;
14997   }
14998   {
14999     char volgroup[] = "VG1";
15000     char physvols_0[] = "/dev/sda1";
15001     char physvols_1[] = "/dev/sda2";
15002     char *physvols[] = {
15003       physvols_0,
15004       physvols_1,
15005       NULL
15006     };
15007     int r;
15008     suppress_error = 0;
15009     r = guestfs_vgcreate (g, volgroup, physvols);
15010     if (r == -1)
15011       return -1;
15012   }
15013   {
15014     char volgroup[] = "VG2";
15015     char physvols_0[] = "/dev/sda3";
15016     char *physvols[] = {
15017       physvols_0,
15018       NULL
15019     };
15020     int r;
15021     suppress_error = 0;
15022     r = guestfs_vgcreate (g, volgroup, physvols);
15023     if (r == -1)
15024       return -1;
15025   }
15026   {
15027     char **r;
15028     int i;
15029     suppress_error = 0;
15030     r = guestfs_vgs (g);
15031     if (r == NULL)
15032       return -1;
15033     if (!r[0]) {
15034       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15035       print_strings (r);
15036       return -1;
15037     }
15038     {
15039       char expected[] = "VG1";
15040       if (strcmp (r[0], expected) != 0) {
15041         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15042         return -1;
15043       }
15044     }
15045     if (!r[1]) {
15046       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15047       print_strings (r);
15048       return -1;
15049     }
15050     {
15051       char expected[] = "VG2";
15052       if (strcmp (r[1], expected) != 0) {
15053         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15054         return -1;
15055       }
15056     }
15057     if (r[2] != NULL) {
15058       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15059       print_strings (r);
15060       return -1;
15061     }
15062     for (i = 0; r[i] != NULL; ++i)
15063       free (r[i]);
15064     free (r);
15065   }
15066   return 0;
15067 }
15068
15069 static int test_pvs_0_skip (void)
15070 {
15071   const char *str;
15072
15073   str = getenv ("SKIP_TEST_PVS_0");
15074   if (str && strcmp (str, "1") == 0) return 1;
15075   str = getenv ("SKIP_TEST_PVS");
15076   if (str && strcmp (str, "1") == 0) return 1;
15077   return 0;
15078 }
15079
15080 static int test_pvs_0 (void)
15081 {
15082   if (test_pvs_0_skip ()) {
15083     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
15084     return 0;
15085   }
15086
15087   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
15088   {
15089     char device[] = "/dev/sda";
15090     int r;
15091     suppress_error = 0;
15092     r = guestfs_blockdev_setrw (g, device);
15093     if (r == -1)
15094       return -1;
15095   }
15096   {
15097     int r;
15098     suppress_error = 0;
15099     r = guestfs_umount_all (g);
15100     if (r == -1)
15101       return -1;
15102   }
15103   {
15104     int r;
15105     suppress_error = 0;
15106     r = guestfs_lvm_remove_all (g);
15107     if (r == -1)
15108       return -1;
15109   }
15110   {
15111     char device[] = "/dev/sda";
15112     char lines_0[] = ",";
15113     char *lines[] = {
15114       lines_0,
15115       NULL
15116     };
15117     int r;
15118     suppress_error = 0;
15119     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15120     if (r == -1)
15121       return -1;
15122   }
15123   {
15124     char device[] = "/dev/sda1";
15125     int r;
15126     suppress_error = 0;
15127     r = guestfs_pvcreate (g, device);
15128     if (r == -1)
15129       return -1;
15130   }
15131   {
15132     char volgroup[] = "VG";
15133     char physvols_0[] = "/dev/sda1";
15134     char *physvols[] = {
15135       physvols_0,
15136       NULL
15137     };
15138     int r;
15139     suppress_error = 0;
15140     r = guestfs_vgcreate (g, volgroup, physvols);
15141     if (r == -1)
15142       return -1;
15143   }
15144   {
15145     char logvol[] = "LV";
15146     char volgroup[] = "VG";
15147     int r;
15148     suppress_error = 0;
15149     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15150     if (r == -1)
15151       return -1;
15152   }
15153   {
15154     char fstype[] = "ext2";
15155     char device[] = "/dev/VG/LV";
15156     int r;
15157     suppress_error = 0;
15158     r = guestfs_mkfs (g, fstype, device);
15159     if (r == -1)
15160       return -1;
15161   }
15162   {
15163     char device[] = "/dev/VG/LV";
15164     char mountpoint[] = "/";
15165     int r;
15166     suppress_error = 0;
15167     r = guestfs_mount (g, device, mountpoint);
15168     if (r == -1)
15169       return -1;
15170   }
15171   /* TestOutputListOfDevices for pvs (0) */
15172   {
15173     char **r;
15174     int i;
15175     suppress_error = 0;
15176     r = guestfs_pvs (g);
15177     if (r == NULL)
15178       return -1;
15179     if (!r[0]) {
15180       fprintf (stderr, "test_pvs_0: short list returned from command\n");
15181       print_strings (r);
15182       return -1;
15183     }
15184     {
15185       char expected[] = "/dev/sda1";
15186       r[0][5] = 's';
15187       if (strcmp (r[0], expected) != 0) {
15188         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15189         return -1;
15190       }
15191     }
15192     if (r[1] != NULL) {
15193       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15194       print_strings (r);
15195       return -1;
15196     }
15197     for (i = 0; r[i] != NULL; ++i)
15198       free (r[i]);
15199     free (r);
15200   }
15201   return 0;
15202 }
15203
15204 static int test_pvs_1_skip (void)
15205 {
15206   const char *str;
15207
15208   str = getenv ("SKIP_TEST_PVS_1");
15209   if (str && strcmp (str, "1") == 0) return 1;
15210   str = getenv ("SKIP_TEST_PVS");
15211   if (str && strcmp (str, "1") == 0) return 1;
15212   return 0;
15213 }
15214
15215 static int test_pvs_1 (void)
15216 {
15217   if (test_pvs_1_skip ()) {
15218     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15219     return 0;
15220   }
15221
15222   /* InitNone|InitEmpty for test_pvs_1 */
15223   {
15224     char device[] = "/dev/sda";
15225     int r;
15226     suppress_error = 0;
15227     r = guestfs_blockdev_setrw (g, device);
15228     if (r == -1)
15229       return -1;
15230   }
15231   {
15232     int r;
15233     suppress_error = 0;
15234     r = guestfs_umount_all (g);
15235     if (r == -1)
15236       return -1;
15237   }
15238   {
15239     int r;
15240     suppress_error = 0;
15241     r = guestfs_lvm_remove_all (g);
15242     if (r == -1)
15243       return -1;
15244   }
15245   /* TestOutputListOfDevices for pvs (1) */
15246   {
15247     char device[] = "/dev/sda";
15248     char lines_0[] = ",10";
15249     char lines_1[] = ",20";
15250     char lines_2[] = ",";
15251     char *lines[] = {
15252       lines_0,
15253       lines_1,
15254       lines_2,
15255       NULL
15256     };
15257     int r;
15258     suppress_error = 0;
15259     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15260     if (r == -1)
15261       return -1;
15262   }
15263   {
15264     char device[] = "/dev/sda1";
15265     int r;
15266     suppress_error = 0;
15267     r = guestfs_pvcreate (g, device);
15268     if (r == -1)
15269       return -1;
15270   }
15271   {
15272     char device[] = "/dev/sda2";
15273     int r;
15274     suppress_error = 0;
15275     r = guestfs_pvcreate (g, device);
15276     if (r == -1)
15277       return -1;
15278   }
15279   {
15280     char device[] = "/dev/sda3";
15281     int r;
15282     suppress_error = 0;
15283     r = guestfs_pvcreate (g, device);
15284     if (r == -1)
15285       return -1;
15286   }
15287   {
15288     char **r;
15289     int i;
15290     suppress_error = 0;
15291     r = guestfs_pvs (g);
15292     if (r == NULL)
15293       return -1;
15294     if (!r[0]) {
15295       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15296       print_strings (r);
15297       return -1;
15298     }
15299     {
15300       char expected[] = "/dev/sda1";
15301       r[0][5] = 's';
15302       if (strcmp (r[0], expected) != 0) {
15303         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15304         return -1;
15305       }
15306     }
15307     if (!r[1]) {
15308       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15309       print_strings (r);
15310       return -1;
15311     }
15312     {
15313       char expected[] = "/dev/sda2";
15314       r[1][5] = 's';
15315       if (strcmp (r[1], expected) != 0) {
15316         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15317         return -1;
15318       }
15319     }
15320     if (!r[2]) {
15321       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15322       print_strings (r);
15323       return -1;
15324     }
15325     {
15326       char expected[] = "/dev/sda3";
15327       r[2][5] = 's';
15328       if (strcmp (r[2], expected) != 0) {
15329         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15330         return -1;
15331       }
15332     }
15333     if (r[3] != NULL) {
15334       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15335       print_strings (r);
15336       return -1;
15337     }
15338     for (i = 0; r[i] != NULL; ++i)
15339       free (r[i]);
15340     free (r);
15341   }
15342   return 0;
15343 }
15344
15345 static int test_list_partitions_0_skip (void)
15346 {
15347   const char *str;
15348
15349   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15350   if (str && strcmp (str, "1") == 0) return 1;
15351   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15352   if (str && strcmp (str, "1") == 0) return 1;
15353   return 0;
15354 }
15355
15356 static int test_list_partitions_0 (void)
15357 {
15358   if (test_list_partitions_0_skip ()) {
15359     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15360     return 0;
15361   }
15362
15363   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15364   {
15365     char device[] = "/dev/sda";
15366     int r;
15367     suppress_error = 0;
15368     r = guestfs_blockdev_setrw (g, device);
15369     if (r == -1)
15370       return -1;
15371   }
15372   {
15373     int r;
15374     suppress_error = 0;
15375     r = guestfs_umount_all (g);
15376     if (r == -1)
15377       return -1;
15378   }
15379   {
15380     int r;
15381     suppress_error = 0;
15382     r = guestfs_lvm_remove_all (g);
15383     if (r == -1)
15384       return -1;
15385   }
15386   {
15387     char device[] = "/dev/sda";
15388     char lines_0[] = ",";
15389     char *lines[] = {
15390       lines_0,
15391       NULL
15392     };
15393     int r;
15394     suppress_error = 0;
15395     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15396     if (r == -1)
15397       return -1;
15398   }
15399   {
15400     char fstype[] = "ext2";
15401     char device[] = "/dev/sda1";
15402     int r;
15403     suppress_error = 0;
15404     r = guestfs_mkfs (g, fstype, device);
15405     if (r == -1)
15406       return -1;
15407   }
15408   {
15409     char device[] = "/dev/sda1";
15410     char mountpoint[] = "/";
15411     int r;
15412     suppress_error = 0;
15413     r = guestfs_mount (g, device, mountpoint);
15414     if (r == -1)
15415       return -1;
15416   }
15417   /* TestOutputListOfDevices for list_partitions (0) */
15418   {
15419     char **r;
15420     int i;
15421     suppress_error = 0;
15422     r = guestfs_list_partitions (g);
15423     if (r == NULL)
15424       return -1;
15425     if (!r[0]) {
15426       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15427       print_strings (r);
15428       return -1;
15429     }
15430     {
15431       char expected[] = "/dev/sda1";
15432       r[0][5] = 's';
15433       if (strcmp (r[0], expected) != 0) {
15434         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15435         return -1;
15436       }
15437     }
15438     if (r[1] != NULL) {
15439       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15440       print_strings (r);
15441       return -1;
15442     }
15443     for (i = 0; r[i] != NULL; ++i)
15444       free (r[i]);
15445     free (r);
15446   }
15447   return 0;
15448 }
15449
15450 static int test_list_partitions_1_skip (void)
15451 {
15452   const char *str;
15453
15454   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15455   if (str && strcmp (str, "1") == 0) return 1;
15456   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15457   if (str && strcmp (str, "1") == 0) return 1;
15458   return 0;
15459 }
15460
15461 static int test_list_partitions_1 (void)
15462 {
15463   if (test_list_partitions_1_skip ()) {
15464     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15465     return 0;
15466   }
15467
15468   /* InitNone|InitEmpty for test_list_partitions_1 */
15469   {
15470     char device[] = "/dev/sda";
15471     int r;
15472     suppress_error = 0;
15473     r = guestfs_blockdev_setrw (g, device);
15474     if (r == -1)
15475       return -1;
15476   }
15477   {
15478     int r;
15479     suppress_error = 0;
15480     r = guestfs_umount_all (g);
15481     if (r == -1)
15482       return -1;
15483   }
15484   {
15485     int r;
15486     suppress_error = 0;
15487     r = guestfs_lvm_remove_all (g);
15488     if (r == -1)
15489       return -1;
15490   }
15491   /* TestOutputListOfDevices for list_partitions (1) */
15492   {
15493     char device[] = "/dev/sda";
15494     char lines_0[] = ",10";
15495     char lines_1[] = ",20";
15496     char lines_2[] = ",";
15497     char *lines[] = {
15498       lines_0,
15499       lines_1,
15500       lines_2,
15501       NULL
15502     };
15503     int r;
15504     suppress_error = 0;
15505     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15506     if (r == -1)
15507       return -1;
15508   }
15509   {
15510     char **r;
15511     int i;
15512     suppress_error = 0;
15513     r = guestfs_list_partitions (g);
15514     if (r == NULL)
15515       return -1;
15516     if (!r[0]) {
15517       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15518       print_strings (r);
15519       return -1;
15520     }
15521     {
15522       char expected[] = "/dev/sda1";
15523       r[0][5] = 's';
15524       if (strcmp (r[0], expected) != 0) {
15525         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15526         return -1;
15527       }
15528     }
15529     if (!r[1]) {
15530       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15531       print_strings (r);
15532       return -1;
15533     }
15534     {
15535       char expected[] = "/dev/sda2";
15536       r[1][5] = 's';
15537       if (strcmp (r[1], expected) != 0) {
15538         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15539         return -1;
15540       }
15541     }
15542     if (!r[2]) {
15543       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15544       print_strings (r);
15545       return -1;
15546     }
15547     {
15548       char expected[] = "/dev/sda3";
15549       r[2][5] = 's';
15550       if (strcmp (r[2], expected) != 0) {
15551         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15552         return -1;
15553       }
15554     }
15555     if (r[3] != NULL) {
15556       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15557       print_strings (r);
15558       return -1;
15559     }
15560     for (i = 0; r[i] != NULL; ++i)
15561       free (r[i]);
15562     free (r);
15563   }
15564   return 0;
15565 }
15566
15567 static int test_list_devices_0_skip (void)
15568 {
15569   const char *str;
15570
15571   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15572   if (str && strcmp (str, "1") == 0) return 1;
15573   str = getenv ("SKIP_TEST_LIST_DEVICES");
15574   if (str && strcmp (str, "1") == 0) return 1;
15575   return 0;
15576 }
15577
15578 static int test_list_devices_0 (void)
15579 {
15580   if (test_list_devices_0_skip ()) {
15581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15582     return 0;
15583   }
15584
15585   /* InitNone|InitEmpty for test_list_devices_0 */
15586   {
15587     char device[] = "/dev/sda";
15588     int r;
15589     suppress_error = 0;
15590     r = guestfs_blockdev_setrw (g, device);
15591     if (r == -1)
15592       return -1;
15593   }
15594   {
15595     int r;
15596     suppress_error = 0;
15597     r = guestfs_umount_all (g);
15598     if (r == -1)
15599       return -1;
15600   }
15601   {
15602     int r;
15603     suppress_error = 0;
15604     r = guestfs_lvm_remove_all (g);
15605     if (r == -1)
15606       return -1;
15607   }
15608   /* TestOutputListOfDevices for list_devices (0) */
15609   {
15610     char **r;
15611     int i;
15612     suppress_error = 0;
15613     r = guestfs_list_devices (g);
15614     if (r == NULL)
15615       return -1;
15616     if (!r[0]) {
15617       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15618       print_strings (r);
15619       return -1;
15620     }
15621     {
15622       char expected[] = "/dev/sda";
15623       r[0][5] = 's';
15624       if (strcmp (r[0], expected) != 0) {
15625         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15626         return -1;
15627       }
15628     }
15629     if (!r[1]) {
15630       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15631       print_strings (r);
15632       return -1;
15633     }
15634     {
15635       char expected[] = "/dev/sdb";
15636       r[1][5] = 's';
15637       if (strcmp (r[1], expected) != 0) {
15638         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15639         return -1;
15640       }
15641     }
15642     if (!r[2]) {
15643       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15644       print_strings (r);
15645       return -1;
15646     }
15647     {
15648       char expected[] = "/dev/sdc";
15649       r[2][5] = 's';
15650       if (strcmp (r[2], expected) != 0) {
15651         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15652         return -1;
15653       }
15654     }
15655     if (!r[3]) {
15656       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15657       print_strings (r);
15658       return -1;
15659     }
15660     {
15661       char expected[] = "/dev/sdd";
15662       r[3][5] = 's';
15663       if (strcmp (r[3], expected) != 0) {
15664         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15665         return -1;
15666       }
15667     }
15668     if (r[4] != NULL) {
15669       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15670       print_strings (r);
15671       return -1;
15672     }
15673     for (i = 0; r[i] != NULL; ++i)
15674       free (r[i]);
15675     free (r);
15676   }
15677   return 0;
15678 }
15679
15680 static int test_ls_0_skip (void)
15681 {
15682   const char *str;
15683
15684   str = getenv ("SKIP_TEST_LS_0");
15685   if (str && strcmp (str, "1") == 0) return 1;
15686   str = getenv ("SKIP_TEST_LS");
15687   if (str && strcmp (str, "1") == 0) return 1;
15688   return 0;
15689 }
15690
15691 static int test_ls_0 (void)
15692 {
15693   if (test_ls_0_skip ()) {
15694     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15695     return 0;
15696   }
15697
15698   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15699   {
15700     char device[] = "/dev/sda";
15701     int r;
15702     suppress_error = 0;
15703     r = guestfs_blockdev_setrw (g, device);
15704     if (r == -1)
15705       return -1;
15706   }
15707   {
15708     int r;
15709     suppress_error = 0;
15710     r = guestfs_umount_all (g);
15711     if (r == -1)
15712       return -1;
15713   }
15714   {
15715     int r;
15716     suppress_error = 0;
15717     r = guestfs_lvm_remove_all (g);
15718     if (r == -1)
15719       return -1;
15720   }
15721   {
15722     char device[] = "/dev/sda";
15723     char lines_0[] = ",";
15724     char *lines[] = {
15725       lines_0,
15726       NULL
15727     };
15728     int r;
15729     suppress_error = 0;
15730     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15731     if (r == -1)
15732       return -1;
15733   }
15734   {
15735     char fstype[] = "ext2";
15736     char device[] = "/dev/sda1";
15737     int r;
15738     suppress_error = 0;
15739     r = guestfs_mkfs (g, fstype, device);
15740     if (r == -1)
15741       return -1;
15742   }
15743   {
15744     char device[] = "/dev/sda1";
15745     char mountpoint[] = "/";
15746     int r;
15747     suppress_error = 0;
15748     r = guestfs_mount (g, device, mountpoint);
15749     if (r == -1)
15750       return -1;
15751   }
15752   /* TestOutputList for ls (0) */
15753   {
15754     char path[] = "/new";
15755     int r;
15756     suppress_error = 0;
15757     r = guestfs_touch (g, path);
15758     if (r == -1)
15759       return -1;
15760   }
15761   {
15762     char path[] = "/newer";
15763     int r;
15764     suppress_error = 0;
15765     r = guestfs_touch (g, path);
15766     if (r == -1)
15767       return -1;
15768   }
15769   {
15770     char path[] = "/newest";
15771     int r;
15772     suppress_error = 0;
15773     r = guestfs_touch (g, path);
15774     if (r == -1)
15775       return -1;
15776   }
15777   {
15778     char directory[] = "/";
15779     char **r;
15780     int i;
15781     suppress_error = 0;
15782     r = guestfs_ls (g, directory);
15783     if (r == NULL)
15784       return -1;
15785     if (!r[0]) {
15786       fprintf (stderr, "test_ls_0: short list returned from command\n");
15787       print_strings (r);
15788       return -1;
15789     }
15790     {
15791       char expected[] = "lost+found";
15792       if (strcmp (r[0], expected) != 0) {
15793         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15794         return -1;
15795       }
15796     }
15797     if (!r[1]) {
15798       fprintf (stderr, "test_ls_0: short list returned from command\n");
15799       print_strings (r);
15800       return -1;
15801     }
15802     {
15803       char expected[] = "new";
15804       if (strcmp (r[1], expected) != 0) {
15805         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15806         return -1;
15807       }
15808     }
15809     if (!r[2]) {
15810       fprintf (stderr, "test_ls_0: short list returned from command\n");
15811       print_strings (r);
15812       return -1;
15813     }
15814     {
15815       char expected[] = "newer";
15816       if (strcmp (r[2], expected) != 0) {
15817         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15818         return -1;
15819       }
15820     }
15821     if (!r[3]) {
15822       fprintf (stderr, "test_ls_0: short list returned from command\n");
15823       print_strings (r);
15824       return -1;
15825     }
15826     {
15827       char expected[] = "newest";
15828       if (strcmp (r[3], expected) != 0) {
15829         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15830         return -1;
15831       }
15832     }
15833     if (r[4] != NULL) {
15834       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15835       print_strings (r);
15836       return -1;
15837     }
15838     for (i = 0; r[i] != NULL; ++i)
15839       free (r[i]);
15840     free (r);
15841   }
15842   return 0;
15843 }
15844
15845 static int test_cat_0_skip (void)
15846 {
15847   const char *str;
15848
15849   str = getenv ("SKIP_TEST_CAT_0");
15850   if (str && strcmp (str, "1") == 0) return 1;
15851   str = getenv ("SKIP_TEST_CAT");
15852   if (str && strcmp (str, "1") == 0) return 1;
15853   return 0;
15854 }
15855
15856 static int test_cat_0 (void)
15857 {
15858   if (test_cat_0_skip ()) {
15859     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15860     return 0;
15861   }
15862
15863   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15864   {
15865     char device[] = "/dev/sda";
15866     int r;
15867     suppress_error = 0;
15868     r = guestfs_blockdev_setrw (g, device);
15869     if (r == -1)
15870       return -1;
15871   }
15872   {
15873     int r;
15874     suppress_error = 0;
15875     r = guestfs_umount_all (g);
15876     if (r == -1)
15877       return -1;
15878   }
15879   {
15880     int r;
15881     suppress_error = 0;
15882     r = guestfs_lvm_remove_all (g);
15883     if (r == -1)
15884       return -1;
15885   }
15886   {
15887     char device[] = "/dev/sda";
15888     char lines_0[] = ",";
15889     char *lines[] = {
15890       lines_0,
15891       NULL
15892     };
15893     int r;
15894     suppress_error = 0;
15895     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15896     if (r == -1)
15897       return -1;
15898   }
15899   {
15900     char fstype[] = "ext2";
15901     char device[] = "/dev/sda1";
15902     int r;
15903     suppress_error = 0;
15904     r = guestfs_mkfs (g, fstype, device);
15905     if (r == -1)
15906       return -1;
15907   }
15908   {
15909     char device[] = "/dev/sda1";
15910     char mountpoint[] = "/";
15911     int r;
15912     suppress_error = 0;
15913     r = guestfs_mount (g, device, mountpoint);
15914     if (r == -1)
15915       return -1;
15916   }
15917   /* TestOutput for cat (0) */
15918   char expected[] = "new file contents";
15919   {
15920     char path[] = "/new";
15921     char content[] = "new file contents";
15922     int r;
15923     suppress_error = 0;
15924     r = guestfs_write_file (g, path, content, 0);
15925     if (r == -1)
15926       return -1;
15927   }
15928   {
15929     char path[] = "/new";
15930     char *r;
15931     suppress_error = 0;
15932     r = guestfs_cat (g, path);
15933     if (r == NULL)
15934       return -1;
15935     if (strcmp (r, expected) != 0) {
15936       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15937       return -1;
15938     }
15939     free (r);
15940   }
15941   return 0;
15942 }
15943
15944 static int test_touch_0_skip (void)
15945 {
15946   const char *str;
15947
15948   str = getenv ("SKIP_TEST_TOUCH_0");
15949   if (str && strcmp (str, "1") == 0) return 1;
15950   str = getenv ("SKIP_TEST_TOUCH");
15951   if (str && strcmp (str, "1") == 0) return 1;
15952   return 0;
15953 }
15954
15955 static int test_touch_0 (void)
15956 {
15957   if (test_touch_0_skip ()) {
15958     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15959     return 0;
15960   }
15961
15962   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15963   {
15964     char device[] = "/dev/sda";
15965     int r;
15966     suppress_error = 0;
15967     r = guestfs_blockdev_setrw (g, device);
15968     if (r == -1)
15969       return -1;
15970   }
15971   {
15972     int r;
15973     suppress_error = 0;
15974     r = guestfs_umount_all (g);
15975     if (r == -1)
15976       return -1;
15977   }
15978   {
15979     int r;
15980     suppress_error = 0;
15981     r = guestfs_lvm_remove_all (g);
15982     if (r == -1)
15983       return -1;
15984   }
15985   {
15986     char device[] = "/dev/sda";
15987     char lines_0[] = ",";
15988     char *lines[] = {
15989       lines_0,
15990       NULL
15991     };
15992     int r;
15993     suppress_error = 0;
15994     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15995     if (r == -1)
15996       return -1;
15997   }
15998   {
15999     char fstype[] = "ext2";
16000     char device[] = "/dev/sda1";
16001     int r;
16002     suppress_error = 0;
16003     r = guestfs_mkfs (g, fstype, device);
16004     if (r == -1)
16005       return -1;
16006   }
16007   {
16008     char device[] = "/dev/sda1";
16009     char mountpoint[] = "/";
16010     int r;
16011     suppress_error = 0;
16012     r = guestfs_mount (g, device, mountpoint);
16013     if (r == -1)
16014       return -1;
16015   }
16016   /* TestOutputTrue for touch (0) */
16017   {
16018     char path[] = "/new";
16019     int r;
16020     suppress_error = 0;
16021     r = guestfs_touch (g, path);
16022     if (r == -1)
16023       return -1;
16024   }
16025   {
16026     char path[] = "/new";
16027     int r;
16028     suppress_error = 0;
16029     r = guestfs_exists (g, path);
16030     if (r == -1)
16031       return -1;
16032     if (!r) {
16033       fprintf (stderr, "test_touch_0: expected true, got false\n");
16034       return -1;
16035     }
16036   }
16037   return 0;
16038 }
16039
16040 static int test_sync_0_skip (void)
16041 {
16042   const char *str;
16043
16044   str = getenv ("SKIP_TEST_SYNC_0");
16045   if (str && strcmp (str, "1") == 0) return 1;
16046   str = getenv ("SKIP_TEST_SYNC");
16047   if (str && strcmp (str, "1") == 0) return 1;
16048   return 0;
16049 }
16050
16051 static int test_sync_0 (void)
16052 {
16053   if (test_sync_0_skip ()) {
16054     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
16055     return 0;
16056   }
16057
16058   /* InitNone|InitEmpty for test_sync_0 */
16059   {
16060     char device[] = "/dev/sda";
16061     int r;
16062     suppress_error = 0;
16063     r = guestfs_blockdev_setrw (g, device);
16064     if (r == -1)
16065       return -1;
16066   }
16067   {
16068     int r;
16069     suppress_error = 0;
16070     r = guestfs_umount_all (g);
16071     if (r == -1)
16072       return -1;
16073   }
16074   {
16075     int r;
16076     suppress_error = 0;
16077     r = guestfs_lvm_remove_all (g);
16078     if (r == -1)
16079       return -1;
16080   }
16081   /* TestRun for sync (0) */
16082   {
16083     int r;
16084     suppress_error = 0;
16085     r = guestfs_sync (g);
16086     if (r == -1)
16087       return -1;
16088   }
16089   return 0;
16090 }
16091
16092 static int test_mount_0_skip (void)
16093 {
16094   const char *str;
16095
16096   str = getenv ("SKIP_TEST_MOUNT_0");
16097   if (str && strcmp (str, "1") == 0) return 1;
16098   str = getenv ("SKIP_TEST_MOUNT");
16099   if (str && strcmp (str, "1") == 0) return 1;
16100   return 0;
16101 }
16102
16103 static int test_mount_0 (void)
16104 {
16105   if (test_mount_0_skip ()) {
16106     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
16107     return 0;
16108   }
16109
16110   /* InitNone|InitEmpty for test_mount_0 */
16111   {
16112     char device[] = "/dev/sda";
16113     int r;
16114     suppress_error = 0;
16115     r = guestfs_blockdev_setrw (g, device);
16116     if (r == -1)
16117       return -1;
16118   }
16119   {
16120     int r;
16121     suppress_error = 0;
16122     r = guestfs_umount_all (g);
16123     if (r == -1)
16124       return -1;
16125   }
16126   {
16127     int r;
16128     suppress_error = 0;
16129     r = guestfs_lvm_remove_all (g);
16130     if (r == -1)
16131       return -1;
16132   }
16133   /* TestOutput for mount (0) */
16134   char expected[] = "new file contents";
16135   {
16136     char device[] = "/dev/sda";
16137     char lines_0[] = ",";
16138     char *lines[] = {
16139       lines_0,
16140       NULL
16141     };
16142     int r;
16143     suppress_error = 0;
16144     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16145     if (r == -1)
16146       return -1;
16147   }
16148   {
16149     char fstype[] = "ext2";
16150     char device[] = "/dev/sda1";
16151     int r;
16152     suppress_error = 0;
16153     r = guestfs_mkfs (g, fstype, device);
16154     if (r == -1)
16155       return -1;
16156   }
16157   {
16158     char device[] = "/dev/sda1";
16159     char mountpoint[] = "/";
16160     int r;
16161     suppress_error = 0;
16162     r = guestfs_mount (g, device, mountpoint);
16163     if (r == -1)
16164       return -1;
16165   }
16166   {
16167     char path[] = "/new";
16168     char content[] = "new file contents";
16169     int r;
16170     suppress_error = 0;
16171     r = guestfs_write_file (g, path, content, 0);
16172     if (r == -1)
16173       return -1;
16174   }
16175   {
16176     char path[] = "/new";
16177     char *r;
16178     suppress_error = 0;
16179     r = guestfs_cat (g, path);
16180     if (r == NULL)
16181       return -1;
16182     if (strcmp (r, expected) != 0) {
16183       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16184       return -1;
16185     }
16186     free (r);
16187   }
16188   return 0;
16189 }
16190
16191 int main (int argc, char *argv[])
16192 {
16193   char c = 0;
16194   int failed = 0;
16195   const char *filename;
16196   int fd;
16197   int nr_tests, test_num = 0;
16198
16199   no_test_warnings ();
16200
16201   g = guestfs_create ();
16202   if (g == NULL) {
16203     printf ("guestfs_create FAILED\n");
16204     exit (1);
16205   }
16206
16207   guestfs_set_error_handler (g, print_error, NULL);
16208
16209   guestfs_set_path (g, "../appliance");
16210
16211   filename = "test1.img";
16212   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16213   if (fd == -1) {
16214     perror (filename);
16215     exit (1);
16216   }
16217   if (lseek (fd, 524288000, SEEK_SET) == -1) {
16218     perror ("lseek");
16219     close (fd);
16220     unlink (filename);
16221     exit (1);
16222   }
16223   if (write (fd, &c, 1) == -1) {
16224     perror ("write");
16225     close (fd);
16226     unlink (filename);
16227     exit (1);
16228   }
16229   if (close (fd) == -1) {
16230     perror (filename);
16231     unlink (filename);
16232     exit (1);
16233   }
16234   if (guestfs_add_drive (g, filename) == -1) {
16235     printf ("guestfs_add_drive %s FAILED\n", filename);
16236     exit (1);
16237   }
16238
16239   filename = "test2.img";
16240   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16241   if (fd == -1) {
16242     perror (filename);
16243     exit (1);
16244   }
16245   if (lseek (fd, 52428800, SEEK_SET) == -1) {
16246     perror ("lseek");
16247     close (fd);
16248     unlink (filename);
16249     exit (1);
16250   }
16251   if (write (fd, &c, 1) == -1) {
16252     perror ("write");
16253     close (fd);
16254     unlink (filename);
16255     exit (1);
16256   }
16257   if (close (fd) == -1) {
16258     perror (filename);
16259     unlink (filename);
16260     exit (1);
16261   }
16262   if (guestfs_add_drive (g, filename) == -1) {
16263     printf ("guestfs_add_drive %s FAILED\n", filename);
16264     exit (1);
16265   }
16266
16267   filename = "test3.img";
16268   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16269   if (fd == -1) {
16270     perror (filename);
16271     exit (1);
16272   }
16273   if (lseek (fd, 10485760, SEEK_SET) == -1) {
16274     perror ("lseek");
16275     close (fd);
16276     unlink (filename);
16277     exit (1);
16278   }
16279   if (write (fd, &c, 1) == -1) {
16280     perror ("write");
16281     close (fd);
16282     unlink (filename);
16283     exit (1);
16284   }
16285   if (close (fd) == -1) {
16286     perror (filename);
16287     unlink (filename);
16288     exit (1);
16289   }
16290   if (guestfs_add_drive (g, filename) == -1) {
16291     printf ("guestfs_add_drive %s FAILED\n", filename);
16292     exit (1);
16293   }
16294
16295   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16296     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16297     exit (1);
16298   }
16299
16300   if (guestfs_launch (g) == -1) {
16301     printf ("guestfs_launch FAILED\n");
16302     exit (1);
16303   }
16304
16305   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
16306   alarm (600);
16307
16308   if (guestfs_wait_ready (g) == -1) {
16309     printf ("guestfs_wait_ready FAILED\n");
16310     exit (1);
16311   }
16312
16313   /* Cancel previous alarm. */
16314   alarm (0);
16315
16316   nr_tests = 151;
16317
16318   test_num++;
16319   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
16320   if (test_scrub_file_0 () == -1) {
16321     printf ("test_scrub_file_0 FAILED\n");
16322     failed++;
16323   }
16324   test_num++;
16325   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
16326   if (test_scrub_device_0 () == -1) {
16327     printf ("test_scrub_device_0 FAILED\n");
16328     failed++;
16329   }
16330   test_num++;
16331   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
16332   if (test_glob_expand_0 () == -1) {
16333     printf ("test_glob_expand_0 FAILED\n");
16334     failed++;
16335   }
16336   test_num++;
16337   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
16338   if (test_glob_expand_1 () == -1) {
16339     printf ("test_glob_expand_1 FAILED\n");
16340     failed++;
16341   }
16342   test_num++;
16343   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
16344   if (test_glob_expand_2 () == -1) {
16345     printf ("test_glob_expand_2 FAILED\n");
16346     failed++;
16347   }
16348   test_num++;
16349   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
16350   if (test_ntfs_3g_probe_0 () == -1) {
16351     printf ("test_ntfs_3g_probe_0 FAILED\n");
16352     failed++;
16353   }
16354   test_num++;
16355   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
16356   if (test_ntfs_3g_probe_1 () == -1) {
16357     printf ("test_ntfs_3g_probe_1 FAILED\n");
16358     failed++;
16359   }
16360   test_num++;
16361   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16362   if (test_sleep_0 () == -1) {
16363     printf ("test_sleep_0 FAILED\n");
16364     failed++;
16365   }
16366   test_num++;
16367   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16368   if (test_find_0 () == -1) {
16369     printf ("test_find_0 FAILED\n");
16370     failed++;
16371   }
16372   test_num++;
16373   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16374   if (test_find_1 () == -1) {
16375     printf ("test_find_1 FAILED\n");
16376     failed++;
16377   }
16378   test_num++;
16379   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16380   if (test_find_2 () == -1) {
16381     printf ("test_find_2 FAILED\n");
16382     failed++;
16383   }
16384   test_num++;
16385   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16386   if (test_lvresize_0 () == -1) {
16387     printf ("test_lvresize_0 FAILED\n");
16388     failed++;
16389   }
16390   test_num++;
16391   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16392   if (test_zerofree_0 () == -1) {
16393     printf ("test_zerofree_0 FAILED\n");
16394     failed++;
16395   }
16396   test_num++;
16397   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16398   if (test_hexdump_0 () == -1) {
16399     printf ("test_hexdump_0 FAILED\n");
16400     failed++;
16401   }
16402   test_num++;
16403   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16404   if (test_strings_e_0 () == -1) {
16405     printf ("test_strings_e_0 FAILED\n");
16406     failed++;
16407   }
16408   test_num++;
16409   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16410   if (test_strings_e_1 () == -1) {
16411     printf ("test_strings_e_1 FAILED\n");
16412     failed++;
16413   }
16414   test_num++;
16415   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16416   if (test_strings_0 () == -1) {
16417     printf ("test_strings_0 FAILED\n");
16418     failed++;
16419   }
16420   test_num++;
16421   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16422   if (test_strings_1 () == -1) {
16423     printf ("test_strings_1 FAILED\n");
16424     failed++;
16425   }
16426   test_num++;
16427   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16428   if (test_equal_0 () == -1) {
16429     printf ("test_equal_0 FAILED\n");
16430     failed++;
16431   }
16432   test_num++;
16433   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16434   if (test_equal_1 () == -1) {
16435     printf ("test_equal_1 FAILED\n");
16436     failed++;
16437   }
16438   test_num++;
16439   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16440   if (test_equal_2 () == -1) {
16441     printf ("test_equal_2 FAILED\n");
16442     failed++;
16443   }
16444   test_num++;
16445   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16446   if (test_ping_daemon_0 () == -1) {
16447     printf ("test_ping_daemon_0 FAILED\n");
16448     failed++;
16449   }
16450   test_num++;
16451   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16452   if (test_dmesg_0 () == -1) {
16453     printf ("test_dmesg_0 FAILED\n");
16454     failed++;
16455   }
16456   test_num++;
16457   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16458   if (test_drop_caches_0 () == -1) {
16459     printf ("test_drop_caches_0 FAILED\n");
16460     failed++;
16461   }
16462   test_num++;
16463   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16464   if (test_mv_0 () == -1) {
16465     printf ("test_mv_0 FAILED\n");
16466     failed++;
16467   }
16468   test_num++;
16469   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16470   if (test_mv_1 () == -1) {
16471     printf ("test_mv_1 FAILED\n");
16472     failed++;
16473   }
16474   test_num++;
16475   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16476   if (test_cp_a_0 () == -1) {
16477     printf ("test_cp_a_0 FAILED\n");
16478     failed++;
16479   }
16480   test_num++;
16481   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16482   if (test_cp_0 () == -1) {
16483     printf ("test_cp_0 FAILED\n");
16484     failed++;
16485   }
16486   test_num++;
16487   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16488   if (test_cp_1 () == -1) {
16489     printf ("test_cp_1 FAILED\n");
16490     failed++;
16491   }
16492   test_num++;
16493   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16494   if (test_cp_2 () == -1) {
16495     printf ("test_cp_2 FAILED\n");
16496     failed++;
16497   }
16498   test_num++;
16499   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16500   if (test_grub_install_0 () == -1) {
16501     printf ("test_grub_install_0 FAILED\n");
16502     failed++;
16503   }
16504   test_num++;
16505   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16506   if (test_zero_0 () == -1) {
16507     printf ("test_zero_0 FAILED\n");
16508     failed++;
16509   }
16510   test_num++;
16511   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16512   if (test_fsck_0 () == -1) {
16513     printf ("test_fsck_0 FAILED\n");
16514     failed++;
16515   }
16516   test_num++;
16517   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16518   if (test_fsck_1 () == -1) {
16519     printf ("test_fsck_1 FAILED\n");
16520     failed++;
16521   }
16522   test_num++;
16523   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16524   if (test_set_e2uuid_0 () == -1) {
16525     printf ("test_set_e2uuid_0 FAILED\n");
16526     failed++;
16527   }
16528   test_num++;
16529   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16530   if (test_set_e2uuid_1 () == -1) {
16531     printf ("test_set_e2uuid_1 FAILED\n");
16532     failed++;
16533   }
16534   test_num++;
16535   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16536   if (test_set_e2uuid_2 () == -1) {
16537     printf ("test_set_e2uuid_2 FAILED\n");
16538     failed++;
16539   }
16540   test_num++;
16541   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16542   if (test_set_e2uuid_3 () == -1) {
16543     printf ("test_set_e2uuid_3 FAILED\n");
16544     failed++;
16545   }
16546   test_num++;
16547   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16548   if (test_set_e2label_0 () == -1) {
16549     printf ("test_set_e2label_0 FAILED\n");
16550     failed++;
16551   }
16552   test_num++;
16553   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16554   if (test_pvremove_0 () == -1) {
16555     printf ("test_pvremove_0 FAILED\n");
16556     failed++;
16557   }
16558   test_num++;
16559   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16560   if (test_pvremove_1 () == -1) {
16561     printf ("test_pvremove_1 FAILED\n");
16562     failed++;
16563   }
16564   test_num++;
16565   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16566   if (test_pvremove_2 () == -1) {
16567     printf ("test_pvremove_2 FAILED\n");
16568     failed++;
16569   }
16570   test_num++;
16571   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16572   if (test_vgremove_0 () == -1) {
16573     printf ("test_vgremove_0 FAILED\n");
16574     failed++;
16575   }
16576   test_num++;
16577   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16578   if (test_vgremove_1 () == -1) {
16579     printf ("test_vgremove_1 FAILED\n");
16580     failed++;
16581   }
16582   test_num++;
16583   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16584   if (test_lvremove_0 () == -1) {
16585     printf ("test_lvremove_0 FAILED\n");
16586     failed++;
16587   }
16588   test_num++;
16589   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16590   if (test_lvremove_1 () == -1) {
16591     printf ("test_lvremove_1 FAILED\n");
16592     failed++;
16593   }
16594   test_num++;
16595   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16596   if (test_lvremove_2 () == -1) {
16597     printf ("test_lvremove_2 FAILED\n");
16598     failed++;
16599   }
16600   test_num++;
16601   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16602   if (test_mount_ro_0 () == -1) {
16603     printf ("test_mount_ro_0 FAILED\n");
16604     failed++;
16605   }
16606   test_num++;
16607   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16608   if (test_mount_ro_1 () == -1) {
16609     printf ("test_mount_ro_1 FAILED\n");
16610     failed++;
16611   }
16612   test_num++;
16613   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16614   if (test_tgz_in_0 () == -1) {
16615     printf ("test_tgz_in_0 FAILED\n");
16616     failed++;
16617   }
16618   test_num++;
16619   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16620   if (test_tar_in_0 () == -1) {
16621     printf ("test_tar_in_0 FAILED\n");
16622     failed++;
16623   }
16624   test_num++;
16625   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16626   if (test_checksum_0 () == -1) {
16627     printf ("test_checksum_0 FAILED\n");
16628     failed++;
16629   }
16630   test_num++;
16631   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16632   if (test_checksum_1 () == -1) {
16633     printf ("test_checksum_1 FAILED\n");
16634     failed++;
16635   }
16636   test_num++;
16637   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16638   if (test_checksum_2 () == -1) {
16639     printf ("test_checksum_2 FAILED\n");
16640     failed++;
16641   }
16642   test_num++;
16643   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16644   if (test_checksum_3 () == -1) {
16645     printf ("test_checksum_3 FAILED\n");
16646     failed++;
16647   }
16648   test_num++;
16649   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16650   if (test_checksum_4 () == -1) {
16651     printf ("test_checksum_4 FAILED\n");
16652     failed++;
16653   }
16654   test_num++;
16655   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16656   if (test_checksum_5 () == -1) {
16657     printf ("test_checksum_5 FAILED\n");
16658     failed++;
16659   }
16660   test_num++;
16661   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16662   if (test_checksum_6 () == -1) {
16663     printf ("test_checksum_6 FAILED\n");
16664     failed++;
16665   }
16666   test_num++;
16667   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16668   if (test_checksum_7 () == -1) {
16669     printf ("test_checksum_7 FAILED\n");
16670     failed++;
16671   }
16672   test_num++;
16673   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16674   if (test_checksum_8 () == -1) {
16675     printf ("test_checksum_8 FAILED\n");
16676     failed++;
16677   }
16678   test_num++;
16679   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16680   if (test_download_0 () == -1) {
16681     printf ("test_download_0 FAILED\n");
16682     failed++;
16683   }
16684   test_num++;
16685   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16686   if (test_upload_0 () == -1) {
16687     printf ("test_upload_0 FAILED\n");
16688     failed++;
16689   }
16690   test_num++;
16691   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16692   if (test_blockdev_rereadpt_0 () == -1) {
16693     printf ("test_blockdev_rereadpt_0 FAILED\n");
16694     failed++;
16695   }
16696   test_num++;
16697   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16698   if (test_blockdev_flushbufs_0 () == -1) {
16699     printf ("test_blockdev_flushbufs_0 FAILED\n");
16700     failed++;
16701   }
16702   test_num++;
16703   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16704   if (test_blockdev_getsize64_0 () == -1) {
16705     printf ("test_blockdev_getsize64_0 FAILED\n");
16706     failed++;
16707   }
16708   test_num++;
16709   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16710   if (test_blockdev_getsz_0 () == -1) {
16711     printf ("test_blockdev_getsz_0 FAILED\n");
16712     failed++;
16713   }
16714   test_num++;
16715   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16716   if (test_blockdev_getbsz_0 () == -1) {
16717     printf ("test_blockdev_getbsz_0 FAILED\n");
16718     failed++;
16719   }
16720   test_num++;
16721   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16722   if (test_blockdev_getss_0 () == -1) {
16723     printf ("test_blockdev_getss_0 FAILED\n");
16724     failed++;
16725   }
16726   test_num++;
16727   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16728   if (test_blockdev_getro_0 () == -1) {
16729     printf ("test_blockdev_getro_0 FAILED\n");
16730     failed++;
16731   }
16732   test_num++;
16733   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16734   if (test_blockdev_setrw_0 () == -1) {
16735     printf ("test_blockdev_setrw_0 FAILED\n");
16736     failed++;
16737   }
16738   test_num++;
16739   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16740   if (test_blockdev_setro_0 () == -1) {
16741     printf ("test_blockdev_setro_0 FAILED\n");
16742     failed++;
16743   }
16744   test_num++;
16745   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16746   if (test_statvfs_0 () == -1) {
16747     printf ("test_statvfs_0 FAILED\n");
16748     failed++;
16749   }
16750   test_num++;
16751   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16752   if (test_lstat_0 () == -1) {
16753     printf ("test_lstat_0 FAILED\n");
16754     failed++;
16755   }
16756   test_num++;
16757   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16758   if (test_stat_0 () == -1) {
16759     printf ("test_stat_0 FAILED\n");
16760     failed++;
16761   }
16762   test_num++;
16763   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16764   if (test_command_lines_0 () == -1) {
16765     printf ("test_command_lines_0 FAILED\n");
16766     failed++;
16767   }
16768   test_num++;
16769   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16770   if (test_command_lines_1 () == -1) {
16771     printf ("test_command_lines_1 FAILED\n");
16772     failed++;
16773   }
16774   test_num++;
16775   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16776   if (test_command_lines_2 () == -1) {
16777     printf ("test_command_lines_2 FAILED\n");
16778     failed++;
16779   }
16780   test_num++;
16781   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16782   if (test_command_lines_3 () == -1) {
16783     printf ("test_command_lines_3 FAILED\n");
16784     failed++;
16785   }
16786   test_num++;
16787   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16788   if (test_command_lines_4 () == -1) {
16789     printf ("test_command_lines_4 FAILED\n");
16790     failed++;
16791   }
16792   test_num++;
16793   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16794   if (test_command_lines_5 () == -1) {
16795     printf ("test_command_lines_5 FAILED\n");
16796     failed++;
16797   }
16798   test_num++;
16799   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16800   if (test_command_lines_6 () == -1) {
16801     printf ("test_command_lines_6 FAILED\n");
16802     failed++;
16803   }
16804   test_num++;
16805   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16806   if (test_command_lines_7 () == -1) {
16807     printf ("test_command_lines_7 FAILED\n");
16808     failed++;
16809   }
16810   test_num++;
16811   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16812   if (test_command_lines_8 () == -1) {
16813     printf ("test_command_lines_8 FAILED\n");
16814     failed++;
16815   }
16816   test_num++;
16817   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16818   if (test_command_lines_9 () == -1) {
16819     printf ("test_command_lines_9 FAILED\n");
16820     failed++;
16821   }
16822   test_num++;
16823   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16824   if (test_command_lines_10 () == -1) {
16825     printf ("test_command_lines_10 FAILED\n");
16826     failed++;
16827   }
16828   test_num++;
16829   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16830   if (test_command_0 () == -1) {
16831     printf ("test_command_0 FAILED\n");
16832     failed++;
16833   }
16834   test_num++;
16835   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16836   if (test_command_1 () == -1) {
16837     printf ("test_command_1 FAILED\n");
16838     failed++;
16839   }
16840   test_num++;
16841   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16842   if (test_command_2 () == -1) {
16843     printf ("test_command_2 FAILED\n");
16844     failed++;
16845   }
16846   test_num++;
16847   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16848   if (test_command_3 () == -1) {
16849     printf ("test_command_3 FAILED\n");
16850     failed++;
16851   }
16852   test_num++;
16853   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16854   if (test_command_4 () == -1) {
16855     printf ("test_command_4 FAILED\n");
16856     failed++;
16857   }
16858   test_num++;
16859   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16860   if (test_command_5 () == -1) {
16861     printf ("test_command_5 FAILED\n");
16862     failed++;
16863   }
16864   test_num++;
16865   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16866   if (test_command_6 () == -1) {
16867     printf ("test_command_6 FAILED\n");
16868     failed++;
16869   }
16870   test_num++;
16871   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16872   if (test_command_7 () == -1) {
16873     printf ("test_command_7 FAILED\n");
16874     failed++;
16875   }
16876   test_num++;
16877   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16878   if (test_command_8 () == -1) {
16879     printf ("test_command_8 FAILED\n");
16880     failed++;
16881   }
16882   test_num++;
16883   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16884   if (test_command_9 () == -1) {
16885     printf ("test_command_9 FAILED\n");
16886     failed++;
16887   }
16888   test_num++;
16889   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16890   if (test_command_10 () == -1) {
16891     printf ("test_command_10 FAILED\n");
16892     failed++;
16893   }
16894   test_num++;
16895   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16896   if (test_command_11 () == -1) {
16897     printf ("test_command_11 FAILED\n");
16898     failed++;
16899   }
16900   test_num++;
16901   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16902   if (test_file_0 () == -1) {
16903     printf ("test_file_0 FAILED\n");
16904     failed++;
16905   }
16906   test_num++;
16907   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16908   if (test_file_1 () == -1) {
16909     printf ("test_file_1 FAILED\n");
16910     failed++;
16911   }
16912   test_num++;
16913   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16914   if (test_file_2 () == -1) {
16915     printf ("test_file_2 FAILED\n");
16916     failed++;
16917   }
16918   test_num++;
16919   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16920   if (test_umount_all_0 () == -1) {
16921     printf ("test_umount_all_0 FAILED\n");
16922     failed++;
16923   }
16924   test_num++;
16925   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16926   if (test_umount_all_1 () == -1) {
16927     printf ("test_umount_all_1 FAILED\n");
16928     failed++;
16929   }
16930   test_num++;
16931   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16932   if (test_mounts_0 () == -1) {
16933     printf ("test_mounts_0 FAILED\n");
16934     failed++;
16935   }
16936   test_num++;
16937   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16938   if (test_umount_0 () == -1) {
16939     printf ("test_umount_0 FAILED\n");
16940     failed++;
16941   }
16942   test_num++;
16943   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16944   if (test_umount_1 () == -1) {
16945     printf ("test_umount_1 FAILED\n");
16946     failed++;
16947   }
16948   test_num++;
16949   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16950   if (test_write_file_0 () == -1) {
16951     printf ("test_write_file_0 FAILED\n");
16952     failed++;
16953   }
16954   test_num++;
16955   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16956   if (test_write_file_1 () == -1) {
16957     printf ("test_write_file_1 FAILED\n");
16958     failed++;
16959   }
16960   test_num++;
16961   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16962   if (test_write_file_2 () == -1) {
16963     printf ("test_write_file_2 FAILED\n");
16964     failed++;
16965   }
16966   test_num++;
16967   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16968   if (test_write_file_3 () == -1) {
16969     printf ("test_write_file_3 FAILED\n");
16970     failed++;
16971   }
16972   test_num++;
16973   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16974   if (test_write_file_4 () == -1) {
16975     printf ("test_write_file_4 FAILED\n");
16976     failed++;
16977   }
16978   test_num++;
16979   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16980   if (test_write_file_5 () == -1) {
16981     printf ("test_write_file_5 FAILED\n");
16982     failed++;
16983   }
16984   test_num++;
16985   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16986   if (test_mkfs_0 () == -1) {
16987     printf ("test_mkfs_0 FAILED\n");
16988     failed++;
16989   }
16990   test_num++;
16991   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16992   if (test_lvcreate_0 () == -1) {
16993     printf ("test_lvcreate_0 FAILED\n");
16994     failed++;
16995   }
16996   test_num++;
16997   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16998   if (test_vgcreate_0 () == -1) {
16999     printf ("test_vgcreate_0 FAILED\n");
17000     failed++;
17001   }
17002   test_num++;
17003   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17004   if (test_pvcreate_0 () == -1) {
17005     printf ("test_pvcreate_0 FAILED\n");
17006     failed++;
17007   }
17008   test_num++;
17009   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17010   if (test_is_dir_0 () == -1) {
17011     printf ("test_is_dir_0 FAILED\n");
17012     failed++;
17013   }
17014   test_num++;
17015   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
17016   if (test_is_dir_1 () == -1) {
17017     printf ("test_is_dir_1 FAILED\n");
17018     failed++;
17019   }
17020   test_num++;
17021   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
17022   if (test_is_file_0 () == -1) {
17023     printf ("test_is_file_0 FAILED\n");
17024     failed++;
17025   }
17026   test_num++;
17027   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
17028   if (test_is_file_1 () == -1) {
17029     printf ("test_is_file_1 FAILED\n");
17030     failed++;
17031   }
17032   test_num++;
17033   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
17034   if (test_exists_0 () == -1) {
17035     printf ("test_exists_0 FAILED\n");
17036     failed++;
17037   }
17038   test_num++;
17039   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
17040   if (test_exists_1 () == -1) {
17041     printf ("test_exists_1 FAILED\n");
17042     failed++;
17043   }
17044   test_num++;
17045   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
17046   if (test_mkdir_p_0 () == -1) {
17047     printf ("test_mkdir_p_0 FAILED\n");
17048     failed++;
17049   }
17050   test_num++;
17051   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
17052   if (test_mkdir_p_1 () == -1) {
17053     printf ("test_mkdir_p_1 FAILED\n");
17054     failed++;
17055   }
17056   test_num++;
17057   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
17058   if (test_mkdir_p_2 () == -1) {
17059     printf ("test_mkdir_p_2 FAILED\n");
17060     failed++;
17061   }
17062   test_num++;
17063   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
17064   if (test_mkdir_p_3 () == -1) {
17065     printf ("test_mkdir_p_3 FAILED\n");
17066     failed++;
17067   }
17068   test_num++;
17069   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
17070   if (test_mkdir_p_4 () == -1) {
17071     printf ("test_mkdir_p_4 FAILED\n");
17072     failed++;
17073   }
17074   test_num++;
17075   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
17076   if (test_mkdir_0 () == -1) {
17077     printf ("test_mkdir_0 FAILED\n");
17078     failed++;
17079   }
17080   test_num++;
17081   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
17082   if (test_mkdir_1 () == -1) {
17083     printf ("test_mkdir_1 FAILED\n");
17084     failed++;
17085   }
17086   test_num++;
17087   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
17088   if (test_rm_rf_0 () == -1) {
17089     printf ("test_rm_rf_0 FAILED\n");
17090     failed++;
17091   }
17092   test_num++;
17093   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
17094   if (test_rmdir_0 () == -1) {
17095     printf ("test_rmdir_0 FAILED\n");
17096     failed++;
17097   }
17098   test_num++;
17099   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
17100   if (test_rmdir_1 () == -1) {
17101     printf ("test_rmdir_1 FAILED\n");
17102     failed++;
17103   }
17104   test_num++;
17105   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
17106   if (test_rmdir_2 () == -1) {
17107     printf ("test_rmdir_2 FAILED\n");
17108     failed++;
17109   }
17110   test_num++;
17111   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
17112   if (test_rm_0 () == -1) {
17113     printf ("test_rm_0 FAILED\n");
17114     failed++;
17115   }
17116   test_num++;
17117   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
17118   if (test_rm_1 () == -1) {
17119     printf ("test_rm_1 FAILED\n");
17120     failed++;
17121   }
17122   test_num++;
17123   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
17124   if (test_rm_2 () == -1) {
17125     printf ("test_rm_2 FAILED\n");
17126     failed++;
17127   }
17128   test_num++;
17129   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
17130   if (test_read_lines_0 () == -1) {
17131     printf ("test_read_lines_0 FAILED\n");
17132     failed++;
17133   }
17134   test_num++;
17135   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
17136   if (test_read_lines_1 () == -1) {
17137     printf ("test_read_lines_1 FAILED\n");
17138     failed++;
17139   }
17140   test_num++;
17141   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
17142   if (test_lvs_0 () == -1) {
17143     printf ("test_lvs_0 FAILED\n");
17144     failed++;
17145   }
17146   test_num++;
17147   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
17148   if (test_lvs_1 () == -1) {
17149     printf ("test_lvs_1 FAILED\n");
17150     failed++;
17151   }
17152   test_num++;
17153   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
17154   if (test_vgs_0 () == -1) {
17155     printf ("test_vgs_0 FAILED\n");
17156     failed++;
17157   }
17158   test_num++;
17159   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17160   if (test_vgs_1 () == -1) {
17161     printf ("test_vgs_1 FAILED\n");
17162     failed++;
17163   }
17164   test_num++;
17165   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17166   if (test_pvs_0 () == -1) {
17167     printf ("test_pvs_0 FAILED\n");
17168     failed++;
17169   }
17170   test_num++;
17171   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17172   if (test_pvs_1 () == -1) {
17173     printf ("test_pvs_1 FAILED\n");
17174     failed++;
17175   }
17176   test_num++;
17177   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17178   if (test_list_partitions_0 () == -1) {
17179     printf ("test_list_partitions_0 FAILED\n");
17180     failed++;
17181   }
17182   test_num++;
17183   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17184   if (test_list_partitions_1 () == -1) {
17185     printf ("test_list_partitions_1 FAILED\n");
17186     failed++;
17187   }
17188   test_num++;
17189   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17190   if (test_list_devices_0 () == -1) {
17191     printf ("test_list_devices_0 FAILED\n");
17192     failed++;
17193   }
17194   test_num++;
17195   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17196   if (test_ls_0 () == -1) {
17197     printf ("test_ls_0 FAILED\n");
17198     failed++;
17199   }
17200   test_num++;
17201   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17202   if (test_cat_0 () == -1) {
17203     printf ("test_cat_0 FAILED\n");
17204     failed++;
17205   }
17206   test_num++;
17207   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17208   if (test_touch_0 () == -1) {
17209     printf ("test_touch_0 FAILED\n");
17210     failed++;
17211   }
17212   test_num++;
17213   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17214   if (test_sync_0 () == -1) {
17215     printf ("test_sync_0 FAILED\n");
17216     failed++;
17217   }
17218   test_num++;
17219   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17220   if (test_mount_0 () == -1) {
17221     printf ("test_mount_0 FAILED\n");
17222     failed++;
17223   }
17224
17225   guestfs_close (g);
17226   unlink ("test1.img");
17227   unlink ("test2.img");
17228   unlink ("test3.img");
17229
17230   if (failed > 0) {
17231     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
17232     exit (1);
17233   }
17234
17235   exit (0);
17236 }