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_mkdtemp_0_skip (void)
 157 {
 158   const char *str;
 159
 160   str = getenv ("SKIP_TEST_MKDTEMP_0");
 161   if (str && strcmp (str, "1") == 0) return 1;
 162   str = getenv ("SKIP_TEST_MKDTEMP");
 163   if (str && strcmp (str, "1") == 0) return 1;
 164   return 0;
 165 }
 166
 167 static int test_mkdtemp_0 (void)
 168 {
 169   if (test_mkdtemp_0_skip ()) {
 170     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdtemp_0");
 171     return 0;
 172   }
 173
 174   /* InitBasicFS for test_mkdtemp_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 mkdtemp (0) */
 229   {
 230     char path[] = "/tmp";
 231     int r;
 232     suppress_error = 0;
 233     r = guestfs_mkdir (g, path);
 234     if (r == -1)
 235       return -1;
 236   }
 237   {
 238     char template[] = "/tmp/tmpXXXXXX";
 239     char *r;
 240     suppress_error = 0;
 241     r = guestfs_mkdtemp (g, template);
 242     if (r == NULL)
 243       return -1;
 244     free (r);
 245   }
 246   return 0;
 247 }
 248
 249 static int test_scrub_file_0_skip (void)
 250 {
 251   const char *str;
 252
 253   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
 254   if (str && strcmp (str, "1") == 0) return 1;
 255   str = getenv ("SKIP_TEST_SCRUB_FILE");
 256   if (str && strcmp (str, "1") == 0) return 1;
 257   return 0;
 258 }
 259
 260 static int test_scrub_file_0 (void)
 261 {
 262   if (test_scrub_file_0_skip ()) {
 263     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_scrub_file_0");
 264     return 0;
 265   }
 266
 267   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
 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   {
 291     char device[] = "/dev/sda";
 292     char lines_0[] = ",";
 293     char *lines[] = {
 294       lines_0,
 295       NULL
 296     };
 297     int r;
 298     suppress_error = 0;
 299     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 300     if (r == -1)
 301       return -1;
 302   }
 303   {
 304     char fstype[] = "ext2";
 305     char device[] = "/dev/sda1";
 306     int r;
 307     suppress_error = 0;
 308     r = guestfs_mkfs (g, fstype, device);
 309     if (r == -1)
 310       return -1;
 311   }
 312   {
 313     char device[] = "/dev/sda1";
 314     char mountpoint[] = "/";
 315     int r;
 316     suppress_error = 0;
 317     r = guestfs_mount (g, device, mountpoint);
 318     if (r == -1)
 319       return -1;
 320   }
 321   /* TestRun for scrub_file (0) */
 322   {
 323     char path[] = "/file";
 324     char content[] = "content";
 325     int r;
 326     suppress_error = 0;
 327     r = guestfs_write_file (g, path, content, 0);
 328     if (r == -1)
 329       return -1;
 330   }
 331   {
 332     char file[] = "/file";
 333     int r;
 334     suppress_error = 0;
 335     r = guestfs_scrub_file (g, file);
 336     if (r == -1)
 337       return -1;
 338   }
 339   return 0;
 340 }
 341
 342 static int test_scrub_device_0_skip (void)
 343 {
 344   const char *str;
 345
 346   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
 347   if (str && strcmp (str, "1") == 0) return 1;
 348   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
 349   if (str && strcmp (str, "1") == 0) return 1;
 350   return 0;
 351 }
 352
 353 static int test_scrub_device_0 (void)
 354 {
 355   if (test_scrub_device_0_skip ()) {
 356     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_scrub_device_0");
 357     return 0;
 358   }
 359
 360   /* InitNone|InitEmpty for test_scrub_device_0 */
 361   {
 362     char device[] = "/dev/sda";
 363     int r;
 364     suppress_error = 0;
 365     r = guestfs_blockdev_setrw (g, device);
 366     if (r == -1)
 367       return -1;
 368   }
 369   {
 370     int r;
 371     suppress_error = 0;
 372     r = guestfs_umount_all (g);
 373     if (r == -1)
 374       return -1;
 375   }
 376   {
 377     int r;
 378     suppress_error = 0;
 379     r = guestfs_lvm_remove_all (g);
 380     if (r == -1)
 381       return -1;
 382   }
 383   /* TestRun for scrub_device (0) */
 384   {
 385     char device[] = "/dev/sdc";
 386     int r;
 387     suppress_error = 0;
 388     r = guestfs_scrub_device (g, device);
 389     if (r == -1)
 390       return -1;
 391   }
 392   return 0;
 393 }
 394
 395 static int test_glob_expand_0_skip (void)
 396 {
 397   const char *str;
 398
 399   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
 400   if (str && strcmp (str, "1") == 0) return 1;
 401   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 402   if (str && strcmp (str, "1") == 0) return 1;
 403   return 0;
 404 }
 405
 406 static int test_glob_expand_0 (void)
 407 {
 408   if (test_glob_expand_0_skip ()) {
 409     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_0");
 410     return 0;
 411   }
 412
 413   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
 414   {
 415     char device[] = "/dev/sda";
 416     int r;
 417     suppress_error = 0;
 418     r = guestfs_blockdev_setrw (g, device);
 419     if (r == -1)
 420       return -1;
 421   }
 422   {
 423     int r;
 424     suppress_error = 0;
 425     r = guestfs_umount_all (g);
 426     if (r == -1)
 427       return -1;
 428   }
 429   {
 430     int r;
 431     suppress_error = 0;
 432     r = guestfs_lvm_remove_all (g);
 433     if (r == -1)
 434       return -1;
 435   }
 436   {
 437     char device[] = "/dev/sda";
 438     char lines_0[] = ",";
 439     char *lines[] = {
 440       lines_0,
 441       NULL
 442     };
 443     int r;
 444     suppress_error = 0;
 445     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 446     if (r == -1)
 447       return -1;
 448   }
 449   {
 450     char fstype[] = "ext2";
 451     char device[] = "/dev/sda1";
 452     int r;
 453     suppress_error = 0;
 454     r = guestfs_mkfs (g, fstype, device);
 455     if (r == -1)
 456       return -1;
 457   }
 458   {
 459     char device[] = "/dev/sda1";
 460     char mountpoint[] = "/";
 461     int r;
 462     suppress_error = 0;
 463     r = guestfs_mount (g, device, mountpoint);
 464     if (r == -1)
 465       return -1;
 466   }
 467   /* TestOutputList for glob_expand (0) */
 468   {
 469     char path[] = "/a/b/c";
 470     int r;
 471     suppress_error = 0;
 472     r = guestfs_mkdir_p (g, path);
 473     if (r == -1)
 474       return -1;
 475   }
 476   {
 477     char path[] = "/a/b/c/d";
 478     int r;
 479     suppress_error = 0;
 480     r = guestfs_touch (g, path);
 481     if (r == -1)
 482       return -1;
 483   }
 484   {
 485     char path[] = "/a/b/c/e";
 486     int r;
 487     suppress_error = 0;
 488     r = guestfs_touch (g, path);
 489     if (r == -1)
 490       return -1;
 491   }
 492   {
 493     char pattern[] = "/a/b/c/*";
 494     char **r;
 495     int i;
 496     suppress_error = 0;
 497     r = guestfs_glob_expand (g, pattern);
 498     if (r == NULL)
 499       return -1;
 500     if (!r[0]) {
 501       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
 502       print_strings (r);
 503       return -1;
 504     }
 505     {
 506       char expected[] = "/a/b/c/d";
 507       if (strcmp (r[0], expected) != 0) {
 508         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 509         return -1;
 510       }
 511     }
 512     if (!r[1]) {
 513       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
 514       print_strings (r);
 515       return -1;
 516     }
 517     {
 518       char expected[] = "/a/b/c/e";
 519       if (strcmp (r[1], expected) != 0) {
 520         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 521         return -1;
 522       }
 523     }
 524     if (r[2] != NULL) {
 525       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
 526       print_strings (r);
 527       return -1;
 528     }
 529     for (i = 0; r[i] != NULL; ++i)
 530       free (r[i]);
 531     free (r);
 532   }
 533   return 0;
 534 }
 535
 536 static int test_glob_expand_1_skip (void)
 537 {
 538   const char *str;
 539
 540   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
 541   if (str && strcmp (str, "1") == 0) return 1;
 542   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 543   if (str && strcmp (str, "1") == 0) return 1;
 544   return 0;
 545 }
 546
 547 static int test_glob_expand_1 (void)
 548 {
 549   if (test_glob_expand_1_skip ()) {
 550     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_1");
 551     return 0;
 552   }
 553
 554   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
 555   {
 556     char device[] = "/dev/sda";
 557     int r;
 558     suppress_error = 0;
 559     r = guestfs_blockdev_setrw (g, device);
 560     if (r == -1)
 561       return -1;
 562   }
 563   {
 564     int r;
 565     suppress_error = 0;
 566     r = guestfs_umount_all (g);
 567     if (r == -1)
 568       return -1;
 569   }
 570   {
 571     int r;
 572     suppress_error = 0;
 573     r = guestfs_lvm_remove_all (g);
 574     if (r == -1)
 575       return -1;
 576   }
 577   {
 578     char device[] = "/dev/sda";
 579     char lines_0[] = ",";
 580     char *lines[] = {
 581       lines_0,
 582       NULL
 583     };
 584     int r;
 585     suppress_error = 0;
 586     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 587     if (r == -1)
 588       return -1;
 589   }
 590   {
 591     char fstype[] = "ext2";
 592     char device[] = "/dev/sda1";
 593     int r;
 594     suppress_error = 0;
 595     r = guestfs_mkfs (g, fstype, device);
 596     if (r == -1)
 597       return -1;
 598   }
 599   {
 600     char device[] = "/dev/sda1";
 601     char mountpoint[] = "/";
 602     int r;
 603     suppress_error = 0;
 604     r = guestfs_mount (g, device, mountpoint);
 605     if (r == -1)
 606       return -1;
 607   }
 608   /* TestOutputList for glob_expand (1) */
 609   {
 610     char path[] = "/a/b/c";
 611     int r;
 612     suppress_error = 0;
 613     r = guestfs_mkdir_p (g, path);
 614     if (r == -1)
 615       return -1;
 616   }
 617   {
 618     char path[] = "/a/b/c/d";
 619     int r;
 620     suppress_error = 0;
 621     r = guestfs_touch (g, path);
 622     if (r == -1)
 623       return -1;
 624   }
 625   {
 626     char path[] = "/a/b/c/e";
 627     int r;
 628     suppress_error = 0;
 629     r = guestfs_touch (g, path);
 630     if (r == -1)
 631       return -1;
 632   }
 633   {
 634     char pattern[] = "/a/*/c/*";
 635     char **r;
 636     int i;
 637     suppress_error = 0;
 638     r = guestfs_glob_expand (g, pattern);
 639     if (r == NULL)
 640       return -1;
 641     if (!r[0]) {
 642       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
 643       print_strings (r);
 644       return -1;
 645     }
 646     {
 647       char expected[] = "/a/b/c/d";
 648       if (strcmp (r[0], expected) != 0) {
 649         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 650         return -1;
 651       }
 652     }
 653     if (!r[1]) {
 654       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
 655       print_strings (r);
 656       return -1;
 657     }
 658     {
 659       char expected[] = "/a/b/c/e";
 660       if (strcmp (r[1], expected) != 0) {
 661         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 662         return -1;
 663       }
 664     }
 665     if (r[2] != NULL) {
 666       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
 667       print_strings (r);
 668       return -1;
 669     }
 670     for (i = 0; r[i] != NULL; ++i)
 671       free (r[i]);
 672     free (r);
 673   }
 674   return 0;
 675 }
 676
 677 static int test_glob_expand_2_skip (void)
 678 {
 679   const char *str;
 680
 681   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
 682   if (str && strcmp (str, "1") == 0) return 1;
 683   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 684   if (str && strcmp (str, "1") == 0) return 1;
 685   return 0;
 686 }
 687
 688 static int test_glob_expand_2 (void)
 689 {
 690   if (test_glob_expand_2_skip ()) {
 691     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_2");
 692     return 0;
 693   }
 694
 695   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
 696   {
 697     char device[] = "/dev/sda";
 698     int r;
 699     suppress_error = 0;
 700     r = guestfs_blockdev_setrw (g, device);
 701     if (r == -1)
 702       return -1;
 703   }
 704   {
 705     int r;
 706     suppress_error = 0;
 707     r = guestfs_umount_all (g);
 708     if (r == -1)
 709       return -1;
 710   }
 711   {
 712     int r;
 713     suppress_error = 0;
 714     r = guestfs_lvm_remove_all (g);
 715     if (r == -1)
 716       return -1;
 717   }
 718   {
 719     char device[] = "/dev/sda";
 720     char lines_0[] = ",";
 721     char *lines[] = {
 722       lines_0,
 723       NULL
 724     };
 725     int r;
 726     suppress_error = 0;
 727     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 728     if (r == -1)
 729       return -1;
 730   }
 731   {
 732     char fstype[] = "ext2";
 733     char device[] = "/dev/sda1";
 734     int r;
 735     suppress_error = 0;
 736     r = guestfs_mkfs (g, fstype, device);
 737     if (r == -1)
 738       return -1;
 739   }
 740   {
 741     char device[] = "/dev/sda1";
 742     char mountpoint[] = "/";
 743     int r;
 744     suppress_error = 0;
 745     r = guestfs_mount (g, device, mountpoint);
 746     if (r == -1)
 747       return -1;
 748   }
 749   /* TestOutputList for glob_expand (2) */
 750   {
 751     char path[] = "/a/b/c";
 752     int r;
 753     suppress_error = 0;
 754     r = guestfs_mkdir_p (g, path);
 755     if (r == -1)
 756       return -1;
 757   }
 758   {
 759     char path[] = "/a/b/c/d";
 760     int r;
 761     suppress_error = 0;
 762     r = guestfs_touch (g, path);
 763     if (r == -1)
 764       return -1;
 765   }
 766   {
 767     char path[] = "/a/b/c/e";
 768     int r;
 769     suppress_error = 0;
 770     r = guestfs_touch (g, path);
 771     if (r == -1)
 772       return -1;
 773   }
 774   {
 775     char pattern[] = "/a/*/x/*";
 776     char **r;
 777     int i;
 778     suppress_error = 0;
 779     r = guestfs_glob_expand (g, pattern);
 780     if (r == NULL)
 781       return -1;
 782     if (r[0] != NULL) {
 783       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
 784       print_strings (r);
 785       return -1;
 786     }
 787     for (i = 0; r[i] != NULL; ++i)
 788       free (r[i]);
 789     free (r);
 790   }
 791   return 0;
 792 }
 793
 794 static int test_ntfs_3g_probe_0_skip (void)
 795 {
 796   const char *str;
 797
 798   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
 799   if (str && strcmp (str, "1") == 0) return 1;
 800   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 801   if (str && strcmp (str, "1") == 0) return 1;
 802   return 0;
 803 }
 804
 805 static int test_ntfs_3g_probe_0 (void)
 806 {
 807   if (test_ntfs_3g_probe_0_skip ()) {
 808     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
 809     return 0;
 810   }
 811
 812   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
 813   {
 814     char device[] = "/dev/sda";
 815     int r;
 816     suppress_error = 0;
 817     r = guestfs_blockdev_setrw (g, device);
 818     if (r == -1)
 819       return -1;
 820   }
 821   {
 822     int r;
 823     suppress_error = 0;
 824     r = guestfs_umount_all (g);
 825     if (r == -1)
 826       return -1;
 827   }
 828   {
 829     int r;
 830     suppress_error = 0;
 831     r = guestfs_lvm_remove_all (g);
 832     if (r == -1)
 833       return -1;
 834   }
 835   /* TestOutputInt for ntfs_3g_probe (0) */
 836   {
 837     char device[] = "/dev/sda";
 838     char lines_0[] = ",";
 839     char *lines[] = {
 840       lines_0,
 841       NULL
 842     };
 843     int r;
 844     suppress_error = 0;
 845     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 846     if (r == -1)
 847       return -1;
 848   }
 849   {
 850     char fstype[] = "ntfs";
 851     char device[] = "/dev/sda1";
 852     int r;
 853     suppress_error = 0;
 854     r = guestfs_mkfs (g, fstype, device);
 855     if (r == -1)
 856       return -1;
 857   }
 858   {
 859     char device[] = "/dev/sda1";
 860     int r;
 861     suppress_error = 0;
 862     r = guestfs_ntfs_3g_probe (g, 1, device);
 863     if (r == -1)
 864       return -1;
 865     if (r != 0) {
 866       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
 867       return -1;
 868     }
 869   }
 870   return 0;
 871 }
 872
 873 static int test_ntfs_3g_probe_1_skip (void)
 874 {
 875   const char *str;
 876
 877   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
 878   if (str && strcmp (str, "1") == 0) return 1;
 879   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 880   if (str && strcmp (str, "1") == 0) return 1;
 881   return 0;
 882 }
 883
 884 static int test_ntfs_3g_probe_1 (void)
 885 {
 886   if (test_ntfs_3g_probe_1_skip ()) {
 887     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
 888     return 0;
 889   }
 890
 891   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
 892   {
 893     char device[] = "/dev/sda";
 894     int r;
 895     suppress_error = 0;
 896     r = guestfs_blockdev_setrw (g, device);
 897     if (r == -1)
 898       return -1;
 899   }
 900   {
 901     int r;
 902     suppress_error = 0;
 903     r = guestfs_umount_all (g);
 904     if (r == -1)
 905       return -1;
 906   }
 907   {
 908     int r;
 909     suppress_error = 0;
 910     r = guestfs_lvm_remove_all (g);
 911     if (r == -1)
 912       return -1;
 913   }
 914   /* TestOutputInt for ntfs_3g_probe (1) */
 915   {
 916     char device[] = "/dev/sda";
 917     char lines_0[] = ",";
 918     char *lines[] = {
 919       lines_0,
 920       NULL
 921     };
 922     int r;
 923     suppress_error = 0;
 924     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 925     if (r == -1)
 926       return -1;
 927   }
 928   {
 929     char fstype[] = "ext2";
 930     char device[] = "/dev/sda1";
 931     int r;
 932     suppress_error = 0;
 933     r = guestfs_mkfs (g, fstype, device);
 934     if (r == -1)
 935       return -1;
 936   }
 937   {
 938     char device[] = "/dev/sda1";
 939     int r;
 940     suppress_error = 0;
 941     r = guestfs_ntfs_3g_probe (g, 1, device);
 942     if (r == -1)
 943       return -1;
 944     if (r != 12) {
 945       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
 946       return -1;
 947     }
 948   }
 949   return 0;
 950 }
 951
 952 static int test_sleep_0_skip (void)
 953 {
 954   const char *str;
 955
 956   str = getenv ("SKIP_TEST_SLEEP_0");
 957   if (str && strcmp (str, "1") == 0) return 1;
 958   str = getenv ("SKIP_TEST_SLEEP");
 959   if (str && strcmp (str, "1") == 0) return 1;
 960   return 0;
 961 }
 962
 963 static int test_sleep_0 (void)
 964 {
 965   if (test_sleep_0_skip ()) {
 966     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
 967     return 0;
 968   }
 969
 970   /* InitNone|InitEmpty for test_sleep_0 */
 971   {
 972     char device[] = "/dev/sda";
 973     int r;
 974     suppress_error = 0;
 975     r = guestfs_blockdev_setrw (g, device);
 976     if (r == -1)
 977       return -1;
 978   }
 979   {
 980     int r;
 981     suppress_error = 0;
 982     r = guestfs_umount_all (g);
 983     if (r == -1)
 984       return -1;
 985   }
 986   {
 987     int r;
 988     suppress_error = 0;
 989     r = guestfs_lvm_remove_all (g);
 990     if (r == -1)
 991       return -1;
 992   }
 993   /* TestRun for sleep (0) */
 994   {
 995     int r;
 996     suppress_error = 0;
 997     r = guestfs_sleep (g, 1);
 998     if (r == -1)
 999       return -1;
1000   }
1001   return 0;
1002 }
1003
1004 static int test_find_0_skip (void)
1005 {
1006   const char *str;
1007
1008   str = getenv ("SKIP_TEST_FIND_0");
1009   if (str && strcmp (str, "1") == 0) return 1;
1010   str = getenv ("SKIP_TEST_FIND");
1011   if (str && strcmp (str, "1") == 0) return 1;
1012   return 0;
1013 }
1014
1015 static int test_find_0 (void)
1016 {
1017   if (test_find_0_skip ()) {
1018     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
1019     return 0;
1020   }
1021
1022   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
1023   {
1024     char device[] = "/dev/sda";
1025     int r;
1026     suppress_error = 0;
1027     r = guestfs_blockdev_setrw (g, device);
1028     if (r == -1)
1029       return -1;
1030   }
1031   {
1032     int r;
1033     suppress_error = 0;
1034     r = guestfs_umount_all (g);
1035     if (r == -1)
1036       return -1;
1037   }
1038   {
1039     int r;
1040     suppress_error = 0;
1041     r = guestfs_lvm_remove_all (g);
1042     if (r == -1)
1043       return -1;
1044   }
1045   {
1046     char device[] = "/dev/sda";
1047     char lines_0[] = ",";
1048     char *lines[] = {
1049       lines_0,
1050       NULL
1051     };
1052     int r;
1053     suppress_error = 0;
1054     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1055     if (r == -1)
1056       return -1;
1057   }
1058   {
1059     char fstype[] = "ext2";
1060     char device[] = "/dev/sda1";
1061     int r;
1062     suppress_error = 0;
1063     r = guestfs_mkfs (g, fstype, device);
1064     if (r == -1)
1065       return -1;
1066   }
1067   {
1068     char device[] = "/dev/sda1";
1069     char mountpoint[] = "/";
1070     int r;
1071     suppress_error = 0;
1072     r = guestfs_mount (g, device, mountpoint);
1073     if (r == -1)
1074       return -1;
1075   }
1076   /* TestOutputList for find (0) */
1077   {
1078     char directory[] = "/";
1079     char **r;
1080     int i;
1081     suppress_error = 0;
1082     r = guestfs_find (g, directory);
1083     if (r == NULL)
1084       return -1;
1085     if (!r[0]) {
1086       fprintf (stderr, "test_find_0: short list returned from command\n");
1087       print_strings (r);
1088       return -1;
1089     }
1090     {
1091       char expected[] = "lost+found";
1092       if (strcmp (r[0], expected) != 0) {
1093         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1094         return -1;
1095       }
1096     }
1097     if (r[1] != NULL) {
1098       fprintf (stderr, "test_find_0: extra elements returned from command\n");
1099       print_strings (r);
1100       return -1;
1101     }
1102     for (i = 0; r[i] != NULL; ++i)
1103       free (r[i]);
1104     free (r);
1105   }
1106   return 0;
1107 }
1108
1109 static int test_find_1_skip (void)
1110 {
1111   const char *str;
1112
1113   str = getenv ("SKIP_TEST_FIND_1");
1114   if (str && strcmp (str, "1") == 0) return 1;
1115   str = getenv ("SKIP_TEST_FIND");
1116   if (str && strcmp (str, "1") == 0) return 1;
1117   return 0;
1118 }
1119
1120 static int test_find_1 (void)
1121 {
1122   if (test_find_1_skip ()) {
1123     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
1124     return 0;
1125   }
1126
1127   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
1128   {
1129     char device[] = "/dev/sda";
1130     int r;
1131     suppress_error = 0;
1132     r = guestfs_blockdev_setrw (g, device);
1133     if (r == -1)
1134       return -1;
1135   }
1136   {
1137     int r;
1138     suppress_error = 0;
1139     r = guestfs_umount_all (g);
1140     if (r == -1)
1141       return -1;
1142   }
1143   {
1144     int r;
1145     suppress_error = 0;
1146     r = guestfs_lvm_remove_all (g);
1147     if (r == -1)
1148       return -1;
1149   }
1150   {
1151     char device[] = "/dev/sda";
1152     char lines_0[] = ",";
1153     char *lines[] = {
1154       lines_0,
1155       NULL
1156     };
1157     int r;
1158     suppress_error = 0;
1159     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1160     if (r == -1)
1161       return -1;
1162   }
1163   {
1164     char fstype[] = "ext2";
1165     char device[] = "/dev/sda1";
1166     int r;
1167     suppress_error = 0;
1168     r = guestfs_mkfs (g, fstype, device);
1169     if (r == -1)
1170       return -1;
1171   }
1172   {
1173     char device[] = "/dev/sda1";
1174     char mountpoint[] = "/";
1175     int r;
1176     suppress_error = 0;
1177     r = guestfs_mount (g, device, mountpoint);
1178     if (r == -1)
1179       return -1;
1180   }
1181   /* TestOutputList for find (1) */
1182   {
1183     char path[] = "/a";
1184     int r;
1185     suppress_error = 0;
1186     r = guestfs_touch (g, path);
1187     if (r == -1)
1188       return -1;
1189   }
1190   {
1191     char path[] = "/b";
1192     int r;
1193     suppress_error = 0;
1194     r = guestfs_mkdir (g, path);
1195     if (r == -1)
1196       return -1;
1197   }
1198   {
1199     char path[] = "/b/c";
1200     int r;
1201     suppress_error = 0;
1202     r = guestfs_touch (g, path);
1203     if (r == -1)
1204       return -1;
1205   }
1206   {
1207     char directory[] = "/";
1208     char **r;
1209     int i;
1210     suppress_error = 0;
1211     r = guestfs_find (g, directory);
1212     if (r == NULL)
1213       return -1;
1214     if (!r[0]) {
1215       fprintf (stderr, "test_find_1: short list returned from command\n");
1216       print_strings (r);
1217       return -1;
1218     }
1219     {
1220       char expected[] = "a";
1221       if (strcmp (r[0], expected) != 0) {
1222         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1223         return -1;
1224       }
1225     }
1226     if (!r[1]) {
1227       fprintf (stderr, "test_find_1: short list returned from command\n");
1228       print_strings (r);
1229       return -1;
1230     }
1231     {
1232       char expected[] = "b";
1233       if (strcmp (r[1], expected) != 0) {
1234         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1235         return -1;
1236       }
1237     }
1238     if (!r[2]) {
1239       fprintf (stderr, "test_find_1: short list returned from command\n");
1240       print_strings (r);
1241       return -1;
1242     }
1243     {
1244       char expected[] = "b/c";
1245       if (strcmp (r[2], expected) != 0) {
1246         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1247         return -1;
1248       }
1249     }
1250     if (!r[3]) {
1251       fprintf (stderr, "test_find_1: short list returned from command\n");
1252       print_strings (r);
1253       return -1;
1254     }
1255     {
1256       char expected[] = "lost+found";
1257       if (strcmp (r[3], expected) != 0) {
1258         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1259         return -1;
1260       }
1261     }
1262     if (r[4] != NULL) {
1263       fprintf (stderr, "test_find_1: extra elements returned from command\n");
1264       print_strings (r);
1265       return -1;
1266     }
1267     for (i = 0; r[i] != NULL; ++i)
1268       free (r[i]);
1269     free (r);
1270   }
1271   return 0;
1272 }
1273
1274 static int test_find_2_skip (void)
1275 {
1276   const char *str;
1277
1278   str = getenv ("SKIP_TEST_FIND_2");
1279   if (str && strcmp (str, "1") == 0) return 1;
1280   str = getenv ("SKIP_TEST_FIND");
1281   if (str && strcmp (str, "1") == 0) return 1;
1282   return 0;
1283 }
1284
1285 static int test_find_2 (void)
1286 {
1287   if (test_find_2_skip ()) {
1288     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
1289     return 0;
1290   }
1291
1292   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
1293   {
1294     char device[] = "/dev/sda";
1295     int r;
1296     suppress_error = 0;
1297     r = guestfs_blockdev_setrw (g, device);
1298     if (r == -1)
1299       return -1;
1300   }
1301   {
1302     int r;
1303     suppress_error = 0;
1304     r = guestfs_umount_all (g);
1305     if (r == -1)
1306       return -1;
1307   }
1308   {
1309     int r;
1310     suppress_error = 0;
1311     r = guestfs_lvm_remove_all (g);
1312     if (r == -1)
1313       return -1;
1314   }
1315   {
1316     char device[] = "/dev/sda";
1317     char lines_0[] = ",";
1318     char *lines[] = {
1319       lines_0,
1320       NULL
1321     };
1322     int r;
1323     suppress_error = 0;
1324     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1325     if (r == -1)
1326       return -1;
1327   }
1328   {
1329     char fstype[] = "ext2";
1330     char device[] = "/dev/sda1";
1331     int r;
1332     suppress_error = 0;
1333     r = guestfs_mkfs (g, fstype, device);
1334     if (r == -1)
1335       return -1;
1336   }
1337   {
1338     char device[] = "/dev/sda1";
1339     char mountpoint[] = "/";
1340     int r;
1341     suppress_error = 0;
1342     r = guestfs_mount (g, device, mountpoint);
1343     if (r == -1)
1344       return -1;
1345   }
1346   /* TestOutputList for find (2) */
1347   {
1348     char path[] = "/a/b/c";
1349     int r;
1350     suppress_error = 0;
1351     r = guestfs_mkdir_p (g, path);
1352     if (r == -1)
1353       return -1;
1354   }
1355   {
1356     char path[] = "/a/b/c/d";
1357     int r;
1358     suppress_error = 0;
1359     r = guestfs_touch (g, path);
1360     if (r == -1)
1361       return -1;
1362   }
1363   {
1364     char directory[] = "/a/b/";
1365     char **r;
1366     int i;
1367     suppress_error = 0;
1368     r = guestfs_find (g, directory);
1369     if (r == NULL)
1370       return -1;
1371     if (!r[0]) {
1372       fprintf (stderr, "test_find_2: short list returned from command\n");
1373       print_strings (r);
1374       return -1;
1375     }
1376     {
1377       char expected[] = "c";
1378       if (strcmp (r[0], expected) != 0) {
1379         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1380         return -1;
1381       }
1382     }
1383     if (!r[1]) {
1384       fprintf (stderr, "test_find_2: short list returned from command\n");
1385       print_strings (r);
1386       return -1;
1387     }
1388     {
1389       char expected[] = "c/d";
1390       if (strcmp (r[1], expected) != 0) {
1391         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1392         return -1;
1393       }
1394     }
1395     if (r[2] != NULL) {
1396       fprintf (stderr, "test_find_2: extra elements returned from command\n");
1397       print_strings (r);
1398       return -1;
1399     }
1400     for (i = 0; r[i] != NULL; ++i)
1401       free (r[i]);
1402     free (r);
1403   }
1404   return 0;
1405 }
1406
1407 static int test_lvresize_0_skip (void)
1408 {
1409   const char *str;
1410
1411   str = getenv ("SKIP_TEST_LVRESIZE_0");
1412   if (str && strcmp (str, "1") == 0) return 1;
1413   str = getenv ("SKIP_TEST_LVRESIZE");
1414   if (str && strcmp (str, "1") == 0) return 1;
1415   return 0;
1416 }
1417
1418 static int test_lvresize_0 (void)
1419 {
1420   if (test_lvresize_0_skip ()) {
1421     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
1422     return 0;
1423   }
1424
1425   /* InitNone|InitEmpty for test_lvresize_0 */
1426   {
1427     char device[] = "/dev/sda";
1428     int r;
1429     suppress_error = 0;
1430     r = guestfs_blockdev_setrw (g, device);
1431     if (r == -1)
1432       return -1;
1433   }
1434   {
1435     int r;
1436     suppress_error = 0;
1437     r = guestfs_umount_all (g);
1438     if (r == -1)
1439       return -1;
1440   }
1441   {
1442     int r;
1443     suppress_error = 0;
1444     r = guestfs_lvm_remove_all (g);
1445     if (r == -1)
1446       return -1;
1447   }
1448   /* TestOutput for lvresize (0) */
1449   char expected[] = "test content";
1450   {
1451     char device[] = "/dev/sda";
1452     char lines_0[] = ",";
1453     char *lines[] = {
1454       lines_0,
1455       NULL
1456     };
1457     int r;
1458     suppress_error = 0;
1459     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1460     if (r == -1)
1461       return -1;
1462   }
1463   {
1464     char device[] = "/dev/sda1";
1465     int r;
1466     suppress_error = 0;
1467     r = guestfs_pvcreate (g, device);
1468     if (r == -1)
1469       return -1;
1470   }
1471   {
1472     char volgroup[] = "VG";
1473     char physvols_0[] = "/dev/sda1";
1474     char *physvols[] = {
1475       physvols_0,
1476       NULL
1477     };
1478     int r;
1479     suppress_error = 0;
1480     r = guestfs_vgcreate (g, volgroup, physvols);
1481     if (r == -1)
1482       return -1;
1483   }
1484   {
1485     char logvol[] = "LV";
1486     char volgroup[] = "VG";
1487     int r;
1488     suppress_error = 0;
1489     r = guestfs_lvcreate (g, logvol, volgroup, 10);
1490     if (r == -1)
1491       return -1;
1492   }
1493   {
1494     char fstype[] = "ext2";
1495     char device[] = "/dev/VG/LV";
1496     int r;
1497     suppress_error = 0;
1498     r = guestfs_mkfs (g, fstype, device);
1499     if (r == -1)
1500       return -1;
1501   }
1502   {
1503     char device[] = "/dev/VG/LV";
1504     char mountpoint[] = "/";
1505     int r;
1506     suppress_error = 0;
1507     r = guestfs_mount (g, device, mountpoint);
1508     if (r == -1)
1509       return -1;
1510   }
1511   {
1512     char path[] = "/new";
1513     char content[] = "test content";
1514     int r;
1515     suppress_error = 0;
1516     r = guestfs_write_file (g, path, content, 0);
1517     if (r == -1)
1518       return -1;
1519   }
1520   {
1521     char pathordevice[] = "/";
1522     int r;
1523     suppress_error = 0;
1524     r = guestfs_umount (g, pathordevice);
1525     if (r == -1)
1526       return -1;
1527   }
1528   {
1529     char device[] = "/dev/VG/LV";
1530     int r;
1531     suppress_error = 0;
1532     r = guestfs_lvresize (g, device, 20);
1533     if (r == -1)
1534       return -1;
1535   }
1536   {
1537     char device[] = "/dev/VG/LV";
1538     int r;
1539     suppress_error = 0;
1540     r = guestfs_e2fsck_f (g, device);
1541     if (r == -1)
1542       return -1;
1543   }
1544   {
1545     char device[] = "/dev/VG/LV";
1546     int r;
1547     suppress_error = 0;
1548     r = guestfs_resize2fs (g, device);
1549     if (r == -1)
1550       return -1;
1551   }
1552   {
1553     char device[] = "/dev/VG/LV";
1554     char mountpoint[] = "/";
1555     int r;
1556     suppress_error = 0;
1557     r = guestfs_mount (g, device, mountpoint);
1558     if (r == -1)
1559       return -1;
1560   }
1561   {
1562     char path[] = "/new";
1563     char *r;
1564     suppress_error = 0;
1565     r = guestfs_cat (g, path);
1566     if (r == NULL)
1567       return -1;
1568     if (strcmp (r, expected) != 0) {
1569       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
1570       return -1;
1571     }
1572     free (r);
1573   }
1574   return 0;
1575 }
1576
1577 static int test_zerofree_0_skip (void)
1578 {
1579   const char *str;
1580
1581   str = getenv ("SKIP_TEST_ZEROFREE_0");
1582   if (str && strcmp (str, "1") == 0) return 1;
1583   str = getenv ("SKIP_TEST_ZEROFREE");
1584   if (str && strcmp (str, "1") == 0) return 1;
1585   return 0;
1586 }
1587
1588 static int test_zerofree_0 (void)
1589 {
1590   if (test_zerofree_0_skip ()) {
1591     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
1592     return 0;
1593   }
1594
1595   /* InitNone|InitEmpty for test_zerofree_0 */
1596   {
1597     char device[] = "/dev/sda";
1598     int r;
1599     suppress_error = 0;
1600     r = guestfs_blockdev_setrw (g, device);
1601     if (r == -1)
1602       return -1;
1603   }
1604   {
1605     int r;
1606     suppress_error = 0;
1607     r = guestfs_umount_all (g);
1608     if (r == -1)
1609       return -1;
1610   }
1611   {
1612     int r;
1613     suppress_error = 0;
1614     r = guestfs_lvm_remove_all (g);
1615     if (r == -1)
1616       return -1;
1617   }
1618   /* TestOutput for zerofree (0) */
1619   char expected[] = "test file";
1620   {
1621     char device[] = "/dev/sda";
1622     char lines_0[] = ",";
1623     char *lines[] = {
1624       lines_0,
1625       NULL
1626     };
1627     int r;
1628     suppress_error = 0;
1629     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1630     if (r == -1)
1631       return -1;
1632   }
1633   {
1634     char fstype[] = "ext3";
1635     char device[] = "/dev/sda1";
1636     int r;
1637     suppress_error = 0;
1638     r = guestfs_mkfs (g, fstype, device);
1639     if (r == -1)
1640       return -1;
1641   }
1642   {
1643     char device[] = "/dev/sda1";
1644     char mountpoint[] = "/";
1645     int r;
1646     suppress_error = 0;
1647     r = guestfs_mount (g, device, mountpoint);
1648     if (r == -1)
1649       return -1;
1650   }
1651   {
1652     char path[] = "/new";
1653     char content[] = "test file";
1654     int r;
1655     suppress_error = 0;
1656     r = guestfs_write_file (g, path, content, 0);
1657     if (r == -1)
1658       return -1;
1659   }
1660   {
1661     char pathordevice[] = "/dev/sda1";
1662     int r;
1663     suppress_error = 0;
1664     r = guestfs_umount (g, pathordevice);
1665     if (r == -1)
1666       return -1;
1667   }
1668   {
1669     char device[] = "/dev/sda1";
1670     int r;
1671     suppress_error = 0;
1672     r = guestfs_zerofree (g, device);
1673     if (r == -1)
1674       return -1;
1675   }
1676   {
1677     char device[] = "/dev/sda1";
1678     char mountpoint[] = "/";
1679     int r;
1680     suppress_error = 0;
1681     r = guestfs_mount (g, device, mountpoint);
1682     if (r == -1)
1683       return -1;
1684   }
1685   {
1686     char path[] = "/new";
1687     char *r;
1688     suppress_error = 0;
1689     r = guestfs_cat (g, path);
1690     if (r == NULL)
1691       return -1;
1692     if (strcmp (r, expected) != 0) {
1693       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1694       return -1;
1695     }
1696     free (r);
1697   }
1698   return 0;
1699 }
1700
1701 static int test_hexdump_0_skip (void)
1702 {
1703   const char *str;
1704
1705   str = getenv ("SKIP_TEST_HEXDUMP_0");
1706   if (str && strcmp (str, "1") == 0) return 1;
1707   str = getenv ("SKIP_TEST_HEXDUMP");
1708   if (str && strcmp (str, "1") == 0) return 1;
1709   return 0;
1710 }
1711
1712 static int test_hexdump_0 (void)
1713 {
1714   if (test_hexdump_0_skip ()) {
1715     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1716     return 0;
1717   }
1718
1719   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1720   {
1721     char device[] = "/dev/sda";
1722     int r;
1723     suppress_error = 0;
1724     r = guestfs_blockdev_setrw (g, device);
1725     if (r == -1)
1726       return -1;
1727   }
1728   {
1729     int r;
1730     suppress_error = 0;
1731     r = guestfs_umount_all (g);
1732     if (r == -1)
1733       return -1;
1734   }
1735   {
1736     int r;
1737     suppress_error = 0;
1738     r = guestfs_lvm_remove_all (g);
1739     if (r == -1)
1740       return -1;
1741   }
1742   {
1743     char device[] = "/dev/sda";
1744     char lines_0[] = ",";
1745     char *lines[] = {
1746       lines_0,
1747       NULL
1748     };
1749     int r;
1750     suppress_error = 0;
1751     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1752     if (r == -1)
1753       return -1;
1754   }
1755   {
1756     char fstype[] = "ext2";
1757     char device[] = "/dev/sda1";
1758     int r;
1759     suppress_error = 0;
1760     r = guestfs_mkfs (g, fstype, device);
1761     if (r == -1)
1762       return -1;
1763   }
1764   {
1765     char device[] = "/dev/sda1";
1766     char mountpoint[] = "/";
1767     int r;
1768     suppress_error = 0;
1769     r = guestfs_mount (g, device, mountpoint);
1770     if (r == -1)
1771       return -1;
1772   }
1773   /* TestOutput for hexdump (0) */
1774   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
1775   {
1776     char path[] = "/new";
1777     char content[] = "hello\nworld\n";
1778     int r;
1779     suppress_error = 0;
1780     r = guestfs_write_file (g, path, content, 12);
1781     if (r == -1)
1782       return -1;
1783   }
1784   {
1785     char path[] = "/new";
1786     char *r;
1787     suppress_error = 0;
1788     r = guestfs_hexdump (g, path);
1789     if (r == NULL)
1790       return -1;
1791     if (strcmp (r, expected) != 0) {
1792       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1793       return -1;
1794     }
1795     free (r);
1796   }
1797   return 0;
1798 }
1799
1800 static int test_strings_e_0_skip (void)
1801 {
1802   const char *str;
1803
1804   str = getenv ("SKIP_TEST_STRINGS_E_0");
1805   if (str && strcmp (str, "1") == 0) return 1;
1806   str = getenv ("SKIP_TEST_STRINGS_E");
1807   if (str && strcmp (str, "1") == 0) return 1;
1808   return 0;
1809 }
1810
1811 static int test_strings_e_0 (void)
1812 {
1813   if (test_strings_e_0_skip ()) {
1814     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1815     return 0;
1816   }
1817
1818   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1819   {
1820     char device[] = "/dev/sda";
1821     int r;
1822     suppress_error = 0;
1823     r = guestfs_blockdev_setrw (g, device);
1824     if (r == -1)
1825       return -1;
1826   }
1827   {
1828     int r;
1829     suppress_error = 0;
1830     r = guestfs_umount_all (g);
1831     if (r == -1)
1832       return -1;
1833   }
1834   {
1835     int r;
1836     suppress_error = 0;
1837     r = guestfs_lvm_remove_all (g);
1838     if (r == -1)
1839       return -1;
1840   }
1841   {
1842     char device[] = "/dev/sda";
1843     char lines_0[] = ",";
1844     char *lines[] = {
1845       lines_0,
1846       NULL
1847     };
1848     int r;
1849     suppress_error = 0;
1850     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1851     if (r == -1)
1852       return -1;
1853   }
1854   {
1855     char fstype[] = "ext2";
1856     char device[] = "/dev/sda1";
1857     int r;
1858     suppress_error = 0;
1859     r = guestfs_mkfs (g, fstype, device);
1860     if (r == -1)
1861       return -1;
1862   }
1863   {
1864     char device[] = "/dev/sda1";
1865     char mountpoint[] = "/";
1866     int r;
1867     suppress_error = 0;
1868     r = guestfs_mount (g, device, mountpoint);
1869     if (r == -1)
1870       return -1;
1871   }
1872   /* TestOutputList for strings_e (0) */
1873   {
1874     char path[] = "/new";
1875     char content[] = "hello\nworld\n";
1876     int r;
1877     suppress_error = 0;
1878     r = guestfs_write_file (g, path, content, 0);
1879     if (r == -1)
1880       return -1;
1881   }
1882   {
1883     char encoding[] = "b";
1884     char path[] = "/new";
1885     char **r;
1886     int i;
1887     suppress_error = 0;
1888     r = guestfs_strings_e (g, encoding, path);
1889     if (r == NULL)
1890       return -1;
1891     if (r[0] != NULL) {
1892       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1893       print_strings (r);
1894       return -1;
1895     }
1896     for (i = 0; r[i] != NULL; ++i)
1897       free (r[i]);
1898     free (r);
1899   }
1900   return 0;
1901 }
1902
1903 static int test_strings_e_1_skip (void)
1904 {
1905   const char *str;
1906
1907   str = getenv ("SKIP_TEST_STRINGS_E_1");
1908   if (str && strcmp (str, "1") == 0) return 1;
1909   str = getenv ("SKIP_TEST_STRINGS_E");
1910   if (str && strcmp (str, "1") == 0) return 1;
1911   return 0;
1912 }
1913
1914 static int test_strings_e_1 (void)
1915 {
1916   if (test_strings_e_1_skip ()) {
1917     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1918     return 0;
1919   }
1920
1921   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1922   return 0;
1923 }
1924
1925 static int test_strings_0_skip (void)
1926 {
1927   const char *str;
1928
1929   str = getenv ("SKIP_TEST_STRINGS_0");
1930   if (str && strcmp (str, "1") == 0) return 1;
1931   str = getenv ("SKIP_TEST_STRINGS");
1932   if (str && strcmp (str, "1") == 0) return 1;
1933   return 0;
1934 }
1935
1936 static int test_strings_0 (void)
1937 {
1938   if (test_strings_0_skip ()) {
1939     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1940     return 0;
1941   }
1942
1943   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1944   {
1945     char device[] = "/dev/sda";
1946     int r;
1947     suppress_error = 0;
1948     r = guestfs_blockdev_setrw (g, device);
1949     if (r == -1)
1950       return -1;
1951   }
1952   {
1953     int r;
1954     suppress_error = 0;
1955     r = guestfs_umount_all (g);
1956     if (r == -1)
1957       return -1;
1958   }
1959   {
1960     int r;
1961     suppress_error = 0;
1962     r = guestfs_lvm_remove_all (g);
1963     if (r == -1)
1964       return -1;
1965   }
1966   {
1967     char device[] = "/dev/sda";
1968     char lines_0[] = ",";
1969     char *lines[] = {
1970       lines_0,
1971       NULL
1972     };
1973     int r;
1974     suppress_error = 0;
1975     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1976     if (r == -1)
1977       return -1;
1978   }
1979   {
1980     char fstype[] = "ext2";
1981     char device[] = "/dev/sda1";
1982     int r;
1983     suppress_error = 0;
1984     r = guestfs_mkfs (g, fstype, device);
1985     if (r == -1)
1986       return -1;
1987   }
1988   {
1989     char device[] = "/dev/sda1";
1990     char mountpoint[] = "/";
1991     int r;
1992     suppress_error = 0;
1993     r = guestfs_mount (g, device, mountpoint);
1994     if (r == -1)
1995       return -1;
1996   }
1997   /* TestOutputList for strings (0) */
1998   {
1999     char path[] = "/new";
2000     char content[] = "hello\nworld\n";
2001     int r;
2002     suppress_error = 0;
2003     r = guestfs_write_file (g, path, content, 0);
2004     if (r == -1)
2005       return -1;
2006   }
2007   {
2008     char path[] = "/new";
2009     char **r;
2010     int i;
2011     suppress_error = 0;
2012     r = guestfs_strings (g, path);
2013     if (r == NULL)
2014       return -1;
2015     if (!r[0]) {
2016       fprintf (stderr, "test_strings_0: short list returned from command\n");
2017       print_strings (r);
2018       return -1;
2019     }
2020     {
2021       char expected[] = "hello";
2022       if (strcmp (r[0], expected) != 0) {
2023         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2024         return -1;
2025       }
2026     }
2027     if (!r[1]) {
2028       fprintf (stderr, "test_strings_0: short list returned from command\n");
2029       print_strings (r);
2030       return -1;
2031     }
2032     {
2033       char expected[] = "world";
2034       if (strcmp (r[1], expected) != 0) {
2035         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2036         return -1;
2037       }
2038     }
2039     if (r[2] != NULL) {
2040       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
2041       print_strings (r);
2042       return -1;
2043     }
2044     for (i = 0; r[i] != NULL; ++i)
2045       free (r[i]);
2046     free (r);
2047   }
2048   return 0;
2049 }
2050
2051 static int test_strings_1_skip (void)
2052 {
2053   const char *str;
2054
2055   str = getenv ("SKIP_TEST_STRINGS_1");
2056   if (str && strcmp (str, "1") == 0) return 1;
2057   str = getenv ("SKIP_TEST_STRINGS");
2058   if (str && strcmp (str, "1") == 0) return 1;
2059   return 0;
2060 }
2061
2062 static int test_strings_1 (void)
2063 {
2064   if (test_strings_1_skip ()) {
2065     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
2066     return 0;
2067   }
2068
2069   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
2070   {
2071     char device[] = "/dev/sda";
2072     int r;
2073     suppress_error = 0;
2074     r = guestfs_blockdev_setrw (g, device);
2075     if (r == -1)
2076       return -1;
2077   }
2078   {
2079     int r;
2080     suppress_error = 0;
2081     r = guestfs_umount_all (g);
2082     if (r == -1)
2083       return -1;
2084   }
2085   {
2086     int r;
2087     suppress_error = 0;
2088     r = guestfs_lvm_remove_all (g);
2089     if (r == -1)
2090       return -1;
2091   }
2092   {
2093     char device[] = "/dev/sda";
2094     char lines_0[] = ",";
2095     char *lines[] = {
2096       lines_0,
2097       NULL
2098     };
2099     int r;
2100     suppress_error = 0;
2101     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2102     if (r == -1)
2103       return -1;
2104   }
2105   {
2106     char fstype[] = "ext2";
2107     char device[] = "/dev/sda1";
2108     int r;
2109     suppress_error = 0;
2110     r = guestfs_mkfs (g, fstype, device);
2111     if (r == -1)
2112       return -1;
2113   }
2114   {
2115     char device[] = "/dev/sda1";
2116     char mountpoint[] = "/";
2117     int r;
2118     suppress_error = 0;
2119     r = guestfs_mount (g, device, mountpoint);
2120     if (r == -1)
2121       return -1;
2122   }
2123   /* TestOutputList for strings (1) */
2124   {
2125     char path[] = "/new";
2126     int r;
2127     suppress_error = 0;
2128     r = guestfs_touch (g, path);
2129     if (r == -1)
2130       return -1;
2131   }
2132   {
2133     char path[] = "/new";
2134     char **r;
2135     int i;
2136     suppress_error = 0;
2137     r = guestfs_strings (g, path);
2138     if (r == NULL)
2139       return -1;
2140     if (r[0] != NULL) {
2141       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
2142       print_strings (r);
2143       return -1;
2144     }
2145     for (i = 0; r[i] != NULL; ++i)
2146       free (r[i]);
2147     free (r);
2148   }
2149   return 0;
2150 }
2151
2152 static int test_equal_0_skip (void)
2153 {
2154   const char *str;
2155
2156   str = getenv ("SKIP_TEST_EQUAL_0");
2157   if (str && strcmp (str, "1") == 0) return 1;
2158   str = getenv ("SKIP_TEST_EQUAL");
2159   if (str && strcmp (str, "1") == 0) return 1;
2160   return 0;
2161 }
2162
2163 static int test_equal_0 (void)
2164 {
2165   if (test_equal_0_skip ()) {
2166     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
2167     return 0;
2168   }
2169
2170   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
2171   {
2172     char device[] = "/dev/sda";
2173     int r;
2174     suppress_error = 0;
2175     r = guestfs_blockdev_setrw (g, device);
2176     if (r == -1)
2177       return -1;
2178   }
2179   {
2180     int r;
2181     suppress_error = 0;
2182     r = guestfs_umount_all (g);
2183     if (r == -1)
2184       return -1;
2185   }
2186   {
2187     int r;
2188     suppress_error = 0;
2189     r = guestfs_lvm_remove_all (g);
2190     if (r == -1)
2191       return -1;
2192   }
2193   {
2194     char device[] = "/dev/sda";
2195     char lines_0[] = ",";
2196     char *lines[] = {
2197       lines_0,
2198       NULL
2199     };
2200     int r;
2201     suppress_error = 0;
2202     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2203     if (r == -1)
2204       return -1;
2205   }
2206   {
2207     char fstype[] = "ext2";
2208     char device[] = "/dev/sda1";
2209     int r;
2210     suppress_error = 0;
2211     r = guestfs_mkfs (g, fstype, device);
2212     if (r == -1)
2213       return -1;
2214   }
2215   {
2216     char device[] = "/dev/sda1";
2217     char mountpoint[] = "/";
2218     int r;
2219     suppress_error = 0;
2220     r = guestfs_mount (g, device, mountpoint);
2221     if (r == -1)
2222       return -1;
2223   }
2224   /* TestOutputTrue for equal (0) */
2225   {
2226     char path[] = "/file1";
2227     char content[] = "contents of a file";
2228     int r;
2229     suppress_error = 0;
2230     r = guestfs_write_file (g, path, content, 0);
2231     if (r == -1)
2232       return -1;
2233   }
2234   {
2235     char src[] = "/file1";
2236     char dest[] = "/file2";
2237     int r;
2238     suppress_error = 0;
2239     r = guestfs_cp (g, src, dest);
2240     if (r == -1)
2241       return -1;
2242   }
2243   {
2244     char file1[] = "/file1";
2245     char file2[] = "/file2";
2246     int r;
2247     suppress_error = 0;
2248     r = guestfs_equal (g, file1, file2);
2249     if (r == -1)
2250       return -1;
2251     if (!r) {
2252       fprintf (stderr, "test_equal_0: expected true, got false\n");
2253       return -1;
2254     }
2255   }
2256   return 0;
2257 }
2258
2259 static int test_equal_1_skip (void)
2260 {
2261   const char *str;
2262
2263   str = getenv ("SKIP_TEST_EQUAL_1");
2264   if (str && strcmp (str, "1") == 0) return 1;
2265   str = getenv ("SKIP_TEST_EQUAL");
2266   if (str && strcmp (str, "1") == 0) return 1;
2267   return 0;
2268 }
2269
2270 static int test_equal_1 (void)
2271 {
2272   if (test_equal_1_skip ()) {
2273     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
2274     return 0;
2275   }
2276
2277   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2278   {
2279     char device[] = "/dev/sda";
2280     int r;
2281     suppress_error = 0;
2282     r = guestfs_blockdev_setrw (g, device);
2283     if (r == -1)
2284       return -1;
2285   }
2286   {
2287     int r;
2288     suppress_error = 0;
2289     r = guestfs_umount_all (g);
2290     if (r == -1)
2291       return -1;
2292   }
2293   {
2294     int r;
2295     suppress_error = 0;
2296     r = guestfs_lvm_remove_all (g);
2297     if (r == -1)
2298       return -1;
2299   }
2300   {
2301     char device[] = "/dev/sda";
2302     char lines_0[] = ",";
2303     char *lines[] = {
2304       lines_0,
2305       NULL
2306     };
2307     int r;
2308     suppress_error = 0;
2309     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2310     if (r == -1)
2311       return -1;
2312   }
2313   {
2314     char fstype[] = "ext2";
2315     char device[] = "/dev/sda1";
2316     int r;
2317     suppress_error = 0;
2318     r = guestfs_mkfs (g, fstype, device);
2319     if (r == -1)
2320       return -1;
2321   }
2322   {
2323     char device[] = "/dev/sda1";
2324     char mountpoint[] = "/";
2325     int r;
2326     suppress_error = 0;
2327     r = guestfs_mount (g, device, mountpoint);
2328     if (r == -1)
2329       return -1;
2330   }
2331   /* TestOutputFalse for equal (1) */
2332   {
2333     char path[] = "/file1";
2334     char content[] = "contents of a file";
2335     int r;
2336     suppress_error = 0;
2337     r = guestfs_write_file (g, path, content, 0);
2338     if (r == -1)
2339       return -1;
2340   }
2341   {
2342     char path[] = "/file2";
2343     char content[] = "contents of another file";
2344     int r;
2345     suppress_error = 0;
2346     r = guestfs_write_file (g, path, content, 0);
2347     if (r == -1)
2348       return -1;
2349   }
2350   {
2351     char file1[] = "/file1";
2352     char file2[] = "/file2";
2353     int r;
2354     suppress_error = 0;
2355     r = guestfs_equal (g, file1, file2);
2356     if (r == -1)
2357       return -1;
2358     if (r) {
2359       fprintf (stderr, "test_equal_1: expected false, got true\n");
2360       return -1;
2361     }
2362   }
2363   return 0;
2364 }
2365
2366 static int test_equal_2_skip (void)
2367 {
2368   const char *str;
2369
2370   str = getenv ("SKIP_TEST_EQUAL_2");
2371   if (str && strcmp (str, "1") == 0) return 1;
2372   str = getenv ("SKIP_TEST_EQUAL");
2373   if (str && strcmp (str, "1") == 0) return 1;
2374   return 0;
2375 }
2376
2377 static int test_equal_2 (void)
2378 {
2379   if (test_equal_2_skip ()) {
2380     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
2381     return 0;
2382   }
2383
2384   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
2385   {
2386     char device[] = "/dev/sda";
2387     int r;
2388     suppress_error = 0;
2389     r = guestfs_blockdev_setrw (g, device);
2390     if (r == -1)
2391       return -1;
2392   }
2393   {
2394     int r;
2395     suppress_error = 0;
2396     r = guestfs_umount_all (g);
2397     if (r == -1)
2398       return -1;
2399   }
2400   {
2401     int r;
2402     suppress_error = 0;
2403     r = guestfs_lvm_remove_all (g);
2404     if (r == -1)
2405       return -1;
2406   }
2407   {
2408     char device[] = "/dev/sda";
2409     char lines_0[] = ",";
2410     char *lines[] = {
2411       lines_0,
2412       NULL
2413     };
2414     int r;
2415     suppress_error = 0;
2416     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2417     if (r == -1)
2418       return -1;
2419   }
2420   {
2421     char fstype[] = "ext2";
2422     char device[] = "/dev/sda1";
2423     int r;
2424     suppress_error = 0;
2425     r = guestfs_mkfs (g, fstype, device);
2426     if (r == -1)
2427       return -1;
2428   }
2429   {
2430     char device[] = "/dev/sda1";
2431     char mountpoint[] = "/";
2432     int r;
2433     suppress_error = 0;
2434     r = guestfs_mount (g, device, mountpoint);
2435     if (r == -1)
2436       return -1;
2437   }
2438   /* TestLastFail for equal (2) */
2439   {
2440     char file1[] = "/file1";
2441     char file2[] = "/file2";
2442     int r;
2443     suppress_error = 1;
2444     r = guestfs_equal (g, file1, file2);
2445     if (r != -1)
2446       return -1;
2447   }
2448   return 0;
2449 }
2450
2451 static int test_ping_daemon_0_skip (void)
2452 {
2453   const char *str;
2454
2455   str = getenv ("SKIP_TEST_PING_DAEMON_0");
2456   if (str && strcmp (str, "1") == 0) return 1;
2457   str = getenv ("SKIP_TEST_PING_DAEMON");
2458   if (str && strcmp (str, "1") == 0) return 1;
2459   return 0;
2460 }
2461
2462 static int test_ping_daemon_0 (void)
2463 {
2464   if (test_ping_daemon_0_skip ()) {
2465     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
2466     return 0;
2467   }
2468
2469   /* InitNone|InitEmpty for test_ping_daemon_0 */
2470   {
2471     char device[] = "/dev/sda";
2472     int r;
2473     suppress_error = 0;
2474     r = guestfs_blockdev_setrw (g, device);
2475     if (r == -1)
2476       return -1;
2477   }
2478   {
2479     int r;
2480     suppress_error = 0;
2481     r = guestfs_umount_all (g);
2482     if (r == -1)
2483       return -1;
2484   }
2485   {
2486     int r;
2487     suppress_error = 0;
2488     r = guestfs_lvm_remove_all (g);
2489     if (r == -1)
2490       return -1;
2491   }
2492   /* TestRun for ping_daemon (0) */
2493   {
2494     int r;
2495     suppress_error = 0;
2496     r = guestfs_ping_daemon (g);
2497     if (r == -1)
2498       return -1;
2499   }
2500   return 0;
2501 }
2502
2503 static int test_dmesg_0_skip (void)
2504 {
2505   const char *str;
2506
2507   str = getenv ("SKIP_TEST_DMESG_0");
2508   if (str && strcmp (str, "1") == 0) return 1;
2509   str = getenv ("SKIP_TEST_DMESG");
2510   if (str && strcmp (str, "1") == 0) return 1;
2511   return 0;
2512 }
2513
2514 static int test_dmesg_0 (void)
2515 {
2516   if (test_dmesg_0_skip ()) {
2517     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
2518     return 0;
2519   }
2520
2521   /* InitNone|InitEmpty for test_dmesg_0 */
2522   {
2523     char device[] = "/dev/sda";
2524     int r;
2525     suppress_error = 0;
2526     r = guestfs_blockdev_setrw (g, device);
2527     if (r == -1)
2528       return -1;
2529   }
2530   {
2531     int r;
2532     suppress_error = 0;
2533     r = guestfs_umount_all (g);
2534     if (r == -1)
2535       return -1;
2536   }
2537   {
2538     int r;
2539     suppress_error = 0;
2540     r = guestfs_lvm_remove_all (g);
2541     if (r == -1)
2542       return -1;
2543   }
2544   /* TestRun for dmesg (0) */
2545   {
2546     char *r;
2547     suppress_error = 0;
2548     r = guestfs_dmesg (g);
2549     if (r == NULL)
2550       return -1;
2551     free (r);
2552   }
2553   return 0;
2554 }
2555
2556 static int test_drop_caches_0_skip (void)
2557 {
2558   const char *str;
2559
2560   str = getenv ("SKIP_TEST_DROP_CACHES_0");
2561   if (str && strcmp (str, "1") == 0) return 1;
2562   str = getenv ("SKIP_TEST_DROP_CACHES");
2563   if (str && strcmp (str, "1") == 0) return 1;
2564   return 0;
2565 }
2566
2567 static int test_drop_caches_0 (void)
2568 {
2569   if (test_drop_caches_0_skip ()) {
2570     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
2571     return 0;
2572   }
2573
2574   /* InitNone|InitEmpty for test_drop_caches_0 */
2575   {
2576     char device[] = "/dev/sda";
2577     int r;
2578     suppress_error = 0;
2579     r = guestfs_blockdev_setrw (g, device);
2580     if (r == -1)
2581       return -1;
2582   }
2583   {
2584     int r;
2585     suppress_error = 0;
2586     r = guestfs_umount_all (g);
2587     if (r == -1)
2588       return -1;
2589   }
2590   {
2591     int r;
2592     suppress_error = 0;
2593     r = guestfs_lvm_remove_all (g);
2594     if (r == -1)
2595       return -1;
2596   }
2597   /* TestRun for drop_caches (0) */
2598   {
2599     int r;
2600     suppress_error = 0;
2601     r = guestfs_drop_caches (g, 3);
2602     if (r == -1)
2603       return -1;
2604   }
2605   return 0;
2606 }
2607
2608 static int test_mv_0_skip (void)
2609 {
2610   const char *str;
2611
2612   str = getenv ("SKIP_TEST_MV_0");
2613   if (str && strcmp (str, "1") == 0) return 1;
2614   str = getenv ("SKIP_TEST_MV");
2615   if (str && strcmp (str, "1") == 0) return 1;
2616   return 0;
2617 }
2618
2619 static int test_mv_0 (void)
2620 {
2621   if (test_mv_0_skip ()) {
2622     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2623     return 0;
2624   }
2625
2626   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2627   {
2628     char device[] = "/dev/sda";
2629     int r;
2630     suppress_error = 0;
2631     r = guestfs_blockdev_setrw (g, device);
2632     if (r == -1)
2633       return -1;
2634   }
2635   {
2636     int r;
2637     suppress_error = 0;
2638     r = guestfs_umount_all (g);
2639     if (r == -1)
2640       return -1;
2641   }
2642   {
2643     int r;
2644     suppress_error = 0;
2645     r = guestfs_lvm_remove_all (g);
2646     if (r == -1)
2647       return -1;
2648   }
2649   {
2650     char device[] = "/dev/sda";
2651     char lines_0[] = ",";
2652     char *lines[] = {
2653       lines_0,
2654       NULL
2655     };
2656     int r;
2657     suppress_error = 0;
2658     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2659     if (r == -1)
2660       return -1;
2661   }
2662   {
2663     char fstype[] = "ext2";
2664     char device[] = "/dev/sda1";
2665     int r;
2666     suppress_error = 0;
2667     r = guestfs_mkfs (g, fstype, device);
2668     if (r == -1)
2669       return -1;
2670   }
2671   {
2672     char device[] = "/dev/sda1";
2673     char mountpoint[] = "/";
2674     int r;
2675     suppress_error = 0;
2676     r = guestfs_mount (g, device, mountpoint);
2677     if (r == -1)
2678       return -1;
2679   }
2680   /* TestOutput for mv (0) */
2681   char expected[] = "file content";
2682   {
2683     char path[] = "/old";
2684     char content[] = "file content";
2685     int r;
2686     suppress_error = 0;
2687     r = guestfs_write_file (g, path, content, 0);
2688     if (r == -1)
2689       return -1;
2690   }
2691   {
2692     char src[] = "/old";
2693     char dest[] = "/new";
2694     int r;
2695     suppress_error = 0;
2696     r = guestfs_mv (g, src, dest);
2697     if (r == -1)
2698       return -1;
2699   }
2700   {
2701     char path[] = "/new";
2702     char *r;
2703     suppress_error = 0;
2704     r = guestfs_cat (g, path);
2705     if (r == NULL)
2706       return -1;
2707     if (strcmp (r, expected) != 0) {
2708       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2709       return -1;
2710     }
2711     free (r);
2712   }
2713   return 0;
2714 }
2715
2716 static int test_mv_1_skip (void)
2717 {
2718   const char *str;
2719
2720   str = getenv ("SKIP_TEST_MV_1");
2721   if (str && strcmp (str, "1") == 0) return 1;
2722   str = getenv ("SKIP_TEST_MV");
2723   if (str && strcmp (str, "1") == 0) return 1;
2724   return 0;
2725 }
2726
2727 static int test_mv_1 (void)
2728 {
2729   if (test_mv_1_skip ()) {
2730     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2731     return 0;
2732   }
2733
2734   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2735   {
2736     char device[] = "/dev/sda";
2737     int r;
2738     suppress_error = 0;
2739     r = guestfs_blockdev_setrw (g, device);
2740     if (r == -1)
2741       return -1;
2742   }
2743   {
2744     int r;
2745     suppress_error = 0;
2746     r = guestfs_umount_all (g);
2747     if (r == -1)
2748       return -1;
2749   }
2750   {
2751     int r;
2752     suppress_error = 0;
2753     r = guestfs_lvm_remove_all (g);
2754     if (r == -1)
2755       return -1;
2756   }
2757   {
2758     char device[] = "/dev/sda";
2759     char lines_0[] = ",";
2760     char *lines[] = {
2761       lines_0,
2762       NULL
2763     };
2764     int r;
2765     suppress_error = 0;
2766     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2767     if (r == -1)
2768       return -1;
2769   }
2770   {
2771     char fstype[] = "ext2";
2772     char device[] = "/dev/sda1";
2773     int r;
2774     suppress_error = 0;
2775     r = guestfs_mkfs (g, fstype, device);
2776     if (r == -1)
2777       return -1;
2778   }
2779   {
2780     char device[] = "/dev/sda1";
2781     char mountpoint[] = "/";
2782     int r;
2783     suppress_error = 0;
2784     r = guestfs_mount (g, device, mountpoint);
2785     if (r == -1)
2786       return -1;
2787   }
2788   /* TestOutputFalse for mv (1) */
2789   {
2790     char path[] = "/old";
2791     char content[] = "file content";
2792     int r;
2793     suppress_error = 0;
2794     r = guestfs_write_file (g, path, content, 0);
2795     if (r == -1)
2796       return -1;
2797   }
2798   {
2799     char src[] = "/old";
2800     char dest[] = "/new";
2801     int r;
2802     suppress_error = 0;
2803     r = guestfs_mv (g, src, dest);
2804     if (r == -1)
2805       return -1;
2806   }
2807   {
2808     char path[] = "/old";
2809     int r;
2810     suppress_error = 0;
2811     r = guestfs_is_file (g, path);
2812     if (r == -1)
2813       return -1;
2814     if (r) {
2815       fprintf (stderr, "test_mv_1: expected false, got true\n");
2816       return -1;
2817     }
2818   }
2819   return 0;
2820 }
2821
2822 static int test_cp_a_0_skip (void)
2823 {
2824   const char *str;
2825
2826   str = getenv ("SKIP_TEST_CP_A_0");
2827   if (str && strcmp (str, "1") == 0) return 1;
2828   str = getenv ("SKIP_TEST_CP_A");
2829   if (str && strcmp (str, "1") == 0) return 1;
2830   return 0;
2831 }
2832
2833 static int test_cp_a_0 (void)
2834 {
2835   if (test_cp_a_0_skip ()) {
2836     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2837     return 0;
2838   }
2839
2840   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2841   {
2842     char device[] = "/dev/sda";
2843     int r;
2844     suppress_error = 0;
2845     r = guestfs_blockdev_setrw (g, device);
2846     if (r == -1)
2847       return -1;
2848   }
2849   {
2850     int r;
2851     suppress_error = 0;
2852     r = guestfs_umount_all (g);
2853     if (r == -1)
2854       return -1;
2855   }
2856   {
2857     int r;
2858     suppress_error = 0;
2859     r = guestfs_lvm_remove_all (g);
2860     if (r == -1)
2861       return -1;
2862   }
2863   {
2864     char device[] = "/dev/sda";
2865     char lines_0[] = ",";
2866     char *lines[] = {
2867       lines_0,
2868       NULL
2869     };
2870     int r;
2871     suppress_error = 0;
2872     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2873     if (r == -1)
2874       return -1;
2875   }
2876   {
2877     char fstype[] = "ext2";
2878     char device[] = "/dev/sda1";
2879     int r;
2880     suppress_error = 0;
2881     r = guestfs_mkfs (g, fstype, device);
2882     if (r == -1)
2883       return -1;
2884   }
2885   {
2886     char device[] = "/dev/sda1";
2887     char mountpoint[] = "/";
2888     int r;
2889     suppress_error = 0;
2890     r = guestfs_mount (g, device, mountpoint);
2891     if (r == -1)
2892       return -1;
2893   }
2894   /* TestOutput for cp_a (0) */
2895   char expected[] = "file content";
2896   {
2897     char path[] = "/olddir";
2898     int r;
2899     suppress_error = 0;
2900     r = guestfs_mkdir (g, path);
2901     if (r == -1)
2902       return -1;
2903   }
2904   {
2905     char path[] = "/newdir";
2906     int r;
2907     suppress_error = 0;
2908     r = guestfs_mkdir (g, path);
2909     if (r == -1)
2910       return -1;
2911   }
2912   {
2913     char path[] = "/olddir/file";
2914     char content[] = "file content";
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_write_file (g, path, content, 0);
2918     if (r == -1)
2919       return -1;
2920   }
2921   {
2922     char src[] = "/olddir";
2923     char dest[] = "/newdir";
2924     int r;
2925     suppress_error = 0;
2926     r = guestfs_cp_a (g, src, dest);
2927     if (r == -1)
2928       return -1;
2929   }
2930   {
2931     char path[] = "/newdir/olddir/file";
2932     char *r;
2933     suppress_error = 0;
2934     r = guestfs_cat (g, path);
2935     if (r == NULL)
2936       return -1;
2937     if (strcmp (r, expected) != 0) {
2938       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2939       return -1;
2940     }
2941     free (r);
2942   }
2943   return 0;
2944 }
2945
2946 static int test_cp_0_skip (void)
2947 {
2948   const char *str;
2949
2950   str = getenv ("SKIP_TEST_CP_0");
2951   if (str && strcmp (str, "1") == 0) return 1;
2952   str = getenv ("SKIP_TEST_CP");
2953   if (str && strcmp (str, "1") == 0) return 1;
2954   return 0;
2955 }
2956
2957 static int test_cp_0 (void)
2958 {
2959   if (test_cp_0_skip ()) {
2960     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2961     return 0;
2962   }
2963
2964   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2965   {
2966     char device[] = "/dev/sda";
2967     int r;
2968     suppress_error = 0;
2969     r = guestfs_blockdev_setrw (g, device);
2970     if (r == -1)
2971       return -1;
2972   }
2973   {
2974     int r;
2975     suppress_error = 0;
2976     r = guestfs_umount_all (g);
2977     if (r == -1)
2978       return -1;
2979   }
2980   {
2981     int r;
2982     suppress_error = 0;
2983     r = guestfs_lvm_remove_all (g);
2984     if (r == -1)
2985       return -1;
2986   }
2987   {
2988     char device[] = "/dev/sda";
2989     char lines_0[] = ",";
2990     char *lines[] = {
2991       lines_0,
2992       NULL
2993     };
2994     int r;
2995     suppress_error = 0;
2996     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2997     if (r == -1)
2998       return -1;
2999   }
3000   {
3001     char fstype[] = "ext2";
3002     char device[] = "/dev/sda1";
3003     int r;
3004     suppress_error = 0;
3005     r = guestfs_mkfs (g, fstype, device);
3006     if (r == -1)
3007       return -1;
3008   }
3009   {
3010     char device[] = "/dev/sda1";
3011     char mountpoint[] = "/";
3012     int r;
3013     suppress_error = 0;
3014     r = guestfs_mount (g, device, mountpoint);
3015     if (r == -1)
3016       return -1;
3017   }
3018   /* TestOutput for cp (0) */
3019   char expected[] = "file content";
3020   {
3021     char path[] = "/old";
3022     char content[] = "file content";
3023     int r;
3024     suppress_error = 0;
3025     r = guestfs_write_file (g, path, content, 0);
3026     if (r == -1)
3027       return -1;
3028   }
3029   {
3030     char src[] = "/old";
3031     char dest[] = "/new";
3032     int r;
3033     suppress_error = 0;
3034     r = guestfs_cp (g, src, dest);
3035     if (r == -1)
3036       return -1;
3037   }
3038   {
3039     char path[] = "/new";
3040     char *r;
3041     suppress_error = 0;
3042     r = guestfs_cat (g, path);
3043     if (r == NULL)
3044       return -1;
3045     if (strcmp (r, expected) != 0) {
3046       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
3047       return -1;
3048     }
3049     free (r);
3050   }
3051   return 0;
3052 }
3053
3054 static int test_cp_1_skip (void)
3055 {
3056   const char *str;
3057
3058   str = getenv ("SKIP_TEST_CP_1");
3059   if (str && strcmp (str, "1") == 0) return 1;
3060   str = getenv ("SKIP_TEST_CP");
3061   if (str && strcmp (str, "1") == 0) return 1;
3062   return 0;
3063 }
3064
3065 static int test_cp_1 (void)
3066 {
3067   if (test_cp_1_skip ()) {
3068     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
3069     return 0;
3070   }
3071
3072   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
3073   {
3074     char device[] = "/dev/sda";
3075     int r;
3076     suppress_error = 0;
3077     r = guestfs_blockdev_setrw (g, device);
3078     if (r == -1)
3079       return -1;
3080   }
3081   {
3082     int r;
3083     suppress_error = 0;
3084     r = guestfs_umount_all (g);
3085     if (r == -1)
3086       return -1;
3087   }
3088   {
3089     int r;
3090     suppress_error = 0;
3091     r = guestfs_lvm_remove_all (g);
3092     if (r == -1)
3093       return -1;
3094   }
3095   {
3096     char device[] = "/dev/sda";
3097     char lines_0[] = ",";
3098     char *lines[] = {
3099       lines_0,
3100       NULL
3101     };
3102     int r;
3103     suppress_error = 0;
3104     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3105     if (r == -1)
3106       return -1;
3107   }
3108   {
3109     char fstype[] = "ext2";
3110     char device[] = "/dev/sda1";
3111     int r;
3112     suppress_error = 0;
3113     r = guestfs_mkfs (g, fstype, device);
3114     if (r == -1)
3115       return -1;
3116   }
3117   {
3118     char device[] = "/dev/sda1";
3119     char mountpoint[] = "/";
3120     int r;
3121     suppress_error = 0;
3122     r = guestfs_mount (g, device, mountpoint);
3123     if (r == -1)
3124       return -1;
3125   }
3126   /* TestOutputTrue for cp (1) */
3127   {
3128     char path[] = "/old";
3129     char content[] = "file content";
3130     int r;
3131     suppress_error = 0;
3132     r = guestfs_write_file (g, path, content, 0);
3133     if (r == -1)
3134       return -1;
3135   }
3136   {
3137     char src[] = "/old";
3138     char dest[] = "/new";
3139     int r;
3140     suppress_error = 0;
3141     r = guestfs_cp (g, src, dest);
3142     if (r == -1)
3143       return -1;
3144   }
3145   {
3146     char path[] = "/old";
3147     int r;
3148     suppress_error = 0;
3149     r = guestfs_is_file (g, path);
3150     if (r == -1)
3151       return -1;
3152     if (!r) {
3153       fprintf (stderr, "test_cp_1: expected true, got false\n");
3154       return -1;
3155     }
3156   }
3157   return 0;
3158 }
3159
3160 static int test_cp_2_skip (void)
3161 {
3162   const char *str;
3163
3164   str = getenv ("SKIP_TEST_CP_2");
3165   if (str && strcmp (str, "1") == 0) return 1;
3166   str = getenv ("SKIP_TEST_CP");
3167   if (str && strcmp (str, "1") == 0) return 1;
3168   return 0;
3169 }
3170
3171 static int test_cp_2 (void)
3172 {
3173   if (test_cp_2_skip ()) {
3174     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
3175     return 0;
3176   }
3177
3178   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
3179   {
3180     char device[] = "/dev/sda";
3181     int r;
3182     suppress_error = 0;
3183     r = guestfs_blockdev_setrw (g, device);
3184     if (r == -1)
3185       return -1;
3186   }
3187   {
3188     int r;
3189     suppress_error = 0;
3190     r = guestfs_umount_all (g);
3191     if (r == -1)
3192       return -1;
3193   }
3194   {
3195     int r;
3196     suppress_error = 0;
3197     r = guestfs_lvm_remove_all (g);
3198     if (r == -1)
3199       return -1;
3200   }
3201   {
3202     char device[] = "/dev/sda";
3203     char lines_0[] = ",";
3204     char *lines[] = {
3205       lines_0,
3206       NULL
3207     };
3208     int r;
3209     suppress_error = 0;
3210     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3211     if (r == -1)
3212       return -1;
3213   }
3214   {
3215     char fstype[] = "ext2";
3216     char device[] = "/dev/sda1";
3217     int r;
3218     suppress_error = 0;
3219     r = guestfs_mkfs (g, fstype, device);
3220     if (r == -1)
3221       return -1;
3222   }
3223   {
3224     char device[] = "/dev/sda1";
3225     char mountpoint[] = "/";
3226     int r;
3227     suppress_error = 0;
3228     r = guestfs_mount (g, device, mountpoint);
3229     if (r == -1)
3230       return -1;
3231   }
3232   /* TestOutput for cp (2) */
3233   char expected[] = "file content";
3234   {
3235     char path[] = "/old";
3236     char content[] = "file content";
3237     int r;
3238     suppress_error = 0;
3239     r = guestfs_write_file (g, path, content, 0);
3240     if (r == -1)
3241       return -1;
3242   }
3243   {
3244     char path[] = "/dir";
3245     int r;
3246     suppress_error = 0;
3247     r = guestfs_mkdir (g, path);
3248     if (r == -1)
3249       return -1;
3250   }
3251   {
3252     char src[] = "/old";
3253     char dest[] = "/dir/new";
3254     int r;
3255     suppress_error = 0;
3256     r = guestfs_cp (g, src, dest);
3257     if (r == -1)
3258       return -1;
3259   }
3260   {
3261     char path[] = "/dir/new";
3262     char *r;
3263     suppress_error = 0;
3264     r = guestfs_cat (g, path);
3265     if (r == NULL)
3266       return -1;
3267     if (strcmp (r, expected) != 0) {
3268       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3269       return -1;
3270     }
3271     free (r);
3272   }
3273   return 0;
3274 }
3275
3276 static int test_grub_install_0_skip (void)
3277 {
3278   const char *str;
3279
3280   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3281   if (str && strcmp (str, "1") == 0) return 1;
3282   str = getenv ("SKIP_TEST_GRUB_INSTALL");
3283   if (str && strcmp (str, "1") == 0) return 1;
3284   return 0;
3285 }
3286
3287 static int test_grub_install_0 (void)
3288 {
3289   if (test_grub_install_0_skip ()) {
3290     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
3291     return 0;
3292   }
3293
3294   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3295   {
3296     char device[] = "/dev/sda";
3297     int r;
3298     suppress_error = 0;
3299     r = guestfs_blockdev_setrw (g, device);
3300     if (r == -1)
3301       return -1;
3302   }
3303   {
3304     int r;
3305     suppress_error = 0;
3306     r = guestfs_umount_all (g);
3307     if (r == -1)
3308       return -1;
3309   }
3310   {
3311     int r;
3312     suppress_error = 0;
3313     r = guestfs_lvm_remove_all (g);
3314     if (r == -1)
3315       return -1;
3316   }
3317   {
3318     char device[] = "/dev/sda";
3319     char lines_0[] = ",";
3320     char *lines[] = {
3321       lines_0,
3322       NULL
3323     };
3324     int r;
3325     suppress_error = 0;
3326     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3327     if (r == -1)
3328       return -1;
3329   }
3330   {
3331     char fstype[] = "ext2";
3332     char device[] = "/dev/sda1";
3333     int r;
3334     suppress_error = 0;
3335     r = guestfs_mkfs (g, fstype, device);
3336     if (r == -1)
3337       return -1;
3338   }
3339   {
3340     char device[] = "/dev/sda1";
3341     char mountpoint[] = "/";
3342     int r;
3343     suppress_error = 0;
3344     r = guestfs_mount (g, device, mountpoint);
3345     if (r == -1)
3346       return -1;
3347   }
3348   /* TestOutputTrue for grub_install (0) */
3349   {
3350     char root[] = "/";
3351     char device[] = "/dev/sda1";
3352     int r;
3353     suppress_error = 0;
3354     r = guestfs_grub_install (g, root, device);
3355     if (r == -1)
3356       return -1;
3357   }
3358   {
3359     char path[] = "/boot";
3360     int r;
3361     suppress_error = 0;
3362     r = guestfs_is_dir (g, path);
3363     if (r == -1)
3364       return -1;
3365     if (!r) {
3366       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3367       return -1;
3368     }
3369   }
3370   return 0;
3371 }
3372
3373 static int test_zero_0_skip (void)
3374 {
3375   const char *str;
3376
3377   str = getenv ("SKIP_TEST_ZERO_0");
3378   if (str && strcmp (str, "1") == 0) return 1;
3379   str = getenv ("SKIP_TEST_ZERO");
3380   if (str && strcmp (str, "1") == 0) return 1;
3381   return 0;
3382 }
3383
3384 static int test_zero_0 (void)
3385 {
3386   if (test_zero_0_skip ()) {
3387     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
3388     return 0;
3389   }
3390
3391   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3392   {
3393     char device[] = "/dev/sda";
3394     int r;
3395     suppress_error = 0;
3396     r = guestfs_blockdev_setrw (g, device);
3397     if (r == -1)
3398       return -1;
3399   }
3400   {
3401     int r;
3402     suppress_error = 0;
3403     r = guestfs_umount_all (g);
3404     if (r == -1)
3405       return -1;
3406   }
3407   {
3408     int r;
3409     suppress_error = 0;
3410     r = guestfs_lvm_remove_all (g);
3411     if (r == -1)
3412       return -1;
3413   }
3414   {
3415     char device[] = "/dev/sda";
3416     char lines_0[] = ",";
3417     char *lines[] = {
3418       lines_0,
3419       NULL
3420     };
3421     int r;
3422     suppress_error = 0;
3423     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3424     if (r == -1)
3425       return -1;
3426   }
3427   {
3428     char fstype[] = "ext2";
3429     char device[] = "/dev/sda1";
3430     int r;
3431     suppress_error = 0;
3432     r = guestfs_mkfs (g, fstype, device);
3433     if (r == -1)
3434       return -1;
3435   }
3436   {
3437     char device[] = "/dev/sda1";
3438     char mountpoint[] = "/";
3439     int r;
3440     suppress_error = 0;
3441     r = guestfs_mount (g, device, mountpoint);
3442     if (r == -1)
3443       return -1;
3444   }
3445   /* TestOutput for zero (0) */
3446   char expected[] = "data";
3447   {
3448     char pathordevice[] = "/dev/sda1";
3449     int r;
3450     suppress_error = 0;
3451     r = guestfs_umount (g, pathordevice);
3452     if (r == -1)
3453       return -1;
3454   }
3455   {
3456     char device[] = "/dev/sda1";
3457     int r;
3458     suppress_error = 0;
3459     r = guestfs_zero (g, device);
3460     if (r == -1)
3461       return -1;
3462   }
3463   {
3464     char path[] = "/dev/sda1";
3465     char *r;
3466     suppress_error = 0;
3467     r = guestfs_file (g, path);
3468     if (r == NULL)
3469       return -1;
3470     if (strcmp (r, expected) != 0) {
3471       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3472       return -1;
3473     }
3474     free (r);
3475   }
3476   return 0;
3477 }
3478
3479 static int test_fsck_0_skip (void)
3480 {
3481   const char *str;
3482
3483   str = getenv ("SKIP_TEST_FSCK_0");
3484   if (str && strcmp (str, "1") == 0) return 1;
3485   str = getenv ("SKIP_TEST_FSCK");
3486   if (str && strcmp (str, "1") == 0) return 1;
3487   return 0;
3488 }
3489
3490 static int test_fsck_0 (void)
3491 {
3492   if (test_fsck_0_skip ()) {
3493     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
3494     return 0;
3495   }
3496
3497   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
3498   {
3499     char device[] = "/dev/sda";
3500     int r;
3501     suppress_error = 0;
3502     r = guestfs_blockdev_setrw (g, device);
3503     if (r == -1)
3504       return -1;
3505   }
3506   {
3507     int r;
3508     suppress_error = 0;
3509     r = guestfs_umount_all (g);
3510     if (r == -1)
3511       return -1;
3512   }
3513   {
3514     int r;
3515     suppress_error = 0;
3516     r = guestfs_lvm_remove_all (g);
3517     if (r == -1)
3518       return -1;
3519   }
3520   {
3521     char device[] = "/dev/sda";
3522     char lines_0[] = ",";
3523     char *lines[] = {
3524       lines_0,
3525       NULL
3526     };
3527     int r;
3528     suppress_error = 0;
3529     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3530     if (r == -1)
3531       return -1;
3532   }
3533   {
3534     char fstype[] = "ext2";
3535     char device[] = "/dev/sda1";
3536     int r;
3537     suppress_error = 0;
3538     r = guestfs_mkfs (g, fstype, device);
3539     if (r == -1)
3540       return -1;
3541   }
3542   {
3543     char device[] = "/dev/sda1";
3544     char mountpoint[] = "/";
3545     int r;
3546     suppress_error = 0;
3547     r = guestfs_mount (g, device, mountpoint);
3548     if (r == -1)
3549       return -1;
3550   }
3551   /* TestOutputInt for fsck (0) */
3552   {
3553     char pathordevice[] = "/dev/sda1";
3554     int r;
3555     suppress_error = 0;
3556     r = guestfs_umount (g, pathordevice);
3557     if (r == -1)
3558       return -1;
3559   }
3560   {
3561     char fstype[] = "ext2";
3562     char device[] = "/dev/sda1";
3563     int r;
3564     suppress_error = 0;
3565     r = guestfs_fsck (g, fstype, device);
3566     if (r == -1)
3567       return -1;
3568     if (r != 0) {
3569       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
3570       return -1;
3571     }
3572   }
3573   return 0;
3574 }
3575
3576 static int test_fsck_1_skip (void)
3577 {
3578   const char *str;
3579
3580   str = getenv ("SKIP_TEST_FSCK_1");
3581   if (str && strcmp (str, "1") == 0) return 1;
3582   str = getenv ("SKIP_TEST_FSCK");
3583   if (str && strcmp (str, "1") == 0) return 1;
3584   return 0;
3585 }
3586
3587 static int test_fsck_1 (void)
3588 {
3589   if (test_fsck_1_skip ()) {
3590     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3591     return 0;
3592   }
3593
3594   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3595   {
3596     char device[] = "/dev/sda";
3597     int r;
3598     suppress_error = 0;
3599     r = guestfs_blockdev_setrw (g, device);
3600     if (r == -1)
3601       return -1;
3602   }
3603   {
3604     int r;
3605     suppress_error = 0;
3606     r = guestfs_umount_all (g);
3607     if (r == -1)
3608       return -1;
3609   }
3610   {
3611     int r;
3612     suppress_error = 0;
3613     r = guestfs_lvm_remove_all (g);
3614     if (r == -1)
3615       return -1;
3616   }
3617   {
3618     char device[] = "/dev/sda";
3619     char lines_0[] = ",";
3620     char *lines[] = {
3621       lines_0,
3622       NULL
3623     };
3624     int r;
3625     suppress_error = 0;
3626     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3627     if (r == -1)
3628       return -1;
3629   }
3630   {
3631     char fstype[] = "ext2";
3632     char device[] = "/dev/sda1";
3633     int r;
3634     suppress_error = 0;
3635     r = guestfs_mkfs (g, fstype, device);
3636     if (r == -1)
3637       return -1;
3638   }
3639   {
3640     char device[] = "/dev/sda1";
3641     char mountpoint[] = "/";
3642     int r;
3643     suppress_error = 0;
3644     r = guestfs_mount (g, device, mountpoint);
3645     if (r == -1)
3646       return -1;
3647   }
3648   /* TestOutputInt for fsck (1) */
3649   {
3650     char pathordevice[] = "/dev/sda1";
3651     int r;
3652     suppress_error = 0;
3653     r = guestfs_umount (g, pathordevice);
3654     if (r == -1)
3655       return -1;
3656   }
3657   {
3658     char device[] = "/dev/sda1";
3659     int r;
3660     suppress_error = 0;
3661     r = guestfs_zero (g, device);
3662     if (r == -1)
3663       return -1;
3664   }
3665   {
3666     char fstype[] = "ext2";
3667     char device[] = "/dev/sda1";
3668     int r;
3669     suppress_error = 0;
3670     r = guestfs_fsck (g, fstype, device);
3671     if (r == -1)
3672       return -1;
3673     if (r != 8) {
3674       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
3675       return -1;
3676     }
3677   }
3678   return 0;
3679 }
3680
3681 static int test_set_e2uuid_0_skip (void)
3682 {
3683   const char *str;
3684
3685   str = getenv ("SKIP_TEST_SET_E2UUID_0");
3686   if (str && strcmp (str, "1") == 0) return 1;
3687   str = getenv ("SKIP_TEST_SET_E2UUID");
3688   if (str && strcmp (str, "1") == 0) return 1;
3689   return 0;
3690 }
3691
3692 static int test_set_e2uuid_0 (void)
3693 {
3694   if (test_set_e2uuid_0_skip ()) {
3695     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3696     return 0;
3697   }
3698
3699   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3700   {
3701     char device[] = "/dev/sda";
3702     int r;
3703     suppress_error = 0;
3704     r = guestfs_blockdev_setrw (g, device);
3705     if (r == -1)
3706       return -1;
3707   }
3708   {
3709     int r;
3710     suppress_error = 0;
3711     r = guestfs_umount_all (g);
3712     if (r == -1)
3713       return -1;
3714   }
3715   {
3716     int r;
3717     suppress_error = 0;
3718     r = guestfs_lvm_remove_all (g);
3719     if (r == -1)
3720       return -1;
3721   }
3722   {
3723     char device[] = "/dev/sda";
3724     char lines_0[] = ",";
3725     char *lines[] = {
3726       lines_0,
3727       NULL
3728     };
3729     int r;
3730     suppress_error = 0;
3731     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3732     if (r == -1)
3733       return -1;
3734   }
3735   {
3736     char fstype[] = "ext2";
3737     char device[] = "/dev/sda1";
3738     int r;
3739     suppress_error = 0;
3740     r = guestfs_mkfs (g, fstype, device);
3741     if (r == -1)
3742       return -1;
3743   }
3744   {
3745     char device[] = "/dev/sda1";
3746     char mountpoint[] = "/";
3747     int r;
3748     suppress_error = 0;
3749     r = guestfs_mount (g, device, mountpoint);
3750     if (r == -1)
3751       return -1;
3752   }
3753   /* TestOutput for set_e2uuid (0) */
3754   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3755   {
3756     char device[] = "/dev/sda1";
3757     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3758     int r;
3759     suppress_error = 0;
3760     r = guestfs_set_e2uuid (g, device, uuid);
3761     if (r == -1)
3762       return -1;
3763   }
3764   {
3765     char device[] = "/dev/sda1";
3766     char *r;
3767     suppress_error = 0;
3768     r = guestfs_get_e2uuid (g, device);
3769     if (r == NULL)
3770       return -1;
3771     if (strcmp (r, expected) != 0) {
3772       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3773       return -1;
3774     }
3775     free (r);
3776   }
3777   return 0;
3778 }
3779
3780 static int test_set_e2uuid_1_skip (void)
3781 {
3782   const char *str;
3783
3784   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3785   if (str && strcmp (str, "1") == 0) return 1;
3786   str = getenv ("SKIP_TEST_SET_E2UUID");
3787   if (str && strcmp (str, "1") == 0) return 1;
3788   return 0;
3789 }
3790
3791 static int test_set_e2uuid_1 (void)
3792 {
3793   if (test_set_e2uuid_1_skip ()) {
3794     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3795     return 0;
3796   }
3797
3798   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3799   {
3800     char device[] = "/dev/sda";
3801     int r;
3802     suppress_error = 0;
3803     r = guestfs_blockdev_setrw (g, device);
3804     if (r == -1)
3805       return -1;
3806   }
3807   {
3808     int r;
3809     suppress_error = 0;
3810     r = guestfs_umount_all (g);
3811     if (r == -1)
3812       return -1;
3813   }
3814   {
3815     int r;
3816     suppress_error = 0;
3817     r = guestfs_lvm_remove_all (g);
3818     if (r == -1)
3819       return -1;
3820   }
3821   {
3822     char device[] = "/dev/sda";
3823     char lines_0[] = ",";
3824     char *lines[] = {
3825       lines_0,
3826       NULL
3827     };
3828     int r;
3829     suppress_error = 0;
3830     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3831     if (r == -1)
3832       return -1;
3833   }
3834   {
3835     char fstype[] = "ext2";
3836     char device[] = "/dev/sda1";
3837     int r;
3838     suppress_error = 0;
3839     r = guestfs_mkfs (g, fstype, device);
3840     if (r == -1)
3841       return -1;
3842   }
3843   {
3844     char device[] = "/dev/sda1";
3845     char mountpoint[] = "/";
3846     int r;
3847     suppress_error = 0;
3848     r = guestfs_mount (g, device, mountpoint);
3849     if (r == -1)
3850       return -1;
3851   }
3852   /* TestOutput for set_e2uuid (1) */
3853   char expected[] = "";
3854   {
3855     char device[] = "/dev/sda1";
3856     char uuid[] = "clear";
3857     int r;
3858     suppress_error = 0;
3859     r = guestfs_set_e2uuid (g, device, uuid);
3860     if (r == -1)
3861       return -1;
3862   }
3863   {
3864     char device[] = "/dev/sda1";
3865     char *r;
3866     suppress_error = 0;
3867     r = guestfs_get_e2uuid (g, device);
3868     if (r == NULL)
3869       return -1;
3870     if (strcmp (r, expected) != 0) {
3871       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3872       return -1;
3873     }
3874     free (r);
3875   }
3876   return 0;
3877 }
3878
3879 static int test_set_e2uuid_2_skip (void)
3880 {
3881   const char *str;
3882
3883   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3884   if (str && strcmp (str, "1") == 0) return 1;
3885   str = getenv ("SKIP_TEST_SET_E2UUID");
3886   if (str && strcmp (str, "1") == 0) return 1;
3887   return 0;
3888 }
3889
3890 static int test_set_e2uuid_2 (void)
3891 {
3892   if (test_set_e2uuid_2_skip ()) {
3893     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3894     return 0;
3895   }
3896
3897   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3898   {
3899     char device[] = "/dev/sda";
3900     int r;
3901     suppress_error = 0;
3902     r = guestfs_blockdev_setrw (g, device);
3903     if (r == -1)
3904       return -1;
3905   }
3906   {
3907     int r;
3908     suppress_error = 0;
3909     r = guestfs_umount_all (g);
3910     if (r == -1)
3911       return -1;
3912   }
3913   {
3914     int r;
3915     suppress_error = 0;
3916     r = guestfs_lvm_remove_all (g);
3917     if (r == -1)
3918       return -1;
3919   }
3920   {
3921     char device[] = "/dev/sda";
3922     char lines_0[] = ",";
3923     char *lines[] = {
3924       lines_0,
3925       NULL
3926     };
3927     int r;
3928     suppress_error = 0;
3929     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3930     if (r == -1)
3931       return -1;
3932   }
3933   {
3934     char fstype[] = "ext2";
3935     char device[] = "/dev/sda1";
3936     int r;
3937     suppress_error = 0;
3938     r = guestfs_mkfs (g, fstype, device);
3939     if (r == -1)
3940       return -1;
3941   }
3942   {
3943     char device[] = "/dev/sda1";
3944     char mountpoint[] = "/";
3945     int r;
3946     suppress_error = 0;
3947     r = guestfs_mount (g, device, mountpoint);
3948     if (r == -1)
3949       return -1;
3950   }
3951   /* TestRun for set_e2uuid (2) */
3952   {
3953     char device[] = "/dev/sda1";
3954     char uuid[] = "random";
3955     int r;
3956     suppress_error = 0;
3957     r = guestfs_set_e2uuid (g, device, uuid);
3958     if (r == -1)
3959       return -1;
3960   }
3961   return 0;
3962 }
3963
3964 static int test_set_e2uuid_3_skip (void)
3965 {
3966   const char *str;
3967
3968   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3969   if (str && strcmp (str, "1") == 0) return 1;
3970   str = getenv ("SKIP_TEST_SET_E2UUID");
3971   if (str && strcmp (str, "1") == 0) return 1;
3972   return 0;
3973 }
3974
3975 static int test_set_e2uuid_3 (void)
3976 {
3977   if (test_set_e2uuid_3_skip ()) {
3978     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3979     return 0;
3980   }
3981
3982   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3983   {
3984     char device[] = "/dev/sda";
3985     int r;
3986     suppress_error = 0;
3987     r = guestfs_blockdev_setrw (g, device);
3988     if (r == -1)
3989       return -1;
3990   }
3991   {
3992     int r;
3993     suppress_error = 0;
3994     r = guestfs_umount_all (g);
3995     if (r == -1)
3996       return -1;
3997   }
3998   {
3999     int r;
4000     suppress_error = 0;
4001     r = guestfs_lvm_remove_all (g);
4002     if (r == -1)
4003       return -1;
4004   }
4005   {
4006     char device[] = "/dev/sda";
4007     char lines_0[] = ",";
4008     char *lines[] = {
4009       lines_0,
4010       NULL
4011     };
4012     int r;
4013     suppress_error = 0;
4014     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4015     if (r == -1)
4016       return -1;
4017   }
4018   {
4019     char fstype[] = "ext2";
4020     char device[] = "/dev/sda1";
4021     int r;
4022     suppress_error = 0;
4023     r = guestfs_mkfs (g, fstype, device);
4024     if (r == -1)
4025       return -1;
4026   }
4027   {
4028     char device[] = "/dev/sda1";
4029     char mountpoint[] = "/";
4030     int r;
4031     suppress_error = 0;
4032     r = guestfs_mount (g, device, mountpoint);
4033     if (r == -1)
4034       return -1;
4035   }
4036   /* TestRun for set_e2uuid (3) */
4037   {
4038     char device[] = "/dev/sda1";
4039     char uuid[] = "time";
4040     int r;
4041     suppress_error = 0;
4042     r = guestfs_set_e2uuid (g, device, uuid);
4043     if (r == -1)
4044       return -1;
4045   }
4046   return 0;
4047 }
4048
4049 static int test_set_e2label_0_skip (void)
4050 {
4051   const char *str;
4052
4053   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
4054   if (str && strcmp (str, "1") == 0) return 1;
4055   str = getenv ("SKIP_TEST_SET_E2LABEL");
4056   if (str && strcmp (str, "1") == 0) return 1;
4057   return 0;
4058 }
4059
4060 static int test_set_e2label_0 (void)
4061 {
4062   if (test_set_e2label_0_skip ()) {
4063     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
4064     return 0;
4065   }
4066
4067   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
4068   {
4069     char device[] = "/dev/sda";
4070     int r;
4071     suppress_error = 0;
4072     r = guestfs_blockdev_setrw (g, device);
4073     if (r == -1)
4074       return -1;
4075   }
4076   {
4077     int r;
4078     suppress_error = 0;
4079     r = guestfs_umount_all (g);
4080     if (r == -1)
4081       return -1;
4082   }
4083   {
4084     int r;
4085     suppress_error = 0;
4086     r = guestfs_lvm_remove_all (g);
4087     if (r == -1)
4088       return -1;
4089   }
4090   {
4091     char device[] = "/dev/sda";
4092     char lines_0[] = ",";
4093     char *lines[] = {
4094       lines_0,
4095       NULL
4096     };
4097     int r;
4098     suppress_error = 0;
4099     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4100     if (r == -1)
4101       return -1;
4102   }
4103   {
4104     char fstype[] = "ext2";
4105     char device[] = "/dev/sda1";
4106     int r;
4107     suppress_error = 0;
4108     r = guestfs_mkfs (g, fstype, device);
4109     if (r == -1)
4110       return -1;
4111   }
4112   {
4113     char device[] = "/dev/sda1";
4114     char mountpoint[] = "/";
4115     int r;
4116     suppress_error = 0;
4117     r = guestfs_mount (g, device, mountpoint);
4118     if (r == -1)
4119       return -1;
4120   }
4121   /* TestOutput for set_e2label (0) */
4122   char expected[] = "testlabel";
4123   {
4124     char device[] = "/dev/sda1";
4125     char label[] = "testlabel";
4126     int r;
4127     suppress_error = 0;
4128     r = guestfs_set_e2label (g, device, label);
4129     if (r == -1)
4130       return -1;
4131   }
4132   {
4133     char device[] = "/dev/sda1";
4134     char *r;
4135     suppress_error = 0;
4136     r = guestfs_get_e2label (g, device);
4137     if (r == NULL)
4138       return -1;
4139     if (strcmp (r, expected) != 0) {
4140       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
4141       return -1;
4142     }
4143     free (r);
4144   }
4145   return 0;
4146 }
4147
4148 static int test_pvremove_0_skip (void)
4149 {
4150   const char *str;
4151
4152   str = getenv ("SKIP_TEST_PVREMOVE_0");
4153   if (str && strcmp (str, "1") == 0) return 1;
4154   str = getenv ("SKIP_TEST_PVREMOVE");
4155   if (str && strcmp (str, "1") == 0) return 1;
4156   return 0;
4157 }
4158
4159 static int test_pvremove_0 (void)
4160 {
4161   if (test_pvremove_0_skip ()) {
4162     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
4163     return 0;
4164   }
4165
4166   /* InitNone|InitEmpty for test_pvremove_0 */
4167   {
4168     char device[] = "/dev/sda";
4169     int r;
4170     suppress_error = 0;
4171     r = guestfs_blockdev_setrw (g, device);
4172     if (r == -1)
4173       return -1;
4174   }
4175   {
4176     int r;
4177     suppress_error = 0;
4178     r = guestfs_umount_all (g);
4179     if (r == -1)
4180       return -1;
4181   }
4182   {
4183     int r;
4184     suppress_error = 0;
4185     r = guestfs_lvm_remove_all (g);
4186     if (r == -1)
4187       return -1;
4188   }
4189   /* TestOutputListOfDevices for pvremove (0) */
4190   {
4191     char device[] = "/dev/sda";
4192     char lines_0[] = ",";
4193     char *lines[] = {
4194       lines_0,
4195       NULL
4196     };
4197     int r;
4198     suppress_error = 0;
4199     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4200     if (r == -1)
4201       return -1;
4202   }
4203   {
4204     char device[] = "/dev/sda1";
4205     int r;
4206     suppress_error = 0;
4207     r = guestfs_pvcreate (g, device);
4208     if (r == -1)
4209       return -1;
4210   }
4211   {
4212     char volgroup[] = "VG";
4213     char physvols_0[] = "/dev/sda1";
4214     char *physvols[] = {
4215       physvols_0,
4216       NULL
4217     };
4218     int r;
4219     suppress_error = 0;
4220     r = guestfs_vgcreate (g, volgroup, physvols);
4221     if (r == -1)
4222       return -1;
4223   }
4224   {
4225     char logvol[] = "LV1";
4226     char volgroup[] = "VG";
4227     int r;
4228     suppress_error = 0;
4229     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4230     if (r == -1)
4231       return -1;
4232   }
4233   {
4234     char logvol[] = "LV2";
4235     char volgroup[] = "VG";
4236     int r;
4237     suppress_error = 0;
4238     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4239     if (r == -1)
4240       return -1;
4241   }
4242   {
4243     char vgname[] = "VG";
4244     int r;
4245     suppress_error = 0;
4246     r = guestfs_vgremove (g, vgname);
4247     if (r == -1)
4248       return -1;
4249   }
4250   {
4251     char device[] = "/dev/sda1";
4252     int r;
4253     suppress_error = 0;
4254     r = guestfs_pvremove (g, device);
4255     if (r == -1)
4256       return -1;
4257   }
4258   {
4259     char **r;
4260     int i;
4261     suppress_error = 0;
4262     r = guestfs_lvs (g);
4263     if (r == NULL)
4264       return -1;
4265     if (r[0] != NULL) {
4266       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
4267       print_strings (r);
4268       return -1;
4269     }
4270     for (i = 0; r[i] != NULL; ++i)
4271       free (r[i]);
4272     free (r);
4273   }
4274   return 0;
4275 }
4276
4277 static int test_pvremove_1_skip (void)
4278 {
4279   const char *str;
4280
4281   str = getenv ("SKIP_TEST_PVREMOVE_1");
4282   if (str && strcmp (str, "1") == 0) return 1;
4283   str = getenv ("SKIP_TEST_PVREMOVE");
4284   if (str && strcmp (str, "1") == 0) return 1;
4285   return 0;
4286 }
4287
4288 static int test_pvremove_1 (void)
4289 {
4290   if (test_pvremove_1_skip ()) {
4291     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
4292     return 0;
4293   }
4294
4295   /* InitNone|InitEmpty for test_pvremove_1 */
4296   {
4297     char device[] = "/dev/sda";
4298     int r;
4299     suppress_error = 0;
4300     r = guestfs_blockdev_setrw (g, device);
4301     if (r == -1)
4302       return -1;
4303   }
4304   {
4305     int r;
4306     suppress_error = 0;
4307     r = guestfs_umount_all (g);
4308     if (r == -1)
4309       return -1;
4310   }
4311   {
4312     int r;
4313     suppress_error = 0;
4314     r = guestfs_lvm_remove_all (g);
4315     if (r == -1)
4316       return -1;
4317   }
4318   /* TestOutputListOfDevices for pvremove (1) */
4319   {
4320     char device[] = "/dev/sda";
4321     char lines_0[] = ",";
4322     char *lines[] = {
4323       lines_0,
4324       NULL
4325     };
4326     int r;
4327     suppress_error = 0;
4328     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4329     if (r == -1)
4330       return -1;
4331   }
4332   {
4333     char device[] = "/dev/sda1";
4334     int r;
4335     suppress_error = 0;
4336     r = guestfs_pvcreate (g, device);
4337     if (r == -1)
4338       return -1;
4339   }
4340   {
4341     char volgroup[] = "VG";
4342     char physvols_0[] = "/dev/sda1";
4343     char *physvols[] = {
4344       physvols_0,
4345       NULL
4346     };
4347     int r;
4348     suppress_error = 0;
4349     r = guestfs_vgcreate (g, volgroup, physvols);
4350     if (r == -1)
4351       return -1;
4352   }
4353   {
4354     char logvol[] = "LV1";
4355     char volgroup[] = "VG";
4356     int r;
4357     suppress_error = 0;
4358     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4359     if (r == -1)
4360       return -1;
4361   }
4362   {
4363     char logvol[] = "LV2";
4364     char volgroup[] = "VG";
4365     int r;
4366     suppress_error = 0;
4367     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4368     if (r == -1)
4369       return -1;
4370   }
4371   {
4372     char vgname[] = "VG";
4373     int r;
4374     suppress_error = 0;
4375     r = guestfs_vgremove (g, vgname);
4376     if (r == -1)
4377       return -1;
4378   }
4379   {
4380     char device[] = "/dev/sda1";
4381     int r;
4382     suppress_error = 0;
4383     r = guestfs_pvremove (g, device);
4384     if (r == -1)
4385       return -1;
4386   }
4387   {
4388     char **r;
4389     int i;
4390     suppress_error = 0;
4391     r = guestfs_vgs (g);
4392     if (r == NULL)
4393       return -1;
4394     if (r[0] != NULL) {
4395       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
4396       print_strings (r);
4397       return -1;
4398     }
4399     for (i = 0; r[i] != NULL; ++i)
4400       free (r[i]);
4401     free (r);
4402   }
4403   return 0;
4404 }
4405
4406 static int test_pvremove_2_skip (void)
4407 {
4408   const char *str;
4409
4410   str = getenv ("SKIP_TEST_PVREMOVE_2");
4411   if (str && strcmp (str, "1") == 0) return 1;
4412   str = getenv ("SKIP_TEST_PVREMOVE");
4413   if (str && strcmp (str, "1") == 0) return 1;
4414   return 0;
4415 }
4416
4417 static int test_pvremove_2 (void)
4418 {
4419   if (test_pvremove_2_skip ()) {
4420     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
4421     return 0;
4422   }
4423
4424   /* InitNone|InitEmpty for test_pvremove_2 */
4425   {
4426     char device[] = "/dev/sda";
4427     int r;
4428     suppress_error = 0;
4429     r = guestfs_blockdev_setrw (g, device);
4430     if (r == -1)
4431       return -1;
4432   }
4433   {
4434     int r;
4435     suppress_error = 0;
4436     r = guestfs_umount_all (g);
4437     if (r == -1)
4438       return -1;
4439   }
4440   {
4441     int r;
4442     suppress_error = 0;
4443     r = guestfs_lvm_remove_all (g);
4444     if (r == -1)
4445       return -1;
4446   }
4447   /* TestOutputListOfDevices for pvremove (2) */
4448   {
4449     char device[] = "/dev/sda";
4450     char lines_0[] = ",";
4451     char *lines[] = {
4452       lines_0,
4453       NULL
4454     };
4455     int r;
4456     suppress_error = 0;
4457     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4458     if (r == -1)
4459       return -1;
4460   }
4461   {
4462     char device[] = "/dev/sda1";
4463     int r;
4464     suppress_error = 0;
4465     r = guestfs_pvcreate (g, device);
4466     if (r == -1)
4467       return -1;
4468   }
4469   {
4470     char volgroup[] = "VG";
4471     char physvols_0[] = "/dev/sda1";
4472     char *physvols[] = {
4473       physvols_0,
4474       NULL
4475     };
4476     int r;
4477     suppress_error = 0;
4478     r = guestfs_vgcreate (g, volgroup, physvols);
4479     if (r == -1)
4480       return -1;
4481   }
4482   {
4483     char logvol[] = "LV1";
4484     char volgroup[] = "VG";
4485     int r;
4486     suppress_error = 0;
4487     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4488     if (r == -1)
4489       return -1;
4490   }
4491   {
4492     char logvol[] = "LV2";
4493     char volgroup[] = "VG";
4494     int r;
4495     suppress_error = 0;
4496     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4497     if (r == -1)
4498       return -1;
4499   }
4500   {
4501     char vgname[] = "VG";
4502     int r;
4503     suppress_error = 0;
4504     r = guestfs_vgremove (g, vgname);
4505     if (r == -1)
4506       return -1;
4507   }
4508   {
4509     char device[] = "/dev/sda1";
4510     int r;
4511     suppress_error = 0;
4512     r = guestfs_pvremove (g, device);
4513     if (r == -1)
4514       return -1;
4515   }
4516   {
4517     char **r;
4518     int i;
4519     suppress_error = 0;
4520     r = guestfs_pvs (g);
4521     if (r == NULL)
4522       return -1;
4523     if (r[0] != NULL) {
4524       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
4525       print_strings (r);
4526       return -1;
4527     }
4528     for (i = 0; r[i] != NULL; ++i)
4529       free (r[i]);
4530     free (r);
4531   }
4532   return 0;
4533 }
4534
4535 static int test_vgremove_0_skip (void)
4536 {
4537   const char *str;
4538
4539   str = getenv ("SKIP_TEST_VGREMOVE_0");
4540   if (str && strcmp (str, "1") == 0) return 1;
4541   str = getenv ("SKIP_TEST_VGREMOVE");
4542   if (str && strcmp (str, "1") == 0) return 1;
4543   return 0;
4544 }
4545
4546 static int test_vgremove_0 (void)
4547 {
4548   if (test_vgremove_0_skip ()) {
4549     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
4550     return 0;
4551   }
4552
4553   /* InitNone|InitEmpty for test_vgremove_0 */
4554   {
4555     char device[] = "/dev/sda";
4556     int r;
4557     suppress_error = 0;
4558     r = guestfs_blockdev_setrw (g, device);
4559     if (r == -1)
4560       return -1;
4561   }
4562   {
4563     int r;
4564     suppress_error = 0;
4565     r = guestfs_umount_all (g);
4566     if (r == -1)
4567       return -1;
4568   }
4569   {
4570     int r;
4571     suppress_error = 0;
4572     r = guestfs_lvm_remove_all (g);
4573     if (r == -1)
4574       return -1;
4575   }
4576   /* TestOutputList for vgremove (0) */
4577   {
4578     char device[] = "/dev/sda";
4579     char lines_0[] = ",";
4580     char *lines[] = {
4581       lines_0,
4582       NULL
4583     };
4584     int r;
4585     suppress_error = 0;
4586     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4587     if (r == -1)
4588       return -1;
4589   }
4590   {
4591     char device[] = "/dev/sda1";
4592     int r;
4593     suppress_error = 0;
4594     r = guestfs_pvcreate (g, device);
4595     if (r == -1)
4596       return -1;
4597   }
4598   {
4599     char volgroup[] = "VG";
4600     char physvols_0[] = "/dev/sda1";
4601     char *physvols[] = {
4602       physvols_0,
4603       NULL
4604     };
4605     int r;
4606     suppress_error = 0;
4607     r = guestfs_vgcreate (g, volgroup, physvols);
4608     if (r == -1)
4609       return -1;
4610   }
4611   {
4612     char logvol[] = "LV1";
4613     char volgroup[] = "VG";
4614     int r;
4615     suppress_error = 0;
4616     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4617     if (r == -1)
4618       return -1;
4619   }
4620   {
4621     char logvol[] = "LV2";
4622     char volgroup[] = "VG";
4623     int r;
4624     suppress_error = 0;
4625     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4626     if (r == -1)
4627       return -1;
4628   }
4629   {
4630     char vgname[] = "VG";
4631     int r;
4632     suppress_error = 0;
4633     r = guestfs_vgremove (g, vgname);
4634     if (r == -1)
4635       return -1;
4636   }
4637   {
4638     char **r;
4639     int i;
4640     suppress_error = 0;
4641     r = guestfs_lvs (g);
4642     if (r == NULL)
4643       return -1;
4644     if (r[0] != NULL) {
4645       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4646       print_strings (r);
4647       return -1;
4648     }
4649     for (i = 0; r[i] != NULL; ++i)
4650       free (r[i]);
4651     free (r);
4652   }
4653   return 0;
4654 }
4655
4656 static int test_vgremove_1_skip (void)
4657 {
4658   const char *str;
4659
4660   str = getenv ("SKIP_TEST_VGREMOVE_1");
4661   if (str && strcmp (str, "1") == 0) return 1;
4662   str = getenv ("SKIP_TEST_VGREMOVE");
4663   if (str && strcmp (str, "1") == 0) return 1;
4664   return 0;
4665 }
4666
4667 static int test_vgremove_1 (void)
4668 {
4669   if (test_vgremove_1_skip ()) {
4670     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4671     return 0;
4672   }
4673
4674   /* InitNone|InitEmpty for test_vgremove_1 */
4675   {
4676     char device[] = "/dev/sda";
4677     int r;
4678     suppress_error = 0;
4679     r = guestfs_blockdev_setrw (g, device);
4680     if (r == -1)
4681       return -1;
4682   }
4683   {
4684     int r;
4685     suppress_error = 0;
4686     r = guestfs_umount_all (g);
4687     if (r == -1)
4688       return -1;
4689   }
4690   {
4691     int r;
4692     suppress_error = 0;
4693     r = guestfs_lvm_remove_all (g);
4694     if (r == -1)
4695       return -1;
4696   }
4697   /* TestOutputList for vgremove (1) */
4698   {
4699     char device[] = "/dev/sda";
4700     char lines_0[] = ",";
4701     char *lines[] = {
4702       lines_0,
4703       NULL
4704     };
4705     int r;
4706     suppress_error = 0;
4707     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4708     if (r == -1)
4709       return -1;
4710   }
4711   {
4712     char device[] = "/dev/sda1";
4713     int r;
4714     suppress_error = 0;
4715     r = guestfs_pvcreate (g, device);
4716     if (r == -1)
4717       return -1;
4718   }
4719   {
4720     char volgroup[] = "VG";
4721     char physvols_0[] = "/dev/sda1";
4722     char *physvols[] = {
4723       physvols_0,
4724       NULL
4725     };
4726     int r;
4727     suppress_error = 0;
4728     r = guestfs_vgcreate (g, volgroup, physvols);
4729     if (r == -1)
4730       return -1;
4731   }
4732   {
4733     char logvol[] = "LV1";
4734     char volgroup[] = "VG";
4735     int r;
4736     suppress_error = 0;
4737     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4738     if (r == -1)
4739       return -1;
4740   }
4741   {
4742     char logvol[] = "LV2";
4743     char volgroup[] = "VG";
4744     int r;
4745     suppress_error = 0;
4746     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4747     if (r == -1)
4748       return -1;
4749   }
4750   {
4751     char vgname[] = "VG";
4752     int r;
4753     suppress_error = 0;
4754     r = guestfs_vgremove (g, vgname);
4755     if (r == -1)
4756       return -1;
4757   }
4758   {
4759     char **r;
4760     int i;
4761     suppress_error = 0;
4762     r = guestfs_vgs (g);
4763     if (r == NULL)
4764       return -1;
4765     if (r[0] != NULL) {
4766       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4767       print_strings (r);
4768       return -1;
4769     }
4770     for (i = 0; r[i] != NULL; ++i)
4771       free (r[i]);
4772     free (r);
4773   }
4774   return 0;
4775 }
4776
4777 static int test_lvremove_0_skip (void)
4778 {
4779   const char *str;
4780
4781   str = getenv ("SKIP_TEST_LVREMOVE_0");
4782   if (str && strcmp (str, "1") == 0) return 1;
4783   str = getenv ("SKIP_TEST_LVREMOVE");
4784   if (str && strcmp (str, "1") == 0) return 1;
4785   return 0;
4786 }
4787
4788 static int test_lvremove_0 (void)
4789 {
4790   if (test_lvremove_0_skip ()) {
4791     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4792     return 0;
4793   }
4794
4795   /* InitNone|InitEmpty for test_lvremove_0 */
4796   {
4797     char device[] = "/dev/sda";
4798     int r;
4799     suppress_error = 0;
4800     r = guestfs_blockdev_setrw (g, device);
4801     if (r == -1)
4802       return -1;
4803   }
4804   {
4805     int r;
4806     suppress_error = 0;
4807     r = guestfs_umount_all (g);
4808     if (r == -1)
4809       return -1;
4810   }
4811   {
4812     int r;
4813     suppress_error = 0;
4814     r = guestfs_lvm_remove_all (g);
4815     if (r == -1)
4816       return -1;
4817   }
4818   /* TestOutputList for lvremove (0) */
4819   {
4820     char device[] = "/dev/sda";
4821     char lines_0[] = ",";
4822     char *lines[] = {
4823       lines_0,
4824       NULL
4825     };
4826     int r;
4827     suppress_error = 0;
4828     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4829     if (r == -1)
4830       return -1;
4831   }
4832   {
4833     char device[] = "/dev/sda1";
4834     int r;
4835     suppress_error = 0;
4836     r = guestfs_pvcreate (g, device);
4837     if (r == -1)
4838       return -1;
4839   }
4840   {
4841     char volgroup[] = "VG";
4842     char physvols_0[] = "/dev/sda1";
4843     char *physvols[] = {
4844       physvols_0,
4845       NULL
4846     };
4847     int r;
4848     suppress_error = 0;
4849     r = guestfs_vgcreate (g, volgroup, physvols);
4850     if (r == -1)
4851       return -1;
4852   }
4853   {
4854     char logvol[] = "LV1";
4855     char volgroup[] = "VG";
4856     int r;
4857     suppress_error = 0;
4858     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4859     if (r == -1)
4860       return -1;
4861   }
4862   {
4863     char logvol[] = "LV2";
4864     char volgroup[] = "VG";
4865     int r;
4866     suppress_error = 0;
4867     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4868     if (r == -1)
4869       return -1;
4870   }
4871   {
4872     char device[] = "/dev/VG/LV1";
4873     int r;
4874     suppress_error = 0;
4875     r = guestfs_lvremove (g, device);
4876     if (r == -1)
4877       return -1;
4878   }
4879   {
4880     char **r;
4881     int i;
4882     suppress_error = 0;
4883     r = guestfs_lvs (g);
4884     if (r == NULL)
4885       return -1;
4886     if (!r[0]) {
4887       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4888       print_strings (r);
4889       return -1;
4890     }
4891     {
4892       char expected[] = "/dev/VG/LV2";
4893       if (strcmp (r[0], expected) != 0) {
4894         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4895         return -1;
4896       }
4897     }
4898     if (r[1] != NULL) {
4899       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4900       print_strings (r);
4901       return -1;
4902     }
4903     for (i = 0; r[i] != NULL; ++i)
4904       free (r[i]);
4905     free (r);
4906   }
4907   return 0;
4908 }
4909
4910 static int test_lvremove_1_skip (void)
4911 {
4912   const char *str;
4913
4914   str = getenv ("SKIP_TEST_LVREMOVE_1");
4915   if (str && strcmp (str, "1") == 0) return 1;
4916   str = getenv ("SKIP_TEST_LVREMOVE");
4917   if (str && strcmp (str, "1") == 0) return 1;
4918   return 0;
4919 }
4920
4921 static int test_lvremove_1 (void)
4922 {
4923   if (test_lvremove_1_skip ()) {
4924     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4925     return 0;
4926   }
4927
4928   /* InitNone|InitEmpty for test_lvremove_1 */
4929   {
4930     char device[] = "/dev/sda";
4931     int r;
4932     suppress_error = 0;
4933     r = guestfs_blockdev_setrw (g, device);
4934     if (r == -1)
4935       return -1;
4936   }
4937   {
4938     int r;
4939     suppress_error = 0;
4940     r = guestfs_umount_all (g);
4941     if (r == -1)
4942       return -1;
4943   }
4944   {
4945     int r;
4946     suppress_error = 0;
4947     r = guestfs_lvm_remove_all (g);
4948     if (r == -1)
4949       return -1;
4950   }
4951   /* TestOutputList for lvremove (1) */
4952   {
4953     char device[] = "/dev/sda";
4954     char lines_0[] = ",";
4955     char *lines[] = {
4956       lines_0,
4957       NULL
4958     };
4959     int r;
4960     suppress_error = 0;
4961     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4962     if (r == -1)
4963       return -1;
4964   }
4965   {
4966     char device[] = "/dev/sda1";
4967     int r;
4968     suppress_error = 0;
4969     r = guestfs_pvcreate (g, device);
4970     if (r == -1)
4971       return -1;
4972   }
4973   {
4974     char volgroup[] = "VG";
4975     char physvols_0[] = "/dev/sda1";
4976     char *physvols[] = {
4977       physvols_0,
4978       NULL
4979     };
4980     int r;
4981     suppress_error = 0;
4982     r = guestfs_vgcreate (g, volgroup, physvols);
4983     if (r == -1)
4984       return -1;
4985   }
4986   {
4987     char logvol[] = "LV1";
4988     char volgroup[] = "VG";
4989     int r;
4990     suppress_error = 0;
4991     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4992     if (r == -1)
4993       return -1;
4994   }
4995   {
4996     char logvol[] = "LV2";
4997     char volgroup[] = "VG";
4998     int r;
4999     suppress_error = 0;
5000     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5001     if (r == -1)
5002       return -1;
5003   }
5004   {
5005     char device[] = "/dev/VG";
5006     int r;
5007     suppress_error = 0;
5008     r = guestfs_lvremove (g, device);
5009     if (r == -1)
5010       return -1;
5011   }
5012   {
5013     char **r;
5014     int i;
5015     suppress_error = 0;
5016     r = guestfs_lvs (g);
5017     if (r == NULL)
5018       return -1;
5019     if (r[0] != NULL) {
5020       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
5021       print_strings (r);
5022       return -1;
5023     }
5024     for (i = 0; r[i] != NULL; ++i)
5025       free (r[i]);
5026     free (r);
5027   }
5028   return 0;
5029 }
5030
5031 static int test_lvremove_2_skip (void)
5032 {
5033   const char *str;
5034
5035   str = getenv ("SKIP_TEST_LVREMOVE_2");
5036   if (str && strcmp (str, "1") == 0) return 1;
5037   str = getenv ("SKIP_TEST_LVREMOVE");
5038   if (str && strcmp (str, "1") == 0) return 1;
5039   return 0;
5040 }
5041
5042 static int test_lvremove_2 (void)
5043 {
5044   if (test_lvremove_2_skip ()) {
5045     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
5046     return 0;
5047   }
5048
5049   /* InitNone|InitEmpty for test_lvremove_2 */
5050   {
5051     char device[] = "/dev/sda";
5052     int r;
5053     suppress_error = 0;
5054     r = guestfs_blockdev_setrw (g, device);
5055     if (r == -1)
5056       return -1;
5057   }
5058   {
5059     int r;
5060     suppress_error = 0;
5061     r = guestfs_umount_all (g);
5062     if (r == -1)
5063       return -1;
5064   }
5065   {
5066     int r;
5067     suppress_error = 0;
5068     r = guestfs_lvm_remove_all (g);
5069     if (r == -1)
5070       return -1;
5071   }
5072   /* TestOutputList for lvremove (2) */
5073   {
5074     char device[] = "/dev/sda";
5075     char lines_0[] = ",";
5076     char *lines[] = {
5077       lines_0,
5078       NULL
5079     };
5080     int r;
5081     suppress_error = 0;
5082     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5083     if (r == -1)
5084       return -1;
5085   }
5086   {
5087     char device[] = "/dev/sda1";
5088     int r;
5089     suppress_error = 0;
5090     r = guestfs_pvcreate (g, device);
5091     if (r == -1)
5092       return -1;
5093   }
5094   {
5095     char volgroup[] = "VG";
5096     char physvols_0[] = "/dev/sda1";
5097     char *physvols[] = {
5098       physvols_0,
5099       NULL
5100     };
5101     int r;
5102     suppress_error = 0;
5103     r = guestfs_vgcreate (g, volgroup, physvols);
5104     if (r == -1)
5105       return -1;
5106   }
5107   {
5108     char logvol[] = "LV1";
5109     char volgroup[] = "VG";
5110     int r;
5111     suppress_error = 0;
5112     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5113     if (r == -1)
5114       return -1;
5115   }
5116   {
5117     char logvol[] = "LV2";
5118     char volgroup[] = "VG";
5119     int r;
5120     suppress_error = 0;
5121     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5122     if (r == -1)
5123       return -1;
5124   }
5125   {
5126     char device[] = "/dev/VG";
5127     int r;
5128     suppress_error = 0;
5129     r = guestfs_lvremove (g, device);
5130     if (r == -1)
5131       return -1;
5132   }
5133   {
5134     char **r;
5135     int i;
5136     suppress_error = 0;
5137     r = guestfs_vgs (g);
5138     if (r == NULL)
5139       return -1;
5140     if (!r[0]) {
5141       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
5142       print_strings (r);
5143       return -1;
5144     }
5145     {
5146       char expected[] = "VG";
5147       if (strcmp (r[0], expected) != 0) {
5148         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5149         return -1;
5150       }
5151     }
5152     if (r[1] != NULL) {
5153       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
5154       print_strings (r);
5155       return -1;
5156     }
5157     for (i = 0; r[i] != NULL; ++i)
5158       free (r[i]);
5159     free (r);
5160   }
5161   return 0;
5162 }
5163
5164 static int test_mount_ro_0_skip (void)
5165 {
5166   const char *str;
5167
5168   str = getenv ("SKIP_TEST_MOUNT_RO_0");
5169   if (str && strcmp (str, "1") == 0) return 1;
5170   str = getenv ("SKIP_TEST_MOUNT_RO");
5171   if (str && strcmp (str, "1") == 0) return 1;
5172   return 0;
5173 }
5174
5175 static int test_mount_ro_0 (void)
5176 {
5177   if (test_mount_ro_0_skip ()) {
5178     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
5179     return 0;
5180   }
5181
5182   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
5183   {
5184     char device[] = "/dev/sda";
5185     int r;
5186     suppress_error = 0;
5187     r = guestfs_blockdev_setrw (g, device);
5188     if (r == -1)
5189       return -1;
5190   }
5191   {
5192     int r;
5193     suppress_error = 0;
5194     r = guestfs_umount_all (g);
5195     if (r == -1)
5196       return -1;
5197   }
5198   {
5199     int r;
5200     suppress_error = 0;
5201     r = guestfs_lvm_remove_all (g);
5202     if (r == -1)
5203       return -1;
5204   }
5205   {
5206     char device[] = "/dev/sda";
5207     char lines_0[] = ",";
5208     char *lines[] = {
5209       lines_0,
5210       NULL
5211     };
5212     int r;
5213     suppress_error = 0;
5214     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5215     if (r == -1)
5216       return -1;
5217   }
5218   {
5219     char fstype[] = "ext2";
5220     char device[] = "/dev/sda1";
5221     int r;
5222     suppress_error = 0;
5223     r = guestfs_mkfs (g, fstype, device);
5224     if (r == -1)
5225       return -1;
5226   }
5227   {
5228     char device[] = "/dev/sda1";
5229     char mountpoint[] = "/";
5230     int r;
5231     suppress_error = 0;
5232     r = guestfs_mount (g, device, mountpoint);
5233     if (r == -1)
5234       return -1;
5235   }
5236   /* TestLastFail for mount_ro (0) */
5237   {
5238     char pathordevice[] = "/";
5239     int r;
5240     suppress_error = 0;
5241     r = guestfs_umount (g, pathordevice);
5242     if (r == -1)
5243       return -1;
5244   }
5245   {
5246     char device[] = "/dev/sda1";
5247     char mountpoint[] = "/";
5248     int r;
5249     suppress_error = 0;
5250     r = guestfs_mount_ro (g, device, mountpoint);
5251     if (r == -1)
5252       return -1;
5253   }
5254   {
5255     char path[] = "/new";
5256     int r;
5257     suppress_error = 1;
5258     r = guestfs_touch (g, path);
5259     if (r != -1)
5260       return -1;
5261   }
5262   return 0;
5263 }
5264
5265 static int test_mount_ro_1_skip (void)
5266 {
5267   const char *str;
5268
5269   str = getenv ("SKIP_TEST_MOUNT_RO_1");
5270   if (str && strcmp (str, "1") == 0) return 1;
5271   str = getenv ("SKIP_TEST_MOUNT_RO");
5272   if (str && strcmp (str, "1") == 0) return 1;
5273   return 0;
5274 }
5275
5276 static int test_mount_ro_1 (void)
5277 {
5278   if (test_mount_ro_1_skip ()) {
5279     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
5280     return 0;
5281   }
5282
5283   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5284   {
5285     char device[] = "/dev/sda";
5286     int r;
5287     suppress_error = 0;
5288     r = guestfs_blockdev_setrw (g, device);
5289     if (r == -1)
5290       return -1;
5291   }
5292   {
5293     int r;
5294     suppress_error = 0;
5295     r = guestfs_umount_all (g);
5296     if (r == -1)
5297       return -1;
5298   }
5299   {
5300     int r;
5301     suppress_error = 0;
5302     r = guestfs_lvm_remove_all (g);
5303     if (r == -1)
5304       return -1;
5305   }
5306   {
5307     char device[] = "/dev/sda";
5308     char lines_0[] = ",";
5309     char *lines[] = {
5310       lines_0,
5311       NULL
5312     };
5313     int r;
5314     suppress_error = 0;
5315     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5316     if (r == -1)
5317       return -1;
5318   }
5319   {
5320     char fstype[] = "ext2";
5321     char device[] = "/dev/sda1";
5322     int r;
5323     suppress_error = 0;
5324     r = guestfs_mkfs (g, fstype, device);
5325     if (r == -1)
5326       return -1;
5327   }
5328   {
5329     char device[] = "/dev/sda1";
5330     char mountpoint[] = "/";
5331     int r;
5332     suppress_error = 0;
5333     r = guestfs_mount (g, device, mountpoint);
5334     if (r == -1)
5335       return -1;
5336   }
5337   /* TestOutput for mount_ro (1) */
5338   char expected[] = "data";
5339   {
5340     char path[] = "/new";
5341     char content[] = "data";
5342     int r;
5343     suppress_error = 0;
5344     r = guestfs_write_file (g, path, content, 0);
5345     if (r == -1)
5346       return -1;
5347   }
5348   {
5349     char pathordevice[] = "/";
5350     int r;
5351     suppress_error = 0;
5352     r = guestfs_umount (g, pathordevice);
5353     if (r == -1)
5354       return -1;
5355   }
5356   {
5357     char device[] = "/dev/sda1";
5358     char mountpoint[] = "/";
5359     int r;
5360     suppress_error = 0;
5361     r = guestfs_mount_ro (g, device, mountpoint);
5362     if (r == -1)
5363       return -1;
5364   }
5365   {
5366     char path[] = "/new";
5367     char *r;
5368     suppress_error = 0;
5369     r = guestfs_cat (g, path);
5370     if (r == NULL)
5371       return -1;
5372     if (strcmp (r, expected) != 0) {
5373       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5374       return -1;
5375     }
5376     free (r);
5377   }
5378   return 0;
5379 }
5380
5381 static int test_tgz_in_0_skip (void)
5382 {
5383   const char *str;
5384
5385   str = getenv ("SKIP_TEST_TGZ_IN_0");
5386   if (str && strcmp (str, "1") == 0) return 1;
5387   str = getenv ("SKIP_TEST_TGZ_IN");
5388   if (str && strcmp (str, "1") == 0) return 1;
5389   return 0;
5390 }
5391
5392 static int test_tgz_in_0 (void)
5393 {
5394   if (test_tgz_in_0_skip ()) {
5395     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
5396     return 0;
5397   }
5398
5399   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5400   {
5401     char device[] = "/dev/sda";
5402     int r;
5403     suppress_error = 0;
5404     r = guestfs_blockdev_setrw (g, device);
5405     if (r == -1)
5406       return -1;
5407   }
5408   {
5409     int r;
5410     suppress_error = 0;
5411     r = guestfs_umount_all (g);
5412     if (r == -1)
5413       return -1;
5414   }
5415   {
5416     int r;
5417     suppress_error = 0;
5418     r = guestfs_lvm_remove_all (g);
5419     if (r == -1)
5420       return -1;
5421   }
5422   {
5423     char device[] = "/dev/sda";
5424     char lines_0[] = ",";
5425     char *lines[] = {
5426       lines_0,
5427       NULL
5428     };
5429     int r;
5430     suppress_error = 0;
5431     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5432     if (r == -1)
5433       return -1;
5434   }
5435   {
5436     char fstype[] = "ext2";
5437     char device[] = "/dev/sda1";
5438     int r;
5439     suppress_error = 0;
5440     r = guestfs_mkfs (g, fstype, device);
5441     if (r == -1)
5442       return -1;
5443   }
5444   {
5445     char device[] = "/dev/sda1";
5446     char mountpoint[] = "/";
5447     int r;
5448     suppress_error = 0;
5449     r = guestfs_mount (g, device, mountpoint);
5450     if (r == -1)
5451       return -1;
5452   }
5453   /* TestOutput for tgz_in (0) */
5454   char expected[] = "hello\n";
5455   {
5456     char directory[] = "/";
5457     int r;
5458     suppress_error = 0;
5459     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5460     if (r == -1)
5461       return -1;
5462   }
5463   {
5464     char path[] = "/hello";
5465     char *r;
5466     suppress_error = 0;
5467     r = guestfs_cat (g, path);
5468     if (r == NULL)
5469       return -1;
5470     if (strcmp (r, expected) != 0) {
5471       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5472       return -1;
5473     }
5474     free (r);
5475   }
5476   return 0;
5477 }
5478
5479 static int test_tar_in_0_skip (void)
5480 {
5481   const char *str;
5482
5483   str = getenv ("SKIP_TEST_TAR_IN_0");
5484   if (str && strcmp (str, "1") == 0) return 1;
5485   str = getenv ("SKIP_TEST_TAR_IN");
5486   if (str && strcmp (str, "1") == 0) return 1;
5487   return 0;
5488 }
5489
5490 static int test_tar_in_0 (void)
5491 {
5492   if (test_tar_in_0_skip ()) {
5493     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5494     return 0;
5495   }
5496
5497   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5498   {
5499     char device[] = "/dev/sda";
5500     int r;
5501     suppress_error = 0;
5502     r = guestfs_blockdev_setrw (g, device);
5503     if (r == -1)
5504       return -1;
5505   }
5506   {
5507     int r;
5508     suppress_error = 0;
5509     r = guestfs_umount_all (g);
5510     if (r == -1)
5511       return -1;
5512   }
5513   {
5514     int r;
5515     suppress_error = 0;
5516     r = guestfs_lvm_remove_all (g);
5517     if (r == -1)
5518       return -1;
5519   }
5520   {
5521     char device[] = "/dev/sda";
5522     char lines_0[] = ",";
5523     char *lines[] = {
5524       lines_0,
5525       NULL
5526     };
5527     int r;
5528     suppress_error = 0;
5529     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5530     if (r == -1)
5531       return -1;
5532   }
5533   {
5534     char fstype[] = "ext2";
5535     char device[] = "/dev/sda1";
5536     int r;
5537     suppress_error = 0;
5538     r = guestfs_mkfs (g, fstype, device);
5539     if (r == -1)
5540       return -1;
5541   }
5542   {
5543     char device[] = "/dev/sda1";
5544     char mountpoint[] = "/";
5545     int r;
5546     suppress_error = 0;
5547     r = guestfs_mount (g, device, mountpoint);
5548     if (r == -1)
5549       return -1;
5550   }
5551   /* TestOutput for tar_in (0) */
5552   char expected[] = "hello\n";
5553   {
5554     char directory[] = "/";
5555     int r;
5556     suppress_error = 0;
5557     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5558     if (r == -1)
5559       return -1;
5560   }
5561   {
5562     char path[] = "/hello";
5563     char *r;
5564     suppress_error = 0;
5565     r = guestfs_cat (g, path);
5566     if (r == NULL)
5567       return -1;
5568     if (strcmp (r, expected) != 0) {
5569       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5570       return -1;
5571     }
5572     free (r);
5573   }
5574   return 0;
5575 }
5576
5577 static int test_checksum_0_skip (void)
5578 {
5579   const char *str;
5580
5581   str = getenv ("SKIP_TEST_CHECKSUM_0");
5582   if (str && strcmp (str, "1") == 0) return 1;
5583   str = getenv ("SKIP_TEST_CHECKSUM");
5584   if (str && strcmp (str, "1") == 0) return 1;
5585   return 0;
5586 }
5587
5588 static int test_checksum_0 (void)
5589 {
5590   if (test_checksum_0_skip ()) {
5591     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5592     return 0;
5593   }
5594
5595   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5596   {
5597     char device[] = "/dev/sda";
5598     int r;
5599     suppress_error = 0;
5600     r = guestfs_blockdev_setrw (g, device);
5601     if (r == -1)
5602       return -1;
5603   }
5604   {
5605     int r;
5606     suppress_error = 0;
5607     r = guestfs_umount_all (g);
5608     if (r == -1)
5609       return -1;
5610   }
5611   {
5612     int r;
5613     suppress_error = 0;
5614     r = guestfs_lvm_remove_all (g);
5615     if (r == -1)
5616       return -1;
5617   }
5618   {
5619     char device[] = "/dev/sda";
5620     char lines_0[] = ",";
5621     char *lines[] = {
5622       lines_0,
5623       NULL
5624     };
5625     int r;
5626     suppress_error = 0;
5627     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5628     if (r == -1)
5629       return -1;
5630   }
5631   {
5632     char fstype[] = "ext2";
5633     char device[] = "/dev/sda1";
5634     int r;
5635     suppress_error = 0;
5636     r = guestfs_mkfs (g, fstype, device);
5637     if (r == -1)
5638       return -1;
5639   }
5640   {
5641     char device[] = "/dev/sda1";
5642     char mountpoint[] = "/";
5643     int r;
5644     suppress_error = 0;
5645     r = guestfs_mount (g, device, mountpoint);
5646     if (r == -1)
5647       return -1;
5648   }
5649   /* TestOutput for checksum (0) */
5650   char expected[] = "935282863";
5651   {
5652     char path[] = "/new";
5653     char content[] = "test\n";
5654     int r;
5655     suppress_error = 0;
5656     r = guestfs_write_file (g, path, content, 0);
5657     if (r == -1)
5658       return -1;
5659   }
5660   {
5661     char csumtype[] = "crc";
5662     char path[] = "/new";
5663     char *r;
5664     suppress_error = 0;
5665     r = guestfs_checksum (g, csumtype, path);
5666     if (r == NULL)
5667       return -1;
5668     if (strcmp (r, expected) != 0) {
5669       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5670       return -1;
5671     }
5672     free (r);
5673   }
5674   return 0;
5675 }
5676
5677 static int test_checksum_1_skip (void)
5678 {
5679   const char *str;
5680
5681   str = getenv ("SKIP_TEST_CHECKSUM_1");
5682   if (str && strcmp (str, "1") == 0) return 1;
5683   str = getenv ("SKIP_TEST_CHECKSUM");
5684   if (str && strcmp (str, "1") == 0) return 1;
5685   return 0;
5686 }
5687
5688 static int test_checksum_1 (void)
5689 {
5690   if (test_checksum_1_skip ()) {
5691     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5692     return 0;
5693   }
5694
5695   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5696   {
5697     char device[] = "/dev/sda";
5698     int r;
5699     suppress_error = 0;
5700     r = guestfs_blockdev_setrw (g, device);
5701     if (r == -1)
5702       return -1;
5703   }
5704   {
5705     int r;
5706     suppress_error = 0;
5707     r = guestfs_umount_all (g);
5708     if (r == -1)
5709       return -1;
5710   }
5711   {
5712     int r;
5713     suppress_error = 0;
5714     r = guestfs_lvm_remove_all (g);
5715     if (r == -1)
5716       return -1;
5717   }
5718   {
5719     char device[] = "/dev/sda";
5720     char lines_0[] = ",";
5721     char *lines[] = {
5722       lines_0,
5723       NULL
5724     };
5725     int r;
5726     suppress_error = 0;
5727     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5728     if (r == -1)
5729       return -1;
5730   }
5731   {
5732     char fstype[] = "ext2";
5733     char device[] = "/dev/sda1";
5734     int r;
5735     suppress_error = 0;
5736     r = guestfs_mkfs (g, fstype, device);
5737     if (r == -1)
5738       return -1;
5739   }
5740   {
5741     char device[] = "/dev/sda1";
5742     char mountpoint[] = "/";
5743     int r;
5744     suppress_error = 0;
5745     r = guestfs_mount (g, device, mountpoint);
5746     if (r == -1)
5747       return -1;
5748   }
5749   /* TestLastFail for checksum (1) */
5750   {
5751     char csumtype[] = "crc";
5752     char path[] = "/new";
5753     char *r;
5754     suppress_error = 1;
5755     r = guestfs_checksum (g, csumtype, path);
5756     if (r != NULL)
5757       return -1;
5758     free (r);
5759   }
5760   return 0;
5761 }
5762
5763 static int test_checksum_2_skip (void)
5764 {
5765   const char *str;
5766
5767   str = getenv ("SKIP_TEST_CHECKSUM_2");
5768   if (str && strcmp (str, "1") == 0) return 1;
5769   str = getenv ("SKIP_TEST_CHECKSUM");
5770   if (str && strcmp (str, "1") == 0) return 1;
5771   return 0;
5772 }
5773
5774 static int test_checksum_2 (void)
5775 {
5776   if (test_checksum_2_skip ()) {
5777     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5778     return 0;
5779   }
5780
5781   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5782   {
5783     char device[] = "/dev/sda";
5784     int r;
5785     suppress_error = 0;
5786     r = guestfs_blockdev_setrw (g, device);
5787     if (r == -1)
5788       return -1;
5789   }
5790   {
5791     int r;
5792     suppress_error = 0;
5793     r = guestfs_umount_all (g);
5794     if (r == -1)
5795       return -1;
5796   }
5797   {
5798     int r;
5799     suppress_error = 0;
5800     r = guestfs_lvm_remove_all (g);
5801     if (r == -1)
5802       return -1;
5803   }
5804   {
5805     char device[] = "/dev/sda";
5806     char lines_0[] = ",";
5807     char *lines[] = {
5808       lines_0,
5809       NULL
5810     };
5811     int r;
5812     suppress_error = 0;
5813     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5814     if (r == -1)
5815       return -1;
5816   }
5817   {
5818     char fstype[] = "ext2";
5819     char device[] = "/dev/sda1";
5820     int r;
5821     suppress_error = 0;
5822     r = guestfs_mkfs (g, fstype, device);
5823     if (r == -1)
5824       return -1;
5825   }
5826   {
5827     char device[] = "/dev/sda1";
5828     char mountpoint[] = "/";
5829     int r;
5830     suppress_error = 0;
5831     r = guestfs_mount (g, device, mountpoint);
5832     if (r == -1)
5833       return -1;
5834   }
5835   /* TestOutput for checksum (2) */
5836   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5837   {
5838     char path[] = "/new";
5839     char content[] = "test\n";
5840     int r;
5841     suppress_error = 0;
5842     r = guestfs_write_file (g, path, content, 0);
5843     if (r == -1)
5844       return -1;
5845   }
5846   {
5847     char csumtype[] = "md5";
5848     char path[] = "/new";
5849     char *r;
5850     suppress_error = 0;
5851     r = guestfs_checksum (g, csumtype, path);
5852     if (r == NULL)
5853       return -1;
5854     if (strcmp (r, expected) != 0) {
5855       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5856       return -1;
5857     }
5858     free (r);
5859   }
5860   return 0;
5861 }
5862
5863 static int test_checksum_3_skip (void)
5864 {
5865   const char *str;
5866
5867   str = getenv ("SKIP_TEST_CHECKSUM_3");
5868   if (str && strcmp (str, "1") == 0) return 1;
5869   str = getenv ("SKIP_TEST_CHECKSUM");
5870   if (str && strcmp (str, "1") == 0) return 1;
5871   return 0;
5872 }
5873
5874 static int test_checksum_3 (void)
5875 {
5876   if (test_checksum_3_skip ()) {
5877     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5878     return 0;
5879   }
5880
5881   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5882   {
5883     char device[] = "/dev/sda";
5884     int r;
5885     suppress_error = 0;
5886     r = guestfs_blockdev_setrw (g, device);
5887     if (r == -1)
5888       return -1;
5889   }
5890   {
5891     int r;
5892     suppress_error = 0;
5893     r = guestfs_umount_all (g);
5894     if (r == -1)
5895       return -1;
5896   }
5897   {
5898     int r;
5899     suppress_error = 0;
5900     r = guestfs_lvm_remove_all (g);
5901     if (r == -1)
5902       return -1;
5903   }
5904   {
5905     char device[] = "/dev/sda";
5906     char lines_0[] = ",";
5907     char *lines[] = {
5908       lines_0,
5909       NULL
5910     };
5911     int r;
5912     suppress_error = 0;
5913     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5914     if (r == -1)
5915       return -1;
5916   }
5917   {
5918     char fstype[] = "ext2";
5919     char device[] = "/dev/sda1";
5920     int r;
5921     suppress_error = 0;
5922     r = guestfs_mkfs (g, fstype, device);
5923     if (r == -1)
5924       return -1;
5925   }
5926   {
5927     char device[] = "/dev/sda1";
5928     char mountpoint[] = "/";
5929     int r;
5930     suppress_error = 0;
5931     r = guestfs_mount (g, device, mountpoint);
5932     if (r == -1)
5933       return -1;
5934   }
5935   /* TestOutput for checksum (3) */
5936   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5937   {
5938     char path[] = "/new";
5939     char content[] = "test\n";
5940     int r;
5941     suppress_error = 0;
5942     r = guestfs_write_file (g, path, content, 0);
5943     if (r == -1)
5944       return -1;
5945   }
5946   {
5947     char csumtype[] = "sha1";
5948     char path[] = "/new";
5949     char *r;
5950     suppress_error = 0;
5951     r = guestfs_checksum (g, csumtype, path);
5952     if (r == NULL)
5953       return -1;
5954     if (strcmp (r, expected) != 0) {
5955       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5956       return -1;
5957     }
5958     free (r);
5959   }
5960   return 0;
5961 }
5962
5963 static int test_checksum_4_skip (void)
5964 {
5965   const char *str;
5966
5967   str = getenv ("SKIP_TEST_CHECKSUM_4");
5968   if (str && strcmp (str, "1") == 0) return 1;
5969   str = getenv ("SKIP_TEST_CHECKSUM");
5970   if (str && strcmp (str, "1") == 0) return 1;
5971   return 0;
5972 }
5973
5974 static int test_checksum_4 (void)
5975 {
5976   if (test_checksum_4_skip ()) {
5977     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5978     return 0;
5979   }
5980
5981   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5982   {
5983     char device[] = "/dev/sda";
5984     int r;
5985     suppress_error = 0;
5986     r = guestfs_blockdev_setrw (g, device);
5987     if (r == -1)
5988       return -1;
5989   }
5990   {
5991     int r;
5992     suppress_error = 0;
5993     r = guestfs_umount_all (g);
5994     if (r == -1)
5995       return -1;
5996   }
5997   {
5998     int r;
5999     suppress_error = 0;
6000     r = guestfs_lvm_remove_all (g);
6001     if (r == -1)
6002       return -1;
6003   }
6004   {
6005     char device[] = "/dev/sda";
6006     char lines_0[] = ",";
6007     char *lines[] = {
6008       lines_0,
6009       NULL
6010     };
6011     int r;
6012     suppress_error = 0;
6013     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6014     if (r == -1)
6015       return -1;
6016   }
6017   {
6018     char fstype[] = "ext2";
6019     char device[] = "/dev/sda1";
6020     int r;
6021     suppress_error = 0;
6022     r = guestfs_mkfs (g, fstype, device);
6023     if (r == -1)
6024       return -1;
6025   }
6026   {
6027     char device[] = "/dev/sda1";
6028     char mountpoint[] = "/";
6029     int r;
6030     suppress_error = 0;
6031     r = guestfs_mount (g, device, mountpoint);
6032     if (r == -1)
6033       return -1;
6034   }
6035   /* TestOutput for checksum (4) */
6036   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
6037   {
6038     char path[] = "/new";
6039     char content[] = "test\n";
6040     int r;
6041     suppress_error = 0;
6042     r = guestfs_write_file (g, path, content, 0);
6043     if (r == -1)
6044       return -1;
6045   }
6046   {
6047     char csumtype[] = "sha224";
6048     char path[] = "/new";
6049     char *r;
6050     suppress_error = 0;
6051     r = guestfs_checksum (g, csumtype, path);
6052     if (r == NULL)
6053       return -1;
6054     if (strcmp (r, expected) != 0) {
6055       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
6056       return -1;
6057     }
6058     free (r);
6059   }
6060   return 0;
6061 }
6062
6063 static int test_checksum_5_skip (void)
6064 {
6065   const char *str;
6066
6067   str = getenv ("SKIP_TEST_CHECKSUM_5");
6068   if (str && strcmp (str, "1") == 0) return 1;
6069   str = getenv ("SKIP_TEST_CHECKSUM");
6070   if (str && strcmp (str, "1") == 0) return 1;
6071   return 0;
6072 }
6073
6074 static int test_checksum_5 (void)
6075 {
6076   if (test_checksum_5_skip ()) {
6077     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
6078     return 0;
6079   }
6080
6081   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
6082   {
6083     char device[] = "/dev/sda";
6084     int r;
6085     suppress_error = 0;
6086     r = guestfs_blockdev_setrw (g, device);
6087     if (r == -1)
6088       return -1;
6089   }
6090   {
6091     int r;
6092     suppress_error = 0;
6093     r = guestfs_umount_all (g);
6094     if (r == -1)
6095       return -1;
6096   }
6097   {
6098     int r;
6099     suppress_error = 0;
6100     r = guestfs_lvm_remove_all (g);
6101     if (r == -1)
6102       return -1;
6103   }
6104   {
6105     char device[] = "/dev/sda";
6106     char lines_0[] = ",";
6107     char *lines[] = {
6108       lines_0,
6109       NULL
6110     };
6111     int r;
6112     suppress_error = 0;
6113     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6114     if (r == -1)
6115       return -1;
6116   }
6117   {
6118     char fstype[] = "ext2";
6119     char device[] = "/dev/sda1";
6120     int r;
6121     suppress_error = 0;
6122     r = guestfs_mkfs (g, fstype, device);
6123     if (r == -1)
6124       return -1;
6125   }
6126   {
6127     char device[] = "/dev/sda1";
6128     char mountpoint[] = "/";
6129     int r;
6130     suppress_error = 0;
6131     r = guestfs_mount (g, device, mountpoint);
6132     if (r == -1)
6133       return -1;
6134   }
6135   /* TestOutput for checksum (5) */
6136   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
6137   {
6138     char path[] = "/new";
6139     char content[] = "test\n";
6140     int r;
6141     suppress_error = 0;
6142     r = guestfs_write_file (g, path, content, 0);
6143     if (r == -1)
6144       return -1;
6145   }
6146   {
6147     char csumtype[] = "sha256";
6148     char path[] = "/new";
6149     char *r;
6150     suppress_error = 0;
6151     r = guestfs_checksum (g, csumtype, path);
6152     if (r == NULL)
6153       return -1;
6154     if (strcmp (r, expected) != 0) {
6155       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
6156       return -1;
6157     }
6158     free (r);
6159   }
6160   return 0;
6161 }
6162
6163 static int test_checksum_6_skip (void)
6164 {
6165   const char *str;
6166
6167   str = getenv ("SKIP_TEST_CHECKSUM_6");
6168   if (str && strcmp (str, "1") == 0) return 1;
6169   str = getenv ("SKIP_TEST_CHECKSUM");
6170   if (str && strcmp (str, "1") == 0) return 1;
6171   return 0;
6172 }
6173
6174 static int test_checksum_6 (void)
6175 {
6176   if (test_checksum_6_skip ()) {
6177     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
6178     return 0;
6179   }
6180
6181   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
6182   {
6183     char device[] = "/dev/sda";
6184     int r;
6185     suppress_error = 0;
6186     r = guestfs_blockdev_setrw (g, device);
6187     if (r == -1)
6188       return -1;
6189   }
6190   {
6191     int r;
6192     suppress_error = 0;
6193     r = guestfs_umount_all (g);
6194     if (r == -1)
6195       return -1;
6196   }
6197   {
6198     int r;
6199     suppress_error = 0;
6200     r = guestfs_lvm_remove_all (g);
6201     if (r == -1)
6202       return -1;
6203   }
6204   {
6205     char device[] = "/dev/sda";
6206     char lines_0[] = ",";
6207     char *lines[] = {
6208       lines_0,
6209       NULL
6210     };
6211     int r;
6212     suppress_error = 0;
6213     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6214     if (r == -1)
6215       return -1;
6216   }
6217   {
6218     char fstype[] = "ext2";
6219     char device[] = "/dev/sda1";
6220     int r;
6221     suppress_error = 0;
6222     r = guestfs_mkfs (g, fstype, device);
6223     if (r == -1)
6224       return -1;
6225   }
6226   {
6227     char device[] = "/dev/sda1";
6228     char mountpoint[] = "/";
6229     int r;
6230     suppress_error = 0;
6231     r = guestfs_mount (g, device, mountpoint);
6232     if (r == -1)
6233       return -1;
6234   }
6235   /* TestOutput for checksum (6) */
6236   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
6237   {
6238     char path[] = "/new";
6239     char content[] = "test\n";
6240     int r;
6241     suppress_error = 0;
6242     r = guestfs_write_file (g, path, content, 0);
6243     if (r == -1)
6244       return -1;
6245   }
6246   {
6247     char csumtype[] = "sha384";
6248     char path[] = "/new";
6249     char *r;
6250     suppress_error = 0;
6251     r = guestfs_checksum (g, csumtype, path);
6252     if (r == NULL)
6253       return -1;
6254     if (strcmp (r, expected) != 0) {
6255       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6256       return -1;
6257     }
6258     free (r);
6259   }
6260   return 0;
6261 }
6262
6263 static int test_checksum_7_skip (void)
6264 {
6265   const char *str;
6266
6267   str = getenv ("SKIP_TEST_CHECKSUM_7");
6268   if (str && strcmp (str, "1") == 0) return 1;
6269   str = getenv ("SKIP_TEST_CHECKSUM");
6270   if (str && strcmp (str, "1") == 0) return 1;
6271   return 0;
6272 }
6273
6274 static int test_checksum_7 (void)
6275 {
6276   if (test_checksum_7_skip ()) {
6277     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
6278     return 0;
6279   }
6280
6281   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6282   {
6283     char device[] = "/dev/sda";
6284     int r;
6285     suppress_error = 0;
6286     r = guestfs_blockdev_setrw (g, device);
6287     if (r == -1)
6288       return -1;
6289   }
6290   {
6291     int r;
6292     suppress_error = 0;
6293     r = guestfs_umount_all (g);
6294     if (r == -1)
6295       return -1;
6296   }
6297   {
6298     int r;
6299     suppress_error = 0;
6300     r = guestfs_lvm_remove_all (g);
6301     if (r == -1)
6302       return -1;
6303   }
6304   {
6305     char device[] = "/dev/sda";
6306     char lines_0[] = ",";
6307     char *lines[] = {
6308       lines_0,
6309       NULL
6310     };
6311     int r;
6312     suppress_error = 0;
6313     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6314     if (r == -1)
6315       return -1;
6316   }
6317   {
6318     char fstype[] = "ext2";
6319     char device[] = "/dev/sda1";
6320     int r;
6321     suppress_error = 0;
6322     r = guestfs_mkfs (g, fstype, device);
6323     if (r == -1)
6324       return -1;
6325   }
6326   {
6327     char device[] = "/dev/sda1";
6328     char mountpoint[] = "/";
6329     int r;
6330     suppress_error = 0;
6331     r = guestfs_mount (g, device, mountpoint);
6332     if (r == -1)
6333       return -1;
6334   }
6335   /* TestOutput for checksum (7) */
6336   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6337   {
6338     char path[] = "/new";
6339     char content[] = "test\n";
6340     int r;
6341     suppress_error = 0;
6342     r = guestfs_write_file (g, path, content, 0);
6343     if (r == -1)
6344       return -1;
6345   }
6346   {
6347     char csumtype[] = "sha512";
6348     char path[] = "/new";
6349     char *r;
6350     suppress_error = 0;
6351     r = guestfs_checksum (g, csumtype, path);
6352     if (r == NULL)
6353       return -1;
6354     if (strcmp (r, expected) != 0) {
6355       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6356       return -1;
6357     }
6358     free (r);
6359   }
6360   return 0;
6361 }
6362
6363 static int test_checksum_8_skip (void)
6364 {
6365   const char *str;
6366
6367   str = getenv ("SKIP_TEST_CHECKSUM_8");
6368   if (str && strcmp (str, "1") == 0) return 1;
6369   str = getenv ("SKIP_TEST_CHECKSUM");
6370   if (str && strcmp (str, "1") == 0) return 1;
6371   return 0;
6372 }
6373
6374 static int test_checksum_8 (void)
6375 {
6376   if (test_checksum_8_skip ()) {
6377     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
6378     return 0;
6379   }
6380
6381   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6382   {
6383     char device[] = "/dev/sda";
6384     int r;
6385     suppress_error = 0;
6386     r = guestfs_blockdev_setrw (g, device);
6387     if (r == -1)
6388       return -1;
6389   }
6390   {
6391     int r;
6392     suppress_error = 0;
6393     r = guestfs_umount_all (g);
6394     if (r == -1)
6395       return -1;
6396   }
6397   {
6398     int r;
6399     suppress_error = 0;
6400     r = guestfs_lvm_remove_all (g);
6401     if (r == -1)
6402       return -1;
6403   }
6404   {
6405     char device[] = "/dev/sda";
6406     char lines_0[] = ",";
6407     char *lines[] = {
6408       lines_0,
6409       NULL
6410     };
6411     int r;
6412     suppress_error = 0;
6413     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6414     if (r == -1)
6415       return -1;
6416   }
6417   {
6418     char fstype[] = "ext2";
6419     char device[] = "/dev/sda1";
6420     int r;
6421     suppress_error = 0;
6422     r = guestfs_mkfs (g, fstype, device);
6423     if (r == -1)
6424       return -1;
6425   }
6426   {
6427     char device[] = "/dev/sda1";
6428     char mountpoint[] = "/";
6429     int r;
6430     suppress_error = 0;
6431     r = guestfs_mount (g, device, mountpoint);
6432     if (r == -1)
6433       return -1;
6434   }
6435   /* TestOutput for checksum (8) */
6436   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6437   {
6438     char options[] = "ro";
6439     char vfstype[] = "squashfs";
6440     char device[] = "/dev/sdd";
6441     char mountpoint[] = "/";
6442     int r;
6443     suppress_error = 0;
6444     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
6445     if (r == -1)
6446       return -1;
6447   }
6448   {
6449     char csumtype[] = "md5";
6450     char path[] = "/known-3";
6451     char *r;
6452     suppress_error = 0;
6453     r = guestfs_checksum (g, csumtype, path);
6454     if (r == NULL)
6455       return -1;
6456     if (strcmp (r, expected) != 0) {
6457       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6458       return -1;
6459     }
6460     free (r);
6461   }
6462   return 0;
6463 }
6464
6465 static int test_download_0_skip (void)
6466 {
6467   const char *str;
6468
6469   str = getenv ("SKIP_TEST_DOWNLOAD_0");
6470   if (str && strcmp (str, "1") == 0) return 1;
6471   str = getenv ("SKIP_TEST_DOWNLOAD");
6472   if (str && strcmp (str, "1") == 0) return 1;
6473   return 0;
6474 }
6475
6476 static int test_download_0 (void)
6477 {
6478   if (test_download_0_skip ()) {
6479     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6480     return 0;
6481   }
6482
6483   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
6484   {
6485     char device[] = "/dev/sda";
6486     int r;
6487     suppress_error = 0;
6488     r = guestfs_blockdev_setrw (g, device);
6489     if (r == -1)
6490       return -1;
6491   }
6492   {
6493     int r;
6494     suppress_error = 0;
6495     r = guestfs_umount_all (g);
6496     if (r == -1)
6497       return -1;
6498   }
6499   {
6500     int r;
6501     suppress_error = 0;
6502     r = guestfs_lvm_remove_all (g);
6503     if (r == -1)
6504       return -1;
6505   }
6506   {
6507     char device[] = "/dev/sda";
6508     char lines_0[] = ",";
6509     char *lines[] = {
6510       lines_0,
6511       NULL
6512     };
6513     int r;
6514     suppress_error = 0;
6515     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6516     if (r == -1)
6517       return -1;
6518   }
6519   {
6520     char fstype[] = "ext2";
6521     char device[] = "/dev/sda1";
6522     int r;
6523     suppress_error = 0;
6524     r = guestfs_mkfs (g, fstype, device);
6525     if (r == -1)
6526       return -1;
6527   }
6528   {
6529     char device[] = "/dev/sda1";
6530     char mountpoint[] = "/";
6531     int r;
6532     suppress_error = 0;
6533     r = guestfs_mount (g, device, mountpoint);
6534     if (r == -1)
6535       return -1;
6536   }
6537   /* TestOutput for download (0) */
6538   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6539   {
6540     char remotefilename[] = "/COPYING.LIB";
6541     int r;
6542     suppress_error = 0;
6543     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6544     if (r == -1)
6545       return -1;
6546   }
6547   {
6548     char remotefilename[] = "/COPYING.LIB";
6549     int r;
6550     suppress_error = 0;
6551     r = guestfs_download (g, remotefilename, "testdownload.tmp");
6552     if (r == -1)
6553       return -1;
6554   }
6555   {
6556     char remotefilename[] = "/upload";
6557     int r;
6558     suppress_error = 0;
6559     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6560     if (r == -1)
6561       return -1;
6562   }
6563   {
6564     char csumtype[] = "md5";
6565     char path[] = "/upload";
6566     char *r;
6567     suppress_error = 0;
6568     r = guestfs_checksum (g, csumtype, path);
6569     if (r == NULL)
6570       return -1;
6571     if (strcmp (r, expected) != 0) {
6572       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6573       return -1;
6574     }
6575     free (r);
6576   }
6577   return 0;
6578 }
6579
6580 static int test_upload_0_skip (void)
6581 {
6582   const char *str;
6583
6584   str = getenv ("SKIP_TEST_UPLOAD_0");
6585   if (str && strcmp (str, "1") == 0) return 1;
6586   str = getenv ("SKIP_TEST_UPLOAD");
6587   if (str && strcmp (str, "1") == 0) return 1;
6588   return 0;
6589 }
6590
6591 static int test_upload_0 (void)
6592 {
6593   if (test_upload_0_skip ()) {
6594     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6595     return 0;
6596   }
6597
6598   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6599   {
6600     char device[] = "/dev/sda";
6601     int r;
6602     suppress_error = 0;
6603     r = guestfs_blockdev_setrw (g, device);
6604     if (r == -1)
6605       return -1;
6606   }
6607   {
6608     int r;
6609     suppress_error = 0;
6610     r = guestfs_umount_all (g);
6611     if (r == -1)
6612       return -1;
6613   }
6614   {
6615     int r;
6616     suppress_error = 0;
6617     r = guestfs_lvm_remove_all (g);
6618     if (r == -1)
6619       return -1;
6620   }
6621   {
6622     char device[] = "/dev/sda";
6623     char lines_0[] = ",";
6624     char *lines[] = {
6625       lines_0,
6626       NULL
6627     };
6628     int r;
6629     suppress_error = 0;
6630     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6631     if (r == -1)
6632       return -1;
6633   }
6634   {
6635     char fstype[] = "ext2";
6636     char device[] = "/dev/sda1";
6637     int r;
6638     suppress_error = 0;
6639     r = guestfs_mkfs (g, fstype, device);
6640     if (r == -1)
6641       return -1;
6642   }
6643   {
6644     char device[] = "/dev/sda1";
6645     char mountpoint[] = "/";
6646     int r;
6647     suppress_error = 0;
6648     r = guestfs_mount (g, device, mountpoint);
6649     if (r == -1)
6650       return -1;
6651   }
6652   /* TestOutput for upload (0) */
6653   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6654   {
6655     char remotefilename[] = "/COPYING.LIB";
6656     int r;
6657     suppress_error = 0;
6658     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6659     if (r == -1)
6660       return -1;
6661   }
6662   {
6663     char csumtype[] = "md5";
6664     char path[] = "/COPYING.LIB";
6665     char *r;
6666     suppress_error = 0;
6667     r = guestfs_checksum (g, csumtype, path);
6668     if (r == NULL)
6669       return -1;
6670     if (strcmp (r, expected) != 0) {
6671       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6672       return -1;
6673     }
6674     free (r);
6675   }
6676   return 0;
6677 }
6678
6679 static int test_blockdev_rereadpt_0_skip (void)
6680 {
6681   const char *str;
6682
6683   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6684   if (str && strcmp (str, "1") == 0) return 1;
6685   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6686   if (str && strcmp (str, "1") == 0) return 1;
6687   return 0;
6688 }
6689
6690 static int test_blockdev_rereadpt_0 (void)
6691 {
6692   if (test_blockdev_rereadpt_0_skip ()) {
6693     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6694     return 0;
6695   }
6696
6697   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6698   {
6699     char device[] = "/dev/sda";
6700     int r;
6701     suppress_error = 0;
6702     r = guestfs_blockdev_setrw (g, device);
6703     if (r == -1)
6704       return -1;
6705   }
6706   {
6707     int r;
6708     suppress_error = 0;
6709     r = guestfs_umount_all (g);
6710     if (r == -1)
6711       return -1;
6712   }
6713   {
6714     int r;
6715     suppress_error = 0;
6716     r = guestfs_lvm_remove_all (g);
6717     if (r == -1)
6718       return -1;
6719   }
6720   /* TestRun for blockdev_rereadpt (0) */
6721   {
6722     char device[] = "/dev/sda";
6723     int r;
6724     suppress_error = 0;
6725     r = guestfs_blockdev_rereadpt (g, device);
6726     if (r == -1)
6727       return -1;
6728   }
6729   return 0;
6730 }
6731
6732 static int test_blockdev_flushbufs_0_skip (void)
6733 {
6734   const char *str;
6735
6736   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6737   if (str && strcmp (str, "1") == 0) return 1;
6738   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6739   if (str && strcmp (str, "1") == 0) return 1;
6740   return 0;
6741 }
6742
6743 static int test_blockdev_flushbufs_0 (void)
6744 {
6745   if (test_blockdev_flushbufs_0_skip ()) {
6746     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6747     return 0;
6748   }
6749
6750   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6751   {
6752     char device[] = "/dev/sda";
6753     int r;
6754     suppress_error = 0;
6755     r = guestfs_blockdev_setrw (g, device);
6756     if (r == -1)
6757       return -1;
6758   }
6759   {
6760     int r;
6761     suppress_error = 0;
6762     r = guestfs_umount_all (g);
6763     if (r == -1)
6764       return -1;
6765   }
6766   {
6767     int r;
6768     suppress_error = 0;
6769     r = guestfs_lvm_remove_all (g);
6770     if (r == -1)
6771       return -1;
6772   }
6773   /* TestRun for blockdev_flushbufs (0) */
6774   {
6775     char device[] = "/dev/sda";
6776     int r;
6777     suppress_error = 0;
6778     r = guestfs_blockdev_flushbufs (g, device);
6779     if (r == -1)
6780       return -1;
6781   }
6782   return 0;
6783 }
6784
6785 static int test_blockdev_getsize64_0_skip (void)
6786 {
6787   const char *str;
6788
6789   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6790   if (str && strcmp (str, "1") == 0) return 1;
6791   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6792   if (str && strcmp (str, "1") == 0) return 1;
6793   return 0;
6794 }
6795
6796 static int test_blockdev_getsize64_0 (void)
6797 {
6798   if (test_blockdev_getsize64_0_skip ()) {
6799     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6800     return 0;
6801   }
6802
6803   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6804   {
6805     char device[] = "/dev/sda";
6806     int r;
6807     suppress_error = 0;
6808     r = guestfs_blockdev_setrw (g, device);
6809     if (r == -1)
6810       return -1;
6811   }
6812   {
6813     int r;
6814     suppress_error = 0;
6815     r = guestfs_umount_all (g);
6816     if (r == -1)
6817       return -1;
6818   }
6819   {
6820     int r;
6821     suppress_error = 0;
6822     r = guestfs_lvm_remove_all (g);
6823     if (r == -1)
6824       return -1;
6825   }
6826   /* TestOutputInt for blockdev_getsize64 (0) */
6827   {
6828     char device[] = "/dev/sda";
6829     int64_t r;
6830     suppress_error = 0;
6831     r = guestfs_blockdev_getsize64 (g, device);
6832     if (r == -1)
6833       return -1;
6834     if (r != 524288000) {
6835       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6836       return -1;
6837     }
6838   }
6839   return 0;
6840 }
6841
6842 static int test_blockdev_getsz_0_skip (void)
6843 {
6844   const char *str;
6845
6846   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6847   if (str && strcmp (str, "1") == 0) return 1;
6848   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6849   if (str && strcmp (str, "1") == 0) return 1;
6850   return 0;
6851 }
6852
6853 static int test_blockdev_getsz_0 (void)
6854 {
6855   if (test_blockdev_getsz_0_skip ()) {
6856     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6857     return 0;
6858   }
6859
6860   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6861   {
6862     char device[] = "/dev/sda";
6863     int r;
6864     suppress_error = 0;
6865     r = guestfs_blockdev_setrw (g, device);
6866     if (r == -1)
6867       return -1;
6868   }
6869   {
6870     int r;
6871     suppress_error = 0;
6872     r = guestfs_umount_all (g);
6873     if (r == -1)
6874       return -1;
6875   }
6876   {
6877     int r;
6878     suppress_error = 0;
6879     r = guestfs_lvm_remove_all (g);
6880     if (r == -1)
6881       return -1;
6882   }
6883   /* TestOutputInt for blockdev_getsz (0) */
6884   {
6885     char device[] = "/dev/sda";
6886     int64_t r;
6887     suppress_error = 0;
6888     r = guestfs_blockdev_getsz (g, device);
6889     if (r == -1)
6890       return -1;
6891     if (r != 1024000) {
6892       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6893       return -1;
6894     }
6895   }
6896   return 0;
6897 }
6898
6899 static int test_blockdev_getbsz_0_skip (void)
6900 {
6901   const char *str;
6902
6903   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6904   if (str && strcmp (str, "1") == 0) return 1;
6905   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6906   if (str && strcmp (str, "1") == 0) return 1;
6907   return 0;
6908 }
6909
6910 static int test_blockdev_getbsz_0 (void)
6911 {
6912   if (test_blockdev_getbsz_0_skip ()) {
6913     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6914     return 0;
6915   }
6916
6917   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6918   {
6919     char device[] = "/dev/sda";
6920     int r;
6921     suppress_error = 0;
6922     r = guestfs_blockdev_setrw (g, device);
6923     if (r == -1)
6924       return -1;
6925   }
6926   {
6927     int r;
6928     suppress_error = 0;
6929     r = guestfs_umount_all (g);
6930     if (r == -1)
6931       return -1;
6932   }
6933   {
6934     int r;
6935     suppress_error = 0;
6936     r = guestfs_lvm_remove_all (g);
6937     if (r == -1)
6938       return -1;
6939   }
6940   /* TestOutputInt for blockdev_getbsz (0) */
6941   {
6942     char device[] = "/dev/sda";
6943     int r;
6944     suppress_error = 0;
6945     r = guestfs_blockdev_getbsz (g, device);
6946     if (r == -1)
6947       return -1;
6948     if (r != 4096) {
6949       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6950       return -1;
6951     }
6952   }
6953   return 0;
6954 }
6955
6956 static int test_blockdev_getss_0_skip (void)
6957 {
6958   const char *str;
6959
6960   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6961   if (str && strcmp (str, "1") == 0) return 1;
6962   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6963   if (str && strcmp (str, "1") == 0) return 1;
6964   return 0;
6965 }
6966
6967 static int test_blockdev_getss_0 (void)
6968 {
6969   if (test_blockdev_getss_0_skip ()) {
6970     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6971     return 0;
6972   }
6973
6974   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6975   {
6976     char device[] = "/dev/sda";
6977     int r;
6978     suppress_error = 0;
6979     r = guestfs_blockdev_setrw (g, device);
6980     if (r == -1)
6981       return -1;
6982   }
6983   {
6984     int r;
6985     suppress_error = 0;
6986     r = guestfs_umount_all (g);
6987     if (r == -1)
6988       return -1;
6989   }
6990   {
6991     int r;
6992     suppress_error = 0;
6993     r = guestfs_lvm_remove_all (g);
6994     if (r == -1)
6995       return -1;
6996   }
6997   /* TestOutputInt for blockdev_getss (0) */
6998   {
6999     char device[] = "/dev/sda";
7000     int r;
7001     suppress_error = 0;
7002     r = guestfs_blockdev_getss (g, device);
7003     if (r == -1)
7004       return -1;
7005     if (r != 512) {
7006       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
7007       return -1;
7008     }
7009   }
7010   return 0;
7011 }
7012
7013 static int test_blockdev_getro_0_skip (void)
7014 {
7015   const char *str;
7016
7017   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
7018   if (str && strcmp (str, "1") == 0) return 1;
7019   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
7020   if (str && strcmp (str, "1") == 0) return 1;
7021   return 0;
7022 }
7023
7024 static int test_blockdev_getro_0 (void)
7025 {
7026   if (test_blockdev_getro_0_skip ()) {
7027     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
7028     return 0;
7029   }
7030
7031   /* InitNone|InitEmpty for test_blockdev_getro_0 */
7032   {
7033     char device[] = "/dev/sda";
7034     int r;
7035     suppress_error = 0;
7036     r = guestfs_blockdev_setrw (g, device);
7037     if (r == -1)
7038       return -1;
7039   }
7040   {
7041     int r;
7042     suppress_error = 0;
7043     r = guestfs_umount_all (g);
7044     if (r == -1)
7045       return -1;
7046   }
7047   {
7048     int r;
7049     suppress_error = 0;
7050     r = guestfs_lvm_remove_all (g);
7051     if (r == -1)
7052       return -1;
7053   }
7054   /* TestOutputTrue for blockdev_getro (0) */
7055   {
7056     char device[] = "/dev/sda";
7057     int r;
7058     suppress_error = 0;
7059     r = guestfs_blockdev_setro (g, device);
7060     if (r == -1)
7061       return -1;
7062   }
7063   {
7064     char device[] = "/dev/sda";
7065     int r;
7066     suppress_error = 0;
7067     r = guestfs_blockdev_getro (g, device);
7068     if (r == -1)
7069       return -1;
7070     if (!r) {
7071       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
7072       return -1;
7073     }
7074   }
7075   return 0;
7076 }
7077
7078 static int test_blockdev_setrw_0_skip (void)
7079 {
7080   const char *str;
7081
7082   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
7083   if (str && strcmp (str, "1") == 0) return 1;
7084   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
7085   if (str && strcmp (str, "1") == 0) return 1;
7086   return 0;
7087 }
7088
7089 static int test_blockdev_setrw_0 (void)
7090 {
7091   if (test_blockdev_setrw_0_skip ()) {
7092     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
7093     return 0;
7094   }
7095
7096   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
7097   {
7098     char device[] = "/dev/sda";
7099     int r;
7100     suppress_error = 0;
7101     r = guestfs_blockdev_setrw (g, device);
7102     if (r == -1)
7103       return -1;
7104   }
7105   {
7106     int r;
7107     suppress_error = 0;
7108     r = guestfs_umount_all (g);
7109     if (r == -1)
7110       return -1;
7111   }
7112   {
7113     int r;
7114     suppress_error = 0;
7115     r = guestfs_lvm_remove_all (g);
7116     if (r == -1)
7117       return -1;
7118   }
7119   /* TestOutputFalse for blockdev_setrw (0) */
7120   {
7121     char device[] = "/dev/sda";
7122     int r;
7123     suppress_error = 0;
7124     r = guestfs_blockdev_setrw (g, device);
7125     if (r == -1)
7126       return -1;
7127   }
7128   {
7129     char device[] = "/dev/sda";
7130     int r;
7131     suppress_error = 0;
7132     r = guestfs_blockdev_getro (g, device);
7133     if (r == -1)
7134       return -1;
7135     if (r) {
7136       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
7137       return -1;
7138     }
7139   }
7140   return 0;
7141 }
7142
7143 static int test_blockdev_setro_0_skip (void)
7144 {
7145   const char *str;
7146
7147   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
7148   if (str && strcmp (str, "1") == 0) return 1;
7149   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
7150   if (str && strcmp (str, "1") == 0) return 1;
7151   return 0;
7152 }
7153
7154 static int test_blockdev_setro_0 (void)
7155 {
7156   if (test_blockdev_setro_0_skip ()) {
7157     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
7158     return 0;
7159   }
7160
7161   /* InitNone|InitEmpty for test_blockdev_setro_0 */
7162   {
7163     char device[] = "/dev/sda";
7164     int r;
7165     suppress_error = 0;
7166     r = guestfs_blockdev_setrw (g, device);
7167     if (r == -1)
7168       return -1;
7169   }
7170   {
7171     int r;
7172     suppress_error = 0;
7173     r = guestfs_umount_all (g);
7174     if (r == -1)
7175       return -1;
7176   }
7177   {
7178     int r;
7179     suppress_error = 0;
7180     r = guestfs_lvm_remove_all (g);
7181     if (r == -1)
7182       return -1;
7183   }
7184   /* TestOutputTrue for blockdev_setro (0) */
7185   {
7186     char device[] = "/dev/sda";
7187     int r;
7188     suppress_error = 0;
7189     r = guestfs_blockdev_setro (g, device);
7190     if (r == -1)
7191       return -1;
7192   }
7193   {
7194     char device[] = "/dev/sda";
7195     int r;
7196     suppress_error = 0;
7197     r = guestfs_blockdev_getro (g, device);
7198     if (r == -1)
7199       return -1;
7200     if (!r) {
7201       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
7202       return -1;
7203     }
7204   }
7205   return 0;
7206 }
7207
7208 static int test_statvfs_0_skip (void)
7209 {
7210   const char *str;
7211
7212   str = getenv ("SKIP_TEST_STATVFS_0");
7213   if (str && strcmp (str, "1") == 0) return 1;
7214   str = getenv ("SKIP_TEST_STATVFS");
7215   if (str && strcmp (str, "1") == 0) return 1;
7216   return 0;
7217 }
7218
7219 static int test_statvfs_0 (void)
7220 {
7221   if (test_statvfs_0_skip ()) {
7222     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
7223     return 0;
7224   }
7225
7226   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
7227   {
7228     char device[] = "/dev/sda";
7229     int r;
7230     suppress_error = 0;
7231     r = guestfs_blockdev_setrw (g, device);
7232     if (r == -1)
7233       return -1;
7234   }
7235   {
7236     int r;
7237     suppress_error = 0;
7238     r = guestfs_umount_all (g);
7239     if (r == -1)
7240       return -1;
7241   }
7242   {
7243     int r;
7244     suppress_error = 0;
7245     r = guestfs_lvm_remove_all (g);
7246     if (r == -1)
7247       return -1;
7248   }
7249   {
7250     char device[] = "/dev/sda";
7251     char lines_0[] = ",";
7252     char *lines[] = {
7253       lines_0,
7254       NULL
7255     };
7256     int r;
7257     suppress_error = 0;
7258     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7259     if (r == -1)
7260       return -1;
7261   }
7262   {
7263     char fstype[] = "ext2";
7264     char device[] = "/dev/sda1";
7265     int r;
7266     suppress_error = 0;
7267     r = guestfs_mkfs (g, fstype, device);
7268     if (r == -1)
7269       return -1;
7270   }
7271   {
7272     char device[] = "/dev/sda1";
7273     char mountpoint[] = "/";
7274     int r;
7275     suppress_error = 0;
7276     r = guestfs_mount (g, device, mountpoint);
7277     if (r == -1)
7278       return -1;
7279   }
7280   /* TestOutputStruct for statvfs (0) */
7281   {
7282     char path[] = "/";
7283     struct guestfs_statvfs *r;
7284     suppress_error = 0;
7285     r = guestfs_statvfs (g, path);
7286     if (r == NULL)
7287       return -1;
7288     if (r->bfree != 487702) {
7289       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7290                (int) r->bfree);
7291       return -1;
7292     }
7293     if (r->blocks != 490020) {
7294       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7295                (int) r->blocks);
7296       return -1;
7297     }
7298     if (r->bsize != 1024) {
7299       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7300                (int) r->bsize);
7301       return -1;
7302     }
7303     free (r);
7304   }
7305   return 0;
7306 }
7307
7308 static int test_lstat_0_skip (void)
7309 {
7310   const char *str;
7311
7312   str = getenv ("SKIP_TEST_LSTAT_0");
7313   if (str && strcmp (str, "1") == 0) return 1;
7314   str = getenv ("SKIP_TEST_LSTAT");
7315   if (str && strcmp (str, "1") == 0) return 1;
7316   return 0;
7317 }
7318
7319 static int test_lstat_0 (void)
7320 {
7321   if (test_lstat_0_skip ()) {
7322     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
7323     return 0;
7324   }
7325
7326   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7327   {
7328     char device[] = "/dev/sda";
7329     int r;
7330     suppress_error = 0;
7331     r = guestfs_blockdev_setrw (g, device);
7332     if (r == -1)
7333       return -1;
7334   }
7335   {
7336     int r;
7337     suppress_error = 0;
7338     r = guestfs_umount_all (g);
7339     if (r == -1)
7340       return -1;
7341   }
7342   {
7343     int r;
7344     suppress_error = 0;
7345     r = guestfs_lvm_remove_all (g);
7346     if (r == -1)
7347       return -1;
7348   }
7349   {
7350     char device[] = "/dev/sda";
7351     char lines_0[] = ",";
7352     char *lines[] = {
7353       lines_0,
7354       NULL
7355     };
7356     int r;
7357     suppress_error = 0;
7358     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7359     if (r == -1)
7360       return -1;
7361   }
7362   {
7363     char fstype[] = "ext2";
7364     char device[] = "/dev/sda1";
7365     int r;
7366     suppress_error = 0;
7367     r = guestfs_mkfs (g, fstype, device);
7368     if (r == -1)
7369       return -1;
7370   }
7371   {
7372     char device[] = "/dev/sda1";
7373     char mountpoint[] = "/";
7374     int r;
7375     suppress_error = 0;
7376     r = guestfs_mount (g, device, mountpoint);
7377     if (r == -1)
7378       return -1;
7379   }
7380   /* TestOutputStruct for lstat (0) */
7381   {
7382     char path[] = "/new";
7383     int r;
7384     suppress_error = 0;
7385     r = guestfs_touch (g, path);
7386     if (r == -1)
7387       return -1;
7388   }
7389   {
7390     char path[] = "/new";
7391     struct guestfs_stat *r;
7392     suppress_error = 0;
7393     r = guestfs_lstat (g, path);
7394     if (r == NULL)
7395       return -1;
7396     if (r->size != 0) {
7397       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7398                (int) r->size);
7399       return -1;
7400     }
7401     free (r);
7402   }
7403   return 0;
7404 }
7405
7406 static int test_stat_0_skip (void)
7407 {
7408   const char *str;
7409
7410   str = getenv ("SKIP_TEST_STAT_0");
7411   if (str && strcmp (str, "1") == 0) return 1;
7412   str = getenv ("SKIP_TEST_STAT");
7413   if (str && strcmp (str, "1") == 0) return 1;
7414   return 0;
7415 }
7416
7417 static int test_stat_0 (void)
7418 {
7419   if (test_stat_0_skip ()) {
7420     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7421     return 0;
7422   }
7423
7424   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7425   {
7426     char device[] = "/dev/sda";
7427     int r;
7428     suppress_error = 0;
7429     r = guestfs_blockdev_setrw (g, device);
7430     if (r == -1)
7431       return -1;
7432   }
7433   {
7434     int r;
7435     suppress_error = 0;
7436     r = guestfs_umount_all (g);
7437     if (r == -1)
7438       return -1;
7439   }
7440   {
7441     int r;
7442     suppress_error = 0;
7443     r = guestfs_lvm_remove_all (g);
7444     if (r == -1)
7445       return -1;
7446   }
7447   {
7448     char device[] = "/dev/sda";
7449     char lines_0[] = ",";
7450     char *lines[] = {
7451       lines_0,
7452       NULL
7453     };
7454     int r;
7455     suppress_error = 0;
7456     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7457     if (r == -1)
7458       return -1;
7459   }
7460   {
7461     char fstype[] = "ext2";
7462     char device[] = "/dev/sda1";
7463     int r;
7464     suppress_error = 0;
7465     r = guestfs_mkfs (g, fstype, device);
7466     if (r == -1)
7467       return -1;
7468   }
7469   {
7470     char device[] = "/dev/sda1";
7471     char mountpoint[] = "/";
7472     int r;
7473     suppress_error = 0;
7474     r = guestfs_mount (g, device, mountpoint);
7475     if (r == -1)
7476       return -1;
7477   }
7478   /* TestOutputStruct for stat (0) */
7479   {
7480     char path[] = "/new";
7481     int r;
7482     suppress_error = 0;
7483     r = guestfs_touch (g, path);
7484     if (r == -1)
7485       return -1;
7486   }
7487   {
7488     char path[] = "/new";
7489     struct guestfs_stat *r;
7490     suppress_error = 0;
7491     r = guestfs_stat (g, path);
7492     if (r == NULL)
7493       return -1;
7494     if (r->size != 0) {
7495       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7496                (int) r->size);
7497       return -1;
7498     }
7499     free (r);
7500   }
7501   return 0;
7502 }
7503
7504 static int test_command_lines_0_skip (void)
7505 {
7506   const char *str;
7507
7508   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7509   if (str && strcmp (str, "1") == 0) return 1;
7510   str = getenv ("SKIP_TEST_COMMAND_LINES");
7511   if (str && strcmp (str, "1") == 0) return 1;
7512   return 0;
7513 }
7514
7515 static int test_command_lines_0 (void)
7516 {
7517   if (test_command_lines_0_skip ()) {
7518     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7519     return 0;
7520   }
7521
7522   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7523   {
7524     char device[] = "/dev/sda";
7525     int r;
7526     suppress_error = 0;
7527     r = guestfs_blockdev_setrw (g, device);
7528     if (r == -1)
7529       return -1;
7530   }
7531   {
7532     int r;
7533     suppress_error = 0;
7534     r = guestfs_umount_all (g);
7535     if (r == -1)
7536       return -1;
7537   }
7538   {
7539     int r;
7540     suppress_error = 0;
7541     r = guestfs_lvm_remove_all (g);
7542     if (r == -1)
7543       return -1;
7544   }
7545   {
7546     char device[] = "/dev/sda";
7547     char lines_0[] = ",";
7548     char *lines[] = {
7549       lines_0,
7550       NULL
7551     };
7552     int r;
7553     suppress_error = 0;
7554     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7555     if (r == -1)
7556       return -1;
7557   }
7558   {
7559     char fstype[] = "ext2";
7560     char device[] = "/dev/sda1";
7561     int r;
7562     suppress_error = 0;
7563     r = guestfs_mkfs (g, fstype, device);
7564     if (r == -1)
7565       return -1;
7566   }
7567   {
7568     char device[] = "/dev/sda1";
7569     char mountpoint[] = "/";
7570     int r;
7571     suppress_error = 0;
7572     r = guestfs_mount (g, device, mountpoint);
7573     if (r == -1)
7574       return -1;
7575   }
7576   /* TestOutputList for command_lines (0) */
7577   {
7578     char remotefilename[] = "/test-command";
7579     int r;
7580     suppress_error = 0;
7581     r = guestfs_upload (g, "test-command", remotefilename);
7582     if (r == -1)
7583       return -1;
7584   }
7585   {
7586     char path[] = "/test-command";
7587     int r;
7588     suppress_error = 0;
7589     r = guestfs_chmod (g, 493, path);
7590     if (r == -1)
7591       return -1;
7592   }
7593   {
7594     char arguments_0[] = "/test-command";
7595     char arguments_1[] = "1";
7596     char *arguments[] = {
7597       arguments_0,
7598       arguments_1,
7599       NULL
7600     };
7601     char **r;
7602     int i;
7603     suppress_error = 0;
7604     r = guestfs_command_lines (g, arguments);
7605     if (r == NULL)
7606       return -1;
7607     if (!r[0]) {
7608       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7609       print_strings (r);
7610       return -1;
7611     }
7612     {
7613       char expected[] = "Result1";
7614       if (strcmp (r[0], expected) != 0) {
7615         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7616         return -1;
7617       }
7618     }
7619     if (r[1] != NULL) {
7620       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7621       print_strings (r);
7622       return -1;
7623     }
7624     for (i = 0; r[i] != NULL; ++i)
7625       free (r[i]);
7626     free (r);
7627   }
7628   return 0;
7629 }
7630
7631 static int test_command_lines_1_skip (void)
7632 {
7633   const char *str;
7634
7635   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7636   if (str && strcmp (str, "1") == 0) return 1;
7637   str = getenv ("SKIP_TEST_COMMAND_LINES");
7638   if (str && strcmp (str, "1") == 0) return 1;
7639   return 0;
7640 }
7641
7642 static int test_command_lines_1 (void)
7643 {
7644   if (test_command_lines_1_skip ()) {
7645     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7646     return 0;
7647   }
7648
7649   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7650   {
7651     char device[] = "/dev/sda";
7652     int r;
7653     suppress_error = 0;
7654     r = guestfs_blockdev_setrw (g, device);
7655     if (r == -1)
7656       return -1;
7657   }
7658   {
7659     int r;
7660     suppress_error = 0;
7661     r = guestfs_umount_all (g);
7662     if (r == -1)
7663       return -1;
7664   }
7665   {
7666     int r;
7667     suppress_error = 0;
7668     r = guestfs_lvm_remove_all (g);
7669     if (r == -1)
7670       return -1;
7671   }
7672   {
7673     char device[] = "/dev/sda";
7674     char lines_0[] = ",";
7675     char *lines[] = {
7676       lines_0,
7677       NULL
7678     };
7679     int r;
7680     suppress_error = 0;
7681     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7682     if (r == -1)
7683       return -1;
7684   }
7685   {
7686     char fstype[] = "ext2";
7687     char device[] = "/dev/sda1";
7688     int r;
7689     suppress_error = 0;
7690     r = guestfs_mkfs (g, fstype, device);
7691     if (r == -1)
7692       return -1;
7693   }
7694   {
7695     char device[] = "/dev/sda1";
7696     char mountpoint[] = "/";
7697     int r;
7698     suppress_error = 0;
7699     r = guestfs_mount (g, device, mountpoint);
7700     if (r == -1)
7701       return -1;
7702   }
7703   /* TestOutputList for command_lines (1) */
7704   {
7705     char remotefilename[] = "/test-command";
7706     int r;
7707     suppress_error = 0;
7708     r = guestfs_upload (g, "test-command", remotefilename);
7709     if (r == -1)
7710       return -1;
7711   }
7712   {
7713     char path[] = "/test-command";
7714     int r;
7715     suppress_error = 0;
7716     r = guestfs_chmod (g, 493, path);
7717     if (r == -1)
7718       return -1;
7719   }
7720   {
7721     char arguments_0[] = "/test-command";
7722     char arguments_1[] = "2";
7723     char *arguments[] = {
7724       arguments_0,
7725       arguments_1,
7726       NULL
7727     };
7728     char **r;
7729     int i;
7730     suppress_error = 0;
7731     r = guestfs_command_lines (g, arguments);
7732     if (r == NULL)
7733       return -1;
7734     if (!r[0]) {
7735       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7736       print_strings (r);
7737       return -1;
7738     }
7739     {
7740       char expected[] = "Result2";
7741       if (strcmp (r[0], expected) != 0) {
7742         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7743         return -1;
7744       }
7745     }
7746     if (r[1] != NULL) {
7747       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7748       print_strings (r);
7749       return -1;
7750     }
7751     for (i = 0; r[i] != NULL; ++i)
7752       free (r[i]);
7753     free (r);
7754   }
7755   return 0;
7756 }
7757
7758 static int test_command_lines_2_skip (void)
7759 {
7760   const char *str;
7761
7762   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7763   if (str && strcmp (str, "1") == 0) return 1;
7764   str = getenv ("SKIP_TEST_COMMAND_LINES");
7765   if (str && strcmp (str, "1") == 0) return 1;
7766   return 0;
7767 }
7768
7769 static int test_command_lines_2 (void)
7770 {
7771   if (test_command_lines_2_skip ()) {
7772     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7773     return 0;
7774   }
7775
7776   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7777   {
7778     char device[] = "/dev/sda";
7779     int r;
7780     suppress_error = 0;
7781     r = guestfs_blockdev_setrw (g, device);
7782     if (r == -1)
7783       return -1;
7784   }
7785   {
7786     int r;
7787     suppress_error = 0;
7788     r = guestfs_umount_all (g);
7789     if (r == -1)
7790       return -1;
7791   }
7792   {
7793     int r;
7794     suppress_error = 0;
7795     r = guestfs_lvm_remove_all (g);
7796     if (r == -1)
7797       return -1;
7798   }
7799   {
7800     char device[] = "/dev/sda";
7801     char lines_0[] = ",";
7802     char *lines[] = {
7803       lines_0,
7804       NULL
7805     };
7806     int r;
7807     suppress_error = 0;
7808     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7809     if (r == -1)
7810       return -1;
7811   }
7812   {
7813     char fstype[] = "ext2";
7814     char device[] = "/dev/sda1";
7815     int r;
7816     suppress_error = 0;
7817     r = guestfs_mkfs (g, fstype, device);
7818     if (r == -1)
7819       return -1;
7820   }
7821   {
7822     char device[] = "/dev/sda1";
7823     char mountpoint[] = "/";
7824     int r;
7825     suppress_error = 0;
7826     r = guestfs_mount (g, device, mountpoint);
7827     if (r == -1)
7828       return -1;
7829   }
7830   /* TestOutputList for command_lines (2) */
7831   {
7832     char remotefilename[] = "/test-command";
7833     int r;
7834     suppress_error = 0;
7835     r = guestfs_upload (g, "test-command", remotefilename);
7836     if (r == -1)
7837       return -1;
7838   }
7839   {
7840     char path[] = "/test-command";
7841     int r;
7842     suppress_error = 0;
7843     r = guestfs_chmod (g, 493, path);
7844     if (r == -1)
7845       return -1;
7846   }
7847   {
7848     char arguments_0[] = "/test-command";
7849     char arguments_1[] = "3";
7850     char *arguments[] = {
7851       arguments_0,
7852       arguments_1,
7853       NULL
7854     };
7855     char **r;
7856     int i;
7857     suppress_error = 0;
7858     r = guestfs_command_lines (g, arguments);
7859     if (r == NULL)
7860       return -1;
7861     if (!r[0]) {
7862       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7863       print_strings (r);
7864       return -1;
7865     }
7866     {
7867       char expected[] = "";
7868       if (strcmp (r[0], expected) != 0) {
7869         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7870         return -1;
7871       }
7872     }
7873     if (!r[1]) {
7874       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7875       print_strings (r);
7876       return -1;
7877     }
7878     {
7879       char expected[] = "Result3";
7880       if (strcmp (r[1], expected) != 0) {
7881         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7882         return -1;
7883       }
7884     }
7885     if (r[2] != NULL) {
7886       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7887       print_strings (r);
7888       return -1;
7889     }
7890     for (i = 0; r[i] != NULL; ++i)
7891       free (r[i]);
7892     free (r);
7893   }
7894   return 0;
7895 }
7896
7897 static int test_command_lines_3_skip (void)
7898 {
7899   const char *str;
7900
7901   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7902   if (str && strcmp (str, "1") == 0) return 1;
7903   str = getenv ("SKIP_TEST_COMMAND_LINES");
7904   if (str && strcmp (str, "1") == 0) return 1;
7905   return 0;
7906 }
7907
7908 static int test_command_lines_3 (void)
7909 {
7910   if (test_command_lines_3_skip ()) {
7911     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7912     return 0;
7913   }
7914
7915   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7916   {
7917     char device[] = "/dev/sda";
7918     int r;
7919     suppress_error = 0;
7920     r = guestfs_blockdev_setrw (g, device);
7921     if (r == -1)
7922       return -1;
7923   }
7924   {
7925     int r;
7926     suppress_error = 0;
7927     r = guestfs_umount_all (g);
7928     if (r == -1)
7929       return -1;
7930   }
7931   {
7932     int r;
7933     suppress_error = 0;
7934     r = guestfs_lvm_remove_all (g);
7935     if (r == -1)
7936       return -1;
7937   }
7938   {
7939     char device[] = "/dev/sda";
7940     char lines_0[] = ",";
7941     char *lines[] = {
7942       lines_0,
7943       NULL
7944     };
7945     int r;
7946     suppress_error = 0;
7947     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7948     if (r == -1)
7949       return -1;
7950   }
7951   {
7952     char fstype[] = "ext2";
7953     char device[] = "/dev/sda1";
7954     int r;
7955     suppress_error = 0;
7956     r = guestfs_mkfs (g, fstype, device);
7957     if (r == -1)
7958       return -1;
7959   }
7960   {
7961     char device[] = "/dev/sda1";
7962     char mountpoint[] = "/";
7963     int r;
7964     suppress_error = 0;
7965     r = guestfs_mount (g, device, mountpoint);
7966     if (r == -1)
7967       return -1;
7968   }
7969   /* TestOutputList for command_lines (3) */
7970   {
7971     char remotefilename[] = "/test-command";
7972     int r;
7973     suppress_error = 0;
7974     r = guestfs_upload (g, "test-command", remotefilename);
7975     if (r == -1)
7976       return -1;
7977   }
7978   {
7979     char path[] = "/test-command";
7980     int r;
7981     suppress_error = 0;
7982     r = guestfs_chmod (g, 493, path);
7983     if (r == -1)
7984       return -1;
7985   }
7986   {
7987     char arguments_0[] = "/test-command";
7988     char arguments_1[] = "4";
7989     char *arguments[] = {
7990       arguments_0,
7991       arguments_1,
7992       NULL
7993     };
7994     char **r;
7995     int i;
7996     suppress_error = 0;
7997     r = guestfs_command_lines (g, arguments);
7998     if (r == NULL)
7999       return -1;
8000     if (!r[0]) {
8001       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8002       print_strings (r);
8003       return -1;
8004     }
8005     {
8006       char expected[] = "";
8007       if (strcmp (r[0], expected) != 0) {
8008         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8009         return -1;
8010       }
8011     }
8012     if (!r[1]) {
8013       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8014       print_strings (r);
8015       return -1;
8016     }
8017     {
8018       char expected[] = "Result4";
8019       if (strcmp (r[1], expected) != 0) {
8020         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8021         return -1;
8022       }
8023     }
8024     if (r[2] != NULL) {
8025       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
8026       print_strings (r);
8027       return -1;
8028     }
8029     for (i = 0; r[i] != NULL; ++i)
8030       free (r[i]);
8031     free (r);
8032   }
8033   return 0;
8034 }
8035
8036 static int test_command_lines_4_skip (void)
8037 {
8038   const char *str;
8039
8040   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
8041   if (str && strcmp (str, "1") == 0) return 1;
8042   str = getenv ("SKIP_TEST_COMMAND_LINES");
8043   if (str && strcmp (str, "1") == 0) return 1;
8044   return 0;
8045 }
8046
8047 static int test_command_lines_4 (void)
8048 {
8049   if (test_command_lines_4_skip ()) {
8050     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
8051     return 0;
8052   }
8053
8054   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
8055   {
8056     char device[] = "/dev/sda";
8057     int r;
8058     suppress_error = 0;
8059     r = guestfs_blockdev_setrw (g, device);
8060     if (r == -1)
8061       return -1;
8062   }
8063   {
8064     int r;
8065     suppress_error = 0;
8066     r = guestfs_umount_all (g);
8067     if (r == -1)
8068       return -1;
8069   }
8070   {
8071     int r;
8072     suppress_error = 0;
8073     r = guestfs_lvm_remove_all (g);
8074     if (r == -1)
8075       return -1;
8076   }
8077   {
8078     char device[] = "/dev/sda";
8079     char lines_0[] = ",";
8080     char *lines[] = {
8081       lines_0,
8082       NULL
8083     };
8084     int r;
8085     suppress_error = 0;
8086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8087     if (r == -1)
8088       return -1;
8089   }
8090   {
8091     char fstype[] = "ext2";
8092     char device[] = "/dev/sda1";
8093     int r;
8094     suppress_error = 0;
8095     r = guestfs_mkfs (g, fstype, device);
8096     if (r == -1)
8097       return -1;
8098   }
8099   {
8100     char device[] = "/dev/sda1";
8101     char mountpoint[] = "/";
8102     int r;
8103     suppress_error = 0;
8104     r = guestfs_mount (g, device, mountpoint);
8105     if (r == -1)
8106       return -1;
8107   }
8108   /* TestOutputList for command_lines (4) */
8109   {
8110     char remotefilename[] = "/test-command";
8111     int r;
8112     suppress_error = 0;
8113     r = guestfs_upload (g, "test-command", remotefilename);
8114     if (r == -1)
8115       return -1;
8116   }
8117   {
8118     char path[] = "/test-command";
8119     int r;
8120     suppress_error = 0;
8121     r = guestfs_chmod (g, 493, path);
8122     if (r == -1)
8123       return -1;
8124   }
8125   {
8126     char arguments_0[] = "/test-command";
8127     char arguments_1[] = "5";
8128     char *arguments[] = {
8129       arguments_0,
8130       arguments_1,
8131       NULL
8132     };
8133     char **r;
8134     int i;
8135     suppress_error = 0;
8136     r = guestfs_command_lines (g, arguments);
8137     if (r == NULL)
8138       return -1;
8139     if (!r[0]) {
8140       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8141       print_strings (r);
8142       return -1;
8143     }
8144     {
8145       char expected[] = "";
8146       if (strcmp (r[0], expected) != 0) {
8147         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8148         return -1;
8149       }
8150     }
8151     if (!r[1]) {
8152       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8153       print_strings (r);
8154       return -1;
8155     }
8156     {
8157       char expected[] = "Result5";
8158       if (strcmp (r[1], expected) != 0) {
8159         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8160         return -1;
8161       }
8162     }
8163     if (!r[2]) {
8164       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8165       print_strings (r);
8166       return -1;
8167     }
8168     {
8169       char expected[] = "";
8170       if (strcmp (r[2], expected) != 0) {
8171         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8172         return -1;
8173       }
8174     }
8175     if (r[3] != NULL) {
8176       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
8177       print_strings (r);
8178       return -1;
8179     }
8180     for (i = 0; r[i] != NULL; ++i)
8181       free (r[i]);
8182     free (r);
8183   }
8184   return 0;
8185 }
8186
8187 static int test_command_lines_5_skip (void)
8188 {
8189   const char *str;
8190
8191   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
8192   if (str && strcmp (str, "1") == 0) return 1;
8193   str = getenv ("SKIP_TEST_COMMAND_LINES");
8194   if (str && strcmp (str, "1") == 0) return 1;
8195   return 0;
8196 }
8197
8198 static int test_command_lines_5 (void)
8199 {
8200   if (test_command_lines_5_skip ()) {
8201     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
8202     return 0;
8203   }
8204
8205   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
8206   {
8207     char device[] = "/dev/sda";
8208     int r;
8209     suppress_error = 0;
8210     r = guestfs_blockdev_setrw (g, device);
8211     if (r == -1)
8212       return -1;
8213   }
8214   {
8215     int r;
8216     suppress_error = 0;
8217     r = guestfs_umount_all (g);
8218     if (r == -1)
8219       return -1;
8220   }
8221   {
8222     int r;
8223     suppress_error = 0;
8224     r = guestfs_lvm_remove_all (g);
8225     if (r == -1)
8226       return -1;
8227   }
8228   {
8229     char device[] = "/dev/sda";
8230     char lines_0[] = ",";
8231     char *lines[] = {
8232       lines_0,
8233       NULL
8234     };
8235     int r;
8236     suppress_error = 0;
8237     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8238     if (r == -1)
8239       return -1;
8240   }
8241   {
8242     char fstype[] = "ext2";
8243     char device[] = "/dev/sda1";
8244     int r;
8245     suppress_error = 0;
8246     r = guestfs_mkfs (g, fstype, device);
8247     if (r == -1)
8248       return -1;
8249   }
8250   {
8251     char device[] = "/dev/sda1";
8252     char mountpoint[] = "/";
8253     int r;
8254     suppress_error = 0;
8255     r = guestfs_mount (g, device, mountpoint);
8256     if (r == -1)
8257       return -1;
8258   }
8259   /* TestOutputList for command_lines (5) */
8260   {
8261     char remotefilename[] = "/test-command";
8262     int r;
8263     suppress_error = 0;
8264     r = guestfs_upload (g, "test-command", remotefilename);
8265     if (r == -1)
8266       return -1;
8267   }
8268   {
8269     char path[] = "/test-command";
8270     int r;
8271     suppress_error = 0;
8272     r = guestfs_chmod (g, 493, path);
8273     if (r == -1)
8274       return -1;
8275   }
8276   {
8277     char arguments_0[] = "/test-command";
8278     char arguments_1[] = "6";
8279     char *arguments[] = {
8280       arguments_0,
8281       arguments_1,
8282       NULL
8283     };
8284     char **r;
8285     int i;
8286     suppress_error = 0;
8287     r = guestfs_command_lines (g, arguments);
8288     if (r == NULL)
8289       return -1;
8290     if (!r[0]) {
8291       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8292       print_strings (r);
8293       return -1;
8294     }
8295     {
8296       char expected[] = "";
8297       if (strcmp (r[0], expected) != 0) {
8298         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8299         return -1;
8300       }
8301     }
8302     if (!r[1]) {
8303       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8304       print_strings (r);
8305       return -1;
8306     }
8307     {
8308       char expected[] = "";
8309       if (strcmp (r[1], expected) != 0) {
8310         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8311         return -1;
8312       }
8313     }
8314     if (!r[2]) {
8315       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8316       print_strings (r);
8317       return -1;
8318     }
8319     {
8320       char expected[] = "Result6";
8321       if (strcmp (r[2], expected) != 0) {
8322         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8323         return -1;
8324       }
8325     }
8326     if (!r[3]) {
8327       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8328       print_strings (r);
8329       return -1;
8330     }
8331     {
8332       char expected[] = "";
8333       if (strcmp (r[3], expected) != 0) {
8334         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8335         return -1;
8336       }
8337     }
8338     if (r[4] != NULL) {
8339       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8340       print_strings (r);
8341       return -1;
8342     }
8343     for (i = 0; r[i] != NULL; ++i)
8344       free (r[i]);
8345     free (r);
8346   }
8347   return 0;
8348 }
8349
8350 static int test_command_lines_6_skip (void)
8351 {
8352   const char *str;
8353
8354   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8355   if (str && strcmp (str, "1") == 0) return 1;
8356   str = getenv ("SKIP_TEST_COMMAND_LINES");
8357   if (str && strcmp (str, "1") == 0) return 1;
8358   return 0;
8359 }
8360
8361 static int test_command_lines_6 (void)
8362 {
8363   if (test_command_lines_6_skip ()) {
8364     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8365     return 0;
8366   }
8367
8368   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8369   {
8370     char device[] = "/dev/sda";
8371     int r;
8372     suppress_error = 0;
8373     r = guestfs_blockdev_setrw (g, device);
8374     if (r == -1)
8375       return -1;
8376   }
8377   {
8378     int r;
8379     suppress_error = 0;
8380     r = guestfs_umount_all (g);
8381     if (r == -1)
8382       return -1;
8383   }
8384   {
8385     int r;
8386     suppress_error = 0;
8387     r = guestfs_lvm_remove_all (g);
8388     if (r == -1)
8389       return -1;
8390   }
8391   {
8392     char device[] = "/dev/sda";
8393     char lines_0[] = ",";
8394     char *lines[] = {
8395       lines_0,
8396       NULL
8397     };
8398     int r;
8399     suppress_error = 0;
8400     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8401     if (r == -1)
8402       return -1;
8403   }
8404   {
8405     char fstype[] = "ext2";
8406     char device[] = "/dev/sda1";
8407     int r;
8408     suppress_error = 0;
8409     r = guestfs_mkfs (g, fstype, device);
8410     if (r == -1)
8411       return -1;
8412   }
8413   {
8414     char device[] = "/dev/sda1";
8415     char mountpoint[] = "/";
8416     int r;
8417     suppress_error = 0;
8418     r = guestfs_mount (g, device, mountpoint);
8419     if (r == -1)
8420       return -1;
8421   }
8422   /* TestOutputList for command_lines (6) */
8423   {
8424     char remotefilename[] = "/test-command";
8425     int r;
8426     suppress_error = 0;
8427     r = guestfs_upload (g, "test-command", remotefilename);
8428     if (r == -1)
8429       return -1;
8430   }
8431   {
8432     char path[] = "/test-command";
8433     int r;
8434     suppress_error = 0;
8435     r = guestfs_chmod (g, 493, path);
8436     if (r == -1)
8437       return -1;
8438   }
8439   {
8440     char arguments_0[] = "/test-command";
8441     char arguments_1[] = "7";
8442     char *arguments[] = {
8443       arguments_0,
8444       arguments_1,
8445       NULL
8446     };
8447     char **r;
8448     int i;
8449     suppress_error = 0;
8450     r = guestfs_command_lines (g, arguments);
8451     if (r == NULL)
8452       return -1;
8453     if (r[0] != NULL) {
8454       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8455       print_strings (r);
8456       return -1;
8457     }
8458     for (i = 0; r[i] != NULL; ++i)
8459       free (r[i]);
8460     free (r);
8461   }
8462   return 0;
8463 }
8464
8465 static int test_command_lines_7_skip (void)
8466 {
8467   const char *str;
8468
8469   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8470   if (str && strcmp (str, "1") == 0) return 1;
8471   str = getenv ("SKIP_TEST_COMMAND_LINES");
8472   if (str && strcmp (str, "1") == 0) return 1;
8473   return 0;
8474 }
8475
8476 static int test_command_lines_7 (void)
8477 {
8478   if (test_command_lines_7_skip ()) {
8479     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8480     return 0;
8481   }
8482
8483   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8484   {
8485     char device[] = "/dev/sda";
8486     int r;
8487     suppress_error = 0;
8488     r = guestfs_blockdev_setrw (g, device);
8489     if (r == -1)
8490       return -1;
8491   }
8492   {
8493     int r;
8494     suppress_error = 0;
8495     r = guestfs_umount_all (g);
8496     if (r == -1)
8497       return -1;
8498   }
8499   {
8500     int r;
8501     suppress_error = 0;
8502     r = guestfs_lvm_remove_all (g);
8503     if (r == -1)
8504       return -1;
8505   }
8506   {
8507     char device[] = "/dev/sda";
8508     char lines_0[] = ",";
8509     char *lines[] = {
8510       lines_0,
8511       NULL
8512     };
8513     int r;
8514     suppress_error = 0;
8515     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8516     if (r == -1)
8517       return -1;
8518   }
8519   {
8520     char fstype[] = "ext2";
8521     char device[] = "/dev/sda1";
8522     int r;
8523     suppress_error = 0;
8524     r = guestfs_mkfs (g, fstype, device);
8525     if (r == -1)
8526       return -1;
8527   }
8528   {
8529     char device[] = "/dev/sda1";
8530     char mountpoint[] = "/";
8531     int r;
8532     suppress_error = 0;
8533     r = guestfs_mount (g, device, mountpoint);
8534     if (r == -1)
8535       return -1;
8536   }
8537   /* TestOutputList for command_lines (7) */
8538   {
8539     char remotefilename[] = "/test-command";
8540     int r;
8541     suppress_error = 0;
8542     r = guestfs_upload (g, "test-command", remotefilename);
8543     if (r == -1)
8544       return -1;
8545   }
8546   {
8547     char path[] = "/test-command";
8548     int r;
8549     suppress_error = 0;
8550     r = guestfs_chmod (g, 493, path);
8551     if (r == -1)
8552       return -1;
8553   }
8554   {
8555     char arguments_0[] = "/test-command";
8556     char arguments_1[] = "8";
8557     char *arguments[] = {
8558       arguments_0,
8559       arguments_1,
8560       NULL
8561     };
8562     char **r;
8563     int i;
8564     suppress_error = 0;
8565     r = guestfs_command_lines (g, arguments);
8566     if (r == NULL)
8567       return -1;
8568     if (!r[0]) {
8569       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8570       print_strings (r);
8571       return -1;
8572     }
8573     {
8574       char expected[] = "";
8575       if (strcmp (r[0], expected) != 0) {
8576         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8577         return -1;
8578       }
8579     }
8580     if (r[1] != NULL) {
8581       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8582       print_strings (r);
8583       return -1;
8584     }
8585     for (i = 0; r[i] != NULL; ++i)
8586       free (r[i]);
8587     free (r);
8588   }
8589   return 0;
8590 }
8591
8592 static int test_command_lines_8_skip (void)
8593 {
8594   const char *str;
8595
8596   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8597   if (str && strcmp (str, "1") == 0) return 1;
8598   str = getenv ("SKIP_TEST_COMMAND_LINES");
8599   if (str && strcmp (str, "1") == 0) return 1;
8600   return 0;
8601 }
8602
8603 static int test_command_lines_8 (void)
8604 {
8605   if (test_command_lines_8_skip ()) {
8606     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8607     return 0;
8608   }
8609
8610   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8611   {
8612     char device[] = "/dev/sda";
8613     int r;
8614     suppress_error = 0;
8615     r = guestfs_blockdev_setrw (g, device);
8616     if (r == -1)
8617       return -1;
8618   }
8619   {
8620     int r;
8621     suppress_error = 0;
8622     r = guestfs_umount_all (g);
8623     if (r == -1)
8624       return -1;
8625   }
8626   {
8627     int r;
8628     suppress_error = 0;
8629     r = guestfs_lvm_remove_all (g);
8630     if (r == -1)
8631       return -1;
8632   }
8633   {
8634     char device[] = "/dev/sda";
8635     char lines_0[] = ",";
8636     char *lines[] = {
8637       lines_0,
8638       NULL
8639     };
8640     int r;
8641     suppress_error = 0;
8642     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8643     if (r == -1)
8644       return -1;
8645   }
8646   {
8647     char fstype[] = "ext2";
8648     char device[] = "/dev/sda1";
8649     int r;
8650     suppress_error = 0;
8651     r = guestfs_mkfs (g, fstype, device);
8652     if (r == -1)
8653       return -1;
8654   }
8655   {
8656     char device[] = "/dev/sda1";
8657     char mountpoint[] = "/";
8658     int r;
8659     suppress_error = 0;
8660     r = guestfs_mount (g, device, mountpoint);
8661     if (r == -1)
8662       return -1;
8663   }
8664   /* TestOutputList for command_lines (8) */
8665   {
8666     char remotefilename[] = "/test-command";
8667     int r;
8668     suppress_error = 0;
8669     r = guestfs_upload (g, "test-command", remotefilename);
8670     if (r == -1)
8671       return -1;
8672   }
8673   {
8674     char path[] = "/test-command";
8675     int r;
8676     suppress_error = 0;
8677     r = guestfs_chmod (g, 493, path);
8678     if (r == -1)
8679       return -1;
8680   }
8681   {
8682     char arguments_0[] = "/test-command";
8683     char arguments_1[] = "9";
8684     char *arguments[] = {
8685       arguments_0,
8686       arguments_1,
8687       NULL
8688     };
8689     char **r;
8690     int i;
8691     suppress_error = 0;
8692     r = guestfs_command_lines (g, arguments);
8693     if (r == NULL)
8694       return -1;
8695     if (!r[0]) {
8696       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8697       print_strings (r);
8698       return -1;
8699     }
8700     {
8701       char expected[] = "";
8702       if (strcmp (r[0], expected) != 0) {
8703         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8704         return -1;
8705       }
8706     }
8707     if (!r[1]) {
8708       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8709       print_strings (r);
8710       return -1;
8711     }
8712     {
8713       char expected[] = "";
8714       if (strcmp (r[1], expected) != 0) {
8715         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8716         return -1;
8717       }
8718     }
8719     if (r[2] != NULL) {
8720       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8721       print_strings (r);
8722       return -1;
8723     }
8724     for (i = 0; r[i] != NULL; ++i)
8725       free (r[i]);
8726     free (r);
8727   }
8728   return 0;
8729 }
8730
8731 static int test_command_lines_9_skip (void)
8732 {
8733   const char *str;
8734
8735   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8736   if (str && strcmp (str, "1") == 0) return 1;
8737   str = getenv ("SKIP_TEST_COMMAND_LINES");
8738   if (str && strcmp (str, "1") == 0) return 1;
8739   return 0;
8740 }
8741
8742 static int test_command_lines_9 (void)
8743 {
8744   if (test_command_lines_9_skip ()) {
8745     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8746     return 0;
8747   }
8748
8749   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8750   {
8751     char device[] = "/dev/sda";
8752     int r;
8753     suppress_error = 0;
8754     r = guestfs_blockdev_setrw (g, device);
8755     if (r == -1)
8756       return -1;
8757   }
8758   {
8759     int r;
8760     suppress_error = 0;
8761     r = guestfs_umount_all (g);
8762     if (r == -1)
8763       return -1;
8764   }
8765   {
8766     int r;
8767     suppress_error = 0;
8768     r = guestfs_lvm_remove_all (g);
8769     if (r == -1)
8770       return -1;
8771   }
8772   {
8773     char device[] = "/dev/sda";
8774     char lines_0[] = ",";
8775     char *lines[] = {
8776       lines_0,
8777       NULL
8778     };
8779     int r;
8780     suppress_error = 0;
8781     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8782     if (r == -1)
8783       return -1;
8784   }
8785   {
8786     char fstype[] = "ext2";
8787     char device[] = "/dev/sda1";
8788     int r;
8789     suppress_error = 0;
8790     r = guestfs_mkfs (g, fstype, device);
8791     if (r == -1)
8792       return -1;
8793   }
8794   {
8795     char device[] = "/dev/sda1";
8796     char mountpoint[] = "/";
8797     int r;
8798     suppress_error = 0;
8799     r = guestfs_mount (g, device, mountpoint);
8800     if (r == -1)
8801       return -1;
8802   }
8803   /* TestOutputList for command_lines (9) */
8804   {
8805     char remotefilename[] = "/test-command";
8806     int r;
8807     suppress_error = 0;
8808     r = guestfs_upload (g, "test-command", remotefilename);
8809     if (r == -1)
8810       return -1;
8811   }
8812   {
8813     char path[] = "/test-command";
8814     int r;
8815     suppress_error = 0;
8816     r = guestfs_chmod (g, 493, path);
8817     if (r == -1)
8818       return -1;
8819   }
8820   {
8821     char arguments_0[] = "/test-command";
8822     char arguments_1[] = "10";
8823     char *arguments[] = {
8824       arguments_0,
8825       arguments_1,
8826       NULL
8827     };
8828     char **r;
8829     int i;
8830     suppress_error = 0;
8831     r = guestfs_command_lines (g, arguments);
8832     if (r == NULL)
8833       return -1;
8834     if (!r[0]) {
8835       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8836       print_strings (r);
8837       return -1;
8838     }
8839     {
8840       char expected[] = "Result10-1";
8841       if (strcmp (r[0], expected) != 0) {
8842         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8843         return -1;
8844       }
8845     }
8846     if (!r[1]) {
8847       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8848       print_strings (r);
8849       return -1;
8850     }
8851     {
8852       char expected[] = "Result10-2";
8853       if (strcmp (r[1], expected) != 0) {
8854         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8855         return -1;
8856       }
8857     }
8858     if (r[2] != NULL) {
8859       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8860       print_strings (r);
8861       return -1;
8862     }
8863     for (i = 0; r[i] != NULL; ++i)
8864       free (r[i]);
8865     free (r);
8866   }
8867   return 0;
8868 }
8869
8870 static int test_command_lines_10_skip (void)
8871 {
8872   const char *str;
8873
8874   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8875   if (str && strcmp (str, "1") == 0) return 1;
8876   str = getenv ("SKIP_TEST_COMMAND_LINES");
8877   if (str && strcmp (str, "1") == 0) return 1;
8878   return 0;
8879 }
8880
8881 static int test_command_lines_10 (void)
8882 {
8883   if (test_command_lines_10_skip ()) {
8884     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8885     return 0;
8886   }
8887
8888   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8889   {
8890     char device[] = "/dev/sda";
8891     int r;
8892     suppress_error = 0;
8893     r = guestfs_blockdev_setrw (g, device);
8894     if (r == -1)
8895       return -1;
8896   }
8897   {
8898     int r;
8899     suppress_error = 0;
8900     r = guestfs_umount_all (g);
8901     if (r == -1)
8902       return -1;
8903   }
8904   {
8905     int r;
8906     suppress_error = 0;
8907     r = guestfs_lvm_remove_all (g);
8908     if (r == -1)
8909       return -1;
8910   }
8911   {
8912     char device[] = "/dev/sda";
8913     char lines_0[] = ",";
8914     char *lines[] = {
8915       lines_0,
8916       NULL
8917     };
8918     int r;
8919     suppress_error = 0;
8920     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8921     if (r == -1)
8922       return -1;
8923   }
8924   {
8925     char fstype[] = "ext2";
8926     char device[] = "/dev/sda1";
8927     int r;
8928     suppress_error = 0;
8929     r = guestfs_mkfs (g, fstype, device);
8930     if (r == -1)
8931       return -1;
8932   }
8933   {
8934     char device[] = "/dev/sda1";
8935     char mountpoint[] = "/";
8936     int r;
8937     suppress_error = 0;
8938     r = guestfs_mount (g, device, mountpoint);
8939     if (r == -1)
8940       return -1;
8941   }
8942   /* TestOutputList for command_lines (10) */
8943   {
8944     char remotefilename[] = "/test-command";
8945     int r;
8946     suppress_error = 0;
8947     r = guestfs_upload (g, "test-command", remotefilename);
8948     if (r == -1)
8949       return -1;
8950   }
8951   {
8952     char path[] = "/test-command";
8953     int r;
8954     suppress_error = 0;
8955     r = guestfs_chmod (g, 493, path);
8956     if (r == -1)
8957       return -1;
8958   }
8959   {
8960     char arguments_0[] = "/test-command";
8961     char arguments_1[] = "11";
8962     char *arguments[] = {
8963       arguments_0,
8964       arguments_1,
8965       NULL
8966     };
8967     char **r;
8968     int i;
8969     suppress_error = 0;
8970     r = guestfs_command_lines (g, arguments);
8971     if (r == NULL)
8972       return -1;
8973     if (!r[0]) {
8974       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8975       print_strings (r);
8976       return -1;
8977     }
8978     {
8979       char expected[] = "Result11-1";
8980       if (strcmp (r[0], expected) != 0) {
8981         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8982         return -1;
8983       }
8984     }
8985     if (!r[1]) {
8986       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8987       print_strings (r);
8988       return -1;
8989     }
8990     {
8991       char expected[] = "Result11-2";
8992       if (strcmp (r[1], expected) != 0) {
8993         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8994         return -1;
8995       }
8996     }
8997     if (r[2] != NULL) {
8998       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8999       print_strings (r);
9000       return -1;
9001     }
9002     for (i = 0; r[i] != NULL; ++i)
9003       free (r[i]);
9004     free (r);
9005   }
9006   return 0;
9007 }
9008
9009 static int test_command_0_skip (void)
9010 {
9011   const char *str;
9012
9013   str = getenv ("SKIP_TEST_COMMAND_0");
9014   if (str && strcmp (str, "1") == 0) return 1;
9015   str = getenv ("SKIP_TEST_COMMAND");
9016   if (str && strcmp (str, "1") == 0) return 1;
9017   return 0;
9018 }
9019
9020 static int test_command_0 (void)
9021 {
9022   if (test_command_0_skip ()) {
9023     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
9024     return 0;
9025   }
9026
9027   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
9028   {
9029     char device[] = "/dev/sda";
9030     int r;
9031     suppress_error = 0;
9032     r = guestfs_blockdev_setrw (g, device);
9033     if (r == -1)
9034       return -1;
9035   }
9036   {
9037     int r;
9038     suppress_error = 0;
9039     r = guestfs_umount_all (g);
9040     if (r == -1)
9041       return -1;
9042   }
9043   {
9044     int r;
9045     suppress_error = 0;
9046     r = guestfs_lvm_remove_all (g);
9047     if (r == -1)
9048       return -1;
9049   }
9050   {
9051     char device[] = "/dev/sda";
9052     char lines_0[] = ",";
9053     char *lines[] = {
9054       lines_0,
9055       NULL
9056     };
9057     int r;
9058     suppress_error = 0;
9059     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9060     if (r == -1)
9061       return -1;
9062   }
9063   {
9064     char fstype[] = "ext2";
9065     char device[] = "/dev/sda1";
9066     int r;
9067     suppress_error = 0;
9068     r = guestfs_mkfs (g, fstype, device);
9069     if (r == -1)
9070       return -1;
9071   }
9072   {
9073     char device[] = "/dev/sda1";
9074     char mountpoint[] = "/";
9075     int r;
9076     suppress_error = 0;
9077     r = guestfs_mount (g, device, mountpoint);
9078     if (r == -1)
9079       return -1;
9080   }
9081   /* TestOutput for command (0) */
9082   char expected[] = "Result1";
9083   {
9084     char remotefilename[] = "/test-command";
9085     int r;
9086     suppress_error = 0;
9087     r = guestfs_upload (g, "test-command", remotefilename);
9088     if (r == -1)
9089       return -1;
9090   }
9091   {
9092     char path[] = "/test-command";
9093     int r;
9094     suppress_error = 0;
9095     r = guestfs_chmod (g, 493, path);
9096     if (r == -1)
9097       return -1;
9098   }
9099   {
9100     char arguments_0[] = "/test-command";
9101     char arguments_1[] = "1";
9102     char *arguments[] = {
9103       arguments_0,
9104       arguments_1,
9105       NULL
9106     };
9107     char *r;
9108     suppress_error = 0;
9109     r = guestfs_command (g, arguments);
9110     if (r == NULL)
9111       return -1;
9112     if (strcmp (r, expected) != 0) {
9113       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
9114       return -1;
9115     }
9116     free (r);
9117   }
9118   return 0;
9119 }
9120
9121 static int test_command_1_skip (void)
9122 {
9123   const char *str;
9124
9125   str = getenv ("SKIP_TEST_COMMAND_1");
9126   if (str && strcmp (str, "1") == 0) return 1;
9127   str = getenv ("SKIP_TEST_COMMAND");
9128   if (str && strcmp (str, "1") == 0) return 1;
9129   return 0;
9130 }
9131
9132 static int test_command_1 (void)
9133 {
9134   if (test_command_1_skip ()) {
9135     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
9136     return 0;
9137   }
9138
9139   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
9140   {
9141     char device[] = "/dev/sda";
9142     int r;
9143     suppress_error = 0;
9144     r = guestfs_blockdev_setrw (g, device);
9145     if (r == -1)
9146       return -1;
9147   }
9148   {
9149     int r;
9150     suppress_error = 0;
9151     r = guestfs_umount_all (g);
9152     if (r == -1)
9153       return -1;
9154   }
9155   {
9156     int r;
9157     suppress_error = 0;
9158     r = guestfs_lvm_remove_all (g);
9159     if (r == -1)
9160       return -1;
9161   }
9162   {
9163     char device[] = "/dev/sda";
9164     char lines_0[] = ",";
9165     char *lines[] = {
9166       lines_0,
9167       NULL
9168     };
9169     int r;
9170     suppress_error = 0;
9171     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9172     if (r == -1)
9173       return -1;
9174   }
9175   {
9176     char fstype[] = "ext2";
9177     char device[] = "/dev/sda1";
9178     int r;
9179     suppress_error = 0;
9180     r = guestfs_mkfs (g, fstype, device);
9181     if (r == -1)
9182       return -1;
9183   }
9184   {
9185     char device[] = "/dev/sda1";
9186     char mountpoint[] = "/";
9187     int r;
9188     suppress_error = 0;
9189     r = guestfs_mount (g, device, mountpoint);
9190     if (r == -1)
9191       return -1;
9192   }
9193   /* TestOutput for command (1) */
9194   char expected[] = "Result2\n";
9195   {
9196     char remotefilename[] = "/test-command";
9197     int r;
9198     suppress_error = 0;
9199     r = guestfs_upload (g, "test-command", remotefilename);
9200     if (r == -1)
9201       return -1;
9202   }
9203   {
9204     char path[] = "/test-command";
9205     int r;
9206     suppress_error = 0;
9207     r = guestfs_chmod (g, 493, path);
9208     if (r == -1)
9209       return -1;
9210   }
9211   {
9212     char arguments_0[] = "/test-command";
9213     char arguments_1[] = "2";
9214     char *arguments[] = {
9215       arguments_0,
9216       arguments_1,
9217       NULL
9218     };
9219     char *r;
9220     suppress_error = 0;
9221     r = guestfs_command (g, arguments);
9222     if (r == NULL)
9223       return -1;
9224     if (strcmp (r, expected) != 0) {
9225       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
9226       return -1;
9227     }
9228     free (r);
9229   }
9230   return 0;
9231 }
9232
9233 static int test_command_2_skip (void)
9234 {
9235   const char *str;
9236
9237   str = getenv ("SKIP_TEST_COMMAND_2");
9238   if (str && strcmp (str, "1") == 0) return 1;
9239   str = getenv ("SKIP_TEST_COMMAND");
9240   if (str && strcmp (str, "1") == 0) return 1;
9241   return 0;
9242 }
9243
9244 static int test_command_2 (void)
9245 {
9246   if (test_command_2_skip ()) {
9247     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
9248     return 0;
9249   }
9250
9251   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9252   {
9253     char device[] = "/dev/sda";
9254     int r;
9255     suppress_error = 0;
9256     r = guestfs_blockdev_setrw (g, device);
9257     if (r == -1)
9258       return -1;
9259   }
9260   {
9261     int r;
9262     suppress_error = 0;
9263     r = guestfs_umount_all (g);
9264     if (r == -1)
9265       return -1;
9266   }
9267   {
9268     int r;
9269     suppress_error = 0;
9270     r = guestfs_lvm_remove_all (g);
9271     if (r == -1)
9272       return -1;
9273   }
9274   {
9275     char device[] = "/dev/sda";
9276     char lines_0[] = ",";
9277     char *lines[] = {
9278       lines_0,
9279       NULL
9280     };
9281     int r;
9282     suppress_error = 0;
9283     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9284     if (r == -1)
9285       return -1;
9286   }
9287   {
9288     char fstype[] = "ext2";
9289     char device[] = "/dev/sda1";
9290     int r;
9291     suppress_error = 0;
9292     r = guestfs_mkfs (g, fstype, device);
9293     if (r == -1)
9294       return -1;
9295   }
9296   {
9297     char device[] = "/dev/sda1";
9298     char mountpoint[] = "/";
9299     int r;
9300     suppress_error = 0;
9301     r = guestfs_mount (g, device, mountpoint);
9302     if (r == -1)
9303       return -1;
9304   }
9305   /* TestOutput for command (2) */
9306   char expected[] = "\nResult3";
9307   {
9308     char remotefilename[] = "/test-command";
9309     int r;
9310     suppress_error = 0;
9311     r = guestfs_upload (g, "test-command", remotefilename);
9312     if (r == -1)
9313       return -1;
9314   }
9315   {
9316     char path[] = "/test-command";
9317     int r;
9318     suppress_error = 0;
9319     r = guestfs_chmod (g, 493, path);
9320     if (r == -1)
9321       return -1;
9322   }
9323   {
9324     char arguments_0[] = "/test-command";
9325     char arguments_1[] = "3";
9326     char *arguments[] = {
9327       arguments_0,
9328       arguments_1,
9329       NULL
9330     };
9331     char *r;
9332     suppress_error = 0;
9333     r = guestfs_command (g, arguments);
9334     if (r == NULL)
9335       return -1;
9336     if (strcmp (r, expected) != 0) {
9337       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9338       return -1;
9339     }
9340     free (r);
9341   }
9342   return 0;
9343 }
9344
9345 static int test_command_3_skip (void)
9346 {
9347   const char *str;
9348
9349   str = getenv ("SKIP_TEST_COMMAND_3");
9350   if (str && strcmp (str, "1") == 0) return 1;
9351   str = getenv ("SKIP_TEST_COMMAND");
9352   if (str && strcmp (str, "1") == 0) return 1;
9353   return 0;
9354 }
9355
9356 static int test_command_3 (void)
9357 {
9358   if (test_command_3_skip ()) {
9359     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9360     return 0;
9361   }
9362
9363   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9364   {
9365     char device[] = "/dev/sda";
9366     int r;
9367     suppress_error = 0;
9368     r = guestfs_blockdev_setrw (g, device);
9369     if (r == -1)
9370       return -1;
9371   }
9372   {
9373     int r;
9374     suppress_error = 0;
9375     r = guestfs_umount_all (g);
9376     if (r == -1)
9377       return -1;
9378   }
9379   {
9380     int r;
9381     suppress_error = 0;
9382     r = guestfs_lvm_remove_all (g);
9383     if (r == -1)
9384       return -1;
9385   }
9386   {
9387     char device[] = "/dev/sda";
9388     char lines_0[] = ",";
9389     char *lines[] = {
9390       lines_0,
9391       NULL
9392     };
9393     int r;
9394     suppress_error = 0;
9395     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9396     if (r == -1)
9397       return -1;
9398   }
9399   {
9400     char fstype[] = "ext2";
9401     char device[] = "/dev/sda1";
9402     int r;
9403     suppress_error = 0;
9404     r = guestfs_mkfs (g, fstype, device);
9405     if (r == -1)
9406       return -1;
9407   }
9408   {
9409     char device[] = "/dev/sda1";
9410     char mountpoint[] = "/";
9411     int r;
9412     suppress_error = 0;
9413     r = guestfs_mount (g, device, mountpoint);
9414     if (r == -1)
9415       return -1;
9416   }
9417   /* TestOutput for command (3) */
9418   char expected[] = "\nResult4\n";
9419   {
9420     char remotefilename[] = "/test-command";
9421     int r;
9422     suppress_error = 0;
9423     r = guestfs_upload (g, "test-command", remotefilename);
9424     if (r == -1)
9425       return -1;
9426   }
9427   {
9428     char path[] = "/test-command";
9429     int r;
9430     suppress_error = 0;
9431     r = guestfs_chmod (g, 493, path);
9432     if (r == -1)
9433       return -1;
9434   }
9435   {
9436     char arguments_0[] = "/test-command";
9437     char arguments_1[] = "4";
9438     char *arguments[] = {
9439       arguments_0,
9440       arguments_1,
9441       NULL
9442     };
9443     char *r;
9444     suppress_error = 0;
9445     r = guestfs_command (g, arguments);
9446     if (r == NULL)
9447       return -1;
9448     if (strcmp (r, expected) != 0) {
9449       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9450       return -1;
9451     }
9452     free (r);
9453   }
9454   return 0;
9455 }
9456
9457 static int test_command_4_skip (void)
9458 {
9459   const char *str;
9460
9461   str = getenv ("SKIP_TEST_COMMAND_4");
9462   if (str && strcmp (str, "1") == 0) return 1;
9463   str = getenv ("SKIP_TEST_COMMAND");
9464   if (str && strcmp (str, "1") == 0) return 1;
9465   return 0;
9466 }
9467
9468 static int test_command_4 (void)
9469 {
9470   if (test_command_4_skip ()) {
9471     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9472     return 0;
9473   }
9474
9475   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9476   {
9477     char device[] = "/dev/sda";
9478     int r;
9479     suppress_error = 0;
9480     r = guestfs_blockdev_setrw (g, device);
9481     if (r == -1)
9482       return -1;
9483   }
9484   {
9485     int r;
9486     suppress_error = 0;
9487     r = guestfs_umount_all (g);
9488     if (r == -1)
9489       return -1;
9490   }
9491   {
9492     int r;
9493     suppress_error = 0;
9494     r = guestfs_lvm_remove_all (g);
9495     if (r == -1)
9496       return -1;
9497   }
9498   {
9499     char device[] = "/dev/sda";
9500     char lines_0[] = ",";
9501     char *lines[] = {
9502       lines_0,
9503       NULL
9504     };
9505     int r;
9506     suppress_error = 0;
9507     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9508     if (r == -1)
9509       return -1;
9510   }
9511   {
9512     char fstype[] = "ext2";
9513     char device[] = "/dev/sda1";
9514     int r;
9515     suppress_error = 0;
9516     r = guestfs_mkfs (g, fstype, device);
9517     if (r == -1)
9518       return -1;
9519   }
9520   {
9521     char device[] = "/dev/sda1";
9522     char mountpoint[] = "/";
9523     int r;
9524     suppress_error = 0;
9525     r = guestfs_mount (g, device, mountpoint);
9526     if (r == -1)
9527       return -1;
9528   }
9529   /* TestOutput for command (4) */
9530   char expected[] = "\nResult5\n\n";
9531   {
9532     char remotefilename[] = "/test-command";
9533     int r;
9534     suppress_error = 0;
9535     r = guestfs_upload (g, "test-command", remotefilename);
9536     if (r == -1)
9537       return -1;
9538   }
9539   {
9540     char path[] = "/test-command";
9541     int r;
9542     suppress_error = 0;
9543     r = guestfs_chmod (g, 493, path);
9544     if (r == -1)
9545       return -1;
9546   }
9547   {
9548     char arguments_0[] = "/test-command";
9549     char arguments_1[] = "5";
9550     char *arguments[] = {
9551       arguments_0,
9552       arguments_1,
9553       NULL
9554     };
9555     char *r;
9556     suppress_error = 0;
9557     r = guestfs_command (g, arguments);
9558     if (r == NULL)
9559       return -1;
9560     if (strcmp (r, expected) != 0) {
9561       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9562       return -1;
9563     }
9564     free (r);
9565   }
9566   return 0;
9567 }
9568
9569 static int test_command_5_skip (void)
9570 {
9571   const char *str;
9572
9573   str = getenv ("SKIP_TEST_COMMAND_5");
9574   if (str && strcmp (str, "1") == 0) return 1;
9575   str = getenv ("SKIP_TEST_COMMAND");
9576   if (str && strcmp (str, "1") == 0) return 1;
9577   return 0;
9578 }
9579
9580 static int test_command_5 (void)
9581 {
9582   if (test_command_5_skip ()) {
9583     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9584     return 0;
9585   }
9586
9587   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9588   {
9589     char device[] = "/dev/sda";
9590     int r;
9591     suppress_error = 0;
9592     r = guestfs_blockdev_setrw (g, device);
9593     if (r == -1)
9594       return -1;
9595   }
9596   {
9597     int r;
9598     suppress_error = 0;
9599     r = guestfs_umount_all (g);
9600     if (r == -1)
9601       return -1;
9602   }
9603   {
9604     int r;
9605     suppress_error = 0;
9606     r = guestfs_lvm_remove_all (g);
9607     if (r == -1)
9608       return -1;
9609   }
9610   {
9611     char device[] = "/dev/sda";
9612     char lines_0[] = ",";
9613     char *lines[] = {
9614       lines_0,
9615       NULL
9616     };
9617     int r;
9618     suppress_error = 0;
9619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9620     if (r == -1)
9621       return -1;
9622   }
9623   {
9624     char fstype[] = "ext2";
9625     char device[] = "/dev/sda1";
9626     int r;
9627     suppress_error = 0;
9628     r = guestfs_mkfs (g, fstype, device);
9629     if (r == -1)
9630       return -1;
9631   }
9632   {
9633     char device[] = "/dev/sda1";
9634     char mountpoint[] = "/";
9635     int r;
9636     suppress_error = 0;
9637     r = guestfs_mount (g, device, mountpoint);
9638     if (r == -1)
9639       return -1;
9640   }
9641   /* TestOutput for command (5) */
9642   char expected[] = "\n\nResult6\n\n";
9643   {
9644     char remotefilename[] = "/test-command";
9645     int r;
9646     suppress_error = 0;
9647     r = guestfs_upload (g, "test-command", remotefilename);
9648     if (r == -1)
9649       return -1;
9650   }
9651   {
9652     char path[] = "/test-command";
9653     int r;
9654     suppress_error = 0;
9655     r = guestfs_chmod (g, 493, path);
9656     if (r == -1)
9657       return -1;
9658   }
9659   {
9660     char arguments_0[] = "/test-command";
9661     char arguments_1[] = "6";
9662     char *arguments[] = {
9663       arguments_0,
9664       arguments_1,
9665       NULL
9666     };
9667     char *r;
9668     suppress_error = 0;
9669     r = guestfs_command (g, arguments);
9670     if (r == NULL)
9671       return -1;
9672     if (strcmp (r, expected) != 0) {
9673       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9674       return -1;
9675     }
9676     free (r);
9677   }
9678   return 0;
9679 }
9680
9681 static int test_command_6_skip (void)
9682 {
9683   const char *str;
9684
9685   str = getenv ("SKIP_TEST_COMMAND_6");
9686   if (str && strcmp (str, "1") == 0) return 1;
9687   str = getenv ("SKIP_TEST_COMMAND");
9688   if (str && strcmp (str, "1") == 0) return 1;
9689   return 0;
9690 }
9691
9692 static int test_command_6 (void)
9693 {
9694   if (test_command_6_skip ()) {
9695     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9696     return 0;
9697   }
9698
9699   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9700   {
9701     char device[] = "/dev/sda";
9702     int r;
9703     suppress_error = 0;
9704     r = guestfs_blockdev_setrw (g, device);
9705     if (r == -1)
9706       return -1;
9707   }
9708   {
9709     int r;
9710     suppress_error = 0;
9711     r = guestfs_umount_all (g);
9712     if (r == -1)
9713       return -1;
9714   }
9715   {
9716     int r;
9717     suppress_error = 0;
9718     r = guestfs_lvm_remove_all (g);
9719     if (r == -1)
9720       return -1;
9721   }
9722   {
9723     char device[] = "/dev/sda";
9724     char lines_0[] = ",";
9725     char *lines[] = {
9726       lines_0,
9727       NULL
9728     };
9729     int r;
9730     suppress_error = 0;
9731     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9732     if (r == -1)
9733       return -1;
9734   }
9735   {
9736     char fstype[] = "ext2";
9737     char device[] = "/dev/sda1";
9738     int r;
9739     suppress_error = 0;
9740     r = guestfs_mkfs (g, fstype, device);
9741     if (r == -1)
9742       return -1;
9743   }
9744   {
9745     char device[] = "/dev/sda1";
9746     char mountpoint[] = "/";
9747     int r;
9748     suppress_error = 0;
9749     r = guestfs_mount (g, device, mountpoint);
9750     if (r == -1)
9751       return -1;
9752   }
9753   /* TestOutput for command (6) */
9754   char expected[] = "";
9755   {
9756     char remotefilename[] = "/test-command";
9757     int r;
9758     suppress_error = 0;
9759     r = guestfs_upload (g, "test-command", remotefilename);
9760     if (r == -1)
9761       return -1;
9762   }
9763   {
9764     char path[] = "/test-command";
9765     int r;
9766     suppress_error = 0;
9767     r = guestfs_chmod (g, 493, path);
9768     if (r == -1)
9769       return -1;
9770   }
9771   {
9772     char arguments_0[] = "/test-command";
9773     char arguments_1[] = "7";
9774     char *arguments[] = {
9775       arguments_0,
9776       arguments_1,
9777       NULL
9778     };
9779     char *r;
9780     suppress_error = 0;
9781     r = guestfs_command (g, arguments);
9782     if (r == NULL)
9783       return -1;
9784     if (strcmp (r, expected) != 0) {
9785       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9786       return -1;
9787     }
9788     free (r);
9789   }
9790   return 0;
9791 }
9792
9793 static int test_command_7_skip (void)
9794 {
9795   const char *str;
9796
9797   str = getenv ("SKIP_TEST_COMMAND_7");
9798   if (str && strcmp (str, "1") == 0) return 1;
9799   str = getenv ("SKIP_TEST_COMMAND");
9800   if (str && strcmp (str, "1") == 0) return 1;
9801   return 0;
9802 }
9803
9804 static int test_command_7 (void)
9805 {
9806   if (test_command_7_skip ()) {
9807     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9808     return 0;
9809   }
9810
9811   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9812   {
9813     char device[] = "/dev/sda";
9814     int r;
9815     suppress_error = 0;
9816     r = guestfs_blockdev_setrw (g, device);
9817     if (r == -1)
9818       return -1;
9819   }
9820   {
9821     int r;
9822     suppress_error = 0;
9823     r = guestfs_umount_all (g);
9824     if (r == -1)
9825       return -1;
9826   }
9827   {
9828     int r;
9829     suppress_error = 0;
9830     r = guestfs_lvm_remove_all (g);
9831     if (r == -1)
9832       return -1;
9833   }
9834   {
9835     char device[] = "/dev/sda";
9836     char lines_0[] = ",";
9837     char *lines[] = {
9838       lines_0,
9839       NULL
9840     };
9841     int r;
9842     suppress_error = 0;
9843     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9844     if (r == -1)
9845       return -1;
9846   }
9847   {
9848     char fstype[] = "ext2";
9849     char device[] = "/dev/sda1";
9850     int r;
9851     suppress_error = 0;
9852     r = guestfs_mkfs (g, fstype, device);
9853     if (r == -1)
9854       return -1;
9855   }
9856   {
9857     char device[] = "/dev/sda1";
9858     char mountpoint[] = "/";
9859     int r;
9860     suppress_error = 0;
9861     r = guestfs_mount (g, device, mountpoint);
9862     if (r == -1)
9863       return -1;
9864   }
9865   /* TestOutput for command (7) */
9866   char expected[] = "\n";
9867   {
9868     char remotefilename[] = "/test-command";
9869     int r;
9870     suppress_error = 0;
9871     r = guestfs_upload (g, "test-command", remotefilename);
9872     if (r == -1)
9873       return -1;
9874   }
9875   {
9876     char path[] = "/test-command";
9877     int r;
9878     suppress_error = 0;
9879     r = guestfs_chmod (g, 493, path);
9880     if (r == -1)
9881       return -1;
9882   }
9883   {
9884     char arguments_0[] = "/test-command";
9885     char arguments_1[] = "8";
9886     char *arguments[] = {
9887       arguments_0,
9888       arguments_1,
9889       NULL
9890     };
9891     char *r;
9892     suppress_error = 0;
9893     r = guestfs_command (g, arguments);
9894     if (r == NULL)
9895       return -1;
9896     if (strcmp (r, expected) != 0) {
9897       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9898       return -1;
9899     }
9900     free (r);
9901   }
9902   return 0;
9903 }
9904
9905 static int test_command_8_skip (void)
9906 {
9907   const char *str;
9908
9909   str = getenv ("SKIP_TEST_COMMAND_8");
9910   if (str && strcmp (str, "1") == 0) return 1;
9911   str = getenv ("SKIP_TEST_COMMAND");
9912   if (str && strcmp (str, "1") == 0) return 1;
9913   return 0;
9914 }
9915
9916 static int test_command_8 (void)
9917 {
9918   if (test_command_8_skip ()) {
9919     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9920     return 0;
9921   }
9922
9923   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9924   {
9925     char device[] = "/dev/sda";
9926     int r;
9927     suppress_error = 0;
9928     r = guestfs_blockdev_setrw (g, device);
9929     if (r == -1)
9930       return -1;
9931   }
9932   {
9933     int r;
9934     suppress_error = 0;
9935     r = guestfs_umount_all (g);
9936     if (r == -1)
9937       return -1;
9938   }
9939   {
9940     int r;
9941     suppress_error = 0;
9942     r = guestfs_lvm_remove_all (g);
9943     if (r == -1)
9944       return -1;
9945   }
9946   {
9947     char device[] = "/dev/sda";
9948     char lines_0[] = ",";
9949     char *lines[] = {
9950       lines_0,
9951       NULL
9952     };
9953     int r;
9954     suppress_error = 0;
9955     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9956     if (r == -1)
9957       return -1;
9958   }
9959   {
9960     char fstype[] = "ext2";
9961     char device[] = "/dev/sda1";
9962     int r;
9963     suppress_error = 0;
9964     r = guestfs_mkfs (g, fstype, device);
9965     if (r == -1)
9966       return -1;
9967   }
9968   {
9969     char device[] = "/dev/sda1";
9970     char mountpoint[] = "/";
9971     int r;
9972     suppress_error = 0;
9973     r = guestfs_mount (g, device, mountpoint);
9974     if (r == -1)
9975       return -1;
9976   }
9977   /* TestOutput for command (8) */
9978   char expected[] = "\n\n";
9979   {
9980     char remotefilename[] = "/test-command";
9981     int r;
9982     suppress_error = 0;
9983     r = guestfs_upload (g, "test-command", remotefilename);
9984     if (r == -1)
9985       return -1;
9986   }
9987   {
9988     char path[] = "/test-command";
9989     int r;
9990     suppress_error = 0;
9991     r = guestfs_chmod (g, 493, path);
9992     if (r == -1)
9993       return -1;
9994   }
9995   {
9996     char arguments_0[] = "/test-command";
9997     char arguments_1[] = "9";
9998     char *arguments[] = {
9999       arguments_0,
10000       arguments_1,
10001       NULL
10002     };
10003     char *r;
10004     suppress_error = 0;
10005     r = guestfs_command (g, arguments);
10006     if (r == NULL)
10007       return -1;
10008     if (strcmp (r, expected) != 0) {
10009       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
10010       return -1;
10011     }
10012     free (r);
10013   }
10014   return 0;
10015 }
10016
10017 static int test_command_9_skip (void)
10018 {
10019   const char *str;
10020
10021   str = getenv ("SKIP_TEST_COMMAND_9");
10022   if (str && strcmp (str, "1") == 0) return 1;
10023   str = getenv ("SKIP_TEST_COMMAND");
10024   if (str && strcmp (str, "1") == 0) return 1;
10025   return 0;
10026 }
10027
10028 static int test_command_9 (void)
10029 {
10030   if (test_command_9_skip ()) {
10031     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
10032     return 0;
10033   }
10034
10035   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
10036   {
10037     char device[] = "/dev/sda";
10038     int r;
10039     suppress_error = 0;
10040     r = guestfs_blockdev_setrw (g, device);
10041     if (r == -1)
10042       return -1;
10043   }
10044   {
10045     int r;
10046     suppress_error = 0;
10047     r = guestfs_umount_all (g);
10048     if (r == -1)
10049       return -1;
10050   }
10051   {
10052     int r;
10053     suppress_error = 0;
10054     r = guestfs_lvm_remove_all (g);
10055     if (r == -1)
10056       return -1;
10057   }
10058   {
10059     char device[] = "/dev/sda";
10060     char lines_0[] = ",";
10061     char *lines[] = {
10062       lines_0,
10063       NULL
10064     };
10065     int r;
10066     suppress_error = 0;
10067     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10068     if (r == -1)
10069       return -1;
10070   }
10071   {
10072     char fstype[] = "ext2";
10073     char device[] = "/dev/sda1";
10074     int r;
10075     suppress_error = 0;
10076     r = guestfs_mkfs (g, fstype, device);
10077     if (r == -1)
10078       return -1;
10079   }
10080   {
10081     char device[] = "/dev/sda1";
10082     char mountpoint[] = "/";
10083     int r;
10084     suppress_error = 0;
10085     r = guestfs_mount (g, device, mountpoint);
10086     if (r == -1)
10087       return -1;
10088   }
10089   /* TestOutput for command (9) */
10090   char expected[] = "Result10-1\nResult10-2\n";
10091   {
10092     char remotefilename[] = "/test-command";
10093     int r;
10094     suppress_error = 0;
10095     r = guestfs_upload (g, "test-command", remotefilename);
10096     if (r == -1)
10097       return -1;
10098   }
10099   {
10100     char path[] = "/test-command";
10101     int r;
10102     suppress_error = 0;
10103     r = guestfs_chmod (g, 493, path);
10104     if (r == -1)
10105       return -1;
10106   }
10107   {
10108     char arguments_0[] = "/test-command";
10109     char arguments_1[] = "10";
10110     char *arguments[] = {
10111       arguments_0,
10112       arguments_1,
10113       NULL
10114     };
10115     char *r;
10116     suppress_error = 0;
10117     r = guestfs_command (g, arguments);
10118     if (r == NULL)
10119       return -1;
10120     if (strcmp (r, expected) != 0) {
10121       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
10122       return -1;
10123     }
10124     free (r);
10125   }
10126   return 0;
10127 }
10128
10129 static int test_command_10_skip (void)
10130 {
10131   const char *str;
10132
10133   str = getenv ("SKIP_TEST_COMMAND_10");
10134   if (str && strcmp (str, "1") == 0) return 1;
10135   str = getenv ("SKIP_TEST_COMMAND");
10136   if (str && strcmp (str, "1") == 0) return 1;
10137   return 0;
10138 }
10139
10140 static int test_command_10 (void)
10141 {
10142   if (test_command_10_skip ()) {
10143     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
10144     return 0;
10145   }
10146
10147   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
10148   {
10149     char device[] = "/dev/sda";
10150     int r;
10151     suppress_error = 0;
10152     r = guestfs_blockdev_setrw (g, device);
10153     if (r == -1)
10154       return -1;
10155   }
10156   {
10157     int r;
10158     suppress_error = 0;
10159     r = guestfs_umount_all (g);
10160     if (r == -1)
10161       return -1;
10162   }
10163   {
10164     int r;
10165     suppress_error = 0;
10166     r = guestfs_lvm_remove_all (g);
10167     if (r == -1)
10168       return -1;
10169   }
10170   {
10171     char device[] = "/dev/sda";
10172     char lines_0[] = ",";
10173     char *lines[] = {
10174       lines_0,
10175       NULL
10176     };
10177     int r;
10178     suppress_error = 0;
10179     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10180     if (r == -1)
10181       return -1;
10182   }
10183   {
10184     char fstype[] = "ext2";
10185     char device[] = "/dev/sda1";
10186     int r;
10187     suppress_error = 0;
10188     r = guestfs_mkfs (g, fstype, device);
10189     if (r == -1)
10190       return -1;
10191   }
10192   {
10193     char device[] = "/dev/sda1";
10194     char mountpoint[] = "/";
10195     int r;
10196     suppress_error = 0;
10197     r = guestfs_mount (g, device, mountpoint);
10198     if (r == -1)
10199       return -1;
10200   }
10201   /* TestOutput for command (10) */
10202   char expected[] = "Result11-1\nResult11-2";
10203   {
10204     char remotefilename[] = "/test-command";
10205     int r;
10206     suppress_error = 0;
10207     r = guestfs_upload (g, "test-command", remotefilename);
10208     if (r == -1)
10209       return -1;
10210   }
10211   {
10212     char path[] = "/test-command";
10213     int r;
10214     suppress_error = 0;
10215     r = guestfs_chmod (g, 493, path);
10216     if (r == -1)
10217       return -1;
10218   }
10219   {
10220     char arguments_0[] = "/test-command";
10221     char arguments_1[] = "11";
10222     char *arguments[] = {
10223       arguments_0,
10224       arguments_1,
10225       NULL
10226     };
10227     char *r;
10228     suppress_error = 0;
10229     r = guestfs_command (g, arguments);
10230     if (r == NULL)
10231       return -1;
10232     if (strcmp (r, expected) != 0) {
10233       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
10234       return -1;
10235     }
10236     free (r);
10237   }
10238   return 0;
10239 }
10240
10241 static int test_command_11_skip (void)
10242 {
10243   const char *str;
10244
10245   str = getenv ("SKIP_TEST_COMMAND_11");
10246   if (str && strcmp (str, "1") == 0) return 1;
10247   str = getenv ("SKIP_TEST_COMMAND");
10248   if (str && strcmp (str, "1") == 0) return 1;
10249   return 0;
10250 }
10251
10252 static int test_command_11 (void)
10253 {
10254   if (test_command_11_skip ()) {
10255     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
10256     return 0;
10257   }
10258
10259   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10260   {
10261     char device[] = "/dev/sda";
10262     int r;
10263     suppress_error = 0;
10264     r = guestfs_blockdev_setrw (g, device);
10265     if (r == -1)
10266       return -1;
10267   }
10268   {
10269     int r;
10270     suppress_error = 0;
10271     r = guestfs_umount_all (g);
10272     if (r == -1)
10273       return -1;
10274   }
10275   {
10276     int r;
10277     suppress_error = 0;
10278     r = guestfs_lvm_remove_all (g);
10279     if (r == -1)
10280       return -1;
10281   }
10282   {
10283     char device[] = "/dev/sda";
10284     char lines_0[] = ",";
10285     char *lines[] = {
10286       lines_0,
10287       NULL
10288     };
10289     int r;
10290     suppress_error = 0;
10291     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10292     if (r == -1)
10293       return -1;
10294   }
10295   {
10296     char fstype[] = "ext2";
10297     char device[] = "/dev/sda1";
10298     int r;
10299     suppress_error = 0;
10300     r = guestfs_mkfs (g, fstype, device);
10301     if (r == -1)
10302       return -1;
10303   }
10304   {
10305     char device[] = "/dev/sda1";
10306     char mountpoint[] = "/";
10307     int r;
10308     suppress_error = 0;
10309     r = guestfs_mount (g, device, mountpoint);
10310     if (r == -1)
10311       return -1;
10312   }
10313   /* TestLastFail for command (11) */
10314   {
10315     char remotefilename[] = "/test-command";
10316     int r;
10317     suppress_error = 0;
10318     r = guestfs_upload (g, "test-command", remotefilename);
10319     if (r == -1)
10320       return -1;
10321   }
10322   {
10323     char path[] = "/test-command";
10324     int r;
10325     suppress_error = 0;
10326     r = guestfs_chmod (g, 493, path);
10327     if (r == -1)
10328       return -1;
10329   }
10330   {
10331     char arguments_0[] = "/test-command";
10332     char *arguments[] = {
10333       arguments_0,
10334       NULL
10335     };
10336     char *r;
10337     suppress_error = 1;
10338     r = guestfs_command (g, arguments);
10339     if (r != NULL)
10340       return -1;
10341     free (r);
10342   }
10343   return 0;
10344 }
10345
10346 static int test_file_0_skip (void)
10347 {
10348   const char *str;
10349
10350   str = getenv ("SKIP_TEST_FILE_0");
10351   if (str && strcmp (str, "1") == 0) return 1;
10352   str = getenv ("SKIP_TEST_FILE");
10353   if (str && strcmp (str, "1") == 0) return 1;
10354   return 0;
10355 }
10356
10357 static int test_file_0 (void)
10358 {
10359   if (test_file_0_skip ()) {
10360     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10361     return 0;
10362   }
10363
10364   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10365   {
10366     char device[] = "/dev/sda";
10367     int r;
10368     suppress_error = 0;
10369     r = guestfs_blockdev_setrw (g, device);
10370     if (r == -1)
10371       return -1;
10372   }
10373   {
10374     int r;
10375     suppress_error = 0;
10376     r = guestfs_umount_all (g);
10377     if (r == -1)
10378       return -1;
10379   }
10380   {
10381     int r;
10382     suppress_error = 0;
10383     r = guestfs_lvm_remove_all (g);
10384     if (r == -1)
10385       return -1;
10386   }
10387   {
10388     char device[] = "/dev/sda";
10389     char lines_0[] = ",";
10390     char *lines[] = {
10391       lines_0,
10392       NULL
10393     };
10394     int r;
10395     suppress_error = 0;
10396     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10397     if (r == -1)
10398       return -1;
10399   }
10400   {
10401     char fstype[] = "ext2";
10402     char device[] = "/dev/sda1";
10403     int r;
10404     suppress_error = 0;
10405     r = guestfs_mkfs (g, fstype, device);
10406     if (r == -1)
10407       return -1;
10408   }
10409   {
10410     char device[] = "/dev/sda1";
10411     char mountpoint[] = "/";
10412     int r;
10413     suppress_error = 0;
10414     r = guestfs_mount (g, device, mountpoint);
10415     if (r == -1)
10416       return -1;
10417   }
10418   /* TestOutput for file (0) */
10419   char expected[] = "empty";
10420   {
10421     char path[] = "/new";
10422     int r;
10423     suppress_error = 0;
10424     r = guestfs_touch (g, path);
10425     if (r == -1)
10426       return -1;
10427   }
10428   {
10429     char path[] = "/new";
10430     char *r;
10431     suppress_error = 0;
10432     r = guestfs_file (g, path);
10433     if (r == NULL)
10434       return -1;
10435     if (strcmp (r, expected) != 0) {
10436       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10437       return -1;
10438     }
10439     free (r);
10440   }
10441   return 0;
10442 }
10443
10444 static int test_file_1_skip (void)
10445 {
10446   const char *str;
10447
10448   str = getenv ("SKIP_TEST_FILE_1");
10449   if (str && strcmp (str, "1") == 0) return 1;
10450   str = getenv ("SKIP_TEST_FILE");
10451   if (str && strcmp (str, "1") == 0) return 1;
10452   return 0;
10453 }
10454
10455 static int test_file_1 (void)
10456 {
10457   if (test_file_1_skip ()) {
10458     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10459     return 0;
10460   }
10461
10462   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10463   {
10464     char device[] = "/dev/sda";
10465     int r;
10466     suppress_error = 0;
10467     r = guestfs_blockdev_setrw (g, device);
10468     if (r == -1)
10469       return -1;
10470   }
10471   {
10472     int r;
10473     suppress_error = 0;
10474     r = guestfs_umount_all (g);
10475     if (r == -1)
10476       return -1;
10477   }
10478   {
10479     int r;
10480     suppress_error = 0;
10481     r = guestfs_lvm_remove_all (g);
10482     if (r == -1)
10483       return -1;
10484   }
10485   {
10486     char device[] = "/dev/sda";
10487     char lines_0[] = ",";
10488     char *lines[] = {
10489       lines_0,
10490       NULL
10491     };
10492     int r;
10493     suppress_error = 0;
10494     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10495     if (r == -1)
10496       return -1;
10497   }
10498   {
10499     char fstype[] = "ext2";
10500     char device[] = "/dev/sda1";
10501     int r;
10502     suppress_error = 0;
10503     r = guestfs_mkfs (g, fstype, device);
10504     if (r == -1)
10505       return -1;
10506   }
10507   {
10508     char device[] = "/dev/sda1";
10509     char mountpoint[] = "/";
10510     int r;
10511     suppress_error = 0;
10512     r = guestfs_mount (g, device, mountpoint);
10513     if (r == -1)
10514       return -1;
10515   }
10516   /* TestOutput for file (1) */
10517   char expected[] = "ASCII text";
10518   {
10519     char path[] = "/new";
10520     char content[] = "some content\n";
10521     int r;
10522     suppress_error = 0;
10523     r = guestfs_write_file (g, path, content, 0);
10524     if (r == -1)
10525       return -1;
10526   }
10527   {
10528     char path[] = "/new";
10529     char *r;
10530     suppress_error = 0;
10531     r = guestfs_file (g, path);
10532     if (r == NULL)
10533       return -1;
10534     if (strcmp (r, expected) != 0) {
10535       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10536       return -1;
10537     }
10538     free (r);
10539   }
10540   return 0;
10541 }
10542
10543 static int test_file_2_skip (void)
10544 {
10545   const char *str;
10546
10547   str = getenv ("SKIP_TEST_FILE_2");
10548   if (str && strcmp (str, "1") == 0) return 1;
10549   str = getenv ("SKIP_TEST_FILE");
10550   if (str && strcmp (str, "1") == 0) return 1;
10551   return 0;
10552 }
10553
10554 static int test_file_2 (void)
10555 {
10556   if (test_file_2_skip ()) {
10557     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10558     return 0;
10559   }
10560
10561   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10562   {
10563     char device[] = "/dev/sda";
10564     int r;
10565     suppress_error = 0;
10566     r = guestfs_blockdev_setrw (g, device);
10567     if (r == -1)
10568       return -1;
10569   }
10570   {
10571     int r;
10572     suppress_error = 0;
10573     r = guestfs_umount_all (g);
10574     if (r == -1)
10575       return -1;
10576   }
10577   {
10578     int r;
10579     suppress_error = 0;
10580     r = guestfs_lvm_remove_all (g);
10581     if (r == -1)
10582       return -1;
10583   }
10584   {
10585     char device[] = "/dev/sda";
10586     char lines_0[] = ",";
10587     char *lines[] = {
10588       lines_0,
10589       NULL
10590     };
10591     int r;
10592     suppress_error = 0;
10593     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10594     if (r == -1)
10595       return -1;
10596   }
10597   {
10598     char fstype[] = "ext2";
10599     char device[] = "/dev/sda1";
10600     int r;
10601     suppress_error = 0;
10602     r = guestfs_mkfs (g, fstype, device);
10603     if (r == -1)
10604       return -1;
10605   }
10606   {
10607     char device[] = "/dev/sda1";
10608     char mountpoint[] = "/";
10609     int r;
10610     suppress_error = 0;
10611     r = guestfs_mount (g, device, mountpoint);
10612     if (r == -1)
10613       return -1;
10614   }
10615   /* TestLastFail for file (2) */
10616   {
10617     char path[] = "/nofile";
10618     char *r;
10619     suppress_error = 1;
10620     r = guestfs_file (g, path);
10621     if (r != NULL)
10622       return -1;
10623     free (r);
10624   }
10625   return 0;
10626 }
10627
10628 static int test_umount_all_0_skip (void)
10629 {
10630   const char *str;
10631
10632   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10633   if (str && strcmp (str, "1") == 0) return 1;
10634   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10635   if (str && strcmp (str, "1") == 0) return 1;
10636   return 0;
10637 }
10638
10639 static int test_umount_all_0 (void)
10640 {
10641   if (test_umount_all_0_skip ()) {
10642     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10643     return 0;
10644   }
10645
10646   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10647   {
10648     char device[] = "/dev/sda";
10649     int r;
10650     suppress_error = 0;
10651     r = guestfs_blockdev_setrw (g, device);
10652     if (r == -1)
10653       return -1;
10654   }
10655   {
10656     int r;
10657     suppress_error = 0;
10658     r = guestfs_umount_all (g);
10659     if (r == -1)
10660       return -1;
10661   }
10662   {
10663     int r;
10664     suppress_error = 0;
10665     r = guestfs_lvm_remove_all (g);
10666     if (r == -1)
10667       return -1;
10668   }
10669   {
10670     char device[] = "/dev/sda";
10671     char lines_0[] = ",";
10672     char *lines[] = {
10673       lines_0,
10674       NULL
10675     };
10676     int r;
10677     suppress_error = 0;
10678     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10679     if (r == -1)
10680       return -1;
10681   }
10682   {
10683     char fstype[] = "ext2";
10684     char device[] = "/dev/sda1";
10685     int r;
10686     suppress_error = 0;
10687     r = guestfs_mkfs (g, fstype, device);
10688     if (r == -1)
10689       return -1;
10690   }
10691   {
10692     char device[] = "/dev/sda1";
10693     char mountpoint[] = "/";
10694     int r;
10695     suppress_error = 0;
10696     r = guestfs_mount (g, device, mountpoint);
10697     if (r == -1)
10698       return -1;
10699   }
10700   /* TestOutputList for umount_all (0) */
10701   {
10702     int r;
10703     suppress_error = 0;
10704     r = guestfs_umount_all (g);
10705     if (r == -1)
10706       return -1;
10707   }
10708   {
10709     char **r;
10710     int i;
10711     suppress_error = 0;
10712     r = guestfs_mounts (g);
10713     if (r == NULL)
10714       return -1;
10715     if (r[0] != NULL) {
10716       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10717       print_strings (r);
10718       return -1;
10719     }
10720     for (i = 0; r[i] != NULL; ++i)
10721       free (r[i]);
10722     free (r);
10723   }
10724   return 0;
10725 }
10726
10727 static int test_umount_all_1_skip (void)
10728 {
10729   const char *str;
10730
10731   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10732   if (str && strcmp (str, "1") == 0) return 1;
10733   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10734   if (str && strcmp (str, "1") == 0) return 1;
10735   return 0;
10736 }
10737
10738 static int test_umount_all_1 (void)
10739 {
10740   if (test_umount_all_1_skip ()) {
10741     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10742     return 0;
10743   }
10744
10745   /* InitNone|InitEmpty for test_umount_all_1 */
10746   {
10747     char device[] = "/dev/sda";
10748     int r;
10749     suppress_error = 0;
10750     r = guestfs_blockdev_setrw (g, device);
10751     if (r == -1)
10752       return -1;
10753   }
10754   {
10755     int r;
10756     suppress_error = 0;
10757     r = guestfs_umount_all (g);
10758     if (r == -1)
10759       return -1;
10760   }
10761   {
10762     int r;
10763     suppress_error = 0;
10764     r = guestfs_lvm_remove_all (g);
10765     if (r == -1)
10766       return -1;
10767   }
10768   /* TestOutputList for umount_all (1) */
10769   {
10770     char device[] = "/dev/sda";
10771     char lines_0[] = ",10";
10772     char lines_1[] = ",20";
10773     char lines_2[] = ",";
10774     char *lines[] = {
10775       lines_0,
10776       lines_1,
10777       lines_2,
10778       NULL
10779     };
10780     int r;
10781     suppress_error = 0;
10782     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10783     if (r == -1)
10784       return -1;
10785   }
10786   {
10787     char fstype[] = "ext2";
10788     char device[] = "/dev/sda1";
10789     int r;
10790     suppress_error = 0;
10791     r = guestfs_mkfs (g, fstype, device);
10792     if (r == -1)
10793       return -1;
10794   }
10795   {
10796     char fstype[] = "ext2";
10797     char device[] = "/dev/sda2";
10798     int r;
10799     suppress_error = 0;
10800     r = guestfs_mkfs (g, fstype, device);
10801     if (r == -1)
10802       return -1;
10803   }
10804   {
10805     char fstype[] = "ext2";
10806     char device[] = "/dev/sda3";
10807     int r;
10808     suppress_error = 0;
10809     r = guestfs_mkfs (g, fstype, device);
10810     if (r == -1)
10811       return -1;
10812   }
10813   {
10814     char device[] = "/dev/sda1";
10815     char mountpoint[] = "/";
10816     int r;
10817     suppress_error = 0;
10818     r = guestfs_mount (g, device, mountpoint);
10819     if (r == -1)
10820       return -1;
10821   }
10822   {
10823     char path[] = "/mp1";
10824     int r;
10825     suppress_error = 0;
10826     r = guestfs_mkdir (g, path);
10827     if (r == -1)
10828       return -1;
10829   }
10830   {
10831     char device[] = "/dev/sda2";
10832     char mountpoint[] = "/mp1";
10833     int r;
10834     suppress_error = 0;
10835     r = guestfs_mount (g, device, mountpoint);
10836     if (r == -1)
10837       return -1;
10838   }
10839   {
10840     char path[] = "/mp1/mp2";
10841     int r;
10842     suppress_error = 0;
10843     r = guestfs_mkdir (g, path);
10844     if (r == -1)
10845       return -1;
10846   }
10847   {
10848     char device[] = "/dev/sda3";
10849     char mountpoint[] = "/mp1/mp2";
10850     int r;
10851     suppress_error = 0;
10852     r = guestfs_mount (g, device, mountpoint);
10853     if (r == -1)
10854       return -1;
10855   }
10856   {
10857     char path[] = "/mp1/mp2/mp3";
10858     int r;
10859     suppress_error = 0;
10860     r = guestfs_mkdir (g, path);
10861     if (r == -1)
10862       return -1;
10863   }
10864   {
10865     int r;
10866     suppress_error = 0;
10867     r = guestfs_umount_all (g);
10868     if (r == -1)
10869       return -1;
10870   }
10871   {
10872     char **r;
10873     int i;
10874     suppress_error = 0;
10875     r = guestfs_mounts (g);
10876     if (r == NULL)
10877       return -1;
10878     if (r[0] != NULL) {
10879       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10880       print_strings (r);
10881       return -1;
10882     }
10883     for (i = 0; r[i] != NULL; ++i)
10884       free (r[i]);
10885     free (r);
10886   }
10887   return 0;
10888 }
10889
10890 static int test_mounts_0_skip (void)
10891 {
10892   const char *str;
10893
10894   str = getenv ("SKIP_TEST_MOUNTS_0");
10895   if (str && strcmp (str, "1") == 0) return 1;
10896   str = getenv ("SKIP_TEST_MOUNTS");
10897   if (str && strcmp (str, "1") == 0) return 1;
10898   return 0;
10899 }
10900
10901 static int test_mounts_0 (void)
10902 {
10903   if (test_mounts_0_skip ()) {
10904     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10905     return 0;
10906   }
10907
10908   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10909   {
10910     char device[] = "/dev/sda";
10911     int r;
10912     suppress_error = 0;
10913     r = guestfs_blockdev_setrw (g, device);
10914     if (r == -1)
10915       return -1;
10916   }
10917   {
10918     int r;
10919     suppress_error = 0;
10920     r = guestfs_umount_all (g);
10921     if (r == -1)
10922       return -1;
10923   }
10924   {
10925     int r;
10926     suppress_error = 0;
10927     r = guestfs_lvm_remove_all (g);
10928     if (r == -1)
10929       return -1;
10930   }
10931   {
10932     char device[] = "/dev/sda";
10933     char lines_0[] = ",";
10934     char *lines[] = {
10935       lines_0,
10936       NULL
10937     };
10938     int r;
10939     suppress_error = 0;
10940     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10941     if (r == -1)
10942       return -1;
10943   }
10944   {
10945     char fstype[] = "ext2";
10946     char device[] = "/dev/sda1";
10947     int r;
10948     suppress_error = 0;
10949     r = guestfs_mkfs (g, fstype, device);
10950     if (r == -1)
10951       return -1;
10952   }
10953   {
10954     char device[] = "/dev/sda1";
10955     char mountpoint[] = "/";
10956     int r;
10957     suppress_error = 0;
10958     r = guestfs_mount (g, device, mountpoint);
10959     if (r == -1)
10960       return -1;
10961   }
10962   /* TestOutputListOfDevices for mounts (0) */
10963   {
10964     char **r;
10965     int i;
10966     suppress_error = 0;
10967     r = guestfs_mounts (g);
10968     if (r == NULL)
10969       return -1;
10970     if (!r[0]) {
10971       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10972       print_strings (r);
10973       return -1;
10974     }
10975     {
10976       char expected[] = "/dev/sda1";
10977       r[0][5] = 's';
10978       if (strcmp (r[0], expected) != 0) {
10979         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10980         return -1;
10981       }
10982     }
10983     if (r[1] != NULL) {
10984       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10985       print_strings (r);
10986       return -1;
10987     }
10988     for (i = 0; r[i] != NULL; ++i)
10989       free (r[i]);
10990     free (r);
10991   }
10992   return 0;
10993 }
10994
10995 static int test_umount_0_skip (void)
10996 {
10997   const char *str;
10998
10999   str = getenv ("SKIP_TEST_UMOUNT_0");
11000   if (str && strcmp (str, "1") == 0) return 1;
11001   str = getenv ("SKIP_TEST_UMOUNT");
11002   if (str && strcmp (str, "1") == 0) return 1;
11003   return 0;
11004 }
11005
11006 static int test_umount_0 (void)
11007 {
11008   if (test_umount_0_skip ()) {
11009     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
11010     return 0;
11011   }
11012
11013   /* InitNone|InitEmpty for test_umount_0 */
11014   {
11015     char device[] = "/dev/sda";
11016     int r;
11017     suppress_error = 0;
11018     r = guestfs_blockdev_setrw (g, device);
11019     if (r == -1)
11020       return -1;
11021   }
11022   {
11023     int r;
11024     suppress_error = 0;
11025     r = guestfs_umount_all (g);
11026     if (r == -1)
11027       return -1;
11028   }
11029   {
11030     int r;
11031     suppress_error = 0;
11032     r = guestfs_lvm_remove_all (g);
11033     if (r == -1)
11034       return -1;
11035   }
11036   /* TestOutputListOfDevices for umount (0) */
11037   {
11038     char device[] = "/dev/sda";
11039     char lines_0[] = ",";
11040     char *lines[] = {
11041       lines_0,
11042       NULL
11043     };
11044     int r;
11045     suppress_error = 0;
11046     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11047     if (r == -1)
11048       return -1;
11049   }
11050   {
11051     char fstype[] = "ext2";
11052     char device[] = "/dev/sda1";
11053     int r;
11054     suppress_error = 0;
11055     r = guestfs_mkfs (g, fstype, device);
11056     if (r == -1)
11057       return -1;
11058   }
11059   {
11060     char device[] = "/dev/sda1";
11061     char mountpoint[] = "/";
11062     int r;
11063     suppress_error = 0;
11064     r = guestfs_mount (g, device, mountpoint);
11065     if (r == -1)
11066       return -1;
11067   }
11068   {
11069     char **r;
11070     int i;
11071     suppress_error = 0;
11072     r = guestfs_mounts (g);
11073     if (r == NULL)
11074       return -1;
11075     if (!r[0]) {
11076       fprintf (stderr, "test_umount_0: short list returned from command\n");
11077       print_strings (r);
11078       return -1;
11079     }
11080     {
11081       char expected[] = "/dev/sda1";
11082       r[0][5] = 's';
11083       if (strcmp (r[0], expected) != 0) {
11084         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11085         return -1;
11086       }
11087     }
11088     if (r[1] != NULL) {
11089       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
11090       print_strings (r);
11091       return -1;
11092     }
11093     for (i = 0; r[i] != NULL; ++i)
11094       free (r[i]);
11095     free (r);
11096   }
11097   return 0;
11098 }
11099
11100 static int test_umount_1_skip (void)
11101 {
11102   const char *str;
11103
11104   str = getenv ("SKIP_TEST_UMOUNT_1");
11105   if (str && strcmp (str, "1") == 0) return 1;
11106   str = getenv ("SKIP_TEST_UMOUNT");
11107   if (str && strcmp (str, "1") == 0) return 1;
11108   return 0;
11109 }
11110
11111 static int test_umount_1 (void)
11112 {
11113   if (test_umount_1_skip ()) {
11114     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
11115     return 0;
11116   }
11117
11118   /* InitNone|InitEmpty for test_umount_1 */
11119   {
11120     char device[] = "/dev/sda";
11121     int r;
11122     suppress_error = 0;
11123     r = guestfs_blockdev_setrw (g, device);
11124     if (r == -1)
11125       return -1;
11126   }
11127   {
11128     int r;
11129     suppress_error = 0;
11130     r = guestfs_umount_all (g);
11131     if (r == -1)
11132       return -1;
11133   }
11134   {
11135     int r;
11136     suppress_error = 0;
11137     r = guestfs_lvm_remove_all (g);
11138     if (r == -1)
11139       return -1;
11140   }
11141   /* TestOutputList for umount (1) */
11142   {
11143     char device[] = "/dev/sda";
11144     char lines_0[] = ",";
11145     char *lines[] = {
11146       lines_0,
11147       NULL
11148     };
11149     int r;
11150     suppress_error = 0;
11151     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11152     if (r == -1)
11153       return -1;
11154   }
11155   {
11156     char fstype[] = "ext2";
11157     char device[] = "/dev/sda1";
11158     int r;
11159     suppress_error = 0;
11160     r = guestfs_mkfs (g, fstype, device);
11161     if (r == -1)
11162       return -1;
11163   }
11164   {
11165     char device[] = "/dev/sda1";
11166     char mountpoint[] = "/";
11167     int r;
11168     suppress_error = 0;
11169     r = guestfs_mount (g, device, mountpoint);
11170     if (r == -1)
11171       return -1;
11172   }
11173   {
11174     char pathordevice[] = "/";
11175     int r;
11176     suppress_error = 0;
11177     r = guestfs_umount (g, pathordevice);
11178     if (r == -1)
11179       return -1;
11180   }
11181   {
11182     char **r;
11183     int i;
11184     suppress_error = 0;
11185     r = guestfs_mounts (g);
11186     if (r == NULL)
11187       return -1;
11188     if (r[0] != NULL) {
11189       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
11190       print_strings (r);
11191       return -1;
11192     }
11193     for (i = 0; r[i] != NULL; ++i)
11194       free (r[i]);
11195     free (r);
11196   }
11197   return 0;
11198 }
11199
11200 static int test_write_file_0_skip (void)
11201 {
11202   const char *str;
11203
11204   str = getenv ("SKIP_TEST_WRITE_FILE_0");
11205   if (str && strcmp (str, "1") == 0) return 1;
11206   str = getenv ("SKIP_TEST_WRITE_FILE");
11207   if (str && strcmp (str, "1") == 0) return 1;
11208   return 0;
11209 }
11210
11211 static int test_write_file_0 (void)
11212 {
11213   if (test_write_file_0_skip ()) {
11214     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
11215     return 0;
11216   }
11217
11218   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
11219   {
11220     char device[] = "/dev/sda";
11221     int r;
11222     suppress_error = 0;
11223     r = guestfs_blockdev_setrw (g, device);
11224     if (r == -1)
11225       return -1;
11226   }
11227   {
11228     int r;
11229     suppress_error = 0;
11230     r = guestfs_umount_all (g);
11231     if (r == -1)
11232       return -1;
11233   }
11234   {
11235     int r;
11236     suppress_error = 0;
11237     r = guestfs_lvm_remove_all (g);
11238     if (r == -1)
11239       return -1;
11240   }
11241   {
11242     char device[] = "/dev/sda";
11243     char lines_0[] = ",";
11244     char *lines[] = {
11245       lines_0,
11246       NULL
11247     };
11248     int r;
11249     suppress_error = 0;
11250     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11251     if (r == -1)
11252       return -1;
11253   }
11254   {
11255     char fstype[] = "ext2";
11256     char device[] = "/dev/sda1";
11257     int r;
11258     suppress_error = 0;
11259     r = guestfs_mkfs (g, fstype, device);
11260     if (r == -1)
11261       return -1;
11262   }
11263   {
11264     char device[] = "/dev/sda1";
11265     char mountpoint[] = "/";
11266     int r;
11267     suppress_error = 0;
11268     r = guestfs_mount (g, device, mountpoint);
11269     if (r == -1)
11270       return -1;
11271   }
11272   /* TestOutput for write_file (0) */
11273   char expected[] = "new file contents";
11274   {
11275     char path[] = "/new";
11276     char content[] = "new file contents";
11277     int r;
11278     suppress_error = 0;
11279     r = guestfs_write_file (g, path, content, 0);
11280     if (r == -1)
11281       return -1;
11282   }
11283   {
11284     char path[] = "/new";
11285     char *r;
11286     suppress_error = 0;
11287     r = guestfs_cat (g, path);
11288     if (r == NULL)
11289       return -1;
11290     if (strcmp (r, expected) != 0) {
11291       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11292       return -1;
11293     }
11294     free (r);
11295   }
11296   return 0;
11297 }
11298
11299 static int test_write_file_1_skip (void)
11300 {
11301   const char *str;
11302
11303   str = getenv ("SKIP_TEST_WRITE_FILE_1");
11304   if (str && strcmp (str, "1") == 0) return 1;
11305   str = getenv ("SKIP_TEST_WRITE_FILE");
11306   if (str && strcmp (str, "1") == 0) return 1;
11307   return 0;
11308 }
11309
11310 static int test_write_file_1 (void)
11311 {
11312   if (test_write_file_1_skip ()) {
11313     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11314     return 0;
11315   }
11316
11317   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11318   {
11319     char device[] = "/dev/sda";
11320     int r;
11321     suppress_error = 0;
11322     r = guestfs_blockdev_setrw (g, device);
11323     if (r == -1)
11324       return -1;
11325   }
11326   {
11327     int r;
11328     suppress_error = 0;
11329     r = guestfs_umount_all (g);
11330     if (r == -1)
11331       return -1;
11332   }
11333   {
11334     int r;
11335     suppress_error = 0;
11336     r = guestfs_lvm_remove_all (g);
11337     if (r == -1)
11338       return -1;
11339   }
11340   {
11341     char device[] = "/dev/sda";
11342     char lines_0[] = ",";
11343     char *lines[] = {
11344       lines_0,
11345       NULL
11346     };
11347     int r;
11348     suppress_error = 0;
11349     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11350     if (r == -1)
11351       return -1;
11352   }
11353   {
11354     char fstype[] = "ext2";
11355     char device[] = "/dev/sda1";
11356     int r;
11357     suppress_error = 0;
11358     r = guestfs_mkfs (g, fstype, device);
11359     if (r == -1)
11360       return -1;
11361   }
11362   {
11363     char device[] = "/dev/sda1";
11364     char mountpoint[] = "/";
11365     int r;
11366     suppress_error = 0;
11367     r = guestfs_mount (g, device, mountpoint);
11368     if (r == -1)
11369       return -1;
11370   }
11371   /* TestOutput for write_file (1) */
11372   char expected[] = "\nnew file contents\n";
11373   {
11374     char path[] = "/new";
11375     char content[] = "\nnew file contents\n";
11376     int r;
11377     suppress_error = 0;
11378     r = guestfs_write_file (g, path, content, 0);
11379     if (r == -1)
11380       return -1;
11381   }
11382   {
11383     char path[] = "/new";
11384     char *r;
11385     suppress_error = 0;
11386     r = guestfs_cat (g, path);
11387     if (r == NULL)
11388       return -1;
11389     if (strcmp (r, expected) != 0) {
11390       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11391       return -1;
11392     }
11393     free (r);
11394   }
11395   return 0;
11396 }
11397
11398 static int test_write_file_2_skip (void)
11399 {
11400   const char *str;
11401
11402   str = getenv ("SKIP_TEST_WRITE_FILE_2");
11403   if (str && strcmp (str, "1") == 0) return 1;
11404   str = getenv ("SKIP_TEST_WRITE_FILE");
11405   if (str && strcmp (str, "1") == 0) return 1;
11406   return 0;
11407 }
11408
11409 static int test_write_file_2 (void)
11410 {
11411   if (test_write_file_2_skip ()) {
11412     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11413     return 0;
11414   }
11415
11416   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11417   {
11418     char device[] = "/dev/sda";
11419     int r;
11420     suppress_error = 0;
11421     r = guestfs_blockdev_setrw (g, device);
11422     if (r == -1)
11423       return -1;
11424   }
11425   {
11426     int r;
11427     suppress_error = 0;
11428     r = guestfs_umount_all (g);
11429     if (r == -1)
11430       return -1;
11431   }
11432   {
11433     int r;
11434     suppress_error = 0;
11435     r = guestfs_lvm_remove_all (g);
11436     if (r == -1)
11437       return -1;
11438   }
11439   {
11440     char device[] = "/dev/sda";
11441     char lines_0[] = ",";
11442     char *lines[] = {
11443       lines_0,
11444       NULL
11445     };
11446     int r;
11447     suppress_error = 0;
11448     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11449     if (r == -1)
11450       return -1;
11451   }
11452   {
11453     char fstype[] = "ext2";
11454     char device[] = "/dev/sda1";
11455     int r;
11456     suppress_error = 0;
11457     r = guestfs_mkfs (g, fstype, device);
11458     if (r == -1)
11459       return -1;
11460   }
11461   {
11462     char device[] = "/dev/sda1";
11463     char mountpoint[] = "/";
11464     int r;
11465     suppress_error = 0;
11466     r = guestfs_mount (g, device, mountpoint);
11467     if (r == -1)
11468       return -1;
11469   }
11470   /* TestOutput for write_file (2) */
11471   char expected[] = "\n\n";
11472   {
11473     char path[] = "/new";
11474     char content[] = "\n\n";
11475     int r;
11476     suppress_error = 0;
11477     r = guestfs_write_file (g, path, content, 0);
11478     if (r == -1)
11479       return -1;
11480   }
11481   {
11482     char path[] = "/new";
11483     char *r;
11484     suppress_error = 0;
11485     r = guestfs_cat (g, path);
11486     if (r == NULL)
11487       return -1;
11488     if (strcmp (r, expected) != 0) {
11489       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11490       return -1;
11491     }
11492     free (r);
11493   }
11494   return 0;
11495 }
11496
11497 static int test_write_file_3_skip (void)
11498 {
11499   const char *str;
11500
11501   str = getenv ("SKIP_TEST_WRITE_FILE_3");
11502   if (str && strcmp (str, "1") == 0) return 1;
11503   str = getenv ("SKIP_TEST_WRITE_FILE");
11504   if (str && strcmp (str, "1") == 0) return 1;
11505   return 0;
11506 }
11507
11508 static int test_write_file_3 (void)
11509 {
11510   if (test_write_file_3_skip ()) {
11511     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11512     return 0;
11513   }
11514
11515   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11516   {
11517     char device[] = "/dev/sda";
11518     int r;
11519     suppress_error = 0;
11520     r = guestfs_blockdev_setrw (g, device);
11521     if (r == -1)
11522       return -1;
11523   }
11524   {
11525     int r;
11526     suppress_error = 0;
11527     r = guestfs_umount_all (g);
11528     if (r == -1)
11529       return -1;
11530   }
11531   {
11532     int r;
11533     suppress_error = 0;
11534     r = guestfs_lvm_remove_all (g);
11535     if (r == -1)
11536       return -1;
11537   }
11538   {
11539     char device[] = "/dev/sda";
11540     char lines_0[] = ",";
11541     char *lines[] = {
11542       lines_0,
11543       NULL
11544     };
11545     int r;
11546     suppress_error = 0;
11547     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11548     if (r == -1)
11549       return -1;
11550   }
11551   {
11552     char fstype[] = "ext2";
11553     char device[] = "/dev/sda1";
11554     int r;
11555     suppress_error = 0;
11556     r = guestfs_mkfs (g, fstype, device);
11557     if (r == -1)
11558       return -1;
11559   }
11560   {
11561     char device[] = "/dev/sda1";
11562     char mountpoint[] = "/";
11563     int r;
11564     suppress_error = 0;
11565     r = guestfs_mount (g, device, mountpoint);
11566     if (r == -1)
11567       return -1;
11568   }
11569   /* TestOutput for write_file (3) */
11570   char expected[] = "";
11571   {
11572     char path[] = "/new";
11573     char content[] = "";
11574     int r;
11575     suppress_error = 0;
11576     r = guestfs_write_file (g, path, content, 0);
11577     if (r == -1)
11578       return -1;
11579   }
11580   {
11581     char path[] = "/new";
11582     char *r;
11583     suppress_error = 0;
11584     r = guestfs_cat (g, path);
11585     if (r == NULL)
11586       return -1;
11587     if (strcmp (r, expected) != 0) {
11588       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11589       return -1;
11590     }
11591     free (r);
11592   }
11593   return 0;
11594 }
11595
11596 static int test_write_file_4_skip (void)
11597 {
11598   const char *str;
11599
11600   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11601   if (str && strcmp (str, "1") == 0) return 1;
11602   str = getenv ("SKIP_TEST_WRITE_FILE");
11603   if (str && strcmp (str, "1") == 0) return 1;
11604   return 0;
11605 }
11606
11607 static int test_write_file_4 (void)
11608 {
11609   if (test_write_file_4_skip ()) {
11610     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11611     return 0;
11612   }
11613
11614   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11615   {
11616     char device[] = "/dev/sda";
11617     int r;
11618     suppress_error = 0;
11619     r = guestfs_blockdev_setrw (g, device);
11620     if (r == -1)
11621       return -1;
11622   }
11623   {
11624     int r;
11625     suppress_error = 0;
11626     r = guestfs_umount_all (g);
11627     if (r == -1)
11628       return -1;
11629   }
11630   {
11631     int r;
11632     suppress_error = 0;
11633     r = guestfs_lvm_remove_all (g);
11634     if (r == -1)
11635       return -1;
11636   }
11637   {
11638     char device[] = "/dev/sda";
11639     char lines_0[] = ",";
11640     char *lines[] = {
11641       lines_0,
11642       NULL
11643     };
11644     int r;
11645     suppress_error = 0;
11646     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11647     if (r == -1)
11648       return -1;
11649   }
11650   {
11651     char fstype[] = "ext2";
11652     char device[] = "/dev/sda1";
11653     int r;
11654     suppress_error = 0;
11655     r = guestfs_mkfs (g, fstype, device);
11656     if (r == -1)
11657       return -1;
11658   }
11659   {
11660     char device[] = "/dev/sda1";
11661     char mountpoint[] = "/";
11662     int r;
11663     suppress_error = 0;
11664     r = guestfs_mount (g, device, mountpoint);
11665     if (r == -1)
11666       return -1;
11667   }
11668   /* TestOutput for write_file (4) */
11669   char expected[] = "\n\n\n";
11670   {
11671     char path[] = "/new";
11672     char content[] = "\n\n\n";
11673     int r;
11674     suppress_error = 0;
11675     r = guestfs_write_file (g, path, content, 0);
11676     if (r == -1)
11677       return -1;
11678   }
11679   {
11680     char path[] = "/new";
11681     char *r;
11682     suppress_error = 0;
11683     r = guestfs_cat (g, path);
11684     if (r == NULL)
11685       return -1;
11686     if (strcmp (r, expected) != 0) {
11687       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11688       return -1;
11689     }
11690     free (r);
11691   }
11692   return 0;
11693 }
11694
11695 static int test_write_file_5_skip (void)
11696 {
11697   const char *str;
11698
11699   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11700   if (str && strcmp (str, "1") == 0) return 1;
11701   str = getenv ("SKIP_TEST_WRITE_FILE");
11702   if (str && strcmp (str, "1") == 0) return 1;
11703   return 0;
11704 }
11705
11706 static int test_write_file_5 (void)
11707 {
11708   if (test_write_file_5_skip ()) {
11709     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11710     return 0;
11711   }
11712
11713   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11714   {
11715     char device[] = "/dev/sda";
11716     int r;
11717     suppress_error = 0;
11718     r = guestfs_blockdev_setrw (g, device);
11719     if (r == -1)
11720       return -1;
11721   }
11722   {
11723     int r;
11724     suppress_error = 0;
11725     r = guestfs_umount_all (g);
11726     if (r == -1)
11727       return -1;
11728   }
11729   {
11730     int r;
11731     suppress_error = 0;
11732     r = guestfs_lvm_remove_all (g);
11733     if (r == -1)
11734       return -1;
11735   }
11736   {
11737     char device[] = "/dev/sda";
11738     char lines_0[] = ",";
11739     char *lines[] = {
11740       lines_0,
11741       NULL
11742     };
11743     int r;
11744     suppress_error = 0;
11745     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11746     if (r == -1)
11747       return -1;
11748   }
11749   {
11750     char fstype[] = "ext2";
11751     char device[] = "/dev/sda1";
11752     int r;
11753     suppress_error = 0;
11754     r = guestfs_mkfs (g, fstype, device);
11755     if (r == -1)
11756       return -1;
11757   }
11758   {
11759     char device[] = "/dev/sda1";
11760     char mountpoint[] = "/";
11761     int r;
11762     suppress_error = 0;
11763     r = guestfs_mount (g, device, mountpoint);
11764     if (r == -1)
11765       return -1;
11766   }
11767   /* TestOutput for write_file (5) */
11768   char expected[] = "\n";
11769   {
11770     char path[] = "/new";
11771     char content[] = "\n";
11772     int r;
11773     suppress_error = 0;
11774     r = guestfs_write_file (g, path, content, 0);
11775     if (r == -1)
11776       return -1;
11777   }
11778   {
11779     char path[] = "/new";
11780     char *r;
11781     suppress_error = 0;
11782     r = guestfs_cat (g, path);
11783     if (r == NULL)
11784       return -1;
11785     if (strcmp (r, expected) != 0) {
11786       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11787       return -1;
11788     }
11789     free (r);
11790   }
11791   return 0;
11792 }
11793
11794 static int test_mkfs_0_skip (void)
11795 {
11796   const char *str;
11797
11798   str = getenv ("SKIP_TEST_MKFS_0");
11799   if (str && strcmp (str, "1") == 0) return 1;
11800   str = getenv ("SKIP_TEST_MKFS");
11801   if (str && strcmp (str, "1") == 0) return 1;
11802   return 0;
11803 }
11804
11805 static int test_mkfs_0 (void)
11806 {
11807   if (test_mkfs_0_skip ()) {
11808     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11809     return 0;
11810   }
11811
11812   /* InitNone|InitEmpty for test_mkfs_0 */
11813   {
11814     char device[] = "/dev/sda";
11815     int r;
11816     suppress_error = 0;
11817     r = guestfs_blockdev_setrw (g, device);
11818     if (r == -1)
11819       return -1;
11820   }
11821   {
11822     int r;
11823     suppress_error = 0;
11824     r = guestfs_umount_all (g);
11825     if (r == -1)
11826       return -1;
11827   }
11828   {
11829     int r;
11830     suppress_error = 0;
11831     r = guestfs_lvm_remove_all (g);
11832     if (r == -1)
11833       return -1;
11834   }
11835   /* TestOutput for mkfs (0) */
11836   char expected[] = "new file contents";
11837   {
11838     char device[] = "/dev/sda";
11839     char lines_0[] = ",";
11840     char *lines[] = {
11841       lines_0,
11842       NULL
11843     };
11844     int r;
11845     suppress_error = 0;
11846     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11847     if (r == -1)
11848       return -1;
11849   }
11850   {
11851     char fstype[] = "ext2";
11852     char device[] = "/dev/sda1";
11853     int r;
11854     suppress_error = 0;
11855     r = guestfs_mkfs (g, fstype, device);
11856     if (r == -1)
11857       return -1;
11858   }
11859   {
11860     char device[] = "/dev/sda1";
11861     char mountpoint[] = "/";
11862     int r;
11863     suppress_error = 0;
11864     r = guestfs_mount (g, device, mountpoint);
11865     if (r == -1)
11866       return -1;
11867   }
11868   {
11869     char path[] = "/new";
11870     char content[] = "new file contents";
11871     int r;
11872     suppress_error = 0;
11873     r = guestfs_write_file (g, path, content, 0);
11874     if (r == -1)
11875       return -1;
11876   }
11877   {
11878     char path[] = "/new";
11879     char *r;
11880     suppress_error = 0;
11881     r = guestfs_cat (g, path);
11882     if (r == NULL)
11883       return -1;
11884     if (strcmp (r, expected) != 0) {
11885       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11886       return -1;
11887     }
11888     free (r);
11889   }
11890   return 0;
11891 }
11892
11893 static int test_lvcreate_0_skip (void)
11894 {
11895   const char *str;
11896
11897   str = getenv ("SKIP_TEST_LVCREATE_0");
11898   if (str && strcmp (str, "1") == 0) return 1;
11899   str = getenv ("SKIP_TEST_LVCREATE");
11900   if (str && strcmp (str, "1") == 0) return 1;
11901   return 0;
11902 }
11903
11904 static int test_lvcreate_0 (void)
11905 {
11906   if (test_lvcreate_0_skip ()) {
11907     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11908     return 0;
11909   }
11910
11911   /* InitNone|InitEmpty for test_lvcreate_0 */
11912   {
11913     char device[] = "/dev/sda";
11914     int r;
11915     suppress_error = 0;
11916     r = guestfs_blockdev_setrw (g, device);
11917     if (r == -1)
11918       return -1;
11919   }
11920   {
11921     int r;
11922     suppress_error = 0;
11923     r = guestfs_umount_all (g);
11924     if (r == -1)
11925       return -1;
11926   }
11927   {
11928     int r;
11929     suppress_error = 0;
11930     r = guestfs_lvm_remove_all (g);
11931     if (r == -1)
11932       return -1;
11933   }
11934   /* TestOutputList for lvcreate (0) */
11935   {
11936     char device[] = "/dev/sda";
11937     char lines_0[] = ",10";
11938     char lines_1[] = ",20";
11939     char lines_2[] = ",";
11940     char *lines[] = {
11941       lines_0,
11942       lines_1,
11943       lines_2,
11944       NULL
11945     };
11946     int r;
11947     suppress_error = 0;
11948     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11949     if (r == -1)
11950       return -1;
11951   }
11952   {
11953     char device[] = "/dev/sda1";
11954     int r;
11955     suppress_error = 0;
11956     r = guestfs_pvcreate (g, device);
11957     if (r == -1)
11958       return -1;
11959   }
11960   {
11961     char device[] = "/dev/sda2";
11962     int r;
11963     suppress_error = 0;
11964     r = guestfs_pvcreate (g, device);
11965     if (r == -1)
11966       return -1;
11967   }
11968   {
11969     char device[] = "/dev/sda3";
11970     int r;
11971     suppress_error = 0;
11972     r = guestfs_pvcreate (g, device);
11973     if (r == -1)
11974       return -1;
11975   }
11976   {
11977     char volgroup[] = "VG1";
11978     char physvols_0[] = "/dev/sda1";
11979     char physvols_1[] = "/dev/sda2";
11980     char *physvols[] = {
11981       physvols_0,
11982       physvols_1,
11983       NULL
11984     };
11985     int r;
11986     suppress_error = 0;
11987     r = guestfs_vgcreate (g, volgroup, physvols);
11988     if (r == -1)
11989       return -1;
11990   }
11991   {
11992     char volgroup[] = "VG2";
11993     char physvols_0[] = "/dev/sda3";
11994     char *physvols[] = {
11995       physvols_0,
11996       NULL
11997     };
11998     int r;
11999     suppress_error = 0;
12000     r = guestfs_vgcreate (g, volgroup, physvols);
12001     if (r == -1)
12002       return -1;
12003   }
12004   {
12005     char logvol[] = "LV1";
12006     char volgroup[] = "VG1";
12007     int r;
12008     suppress_error = 0;
12009     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12010     if (r == -1)
12011       return -1;
12012   }
12013   {
12014     char logvol[] = "LV2";
12015     char volgroup[] = "VG1";
12016     int r;
12017     suppress_error = 0;
12018     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12019     if (r == -1)
12020       return -1;
12021   }
12022   {
12023     char logvol[] = "LV3";
12024     char volgroup[] = "VG2";
12025     int r;
12026     suppress_error = 0;
12027     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12028     if (r == -1)
12029       return -1;
12030   }
12031   {
12032     char logvol[] = "LV4";
12033     char volgroup[] = "VG2";
12034     int r;
12035     suppress_error = 0;
12036     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12037     if (r == -1)
12038       return -1;
12039   }
12040   {
12041     char logvol[] = "LV5";
12042     char volgroup[] = "VG2";
12043     int r;
12044     suppress_error = 0;
12045     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12046     if (r == -1)
12047       return -1;
12048   }
12049   {
12050     char **r;
12051     int i;
12052     suppress_error = 0;
12053     r = guestfs_lvs (g);
12054     if (r == NULL)
12055       return -1;
12056     if (!r[0]) {
12057       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12058       print_strings (r);
12059       return -1;
12060     }
12061     {
12062       char expected[] = "/dev/VG1/LV1";
12063       if (strcmp (r[0], expected) != 0) {
12064         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12065         return -1;
12066       }
12067     }
12068     if (!r[1]) {
12069       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12070       print_strings (r);
12071       return -1;
12072     }
12073     {
12074       char expected[] = "/dev/VG1/LV2";
12075       if (strcmp (r[1], expected) != 0) {
12076         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12077         return -1;
12078       }
12079     }
12080     if (!r[2]) {
12081       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12082       print_strings (r);
12083       return -1;
12084     }
12085     {
12086       char expected[] = "/dev/VG2/LV3";
12087       if (strcmp (r[2], expected) != 0) {
12088         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12089         return -1;
12090       }
12091     }
12092     if (!r[3]) {
12093       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12094       print_strings (r);
12095       return -1;
12096     }
12097     {
12098       char expected[] = "/dev/VG2/LV4";
12099       if (strcmp (r[3], expected) != 0) {
12100         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12101         return -1;
12102       }
12103     }
12104     if (!r[4]) {
12105       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12106       print_strings (r);
12107       return -1;
12108     }
12109     {
12110       char expected[] = "/dev/VG2/LV5";
12111       if (strcmp (r[4], expected) != 0) {
12112         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
12113         return -1;
12114       }
12115     }
12116     if (r[5] != NULL) {
12117       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
12118       print_strings (r);
12119       return -1;
12120     }
12121     for (i = 0; r[i] != NULL; ++i)
12122       free (r[i]);
12123     free (r);
12124   }
12125   return 0;
12126 }
12127
12128 static int test_vgcreate_0_skip (void)
12129 {
12130   const char *str;
12131
12132   str = getenv ("SKIP_TEST_VGCREATE_0");
12133   if (str && strcmp (str, "1") == 0) return 1;
12134   str = getenv ("SKIP_TEST_VGCREATE");
12135   if (str && strcmp (str, "1") == 0) return 1;
12136   return 0;
12137 }
12138
12139 static int test_vgcreate_0 (void)
12140 {
12141   if (test_vgcreate_0_skip ()) {
12142     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
12143     return 0;
12144   }
12145
12146   /* InitNone|InitEmpty for test_vgcreate_0 */
12147   {
12148     char device[] = "/dev/sda";
12149     int r;
12150     suppress_error = 0;
12151     r = guestfs_blockdev_setrw (g, device);
12152     if (r == -1)
12153       return -1;
12154   }
12155   {
12156     int r;
12157     suppress_error = 0;
12158     r = guestfs_umount_all (g);
12159     if (r == -1)
12160       return -1;
12161   }
12162   {
12163     int r;
12164     suppress_error = 0;
12165     r = guestfs_lvm_remove_all (g);
12166     if (r == -1)
12167       return -1;
12168   }
12169   /* TestOutputList for vgcreate (0) */
12170   {
12171     char device[] = "/dev/sda";
12172     char lines_0[] = ",10";
12173     char lines_1[] = ",20";
12174     char lines_2[] = ",";
12175     char *lines[] = {
12176       lines_0,
12177       lines_1,
12178       lines_2,
12179       NULL
12180     };
12181     int r;
12182     suppress_error = 0;
12183     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12184     if (r == -1)
12185       return -1;
12186   }
12187   {
12188     char device[] = "/dev/sda1";
12189     int r;
12190     suppress_error = 0;
12191     r = guestfs_pvcreate (g, device);
12192     if (r == -1)
12193       return -1;
12194   }
12195   {
12196     char device[] = "/dev/sda2";
12197     int r;
12198     suppress_error = 0;
12199     r = guestfs_pvcreate (g, device);
12200     if (r == -1)
12201       return -1;
12202   }
12203   {
12204     char device[] = "/dev/sda3";
12205     int r;
12206     suppress_error = 0;
12207     r = guestfs_pvcreate (g, device);
12208     if (r == -1)
12209       return -1;
12210   }
12211   {
12212     char volgroup[] = "VG1";
12213     char physvols_0[] = "/dev/sda1";
12214     char physvols_1[] = "/dev/sda2";
12215     char *physvols[] = {
12216       physvols_0,
12217       physvols_1,
12218       NULL
12219     };
12220     int r;
12221     suppress_error = 0;
12222     r = guestfs_vgcreate (g, volgroup, physvols);
12223     if (r == -1)
12224       return -1;
12225   }
12226   {
12227     char volgroup[] = "VG2";
12228     char physvols_0[] = "/dev/sda3";
12229     char *physvols[] = {
12230       physvols_0,
12231       NULL
12232     };
12233     int r;
12234     suppress_error = 0;
12235     r = guestfs_vgcreate (g, volgroup, physvols);
12236     if (r == -1)
12237       return -1;
12238   }
12239   {
12240     char **r;
12241     int i;
12242     suppress_error = 0;
12243     r = guestfs_vgs (g);
12244     if (r == NULL)
12245       return -1;
12246     if (!r[0]) {
12247       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12248       print_strings (r);
12249       return -1;
12250     }
12251     {
12252       char expected[] = "VG1";
12253       if (strcmp (r[0], expected) != 0) {
12254         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12255         return -1;
12256       }
12257     }
12258     if (!r[1]) {
12259       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12260       print_strings (r);
12261       return -1;
12262     }
12263     {
12264       char expected[] = "VG2";
12265       if (strcmp (r[1], expected) != 0) {
12266         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12267         return -1;
12268       }
12269     }
12270     if (r[2] != NULL) {
12271       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12272       print_strings (r);
12273       return -1;
12274     }
12275     for (i = 0; r[i] != NULL; ++i)
12276       free (r[i]);
12277     free (r);
12278   }
12279   return 0;
12280 }
12281
12282 static int test_pvcreate_0_skip (void)
12283 {
12284   const char *str;
12285
12286   str = getenv ("SKIP_TEST_PVCREATE_0");
12287   if (str && strcmp (str, "1") == 0) return 1;
12288   str = getenv ("SKIP_TEST_PVCREATE");
12289   if (str && strcmp (str, "1") == 0) return 1;
12290   return 0;
12291 }
12292
12293 static int test_pvcreate_0 (void)
12294 {
12295   if (test_pvcreate_0_skip ()) {
12296     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12297     return 0;
12298   }
12299
12300   /* InitNone|InitEmpty for test_pvcreate_0 */
12301   {
12302     char device[] = "/dev/sda";
12303     int r;
12304     suppress_error = 0;
12305     r = guestfs_blockdev_setrw (g, device);
12306     if (r == -1)
12307       return -1;
12308   }
12309   {
12310     int r;
12311     suppress_error = 0;
12312     r = guestfs_umount_all (g);
12313     if (r == -1)
12314       return -1;
12315   }
12316   {
12317     int r;
12318     suppress_error = 0;
12319     r = guestfs_lvm_remove_all (g);
12320     if (r == -1)
12321       return -1;
12322   }
12323   /* TestOutputListOfDevices for pvcreate (0) */
12324   {
12325     char device[] = "/dev/sda";
12326     char lines_0[] = ",10";
12327     char lines_1[] = ",20";
12328     char lines_2[] = ",";
12329     char *lines[] = {
12330       lines_0,
12331       lines_1,
12332       lines_2,
12333       NULL
12334     };
12335     int r;
12336     suppress_error = 0;
12337     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12338     if (r == -1)
12339       return -1;
12340   }
12341   {
12342     char device[] = "/dev/sda1";
12343     int r;
12344     suppress_error = 0;
12345     r = guestfs_pvcreate (g, device);
12346     if (r == -1)
12347       return -1;
12348   }
12349   {
12350     char device[] = "/dev/sda2";
12351     int r;
12352     suppress_error = 0;
12353     r = guestfs_pvcreate (g, device);
12354     if (r == -1)
12355       return -1;
12356   }
12357   {
12358     char device[] = "/dev/sda3";
12359     int r;
12360     suppress_error = 0;
12361     r = guestfs_pvcreate (g, device);
12362     if (r == -1)
12363       return -1;
12364   }
12365   {
12366     char **r;
12367     int i;
12368     suppress_error = 0;
12369     r = guestfs_pvs (g);
12370     if (r == NULL)
12371       return -1;
12372     if (!r[0]) {
12373       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12374       print_strings (r);
12375       return -1;
12376     }
12377     {
12378       char expected[] = "/dev/sda1";
12379       r[0][5] = 's';
12380       if (strcmp (r[0], expected) != 0) {
12381         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12382         return -1;
12383       }
12384     }
12385     if (!r[1]) {
12386       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12387       print_strings (r);
12388       return -1;
12389     }
12390     {
12391       char expected[] = "/dev/sda2";
12392       r[1][5] = 's';
12393       if (strcmp (r[1], expected) != 0) {
12394         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12395         return -1;
12396       }
12397     }
12398     if (!r[2]) {
12399       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12400       print_strings (r);
12401       return -1;
12402     }
12403     {
12404       char expected[] = "/dev/sda3";
12405       r[2][5] = 's';
12406       if (strcmp (r[2], expected) != 0) {
12407         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12408         return -1;
12409       }
12410     }
12411     if (r[3] != NULL) {
12412       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12413       print_strings (r);
12414       return -1;
12415     }
12416     for (i = 0; r[i] != NULL; ++i)
12417       free (r[i]);
12418     free (r);
12419   }
12420   return 0;
12421 }
12422
12423 static int test_is_dir_0_skip (void)
12424 {
12425   const char *str;
12426
12427   str = getenv ("SKIP_TEST_IS_DIR_0");
12428   if (str && strcmp (str, "1") == 0) return 1;
12429   str = getenv ("SKIP_TEST_IS_DIR");
12430   if (str && strcmp (str, "1") == 0) return 1;
12431   return 0;
12432 }
12433
12434 static int test_is_dir_0 (void)
12435 {
12436   if (test_is_dir_0_skip ()) {
12437     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12438     return 0;
12439   }
12440
12441   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12442   {
12443     char device[] = "/dev/sda";
12444     int r;
12445     suppress_error = 0;
12446     r = guestfs_blockdev_setrw (g, device);
12447     if (r == -1)
12448       return -1;
12449   }
12450   {
12451     int r;
12452     suppress_error = 0;
12453     r = guestfs_umount_all (g);
12454     if (r == -1)
12455       return -1;
12456   }
12457   {
12458     int r;
12459     suppress_error = 0;
12460     r = guestfs_lvm_remove_all (g);
12461     if (r == -1)
12462       return -1;
12463   }
12464   {
12465     char device[] = "/dev/sda";
12466     char lines_0[] = ",";
12467     char *lines[] = {
12468       lines_0,
12469       NULL
12470     };
12471     int r;
12472     suppress_error = 0;
12473     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12474     if (r == -1)
12475       return -1;
12476   }
12477   {
12478     char fstype[] = "ext2";
12479     char device[] = "/dev/sda1";
12480     int r;
12481     suppress_error = 0;
12482     r = guestfs_mkfs (g, fstype, device);
12483     if (r == -1)
12484       return -1;
12485   }
12486   {
12487     char device[] = "/dev/sda1";
12488     char mountpoint[] = "/";
12489     int r;
12490     suppress_error = 0;
12491     r = guestfs_mount (g, device, mountpoint);
12492     if (r == -1)
12493       return -1;
12494   }
12495   /* TestOutputFalse for is_dir (0) */
12496   {
12497     char path[] = "/new";
12498     int r;
12499     suppress_error = 0;
12500     r = guestfs_touch (g, path);
12501     if (r == -1)
12502       return -1;
12503   }
12504   {
12505     char path[] = "/new";
12506     int r;
12507     suppress_error = 0;
12508     r = guestfs_is_dir (g, path);
12509     if (r == -1)
12510       return -1;
12511     if (r) {
12512       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12513       return -1;
12514     }
12515   }
12516   return 0;
12517 }
12518
12519 static int test_is_dir_1_skip (void)
12520 {
12521   const char *str;
12522
12523   str = getenv ("SKIP_TEST_IS_DIR_1");
12524   if (str && strcmp (str, "1") == 0) return 1;
12525   str = getenv ("SKIP_TEST_IS_DIR");
12526   if (str && strcmp (str, "1") == 0) return 1;
12527   return 0;
12528 }
12529
12530 static int test_is_dir_1 (void)
12531 {
12532   if (test_is_dir_1_skip ()) {
12533     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12534     return 0;
12535   }
12536
12537   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12538   {
12539     char device[] = "/dev/sda";
12540     int r;
12541     suppress_error = 0;
12542     r = guestfs_blockdev_setrw (g, device);
12543     if (r == -1)
12544       return -1;
12545   }
12546   {
12547     int r;
12548     suppress_error = 0;
12549     r = guestfs_umount_all (g);
12550     if (r == -1)
12551       return -1;
12552   }
12553   {
12554     int r;
12555     suppress_error = 0;
12556     r = guestfs_lvm_remove_all (g);
12557     if (r == -1)
12558       return -1;
12559   }
12560   {
12561     char device[] = "/dev/sda";
12562     char lines_0[] = ",";
12563     char *lines[] = {
12564       lines_0,
12565       NULL
12566     };
12567     int r;
12568     suppress_error = 0;
12569     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12570     if (r == -1)
12571       return -1;
12572   }
12573   {
12574     char fstype[] = "ext2";
12575     char device[] = "/dev/sda1";
12576     int r;
12577     suppress_error = 0;
12578     r = guestfs_mkfs (g, fstype, device);
12579     if (r == -1)
12580       return -1;
12581   }
12582   {
12583     char device[] = "/dev/sda1";
12584     char mountpoint[] = "/";
12585     int r;
12586     suppress_error = 0;
12587     r = guestfs_mount (g, device, mountpoint);
12588     if (r == -1)
12589       return -1;
12590   }
12591   /* TestOutputTrue for is_dir (1) */
12592   {
12593     char path[] = "/new";
12594     int r;
12595     suppress_error = 0;
12596     r = guestfs_mkdir (g, path);
12597     if (r == -1)
12598       return -1;
12599   }
12600   {
12601     char path[] = "/new";
12602     int r;
12603     suppress_error = 0;
12604     r = guestfs_is_dir (g, path);
12605     if (r == -1)
12606       return -1;
12607     if (!r) {
12608       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12609       return -1;
12610     }
12611   }
12612   return 0;
12613 }
12614
12615 static int test_is_file_0_skip (void)
12616 {
12617   const char *str;
12618
12619   str = getenv ("SKIP_TEST_IS_FILE_0");
12620   if (str && strcmp (str, "1") == 0) return 1;
12621   str = getenv ("SKIP_TEST_IS_FILE");
12622   if (str && strcmp (str, "1") == 0) return 1;
12623   return 0;
12624 }
12625
12626 static int test_is_file_0 (void)
12627 {
12628   if (test_is_file_0_skip ()) {
12629     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12630     return 0;
12631   }
12632
12633   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12634   {
12635     char device[] = "/dev/sda";
12636     int r;
12637     suppress_error = 0;
12638     r = guestfs_blockdev_setrw (g, device);
12639     if (r == -1)
12640       return -1;
12641   }
12642   {
12643     int r;
12644     suppress_error = 0;
12645     r = guestfs_umount_all (g);
12646     if (r == -1)
12647       return -1;
12648   }
12649   {
12650     int r;
12651     suppress_error = 0;
12652     r = guestfs_lvm_remove_all (g);
12653     if (r == -1)
12654       return -1;
12655   }
12656   {
12657     char device[] = "/dev/sda";
12658     char lines_0[] = ",";
12659     char *lines[] = {
12660       lines_0,
12661       NULL
12662     };
12663     int r;
12664     suppress_error = 0;
12665     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12666     if (r == -1)
12667       return -1;
12668   }
12669   {
12670     char fstype[] = "ext2";
12671     char device[] = "/dev/sda1";
12672     int r;
12673     suppress_error = 0;
12674     r = guestfs_mkfs (g, fstype, device);
12675     if (r == -1)
12676       return -1;
12677   }
12678   {
12679     char device[] = "/dev/sda1";
12680     char mountpoint[] = "/";
12681     int r;
12682     suppress_error = 0;
12683     r = guestfs_mount (g, device, mountpoint);
12684     if (r == -1)
12685       return -1;
12686   }
12687   /* TestOutputTrue for is_file (0) */
12688   {
12689     char path[] = "/new";
12690     int r;
12691     suppress_error = 0;
12692     r = guestfs_touch (g, path);
12693     if (r == -1)
12694       return -1;
12695   }
12696   {
12697     char path[] = "/new";
12698     int r;
12699     suppress_error = 0;
12700     r = guestfs_is_file (g, path);
12701     if (r == -1)
12702       return -1;
12703     if (!r) {
12704       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12705       return -1;
12706     }
12707   }
12708   return 0;
12709 }
12710
12711 static int test_is_file_1_skip (void)
12712 {
12713   const char *str;
12714
12715   str = getenv ("SKIP_TEST_IS_FILE_1");
12716   if (str && strcmp (str, "1") == 0) return 1;
12717   str = getenv ("SKIP_TEST_IS_FILE");
12718   if (str && strcmp (str, "1") == 0) return 1;
12719   return 0;
12720 }
12721
12722 static int test_is_file_1 (void)
12723 {
12724   if (test_is_file_1_skip ()) {
12725     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12726     return 0;
12727   }
12728
12729   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12730   {
12731     char device[] = "/dev/sda";
12732     int r;
12733     suppress_error = 0;
12734     r = guestfs_blockdev_setrw (g, device);
12735     if (r == -1)
12736       return -1;
12737   }
12738   {
12739     int r;
12740     suppress_error = 0;
12741     r = guestfs_umount_all (g);
12742     if (r == -1)
12743       return -1;
12744   }
12745   {
12746     int r;
12747     suppress_error = 0;
12748     r = guestfs_lvm_remove_all (g);
12749     if (r == -1)
12750       return -1;
12751   }
12752   {
12753     char device[] = "/dev/sda";
12754     char lines_0[] = ",";
12755     char *lines[] = {
12756       lines_0,
12757       NULL
12758     };
12759     int r;
12760     suppress_error = 0;
12761     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12762     if (r == -1)
12763       return -1;
12764   }
12765   {
12766     char fstype[] = "ext2";
12767     char device[] = "/dev/sda1";
12768     int r;
12769     suppress_error = 0;
12770     r = guestfs_mkfs (g, fstype, device);
12771     if (r == -1)
12772       return -1;
12773   }
12774   {
12775     char device[] = "/dev/sda1";
12776     char mountpoint[] = "/";
12777     int r;
12778     suppress_error = 0;
12779     r = guestfs_mount (g, device, mountpoint);
12780     if (r == -1)
12781       return -1;
12782   }
12783   /* TestOutputFalse for is_file (1) */
12784   {
12785     char path[] = "/new";
12786     int r;
12787     suppress_error = 0;
12788     r = guestfs_mkdir (g, path);
12789     if (r == -1)
12790       return -1;
12791   }
12792   {
12793     char path[] = "/new";
12794     int r;
12795     suppress_error = 0;
12796     r = guestfs_is_file (g, path);
12797     if (r == -1)
12798       return -1;
12799     if (r) {
12800       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12801       return -1;
12802     }
12803   }
12804   return 0;
12805 }
12806
12807 static int test_exists_0_skip (void)
12808 {
12809   const char *str;
12810
12811   str = getenv ("SKIP_TEST_EXISTS_0");
12812   if (str && strcmp (str, "1") == 0) return 1;
12813   str = getenv ("SKIP_TEST_EXISTS");
12814   if (str && strcmp (str, "1") == 0) return 1;
12815   return 0;
12816 }
12817
12818 static int test_exists_0 (void)
12819 {
12820   if (test_exists_0_skip ()) {
12821     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12822     return 0;
12823   }
12824
12825   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12826   {
12827     char device[] = "/dev/sda";
12828     int r;
12829     suppress_error = 0;
12830     r = guestfs_blockdev_setrw (g, device);
12831     if (r == -1)
12832       return -1;
12833   }
12834   {
12835     int r;
12836     suppress_error = 0;
12837     r = guestfs_umount_all (g);
12838     if (r == -1)
12839       return -1;
12840   }
12841   {
12842     int r;
12843     suppress_error = 0;
12844     r = guestfs_lvm_remove_all (g);
12845     if (r == -1)
12846       return -1;
12847   }
12848   {
12849     char device[] = "/dev/sda";
12850     char lines_0[] = ",";
12851     char *lines[] = {
12852       lines_0,
12853       NULL
12854     };
12855     int r;
12856     suppress_error = 0;
12857     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12858     if (r == -1)
12859       return -1;
12860   }
12861   {
12862     char fstype[] = "ext2";
12863     char device[] = "/dev/sda1";
12864     int r;
12865     suppress_error = 0;
12866     r = guestfs_mkfs (g, fstype, device);
12867     if (r == -1)
12868       return -1;
12869   }
12870   {
12871     char device[] = "/dev/sda1";
12872     char mountpoint[] = "/";
12873     int r;
12874     suppress_error = 0;
12875     r = guestfs_mount (g, device, mountpoint);
12876     if (r == -1)
12877       return -1;
12878   }
12879   /* TestOutputTrue for exists (0) */
12880   {
12881     char path[] = "/new";
12882     int r;
12883     suppress_error = 0;
12884     r = guestfs_touch (g, path);
12885     if (r == -1)
12886       return -1;
12887   }
12888   {
12889     char path[] = "/new";
12890     int r;
12891     suppress_error = 0;
12892     r = guestfs_exists (g, path);
12893     if (r == -1)
12894       return -1;
12895     if (!r) {
12896       fprintf (stderr, "test_exists_0: expected true, got false\n");
12897       return -1;
12898     }
12899   }
12900   return 0;
12901 }
12902
12903 static int test_exists_1_skip (void)
12904 {
12905   const char *str;
12906
12907   str = getenv ("SKIP_TEST_EXISTS_1");
12908   if (str && strcmp (str, "1") == 0) return 1;
12909   str = getenv ("SKIP_TEST_EXISTS");
12910   if (str && strcmp (str, "1") == 0) return 1;
12911   return 0;
12912 }
12913
12914 static int test_exists_1 (void)
12915 {
12916   if (test_exists_1_skip ()) {
12917     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12918     return 0;
12919   }
12920
12921   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12922   {
12923     char device[] = "/dev/sda";
12924     int r;
12925     suppress_error = 0;
12926     r = guestfs_blockdev_setrw (g, device);
12927     if (r == -1)
12928       return -1;
12929   }
12930   {
12931     int r;
12932     suppress_error = 0;
12933     r = guestfs_umount_all (g);
12934     if (r == -1)
12935       return -1;
12936   }
12937   {
12938     int r;
12939     suppress_error = 0;
12940     r = guestfs_lvm_remove_all (g);
12941     if (r == -1)
12942       return -1;
12943   }
12944   {
12945     char device[] = "/dev/sda";
12946     char lines_0[] = ",";
12947     char *lines[] = {
12948       lines_0,
12949       NULL
12950     };
12951     int r;
12952     suppress_error = 0;
12953     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12954     if (r == -1)
12955       return -1;
12956   }
12957   {
12958     char fstype[] = "ext2";
12959     char device[] = "/dev/sda1";
12960     int r;
12961     suppress_error = 0;
12962     r = guestfs_mkfs (g, fstype, device);
12963     if (r == -1)
12964       return -1;
12965   }
12966   {
12967     char device[] = "/dev/sda1";
12968     char mountpoint[] = "/";
12969     int r;
12970     suppress_error = 0;
12971     r = guestfs_mount (g, device, mountpoint);
12972     if (r == -1)
12973       return -1;
12974   }
12975   /* TestOutputTrue for exists (1) */
12976   {
12977     char path[] = "/new";
12978     int r;
12979     suppress_error = 0;
12980     r = guestfs_mkdir (g, path);
12981     if (r == -1)
12982       return -1;
12983   }
12984   {
12985     char path[] = "/new";
12986     int r;
12987     suppress_error = 0;
12988     r = guestfs_exists (g, path);
12989     if (r == -1)
12990       return -1;
12991     if (!r) {
12992       fprintf (stderr, "test_exists_1: expected true, got false\n");
12993       return -1;
12994     }
12995   }
12996   return 0;
12997 }
12998
12999 static int test_mkdir_p_0_skip (void)
13000 {
13001   const char *str;
13002
13003   str = getenv ("SKIP_TEST_MKDIR_P_0");
13004   if (str && strcmp (str, "1") == 0) return 1;
13005   str = getenv ("SKIP_TEST_MKDIR_P");
13006   if (str && strcmp (str, "1") == 0) return 1;
13007   return 0;
13008 }
13009
13010 static int test_mkdir_p_0 (void)
13011 {
13012   if (test_mkdir_p_0_skip ()) {
13013     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
13014     return 0;
13015   }
13016
13017   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
13018   {
13019     char device[] = "/dev/sda";
13020     int r;
13021     suppress_error = 0;
13022     r = guestfs_blockdev_setrw (g, device);
13023     if (r == -1)
13024       return -1;
13025   }
13026   {
13027     int r;
13028     suppress_error = 0;
13029     r = guestfs_umount_all (g);
13030     if (r == -1)
13031       return -1;
13032   }
13033   {
13034     int r;
13035     suppress_error = 0;
13036     r = guestfs_lvm_remove_all (g);
13037     if (r == -1)
13038       return -1;
13039   }
13040   {
13041     char device[] = "/dev/sda";
13042     char lines_0[] = ",";
13043     char *lines[] = {
13044       lines_0,
13045       NULL
13046     };
13047     int r;
13048     suppress_error = 0;
13049     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13050     if (r == -1)
13051       return -1;
13052   }
13053   {
13054     char fstype[] = "ext2";
13055     char device[] = "/dev/sda1";
13056     int r;
13057     suppress_error = 0;
13058     r = guestfs_mkfs (g, fstype, device);
13059     if (r == -1)
13060       return -1;
13061   }
13062   {
13063     char device[] = "/dev/sda1";
13064     char mountpoint[] = "/";
13065     int r;
13066     suppress_error = 0;
13067     r = guestfs_mount (g, device, mountpoint);
13068     if (r == -1)
13069       return -1;
13070   }
13071   /* TestOutputTrue for mkdir_p (0) */
13072   {
13073     char path[] = "/new/foo/bar";
13074     int r;
13075     suppress_error = 0;
13076     r = guestfs_mkdir_p (g, path);
13077     if (r == -1)
13078       return -1;
13079   }
13080   {
13081     char path[] = "/new/foo/bar";
13082     int r;
13083     suppress_error = 0;
13084     r = guestfs_is_dir (g, path);
13085     if (r == -1)
13086       return -1;
13087     if (!r) {
13088       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
13089       return -1;
13090     }
13091   }
13092   return 0;
13093 }
13094
13095 static int test_mkdir_p_1_skip (void)
13096 {
13097   const char *str;
13098
13099   str = getenv ("SKIP_TEST_MKDIR_P_1");
13100   if (str && strcmp (str, "1") == 0) return 1;
13101   str = getenv ("SKIP_TEST_MKDIR_P");
13102   if (str && strcmp (str, "1") == 0) return 1;
13103   return 0;
13104 }
13105
13106 static int test_mkdir_p_1 (void)
13107 {
13108   if (test_mkdir_p_1_skip ()) {
13109     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
13110     return 0;
13111   }
13112
13113   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
13114   {
13115     char device[] = "/dev/sda";
13116     int r;
13117     suppress_error = 0;
13118     r = guestfs_blockdev_setrw (g, device);
13119     if (r == -1)
13120       return -1;
13121   }
13122   {
13123     int r;
13124     suppress_error = 0;
13125     r = guestfs_umount_all (g);
13126     if (r == -1)
13127       return -1;
13128   }
13129   {
13130     int r;
13131     suppress_error = 0;
13132     r = guestfs_lvm_remove_all (g);
13133     if (r == -1)
13134       return -1;
13135   }
13136   {
13137     char device[] = "/dev/sda";
13138     char lines_0[] = ",";
13139     char *lines[] = {
13140       lines_0,
13141       NULL
13142     };
13143     int r;
13144     suppress_error = 0;
13145     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13146     if (r == -1)
13147       return -1;
13148   }
13149   {
13150     char fstype[] = "ext2";
13151     char device[] = "/dev/sda1";
13152     int r;
13153     suppress_error = 0;
13154     r = guestfs_mkfs (g, fstype, device);
13155     if (r == -1)
13156       return -1;
13157   }
13158   {
13159     char device[] = "/dev/sda1";
13160     char mountpoint[] = "/";
13161     int r;
13162     suppress_error = 0;
13163     r = guestfs_mount (g, device, mountpoint);
13164     if (r == -1)
13165       return -1;
13166   }
13167   /* TestOutputTrue for mkdir_p (1) */
13168   {
13169     char path[] = "/new/foo/bar";
13170     int r;
13171     suppress_error = 0;
13172     r = guestfs_mkdir_p (g, path);
13173     if (r == -1)
13174       return -1;
13175   }
13176   {
13177     char path[] = "/new/foo";
13178     int r;
13179     suppress_error = 0;
13180     r = guestfs_is_dir (g, path);
13181     if (r == -1)
13182       return -1;
13183     if (!r) {
13184       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
13185       return -1;
13186     }
13187   }
13188   return 0;
13189 }
13190
13191 static int test_mkdir_p_2_skip (void)
13192 {
13193   const char *str;
13194
13195   str = getenv ("SKIP_TEST_MKDIR_P_2");
13196   if (str && strcmp (str, "1") == 0) return 1;
13197   str = getenv ("SKIP_TEST_MKDIR_P");
13198   if (str && strcmp (str, "1") == 0) return 1;
13199   return 0;
13200 }
13201
13202 static int test_mkdir_p_2 (void)
13203 {
13204   if (test_mkdir_p_2_skip ()) {
13205     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
13206     return 0;
13207   }
13208
13209   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
13210   {
13211     char device[] = "/dev/sda";
13212     int r;
13213     suppress_error = 0;
13214     r = guestfs_blockdev_setrw (g, device);
13215     if (r == -1)
13216       return -1;
13217   }
13218   {
13219     int r;
13220     suppress_error = 0;
13221     r = guestfs_umount_all (g);
13222     if (r == -1)
13223       return -1;
13224   }
13225   {
13226     int r;
13227     suppress_error = 0;
13228     r = guestfs_lvm_remove_all (g);
13229     if (r == -1)
13230       return -1;
13231   }
13232   {
13233     char device[] = "/dev/sda";
13234     char lines_0[] = ",";
13235     char *lines[] = {
13236       lines_0,
13237       NULL
13238     };
13239     int r;
13240     suppress_error = 0;
13241     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13242     if (r == -1)
13243       return -1;
13244   }
13245   {
13246     char fstype[] = "ext2";
13247     char device[] = "/dev/sda1";
13248     int r;
13249     suppress_error = 0;
13250     r = guestfs_mkfs (g, fstype, device);
13251     if (r == -1)
13252       return -1;
13253   }
13254   {
13255     char device[] = "/dev/sda1";
13256     char mountpoint[] = "/";
13257     int r;
13258     suppress_error = 0;
13259     r = guestfs_mount (g, device, mountpoint);
13260     if (r == -1)
13261       return -1;
13262   }
13263   /* TestOutputTrue for mkdir_p (2) */
13264   {
13265     char path[] = "/new/foo/bar";
13266     int r;
13267     suppress_error = 0;
13268     r = guestfs_mkdir_p (g, path);
13269     if (r == -1)
13270       return -1;
13271   }
13272   {
13273     char path[] = "/new";
13274     int r;
13275     suppress_error = 0;
13276     r = guestfs_is_dir (g, path);
13277     if (r == -1)
13278       return -1;
13279     if (!r) {
13280       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13281       return -1;
13282     }
13283   }
13284   return 0;
13285 }
13286
13287 static int test_mkdir_p_3_skip (void)
13288 {
13289   const char *str;
13290
13291   str = getenv ("SKIP_TEST_MKDIR_P_3");
13292   if (str && strcmp (str, "1") == 0) return 1;
13293   str = getenv ("SKIP_TEST_MKDIR_P");
13294   if (str && strcmp (str, "1") == 0) return 1;
13295   return 0;
13296 }
13297
13298 static int test_mkdir_p_3 (void)
13299 {
13300   if (test_mkdir_p_3_skip ()) {
13301     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13302     return 0;
13303   }
13304
13305   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13306   {
13307     char device[] = "/dev/sda";
13308     int r;
13309     suppress_error = 0;
13310     r = guestfs_blockdev_setrw (g, device);
13311     if (r == -1)
13312       return -1;
13313   }
13314   {
13315     int r;
13316     suppress_error = 0;
13317     r = guestfs_umount_all (g);
13318     if (r == -1)
13319       return -1;
13320   }
13321   {
13322     int r;
13323     suppress_error = 0;
13324     r = guestfs_lvm_remove_all (g);
13325     if (r == -1)
13326       return -1;
13327   }
13328   {
13329     char device[] = "/dev/sda";
13330     char lines_0[] = ",";
13331     char *lines[] = {
13332       lines_0,
13333       NULL
13334     };
13335     int r;
13336     suppress_error = 0;
13337     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13338     if (r == -1)
13339       return -1;
13340   }
13341   {
13342     char fstype[] = "ext2";
13343     char device[] = "/dev/sda1";
13344     int r;
13345     suppress_error = 0;
13346     r = guestfs_mkfs (g, fstype, device);
13347     if (r == -1)
13348       return -1;
13349   }
13350   {
13351     char device[] = "/dev/sda1";
13352     char mountpoint[] = "/";
13353     int r;
13354     suppress_error = 0;
13355     r = guestfs_mount (g, device, mountpoint);
13356     if (r == -1)
13357       return -1;
13358   }
13359   /* TestRun for mkdir_p (3) */
13360   {
13361     char path[] = "/new";
13362     int r;
13363     suppress_error = 0;
13364     r = guestfs_mkdir (g, path);
13365     if (r == -1)
13366       return -1;
13367   }
13368   {
13369     char path[] = "/new";
13370     int r;
13371     suppress_error = 0;
13372     r = guestfs_mkdir_p (g, path);
13373     if (r == -1)
13374       return -1;
13375   }
13376   return 0;
13377 }
13378
13379 static int test_mkdir_p_4_skip (void)
13380 {
13381   const char *str;
13382
13383   str = getenv ("SKIP_TEST_MKDIR_P_4");
13384   if (str && strcmp (str, "1") == 0) return 1;
13385   str = getenv ("SKIP_TEST_MKDIR_P");
13386   if (str && strcmp (str, "1") == 0) return 1;
13387   return 0;
13388 }
13389
13390 static int test_mkdir_p_4 (void)
13391 {
13392   if (test_mkdir_p_4_skip ()) {
13393     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13394     return 0;
13395   }
13396
13397   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13398   {
13399     char device[] = "/dev/sda";
13400     int r;
13401     suppress_error = 0;
13402     r = guestfs_blockdev_setrw (g, device);
13403     if (r == -1)
13404       return -1;
13405   }
13406   {
13407     int r;
13408     suppress_error = 0;
13409     r = guestfs_umount_all (g);
13410     if (r == -1)
13411       return -1;
13412   }
13413   {
13414     int r;
13415     suppress_error = 0;
13416     r = guestfs_lvm_remove_all (g);
13417     if (r == -1)
13418       return -1;
13419   }
13420   {
13421     char device[] = "/dev/sda";
13422     char lines_0[] = ",";
13423     char *lines[] = {
13424       lines_0,
13425       NULL
13426     };
13427     int r;
13428     suppress_error = 0;
13429     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13430     if (r == -1)
13431       return -1;
13432   }
13433   {
13434     char fstype[] = "ext2";
13435     char device[] = "/dev/sda1";
13436     int r;
13437     suppress_error = 0;
13438     r = guestfs_mkfs (g, fstype, device);
13439     if (r == -1)
13440       return -1;
13441   }
13442   {
13443     char device[] = "/dev/sda1";
13444     char mountpoint[] = "/";
13445     int r;
13446     suppress_error = 0;
13447     r = guestfs_mount (g, device, mountpoint);
13448     if (r == -1)
13449       return -1;
13450   }
13451   /* TestLastFail for mkdir_p (4) */
13452   {
13453     char path[] = "/new";
13454     int r;
13455     suppress_error = 0;
13456     r = guestfs_touch (g, path);
13457     if (r == -1)
13458       return -1;
13459   }
13460   {
13461     char path[] = "/new";
13462     int r;
13463     suppress_error = 1;
13464     r = guestfs_mkdir_p (g, path);
13465     if (r != -1)
13466       return -1;
13467   }
13468   return 0;
13469 }
13470
13471 static int test_mkdir_0_skip (void)
13472 {
13473   const char *str;
13474
13475   str = getenv ("SKIP_TEST_MKDIR_0");
13476   if (str && strcmp (str, "1") == 0) return 1;
13477   str = getenv ("SKIP_TEST_MKDIR");
13478   if (str && strcmp (str, "1") == 0) return 1;
13479   return 0;
13480 }
13481
13482 static int test_mkdir_0 (void)
13483 {
13484   if (test_mkdir_0_skip ()) {
13485     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13486     return 0;
13487   }
13488
13489   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13490   {
13491     char device[] = "/dev/sda";
13492     int r;
13493     suppress_error = 0;
13494     r = guestfs_blockdev_setrw (g, device);
13495     if (r == -1)
13496       return -1;
13497   }
13498   {
13499     int r;
13500     suppress_error = 0;
13501     r = guestfs_umount_all (g);
13502     if (r == -1)
13503       return -1;
13504   }
13505   {
13506     int r;
13507     suppress_error = 0;
13508     r = guestfs_lvm_remove_all (g);
13509     if (r == -1)
13510       return -1;
13511   }
13512   {
13513     char device[] = "/dev/sda";
13514     char lines_0[] = ",";
13515     char *lines[] = {
13516       lines_0,
13517       NULL
13518     };
13519     int r;
13520     suppress_error = 0;
13521     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13522     if (r == -1)
13523       return -1;
13524   }
13525   {
13526     char fstype[] = "ext2";
13527     char device[] = "/dev/sda1";
13528     int r;
13529     suppress_error = 0;
13530     r = guestfs_mkfs (g, fstype, device);
13531     if (r == -1)
13532       return -1;
13533   }
13534   {
13535     char device[] = "/dev/sda1";
13536     char mountpoint[] = "/";
13537     int r;
13538     suppress_error = 0;
13539     r = guestfs_mount (g, device, mountpoint);
13540     if (r == -1)
13541       return -1;
13542   }
13543   /* TestOutputTrue for mkdir (0) */
13544   {
13545     char path[] = "/new";
13546     int r;
13547     suppress_error = 0;
13548     r = guestfs_mkdir (g, path);
13549     if (r == -1)
13550       return -1;
13551   }
13552   {
13553     char path[] = "/new";
13554     int r;
13555     suppress_error = 0;
13556     r = guestfs_is_dir (g, path);
13557     if (r == -1)
13558       return -1;
13559     if (!r) {
13560       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13561       return -1;
13562     }
13563   }
13564   return 0;
13565 }
13566
13567 static int test_mkdir_1_skip (void)
13568 {
13569   const char *str;
13570
13571   str = getenv ("SKIP_TEST_MKDIR_1");
13572   if (str && strcmp (str, "1") == 0) return 1;
13573   str = getenv ("SKIP_TEST_MKDIR");
13574   if (str && strcmp (str, "1") == 0) return 1;
13575   return 0;
13576 }
13577
13578 static int test_mkdir_1 (void)
13579 {
13580   if (test_mkdir_1_skip ()) {
13581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13582     return 0;
13583   }
13584
13585   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13586   {
13587     char device[] = "/dev/sda";
13588     int r;
13589     suppress_error = 0;
13590     r = guestfs_blockdev_setrw (g, device);
13591     if (r == -1)
13592       return -1;
13593   }
13594   {
13595     int r;
13596     suppress_error = 0;
13597     r = guestfs_umount_all (g);
13598     if (r == -1)
13599       return -1;
13600   }
13601   {
13602     int r;
13603     suppress_error = 0;
13604     r = guestfs_lvm_remove_all (g);
13605     if (r == -1)
13606       return -1;
13607   }
13608   {
13609     char device[] = "/dev/sda";
13610     char lines_0[] = ",";
13611     char *lines[] = {
13612       lines_0,
13613       NULL
13614     };
13615     int r;
13616     suppress_error = 0;
13617     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13618     if (r == -1)
13619       return -1;
13620   }
13621   {
13622     char fstype[] = "ext2";
13623     char device[] = "/dev/sda1";
13624     int r;
13625     suppress_error = 0;
13626     r = guestfs_mkfs (g, fstype, device);
13627     if (r == -1)
13628       return -1;
13629   }
13630   {
13631     char device[] = "/dev/sda1";
13632     char mountpoint[] = "/";
13633     int r;
13634     suppress_error = 0;
13635     r = guestfs_mount (g, device, mountpoint);
13636     if (r == -1)
13637       return -1;
13638   }
13639   /* TestLastFail for mkdir (1) */
13640   {
13641     char path[] = "/new/foo/bar";
13642     int r;
13643     suppress_error = 1;
13644     r = guestfs_mkdir (g, path);
13645     if (r != -1)
13646       return -1;
13647   }
13648   return 0;
13649 }
13650
13651 static int test_rm_rf_0_skip (void)
13652 {
13653   const char *str;
13654
13655   str = getenv ("SKIP_TEST_RM_RF_0");
13656   if (str && strcmp (str, "1") == 0) return 1;
13657   str = getenv ("SKIP_TEST_RM_RF");
13658   if (str && strcmp (str, "1") == 0) return 1;
13659   return 0;
13660 }
13661
13662 static int test_rm_rf_0 (void)
13663 {
13664   if (test_rm_rf_0_skip ()) {
13665     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13666     return 0;
13667   }
13668
13669   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13670   {
13671     char device[] = "/dev/sda";
13672     int r;
13673     suppress_error = 0;
13674     r = guestfs_blockdev_setrw (g, device);
13675     if (r == -1)
13676       return -1;
13677   }
13678   {
13679     int r;
13680     suppress_error = 0;
13681     r = guestfs_umount_all (g);
13682     if (r == -1)
13683       return -1;
13684   }
13685   {
13686     int r;
13687     suppress_error = 0;
13688     r = guestfs_lvm_remove_all (g);
13689     if (r == -1)
13690       return -1;
13691   }
13692   {
13693     char device[] = "/dev/sda";
13694     char lines_0[] = ",";
13695     char *lines[] = {
13696       lines_0,
13697       NULL
13698     };
13699     int r;
13700     suppress_error = 0;
13701     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13702     if (r == -1)
13703       return -1;
13704   }
13705   {
13706     char fstype[] = "ext2";
13707     char device[] = "/dev/sda1";
13708     int r;
13709     suppress_error = 0;
13710     r = guestfs_mkfs (g, fstype, device);
13711     if (r == -1)
13712       return -1;
13713   }
13714   {
13715     char device[] = "/dev/sda1";
13716     char mountpoint[] = "/";
13717     int r;
13718     suppress_error = 0;
13719     r = guestfs_mount (g, device, mountpoint);
13720     if (r == -1)
13721       return -1;
13722   }
13723   /* TestOutputFalse for rm_rf (0) */
13724   {
13725     char path[] = "/new";
13726     int r;
13727     suppress_error = 0;
13728     r = guestfs_mkdir (g, path);
13729     if (r == -1)
13730       return -1;
13731   }
13732   {
13733     char path[] = "/new/foo";
13734     int r;
13735     suppress_error = 0;
13736     r = guestfs_mkdir (g, path);
13737     if (r == -1)
13738       return -1;
13739   }
13740   {
13741     char path[] = "/new/foo/bar";
13742     int r;
13743     suppress_error = 0;
13744     r = guestfs_touch (g, path);
13745     if (r == -1)
13746       return -1;
13747   }
13748   {
13749     char path[] = "/new";
13750     int r;
13751     suppress_error = 0;
13752     r = guestfs_rm_rf (g, path);
13753     if (r == -1)
13754       return -1;
13755   }
13756   {
13757     char path[] = "/new";
13758     int r;
13759     suppress_error = 0;
13760     r = guestfs_exists (g, path);
13761     if (r == -1)
13762       return -1;
13763     if (r) {
13764       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13765       return -1;
13766     }
13767   }
13768   return 0;
13769 }
13770
13771 static int test_rmdir_0_skip (void)
13772 {
13773   const char *str;
13774
13775   str = getenv ("SKIP_TEST_RMDIR_0");
13776   if (str && strcmp (str, "1") == 0) return 1;
13777   str = getenv ("SKIP_TEST_RMDIR");
13778   if (str && strcmp (str, "1") == 0) return 1;
13779   return 0;
13780 }
13781
13782 static int test_rmdir_0 (void)
13783 {
13784   if (test_rmdir_0_skip ()) {
13785     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13786     return 0;
13787   }
13788
13789   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13790   {
13791     char device[] = "/dev/sda";
13792     int r;
13793     suppress_error = 0;
13794     r = guestfs_blockdev_setrw (g, device);
13795     if (r == -1)
13796       return -1;
13797   }
13798   {
13799     int r;
13800     suppress_error = 0;
13801     r = guestfs_umount_all (g);
13802     if (r == -1)
13803       return -1;
13804   }
13805   {
13806     int r;
13807     suppress_error = 0;
13808     r = guestfs_lvm_remove_all (g);
13809     if (r == -1)
13810       return -1;
13811   }
13812   {
13813     char device[] = "/dev/sda";
13814     char lines_0[] = ",";
13815     char *lines[] = {
13816       lines_0,
13817       NULL
13818     };
13819     int r;
13820     suppress_error = 0;
13821     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13822     if (r == -1)
13823       return -1;
13824   }
13825   {
13826     char fstype[] = "ext2";
13827     char device[] = "/dev/sda1";
13828     int r;
13829     suppress_error = 0;
13830     r = guestfs_mkfs (g, fstype, device);
13831     if (r == -1)
13832       return -1;
13833   }
13834   {
13835     char device[] = "/dev/sda1";
13836     char mountpoint[] = "/";
13837     int r;
13838     suppress_error = 0;
13839     r = guestfs_mount (g, device, mountpoint);
13840     if (r == -1)
13841       return -1;
13842   }
13843   /* TestRun for rmdir (0) */
13844   {
13845     char path[] = "/new";
13846     int r;
13847     suppress_error = 0;
13848     r = guestfs_mkdir (g, path);
13849     if (r == -1)
13850       return -1;
13851   }
13852   {
13853     char path[] = "/new";
13854     int r;
13855     suppress_error = 0;
13856     r = guestfs_rmdir (g, path);
13857     if (r == -1)
13858       return -1;
13859   }
13860   return 0;
13861 }
13862
13863 static int test_rmdir_1_skip (void)
13864 {
13865   const char *str;
13866
13867   str = getenv ("SKIP_TEST_RMDIR_1");
13868   if (str && strcmp (str, "1") == 0) return 1;
13869   str = getenv ("SKIP_TEST_RMDIR");
13870   if (str && strcmp (str, "1") == 0) return 1;
13871   return 0;
13872 }
13873
13874 static int test_rmdir_1 (void)
13875 {
13876   if (test_rmdir_1_skip ()) {
13877     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13878     return 0;
13879   }
13880
13881   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13882   {
13883     char device[] = "/dev/sda";
13884     int r;
13885     suppress_error = 0;
13886     r = guestfs_blockdev_setrw (g, device);
13887     if (r == -1)
13888       return -1;
13889   }
13890   {
13891     int r;
13892     suppress_error = 0;
13893     r = guestfs_umount_all (g);
13894     if (r == -1)
13895       return -1;
13896   }
13897   {
13898     int r;
13899     suppress_error = 0;
13900     r = guestfs_lvm_remove_all (g);
13901     if (r == -1)
13902       return -1;
13903   }
13904   {
13905     char device[] = "/dev/sda";
13906     char lines_0[] = ",";
13907     char *lines[] = {
13908       lines_0,
13909       NULL
13910     };
13911     int r;
13912     suppress_error = 0;
13913     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13914     if (r == -1)
13915       return -1;
13916   }
13917   {
13918     char fstype[] = "ext2";
13919     char device[] = "/dev/sda1";
13920     int r;
13921     suppress_error = 0;
13922     r = guestfs_mkfs (g, fstype, device);
13923     if (r == -1)
13924       return -1;
13925   }
13926   {
13927     char device[] = "/dev/sda1";
13928     char mountpoint[] = "/";
13929     int r;
13930     suppress_error = 0;
13931     r = guestfs_mount (g, device, mountpoint);
13932     if (r == -1)
13933       return -1;
13934   }
13935   /* TestLastFail for rmdir (1) */
13936   {
13937     char path[] = "/new";
13938     int r;
13939     suppress_error = 1;
13940     r = guestfs_rmdir (g, path);
13941     if (r != -1)
13942       return -1;
13943   }
13944   return 0;
13945 }
13946
13947 static int test_rmdir_2_skip (void)
13948 {
13949   const char *str;
13950
13951   str = getenv ("SKIP_TEST_RMDIR_2");
13952   if (str && strcmp (str, "1") == 0) return 1;
13953   str = getenv ("SKIP_TEST_RMDIR");
13954   if (str && strcmp (str, "1") == 0) return 1;
13955   return 0;
13956 }
13957
13958 static int test_rmdir_2 (void)
13959 {
13960   if (test_rmdir_2_skip ()) {
13961     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13962     return 0;
13963   }
13964
13965   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13966   {
13967     char device[] = "/dev/sda";
13968     int r;
13969     suppress_error = 0;
13970     r = guestfs_blockdev_setrw (g, device);
13971     if (r == -1)
13972       return -1;
13973   }
13974   {
13975     int r;
13976     suppress_error = 0;
13977     r = guestfs_umount_all (g);
13978     if (r == -1)
13979       return -1;
13980   }
13981   {
13982     int r;
13983     suppress_error = 0;
13984     r = guestfs_lvm_remove_all (g);
13985     if (r == -1)
13986       return -1;
13987   }
13988   {
13989     char device[] = "/dev/sda";
13990     char lines_0[] = ",";
13991     char *lines[] = {
13992       lines_0,
13993       NULL
13994     };
13995     int r;
13996     suppress_error = 0;
13997     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13998     if (r == -1)
13999       return -1;
14000   }
14001   {
14002     char fstype[] = "ext2";
14003     char device[] = "/dev/sda1";
14004     int r;
14005     suppress_error = 0;
14006     r = guestfs_mkfs (g, fstype, device);
14007     if (r == -1)
14008       return -1;
14009   }
14010   {
14011     char device[] = "/dev/sda1";
14012     char mountpoint[] = "/";
14013     int r;
14014     suppress_error = 0;
14015     r = guestfs_mount (g, device, mountpoint);
14016     if (r == -1)
14017       return -1;
14018   }
14019   /* TestLastFail for rmdir (2) */
14020   {
14021     char path[] = "/new";
14022     int r;
14023     suppress_error = 0;
14024     r = guestfs_touch (g, path);
14025     if (r == -1)
14026       return -1;
14027   }
14028   {
14029     char path[] = "/new";
14030     int r;
14031     suppress_error = 1;
14032     r = guestfs_rmdir (g, path);
14033     if (r != -1)
14034       return -1;
14035   }
14036   return 0;
14037 }
14038
14039 static int test_rm_0_skip (void)
14040 {
14041   const char *str;
14042
14043   str = getenv ("SKIP_TEST_RM_0");
14044   if (str && strcmp (str, "1") == 0) return 1;
14045   str = getenv ("SKIP_TEST_RM");
14046   if (str && strcmp (str, "1") == 0) return 1;
14047   return 0;
14048 }
14049
14050 static int test_rm_0 (void)
14051 {
14052   if (test_rm_0_skip ()) {
14053     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
14054     return 0;
14055   }
14056
14057   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
14058   {
14059     char device[] = "/dev/sda";
14060     int r;
14061     suppress_error = 0;
14062     r = guestfs_blockdev_setrw (g, device);
14063     if (r == -1)
14064       return -1;
14065   }
14066   {
14067     int r;
14068     suppress_error = 0;
14069     r = guestfs_umount_all (g);
14070     if (r == -1)
14071       return -1;
14072   }
14073   {
14074     int r;
14075     suppress_error = 0;
14076     r = guestfs_lvm_remove_all (g);
14077     if (r == -1)
14078       return -1;
14079   }
14080   {
14081     char device[] = "/dev/sda";
14082     char lines_0[] = ",";
14083     char *lines[] = {
14084       lines_0,
14085       NULL
14086     };
14087     int r;
14088     suppress_error = 0;
14089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14090     if (r == -1)
14091       return -1;
14092   }
14093   {
14094     char fstype[] = "ext2";
14095     char device[] = "/dev/sda1";
14096     int r;
14097     suppress_error = 0;
14098     r = guestfs_mkfs (g, fstype, device);
14099     if (r == -1)
14100       return -1;
14101   }
14102   {
14103     char device[] = "/dev/sda1";
14104     char mountpoint[] = "/";
14105     int r;
14106     suppress_error = 0;
14107     r = guestfs_mount (g, device, mountpoint);
14108     if (r == -1)
14109       return -1;
14110   }
14111   /* TestRun for rm (0) */
14112   {
14113     char path[] = "/new";
14114     int r;
14115     suppress_error = 0;
14116     r = guestfs_touch (g, path);
14117     if (r == -1)
14118       return -1;
14119   }
14120   {
14121     char path[] = "/new";
14122     int r;
14123     suppress_error = 0;
14124     r = guestfs_rm (g, path);
14125     if (r == -1)
14126       return -1;
14127   }
14128   return 0;
14129 }
14130
14131 static int test_rm_1_skip (void)
14132 {
14133   const char *str;
14134
14135   str = getenv ("SKIP_TEST_RM_1");
14136   if (str && strcmp (str, "1") == 0) return 1;
14137   str = getenv ("SKIP_TEST_RM");
14138   if (str && strcmp (str, "1") == 0) return 1;
14139   return 0;
14140 }
14141
14142 static int test_rm_1 (void)
14143 {
14144   if (test_rm_1_skip ()) {
14145     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
14146     return 0;
14147   }
14148
14149   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14150   {
14151     char device[] = "/dev/sda";
14152     int r;
14153     suppress_error = 0;
14154     r = guestfs_blockdev_setrw (g, device);
14155     if (r == -1)
14156       return -1;
14157   }
14158   {
14159     int r;
14160     suppress_error = 0;
14161     r = guestfs_umount_all (g);
14162     if (r == -1)
14163       return -1;
14164   }
14165   {
14166     int r;
14167     suppress_error = 0;
14168     r = guestfs_lvm_remove_all (g);
14169     if (r == -1)
14170       return -1;
14171   }
14172   {
14173     char device[] = "/dev/sda";
14174     char lines_0[] = ",";
14175     char *lines[] = {
14176       lines_0,
14177       NULL
14178     };
14179     int r;
14180     suppress_error = 0;
14181     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14182     if (r == -1)
14183       return -1;
14184   }
14185   {
14186     char fstype[] = "ext2";
14187     char device[] = "/dev/sda1";
14188     int r;
14189     suppress_error = 0;
14190     r = guestfs_mkfs (g, fstype, device);
14191     if (r == -1)
14192       return -1;
14193   }
14194   {
14195     char device[] = "/dev/sda1";
14196     char mountpoint[] = "/";
14197     int r;
14198     suppress_error = 0;
14199     r = guestfs_mount (g, device, mountpoint);
14200     if (r == -1)
14201       return -1;
14202   }
14203   /* TestLastFail for rm (1) */
14204   {
14205     char path[] = "/new";
14206     int r;
14207     suppress_error = 1;
14208     r = guestfs_rm (g, path);
14209     if (r != -1)
14210       return -1;
14211   }
14212   return 0;
14213 }
14214
14215 static int test_rm_2_skip (void)
14216 {
14217   const char *str;
14218
14219   str = getenv ("SKIP_TEST_RM_2");
14220   if (str && strcmp (str, "1") == 0) return 1;
14221   str = getenv ("SKIP_TEST_RM");
14222   if (str && strcmp (str, "1") == 0) return 1;
14223   return 0;
14224 }
14225
14226 static int test_rm_2 (void)
14227 {
14228   if (test_rm_2_skip ()) {
14229     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
14230     return 0;
14231   }
14232
14233   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
14234   {
14235     char device[] = "/dev/sda";
14236     int r;
14237     suppress_error = 0;
14238     r = guestfs_blockdev_setrw (g, device);
14239     if (r == -1)
14240       return -1;
14241   }
14242   {
14243     int r;
14244     suppress_error = 0;
14245     r = guestfs_umount_all (g);
14246     if (r == -1)
14247       return -1;
14248   }
14249   {
14250     int r;
14251     suppress_error = 0;
14252     r = guestfs_lvm_remove_all (g);
14253     if (r == -1)
14254       return -1;
14255   }
14256   {
14257     char device[] = "/dev/sda";
14258     char lines_0[] = ",";
14259     char *lines[] = {
14260       lines_0,
14261       NULL
14262     };
14263     int r;
14264     suppress_error = 0;
14265     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14266     if (r == -1)
14267       return -1;
14268   }
14269   {
14270     char fstype[] = "ext2";
14271     char device[] = "/dev/sda1";
14272     int r;
14273     suppress_error = 0;
14274     r = guestfs_mkfs (g, fstype, device);
14275     if (r == -1)
14276       return -1;
14277   }
14278   {
14279     char device[] = "/dev/sda1";
14280     char mountpoint[] = "/";
14281     int r;
14282     suppress_error = 0;
14283     r = guestfs_mount (g, device, mountpoint);
14284     if (r == -1)
14285       return -1;
14286   }
14287   /* TestLastFail for rm (2) */
14288   {
14289     char path[] = "/new";
14290     int r;
14291     suppress_error = 0;
14292     r = guestfs_mkdir (g, path);
14293     if (r == -1)
14294       return -1;
14295   }
14296   {
14297     char path[] = "/new";
14298     int r;
14299     suppress_error = 1;
14300     r = guestfs_rm (g, path);
14301     if (r != -1)
14302       return -1;
14303   }
14304   return 0;
14305 }
14306
14307 static int test_read_lines_0_skip (void)
14308 {
14309   const char *str;
14310
14311   str = getenv ("SKIP_TEST_READ_LINES_0");
14312   if (str && strcmp (str, "1") == 0) return 1;
14313   str = getenv ("SKIP_TEST_READ_LINES");
14314   if (str && strcmp (str, "1") == 0) return 1;
14315   return 0;
14316 }
14317
14318 static int test_read_lines_0 (void)
14319 {
14320   if (test_read_lines_0_skip ()) {
14321     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14322     return 0;
14323   }
14324
14325   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14326   {
14327     char device[] = "/dev/sda";
14328     int r;
14329     suppress_error = 0;
14330     r = guestfs_blockdev_setrw (g, device);
14331     if (r == -1)
14332       return -1;
14333   }
14334   {
14335     int r;
14336     suppress_error = 0;
14337     r = guestfs_umount_all (g);
14338     if (r == -1)
14339       return -1;
14340   }
14341   {
14342     int r;
14343     suppress_error = 0;
14344     r = guestfs_lvm_remove_all (g);
14345     if (r == -1)
14346       return -1;
14347   }
14348   {
14349     char device[] = "/dev/sda";
14350     char lines_0[] = ",";
14351     char *lines[] = {
14352       lines_0,
14353       NULL
14354     };
14355     int r;
14356     suppress_error = 0;
14357     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14358     if (r == -1)
14359       return -1;
14360   }
14361   {
14362     char fstype[] = "ext2";
14363     char device[] = "/dev/sda1";
14364     int r;
14365     suppress_error = 0;
14366     r = guestfs_mkfs (g, fstype, device);
14367     if (r == -1)
14368       return -1;
14369   }
14370   {
14371     char device[] = "/dev/sda1";
14372     char mountpoint[] = "/";
14373     int r;
14374     suppress_error = 0;
14375     r = guestfs_mount (g, device, mountpoint);
14376     if (r == -1)
14377       return -1;
14378   }
14379   /* TestOutputList for read_lines (0) */
14380   {
14381     char path[] = "/new";
14382     char content[] = "line1\r\nline2\nline3";
14383     int r;
14384     suppress_error = 0;
14385     r = guestfs_write_file (g, path, content, 0);
14386     if (r == -1)
14387       return -1;
14388   }
14389   {
14390     char path[] = "/new";
14391     char **r;
14392     int i;
14393     suppress_error = 0;
14394     r = guestfs_read_lines (g, path);
14395     if (r == NULL)
14396       return -1;
14397     if (!r[0]) {
14398       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14399       print_strings (r);
14400       return -1;
14401     }
14402     {
14403       char expected[] = "line1";
14404       if (strcmp (r[0], expected) != 0) {
14405         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14406         return -1;
14407       }
14408     }
14409     if (!r[1]) {
14410       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14411       print_strings (r);
14412       return -1;
14413     }
14414     {
14415       char expected[] = "line2";
14416       if (strcmp (r[1], expected) != 0) {
14417         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14418         return -1;
14419       }
14420     }
14421     if (!r[2]) {
14422       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14423       print_strings (r);
14424       return -1;
14425     }
14426     {
14427       char expected[] = "line3";
14428       if (strcmp (r[2], expected) != 0) {
14429         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14430         return -1;
14431       }
14432     }
14433     if (r[3] != NULL) {
14434       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14435       print_strings (r);
14436       return -1;
14437     }
14438     for (i = 0; r[i] != NULL; ++i)
14439       free (r[i]);
14440     free (r);
14441   }
14442   return 0;
14443 }
14444
14445 static int test_read_lines_1_skip (void)
14446 {
14447   const char *str;
14448
14449   str = getenv ("SKIP_TEST_READ_LINES_1");
14450   if (str && strcmp (str, "1") == 0) return 1;
14451   str = getenv ("SKIP_TEST_READ_LINES");
14452   if (str && strcmp (str, "1") == 0) return 1;
14453   return 0;
14454 }
14455
14456 static int test_read_lines_1 (void)
14457 {
14458   if (test_read_lines_1_skip ()) {
14459     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14460     return 0;
14461   }
14462
14463   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14464   {
14465     char device[] = "/dev/sda";
14466     int r;
14467     suppress_error = 0;
14468     r = guestfs_blockdev_setrw (g, device);
14469     if (r == -1)
14470       return -1;
14471   }
14472   {
14473     int r;
14474     suppress_error = 0;
14475     r = guestfs_umount_all (g);
14476     if (r == -1)
14477       return -1;
14478   }
14479   {
14480     int r;
14481     suppress_error = 0;
14482     r = guestfs_lvm_remove_all (g);
14483     if (r == -1)
14484       return -1;
14485   }
14486   {
14487     char device[] = "/dev/sda";
14488     char lines_0[] = ",";
14489     char *lines[] = {
14490       lines_0,
14491       NULL
14492     };
14493     int r;
14494     suppress_error = 0;
14495     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14496     if (r == -1)
14497       return -1;
14498   }
14499   {
14500     char fstype[] = "ext2";
14501     char device[] = "/dev/sda1";
14502     int r;
14503     suppress_error = 0;
14504     r = guestfs_mkfs (g, fstype, device);
14505     if (r == -1)
14506       return -1;
14507   }
14508   {
14509     char device[] = "/dev/sda1";
14510     char mountpoint[] = "/";
14511     int r;
14512     suppress_error = 0;
14513     r = guestfs_mount (g, device, mountpoint);
14514     if (r == -1)
14515       return -1;
14516   }
14517   /* TestOutputList for read_lines (1) */
14518   {
14519     char path[] = "/new";
14520     char content[] = "";
14521     int r;
14522     suppress_error = 0;
14523     r = guestfs_write_file (g, path, content, 0);
14524     if (r == -1)
14525       return -1;
14526   }
14527   {
14528     char path[] = "/new";
14529     char **r;
14530     int i;
14531     suppress_error = 0;
14532     r = guestfs_read_lines (g, path);
14533     if (r == NULL)
14534       return -1;
14535     if (r[0] != NULL) {
14536       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14537       print_strings (r);
14538       return -1;
14539     }
14540     for (i = 0; r[i] != NULL; ++i)
14541       free (r[i]);
14542     free (r);
14543   }
14544   return 0;
14545 }
14546
14547 static int test_lvs_0_skip (void)
14548 {
14549   const char *str;
14550
14551   str = getenv ("SKIP_TEST_LVS_0");
14552   if (str && strcmp (str, "1") == 0) return 1;
14553   str = getenv ("SKIP_TEST_LVS");
14554   if (str && strcmp (str, "1") == 0) return 1;
14555   return 0;
14556 }
14557
14558 static int test_lvs_0 (void)
14559 {
14560   if (test_lvs_0_skip ()) {
14561     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14562     return 0;
14563   }
14564
14565   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14566   {
14567     char device[] = "/dev/sda";
14568     int r;
14569     suppress_error = 0;
14570     r = guestfs_blockdev_setrw (g, device);
14571     if (r == -1)
14572       return -1;
14573   }
14574   {
14575     int r;
14576     suppress_error = 0;
14577     r = guestfs_umount_all (g);
14578     if (r == -1)
14579       return -1;
14580   }
14581   {
14582     int r;
14583     suppress_error = 0;
14584     r = guestfs_lvm_remove_all (g);
14585     if (r == -1)
14586       return -1;
14587   }
14588   {
14589     char device[] = "/dev/sda";
14590     char lines_0[] = ",";
14591     char *lines[] = {
14592       lines_0,
14593       NULL
14594     };
14595     int r;
14596     suppress_error = 0;
14597     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14598     if (r == -1)
14599       return -1;
14600   }
14601   {
14602     char device[] = "/dev/sda1";
14603     int r;
14604     suppress_error = 0;
14605     r = guestfs_pvcreate (g, device);
14606     if (r == -1)
14607       return -1;
14608   }
14609   {
14610     char volgroup[] = "VG";
14611     char physvols_0[] = "/dev/sda1";
14612     char *physvols[] = {
14613       physvols_0,
14614       NULL
14615     };
14616     int r;
14617     suppress_error = 0;
14618     r = guestfs_vgcreate (g, volgroup, physvols);
14619     if (r == -1)
14620       return -1;
14621   }
14622   {
14623     char logvol[] = "LV";
14624     char volgroup[] = "VG";
14625     int r;
14626     suppress_error = 0;
14627     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14628     if (r == -1)
14629       return -1;
14630   }
14631   {
14632     char fstype[] = "ext2";
14633     char device[] = "/dev/VG/LV";
14634     int r;
14635     suppress_error = 0;
14636     r = guestfs_mkfs (g, fstype, device);
14637     if (r == -1)
14638       return -1;
14639   }
14640   {
14641     char device[] = "/dev/VG/LV";
14642     char mountpoint[] = "/";
14643     int r;
14644     suppress_error = 0;
14645     r = guestfs_mount (g, device, mountpoint);
14646     if (r == -1)
14647       return -1;
14648   }
14649   /* TestOutputList for lvs (0) */
14650   {
14651     char **r;
14652     int i;
14653     suppress_error = 0;
14654     r = guestfs_lvs (g);
14655     if (r == NULL)
14656       return -1;
14657     if (!r[0]) {
14658       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14659       print_strings (r);
14660       return -1;
14661     }
14662     {
14663       char expected[] = "/dev/VG/LV";
14664       if (strcmp (r[0], expected) != 0) {
14665         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14666         return -1;
14667       }
14668     }
14669     if (r[1] != NULL) {
14670       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14671       print_strings (r);
14672       return -1;
14673     }
14674     for (i = 0; r[i] != NULL; ++i)
14675       free (r[i]);
14676     free (r);
14677   }
14678   return 0;
14679 }
14680
14681 static int test_lvs_1_skip (void)
14682 {
14683   const char *str;
14684
14685   str = getenv ("SKIP_TEST_LVS_1");
14686   if (str && strcmp (str, "1") == 0) return 1;
14687   str = getenv ("SKIP_TEST_LVS");
14688   if (str && strcmp (str, "1") == 0) return 1;
14689   return 0;
14690 }
14691
14692 static int test_lvs_1 (void)
14693 {
14694   if (test_lvs_1_skip ()) {
14695     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14696     return 0;
14697   }
14698
14699   /* InitNone|InitEmpty for test_lvs_1 */
14700   {
14701     char device[] = "/dev/sda";
14702     int r;
14703     suppress_error = 0;
14704     r = guestfs_blockdev_setrw (g, device);
14705     if (r == -1)
14706       return -1;
14707   }
14708   {
14709     int r;
14710     suppress_error = 0;
14711     r = guestfs_umount_all (g);
14712     if (r == -1)
14713       return -1;
14714   }
14715   {
14716     int r;
14717     suppress_error = 0;
14718     r = guestfs_lvm_remove_all (g);
14719     if (r == -1)
14720       return -1;
14721   }
14722   /* TestOutputList for lvs (1) */
14723   {
14724     char device[] = "/dev/sda";
14725     char lines_0[] = ",10";
14726     char lines_1[] = ",20";
14727     char lines_2[] = ",";
14728     char *lines[] = {
14729       lines_0,
14730       lines_1,
14731       lines_2,
14732       NULL
14733     };
14734     int r;
14735     suppress_error = 0;
14736     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14737     if (r == -1)
14738       return -1;
14739   }
14740   {
14741     char device[] = "/dev/sda1";
14742     int r;
14743     suppress_error = 0;
14744     r = guestfs_pvcreate (g, device);
14745     if (r == -1)
14746       return -1;
14747   }
14748   {
14749     char device[] = "/dev/sda2";
14750     int r;
14751     suppress_error = 0;
14752     r = guestfs_pvcreate (g, device);
14753     if (r == -1)
14754       return -1;
14755   }
14756   {
14757     char device[] = "/dev/sda3";
14758     int r;
14759     suppress_error = 0;
14760     r = guestfs_pvcreate (g, device);
14761     if (r == -1)
14762       return -1;
14763   }
14764   {
14765     char volgroup[] = "VG1";
14766     char physvols_0[] = "/dev/sda1";
14767     char physvols_1[] = "/dev/sda2";
14768     char *physvols[] = {
14769       physvols_0,
14770       physvols_1,
14771       NULL
14772     };
14773     int r;
14774     suppress_error = 0;
14775     r = guestfs_vgcreate (g, volgroup, physvols);
14776     if (r == -1)
14777       return -1;
14778   }
14779   {
14780     char volgroup[] = "VG2";
14781     char physvols_0[] = "/dev/sda3";
14782     char *physvols[] = {
14783       physvols_0,
14784       NULL
14785     };
14786     int r;
14787     suppress_error = 0;
14788     r = guestfs_vgcreate (g, volgroup, physvols);
14789     if (r == -1)
14790       return -1;
14791   }
14792   {
14793     char logvol[] = "LV1";
14794     char volgroup[] = "VG1";
14795     int r;
14796     suppress_error = 0;
14797     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14798     if (r == -1)
14799       return -1;
14800   }
14801   {
14802     char logvol[] = "LV2";
14803     char volgroup[] = "VG1";
14804     int r;
14805     suppress_error = 0;
14806     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14807     if (r == -1)
14808       return -1;
14809   }
14810   {
14811     char logvol[] = "LV3";
14812     char volgroup[] = "VG2";
14813     int r;
14814     suppress_error = 0;
14815     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14816     if (r == -1)
14817       return -1;
14818   }
14819   {
14820     char **r;
14821     int i;
14822     suppress_error = 0;
14823     r = guestfs_lvs (g);
14824     if (r == NULL)
14825       return -1;
14826     if (!r[0]) {
14827       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14828       print_strings (r);
14829       return -1;
14830     }
14831     {
14832       char expected[] = "/dev/VG1/LV1";
14833       if (strcmp (r[0], expected) != 0) {
14834         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14835         return -1;
14836       }
14837     }
14838     if (!r[1]) {
14839       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14840       print_strings (r);
14841       return -1;
14842     }
14843     {
14844       char expected[] = "/dev/VG1/LV2";
14845       if (strcmp (r[1], expected) != 0) {
14846         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14847         return -1;
14848       }
14849     }
14850     if (!r[2]) {
14851       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14852       print_strings (r);
14853       return -1;
14854     }
14855     {
14856       char expected[] = "/dev/VG2/LV3";
14857       if (strcmp (r[2], expected) != 0) {
14858         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14859         return -1;
14860       }
14861     }
14862     if (r[3] != NULL) {
14863       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14864       print_strings (r);
14865       return -1;
14866     }
14867     for (i = 0; r[i] != NULL; ++i)
14868       free (r[i]);
14869     free (r);
14870   }
14871   return 0;
14872 }
14873
14874 static int test_vgs_0_skip (void)
14875 {
14876   const char *str;
14877
14878   str = getenv ("SKIP_TEST_VGS_0");
14879   if (str && strcmp (str, "1") == 0) return 1;
14880   str = getenv ("SKIP_TEST_VGS");
14881   if (str && strcmp (str, "1") == 0) return 1;
14882   return 0;
14883 }
14884
14885 static int test_vgs_0 (void)
14886 {
14887   if (test_vgs_0_skip ()) {
14888     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14889     return 0;
14890   }
14891
14892   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14893   {
14894     char device[] = "/dev/sda";
14895     int r;
14896     suppress_error = 0;
14897     r = guestfs_blockdev_setrw (g, device);
14898     if (r == -1)
14899       return -1;
14900   }
14901   {
14902     int r;
14903     suppress_error = 0;
14904     r = guestfs_umount_all (g);
14905     if (r == -1)
14906       return -1;
14907   }
14908   {
14909     int r;
14910     suppress_error = 0;
14911     r = guestfs_lvm_remove_all (g);
14912     if (r == -1)
14913       return -1;
14914   }
14915   {
14916     char device[] = "/dev/sda";
14917     char lines_0[] = ",";
14918     char *lines[] = {
14919       lines_0,
14920       NULL
14921     };
14922     int r;
14923     suppress_error = 0;
14924     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14925     if (r == -1)
14926       return -1;
14927   }
14928   {
14929     char device[] = "/dev/sda1";
14930     int r;
14931     suppress_error = 0;
14932     r = guestfs_pvcreate (g, device);
14933     if (r == -1)
14934       return -1;
14935   }
14936   {
14937     char volgroup[] = "VG";
14938     char physvols_0[] = "/dev/sda1";
14939     char *physvols[] = {
14940       physvols_0,
14941       NULL
14942     };
14943     int r;
14944     suppress_error = 0;
14945     r = guestfs_vgcreate (g, volgroup, physvols);
14946     if (r == -1)
14947       return -1;
14948   }
14949   {
14950     char logvol[] = "LV";
14951     char volgroup[] = "VG";
14952     int r;
14953     suppress_error = 0;
14954     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14955     if (r == -1)
14956       return -1;
14957   }
14958   {
14959     char fstype[] = "ext2";
14960     char device[] = "/dev/VG/LV";
14961     int r;
14962     suppress_error = 0;
14963     r = guestfs_mkfs (g, fstype, device);
14964     if (r == -1)
14965       return -1;
14966   }
14967   {
14968     char device[] = "/dev/VG/LV";
14969     char mountpoint[] = "/";
14970     int r;
14971     suppress_error = 0;
14972     r = guestfs_mount (g, device, mountpoint);
14973     if (r == -1)
14974       return -1;
14975   }
14976   /* TestOutputList for vgs (0) */
14977   {
14978     char **r;
14979     int i;
14980     suppress_error = 0;
14981     r = guestfs_vgs (g);
14982     if (r == NULL)
14983       return -1;
14984     if (!r[0]) {
14985       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14986       print_strings (r);
14987       return -1;
14988     }
14989     {
14990       char expected[] = "VG";
14991       if (strcmp (r[0], expected) != 0) {
14992         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14993         return -1;
14994       }
14995     }
14996     if (r[1] != NULL) {
14997       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14998       print_strings (r);
14999       return -1;
15000     }
15001     for (i = 0; r[i] != NULL; ++i)
15002       free (r[i]);
15003     free (r);
15004   }
15005   return 0;
15006 }
15007
15008 static int test_vgs_1_skip (void)
15009 {
15010   const char *str;
15011
15012   str = getenv ("SKIP_TEST_VGS_1");
15013   if (str && strcmp (str, "1") == 0) return 1;
15014   str = getenv ("SKIP_TEST_VGS");
15015   if (str && strcmp (str, "1") == 0) return 1;
15016   return 0;
15017 }
15018
15019 static int test_vgs_1 (void)
15020 {
15021   if (test_vgs_1_skip ()) {
15022     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
15023     return 0;
15024   }
15025
15026   /* InitNone|InitEmpty for test_vgs_1 */
15027   {
15028     char device[] = "/dev/sda";
15029     int r;
15030     suppress_error = 0;
15031     r = guestfs_blockdev_setrw (g, device);
15032     if (r == -1)
15033       return -1;
15034   }
15035   {
15036     int r;
15037     suppress_error = 0;
15038     r = guestfs_umount_all (g);
15039     if (r == -1)
15040       return -1;
15041   }
15042   {
15043     int r;
15044     suppress_error = 0;
15045     r = guestfs_lvm_remove_all (g);
15046     if (r == -1)
15047       return -1;
15048   }
15049   /* TestOutputList for vgs (1) */
15050   {
15051     char device[] = "/dev/sda";
15052     char lines_0[] = ",10";
15053     char lines_1[] = ",20";
15054     char lines_2[] = ",";
15055     char *lines[] = {
15056       lines_0,
15057       lines_1,
15058       lines_2,
15059       NULL
15060     };
15061     int r;
15062     suppress_error = 0;
15063     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15064     if (r == -1)
15065       return -1;
15066   }
15067   {
15068     char device[] = "/dev/sda1";
15069     int r;
15070     suppress_error = 0;
15071     r = guestfs_pvcreate (g, device);
15072     if (r == -1)
15073       return -1;
15074   }
15075   {
15076     char device[] = "/dev/sda2";
15077     int r;
15078     suppress_error = 0;
15079     r = guestfs_pvcreate (g, device);
15080     if (r == -1)
15081       return -1;
15082   }
15083   {
15084     char device[] = "/dev/sda3";
15085     int r;
15086     suppress_error = 0;
15087     r = guestfs_pvcreate (g, device);
15088     if (r == -1)
15089       return -1;
15090   }
15091   {
15092     char volgroup[] = "VG1";
15093     char physvols_0[] = "/dev/sda1";
15094     char physvols_1[] = "/dev/sda2";
15095     char *physvols[] = {
15096       physvols_0,
15097       physvols_1,
15098       NULL
15099     };
15100     int r;
15101     suppress_error = 0;
15102     r = guestfs_vgcreate (g, volgroup, physvols);
15103     if (r == -1)
15104       return -1;
15105   }
15106   {
15107     char volgroup[] = "VG2";
15108     char physvols_0[] = "/dev/sda3";
15109     char *physvols[] = {
15110       physvols_0,
15111       NULL
15112     };
15113     int r;
15114     suppress_error = 0;
15115     r = guestfs_vgcreate (g, volgroup, physvols);
15116     if (r == -1)
15117       return -1;
15118   }
15119   {
15120     char **r;
15121     int i;
15122     suppress_error = 0;
15123     r = guestfs_vgs (g);
15124     if (r == NULL)
15125       return -1;
15126     if (!r[0]) {
15127       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15128       print_strings (r);
15129       return -1;
15130     }
15131     {
15132       char expected[] = "VG1";
15133       if (strcmp (r[0], expected) != 0) {
15134         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15135         return -1;
15136       }
15137     }
15138     if (!r[1]) {
15139       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15140       print_strings (r);
15141       return -1;
15142     }
15143     {
15144       char expected[] = "VG2";
15145       if (strcmp (r[1], expected) != 0) {
15146         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15147         return -1;
15148       }
15149     }
15150     if (r[2] != NULL) {
15151       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15152       print_strings (r);
15153       return -1;
15154     }
15155     for (i = 0; r[i] != NULL; ++i)
15156       free (r[i]);
15157     free (r);
15158   }
15159   return 0;
15160 }
15161
15162 static int test_pvs_0_skip (void)
15163 {
15164   const char *str;
15165
15166   str = getenv ("SKIP_TEST_PVS_0");
15167   if (str && strcmp (str, "1") == 0) return 1;
15168   str = getenv ("SKIP_TEST_PVS");
15169   if (str && strcmp (str, "1") == 0) return 1;
15170   return 0;
15171 }
15172
15173 static int test_pvs_0 (void)
15174 {
15175   if (test_pvs_0_skip ()) {
15176     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
15177     return 0;
15178   }
15179
15180   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
15181   {
15182     char device[] = "/dev/sda";
15183     int r;
15184     suppress_error = 0;
15185     r = guestfs_blockdev_setrw (g, device);
15186     if (r == -1)
15187       return -1;
15188   }
15189   {
15190     int r;
15191     suppress_error = 0;
15192     r = guestfs_umount_all (g);
15193     if (r == -1)
15194       return -1;
15195   }
15196   {
15197     int r;
15198     suppress_error = 0;
15199     r = guestfs_lvm_remove_all (g);
15200     if (r == -1)
15201       return -1;
15202   }
15203   {
15204     char device[] = "/dev/sda";
15205     char lines_0[] = ",";
15206     char *lines[] = {
15207       lines_0,
15208       NULL
15209     };
15210     int r;
15211     suppress_error = 0;
15212     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15213     if (r == -1)
15214       return -1;
15215   }
15216   {
15217     char device[] = "/dev/sda1";
15218     int r;
15219     suppress_error = 0;
15220     r = guestfs_pvcreate (g, device);
15221     if (r == -1)
15222       return -1;
15223   }
15224   {
15225     char volgroup[] = "VG";
15226     char physvols_0[] = "/dev/sda1";
15227     char *physvols[] = {
15228       physvols_0,
15229       NULL
15230     };
15231     int r;
15232     suppress_error = 0;
15233     r = guestfs_vgcreate (g, volgroup, physvols);
15234     if (r == -1)
15235       return -1;
15236   }
15237   {
15238     char logvol[] = "LV";
15239     char volgroup[] = "VG";
15240     int r;
15241     suppress_error = 0;
15242     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15243     if (r == -1)
15244       return -1;
15245   }
15246   {
15247     char fstype[] = "ext2";
15248     char device[] = "/dev/VG/LV";
15249     int r;
15250     suppress_error = 0;
15251     r = guestfs_mkfs (g, fstype, device);
15252     if (r == -1)
15253       return -1;
15254   }
15255   {
15256     char device[] = "/dev/VG/LV";
15257     char mountpoint[] = "/";
15258     int r;
15259     suppress_error = 0;
15260     r = guestfs_mount (g, device, mountpoint);
15261     if (r == -1)
15262       return -1;
15263   }
15264   /* TestOutputListOfDevices for pvs (0) */
15265   {
15266     char **r;
15267     int i;
15268     suppress_error = 0;
15269     r = guestfs_pvs (g);
15270     if (r == NULL)
15271       return -1;
15272     if (!r[0]) {
15273       fprintf (stderr, "test_pvs_0: short list returned from command\n");
15274       print_strings (r);
15275       return -1;
15276     }
15277     {
15278       char expected[] = "/dev/sda1";
15279       r[0][5] = 's';
15280       if (strcmp (r[0], expected) != 0) {
15281         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15282         return -1;
15283       }
15284     }
15285     if (r[1] != NULL) {
15286       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15287       print_strings (r);
15288       return -1;
15289     }
15290     for (i = 0; r[i] != NULL; ++i)
15291       free (r[i]);
15292     free (r);
15293   }
15294   return 0;
15295 }
15296
15297 static int test_pvs_1_skip (void)
15298 {
15299   const char *str;
15300
15301   str = getenv ("SKIP_TEST_PVS_1");
15302   if (str && strcmp (str, "1") == 0) return 1;
15303   str = getenv ("SKIP_TEST_PVS");
15304   if (str && strcmp (str, "1") == 0) return 1;
15305   return 0;
15306 }
15307
15308 static int test_pvs_1 (void)
15309 {
15310   if (test_pvs_1_skip ()) {
15311     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15312     return 0;
15313   }
15314
15315   /* InitNone|InitEmpty for test_pvs_1 */
15316   {
15317     char device[] = "/dev/sda";
15318     int r;
15319     suppress_error = 0;
15320     r = guestfs_blockdev_setrw (g, device);
15321     if (r == -1)
15322       return -1;
15323   }
15324   {
15325     int r;
15326     suppress_error = 0;
15327     r = guestfs_umount_all (g);
15328     if (r == -1)
15329       return -1;
15330   }
15331   {
15332     int r;
15333     suppress_error = 0;
15334     r = guestfs_lvm_remove_all (g);
15335     if (r == -1)
15336       return -1;
15337   }
15338   /* TestOutputListOfDevices for pvs (1) */
15339   {
15340     char device[] = "/dev/sda";
15341     char lines_0[] = ",10";
15342     char lines_1[] = ",20";
15343     char lines_2[] = ",";
15344     char *lines[] = {
15345       lines_0,
15346       lines_1,
15347       lines_2,
15348       NULL
15349     };
15350     int r;
15351     suppress_error = 0;
15352     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15353     if (r == -1)
15354       return -1;
15355   }
15356   {
15357     char device[] = "/dev/sda1";
15358     int r;
15359     suppress_error = 0;
15360     r = guestfs_pvcreate (g, device);
15361     if (r == -1)
15362       return -1;
15363   }
15364   {
15365     char device[] = "/dev/sda2";
15366     int r;
15367     suppress_error = 0;
15368     r = guestfs_pvcreate (g, device);
15369     if (r == -1)
15370       return -1;
15371   }
15372   {
15373     char device[] = "/dev/sda3";
15374     int r;
15375     suppress_error = 0;
15376     r = guestfs_pvcreate (g, device);
15377     if (r == -1)
15378       return -1;
15379   }
15380   {
15381     char **r;
15382     int i;
15383     suppress_error = 0;
15384     r = guestfs_pvs (g);
15385     if (r == NULL)
15386       return -1;
15387     if (!r[0]) {
15388       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15389       print_strings (r);
15390       return -1;
15391     }
15392     {
15393       char expected[] = "/dev/sda1";
15394       r[0][5] = 's';
15395       if (strcmp (r[0], expected) != 0) {
15396         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15397         return -1;
15398       }
15399     }
15400     if (!r[1]) {
15401       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15402       print_strings (r);
15403       return -1;
15404     }
15405     {
15406       char expected[] = "/dev/sda2";
15407       r[1][5] = 's';
15408       if (strcmp (r[1], expected) != 0) {
15409         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15410         return -1;
15411       }
15412     }
15413     if (!r[2]) {
15414       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15415       print_strings (r);
15416       return -1;
15417     }
15418     {
15419       char expected[] = "/dev/sda3";
15420       r[2][5] = 's';
15421       if (strcmp (r[2], expected) != 0) {
15422         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15423         return -1;
15424       }
15425     }
15426     if (r[3] != NULL) {
15427       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15428       print_strings (r);
15429       return -1;
15430     }
15431     for (i = 0; r[i] != NULL; ++i)
15432       free (r[i]);
15433     free (r);
15434   }
15435   return 0;
15436 }
15437
15438 static int test_list_partitions_0_skip (void)
15439 {
15440   const char *str;
15441
15442   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15443   if (str && strcmp (str, "1") == 0) return 1;
15444   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15445   if (str && strcmp (str, "1") == 0) return 1;
15446   return 0;
15447 }
15448
15449 static int test_list_partitions_0 (void)
15450 {
15451   if (test_list_partitions_0_skip ()) {
15452     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15453     return 0;
15454   }
15455
15456   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15457   {
15458     char device[] = "/dev/sda";
15459     int r;
15460     suppress_error = 0;
15461     r = guestfs_blockdev_setrw (g, device);
15462     if (r == -1)
15463       return -1;
15464   }
15465   {
15466     int r;
15467     suppress_error = 0;
15468     r = guestfs_umount_all (g);
15469     if (r == -1)
15470       return -1;
15471   }
15472   {
15473     int r;
15474     suppress_error = 0;
15475     r = guestfs_lvm_remove_all (g);
15476     if (r == -1)
15477       return -1;
15478   }
15479   {
15480     char device[] = "/dev/sda";
15481     char lines_0[] = ",";
15482     char *lines[] = {
15483       lines_0,
15484       NULL
15485     };
15486     int r;
15487     suppress_error = 0;
15488     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15489     if (r == -1)
15490       return -1;
15491   }
15492   {
15493     char fstype[] = "ext2";
15494     char device[] = "/dev/sda1";
15495     int r;
15496     suppress_error = 0;
15497     r = guestfs_mkfs (g, fstype, device);
15498     if (r == -1)
15499       return -1;
15500   }
15501   {
15502     char device[] = "/dev/sda1";
15503     char mountpoint[] = "/";
15504     int r;
15505     suppress_error = 0;
15506     r = guestfs_mount (g, device, mountpoint);
15507     if (r == -1)
15508       return -1;
15509   }
15510   /* TestOutputListOfDevices for list_partitions (0) */
15511   {
15512     char **r;
15513     int i;
15514     suppress_error = 0;
15515     r = guestfs_list_partitions (g);
15516     if (r == NULL)
15517       return -1;
15518     if (!r[0]) {
15519       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15520       print_strings (r);
15521       return -1;
15522     }
15523     {
15524       char expected[] = "/dev/sda1";
15525       r[0][5] = 's';
15526       if (strcmp (r[0], expected) != 0) {
15527         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15528         return -1;
15529       }
15530     }
15531     if (r[1] != NULL) {
15532       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15533       print_strings (r);
15534       return -1;
15535     }
15536     for (i = 0; r[i] != NULL; ++i)
15537       free (r[i]);
15538     free (r);
15539   }
15540   return 0;
15541 }
15542
15543 static int test_list_partitions_1_skip (void)
15544 {
15545   const char *str;
15546
15547   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15548   if (str && strcmp (str, "1") == 0) return 1;
15549   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15550   if (str && strcmp (str, "1") == 0) return 1;
15551   return 0;
15552 }
15553
15554 static int test_list_partitions_1 (void)
15555 {
15556   if (test_list_partitions_1_skip ()) {
15557     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15558     return 0;
15559   }
15560
15561   /* InitNone|InitEmpty for test_list_partitions_1 */
15562   {
15563     char device[] = "/dev/sda";
15564     int r;
15565     suppress_error = 0;
15566     r = guestfs_blockdev_setrw (g, device);
15567     if (r == -1)
15568       return -1;
15569   }
15570   {
15571     int r;
15572     suppress_error = 0;
15573     r = guestfs_umount_all (g);
15574     if (r == -1)
15575       return -1;
15576   }
15577   {
15578     int r;
15579     suppress_error = 0;
15580     r = guestfs_lvm_remove_all (g);
15581     if (r == -1)
15582       return -1;
15583   }
15584   /* TestOutputListOfDevices for list_partitions (1) */
15585   {
15586     char device[] = "/dev/sda";
15587     char lines_0[] = ",10";
15588     char lines_1[] = ",20";
15589     char lines_2[] = ",";
15590     char *lines[] = {
15591       lines_0,
15592       lines_1,
15593       lines_2,
15594       NULL
15595     };
15596     int r;
15597     suppress_error = 0;
15598     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15599     if (r == -1)
15600       return -1;
15601   }
15602   {
15603     char **r;
15604     int i;
15605     suppress_error = 0;
15606     r = guestfs_list_partitions (g);
15607     if (r == NULL)
15608       return -1;
15609     if (!r[0]) {
15610       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15611       print_strings (r);
15612       return -1;
15613     }
15614     {
15615       char expected[] = "/dev/sda1";
15616       r[0][5] = 's';
15617       if (strcmp (r[0], expected) != 0) {
15618         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15619         return -1;
15620       }
15621     }
15622     if (!r[1]) {
15623       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15624       print_strings (r);
15625       return -1;
15626     }
15627     {
15628       char expected[] = "/dev/sda2";
15629       r[1][5] = 's';
15630       if (strcmp (r[1], expected) != 0) {
15631         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15632         return -1;
15633       }
15634     }
15635     if (!r[2]) {
15636       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15637       print_strings (r);
15638       return -1;
15639     }
15640     {
15641       char expected[] = "/dev/sda3";
15642       r[2][5] = 's';
15643       if (strcmp (r[2], expected) != 0) {
15644         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15645         return -1;
15646       }
15647     }
15648     if (r[3] != NULL) {
15649       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15650       print_strings (r);
15651       return -1;
15652     }
15653     for (i = 0; r[i] != NULL; ++i)
15654       free (r[i]);
15655     free (r);
15656   }
15657   return 0;
15658 }
15659
15660 static int test_list_devices_0_skip (void)
15661 {
15662   const char *str;
15663
15664   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15665   if (str && strcmp (str, "1") == 0) return 1;
15666   str = getenv ("SKIP_TEST_LIST_DEVICES");
15667   if (str && strcmp (str, "1") == 0) return 1;
15668   return 0;
15669 }
15670
15671 static int test_list_devices_0 (void)
15672 {
15673   if (test_list_devices_0_skip ()) {
15674     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15675     return 0;
15676   }
15677
15678   /* InitNone|InitEmpty for test_list_devices_0 */
15679   {
15680     char device[] = "/dev/sda";
15681     int r;
15682     suppress_error = 0;
15683     r = guestfs_blockdev_setrw (g, device);
15684     if (r == -1)
15685       return -1;
15686   }
15687   {
15688     int r;
15689     suppress_error = 0;
15690     r = guestfs_umount_all (g);
15691     if (r == -1)
15692       return -1;
15693   }
15694   {
15695     int r;
15696     suppress_error = 0;
15697     r = guestfs_lvm_remove_all (g);
15698     if (r == -1)
15699       return -1;
15700   }
15701   /* TestOutputListOfDevices for list_devices (0) */
15702   {
15703     char **r;
15704     int i;
15705     suppress_error = 0;
15706     r = guestfs_list_devices (g);
15707     if (r == NULL)
15708       return -1;
15709     if (!r[0]) {
15710       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15711       print_strings (r);
15712       return -1;
15713     }
15714     {
15715       char expected[] = "/dev/sda";
15716       r[0][5] = 's';
15717       if (strcmp (r[0], expected) != 0) {
15718         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15719         return -1;
15720       }
15721     }
15722     if (!r[1]) {
15723       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15724       print_strings (r);
15725       return -1;
15726     }
15727     {
15728       char expected[] = "/dev/sdb";
15729       r[1][5] = 's';
15730       if (strcmp (r[1], expected) != 0) {
15731         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15732         return -1;
15733       }
15734     }
15735     if (!r[2]) {
15736       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15737       print_strings (r);
15738       return -1;
15739     }
15740     {
15741       char expected[] = "/dev/sdc";
15742       r[2][5] = 's';
15743       if (strcmp (r[2], expected) != 0) {
15744         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15745         return -1;
15746       }
15747     }
15748     if (!r[3]) {
15749       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15750       print_strings (r);
15751       return -1;
15752     }
15753     {
15754       char expected[] = "/dev/sdd";
15755       r[3][5] = 's';
15756       if (strcmp (r[3], expected) != 0) {
15757         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15758         return -1;
15759       }
15760     }
15761     if (r[4] != NULL) {
15762       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15763       print_strings (r);
15764       return -1;
15765     }
15766     for (i = 0; r[i] != NULL; ++i)
15767       free (r[i]);
15768     free (r);
15769   }
15770   return 0;
15771 }
15772
15773 static int test_ls_0_skip (void)
15774 {
15775   const char *str;
15776
15777   str = getenv ("SKIP_TEST_LS_0");
15778   if (str && strcmp (str, "1") == 0) return 1;
15779   str = getenv ("SKIP_TEST_LS");
15780   if (str && strcmp (str, "1") == 0) return 1;
15781   return 0;
15782 }
15783
15784 static int test_ls_0 (void)
15785 {
15786   if (test_ls_0_skip ()) {
15787     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15788     return 0;
15789   }
15790
15791   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15792   {
15793     char device[] = "/dev/sda";
15794     int r;
15795     suppress_error = 0;
15796     r = guestfs_blockdev_setrw (g, device);
15797     if (r == -1)
15798       return -1;
15799   }
15800   {
15801     int r;
15802     suppress_error = 0;
15803     r = guestfs_umount_all (g);
15804     if (r == -1)
15805       return -1;
15806   }
15807   {
15808     int r;
15809     suppress_error = 0;
15810     r = guestfs_lvm_remove_all (g);
15811     if (r == -1)
15812       return -1;
15813   }
15814   {
15815     char device[] = "/dev/sda";
15816     char lines_0[] = ",";
15817     char *lines[] = {
15818       lines_0,
15819       NULL
15820     };
15821     int r;
15822     suppress_error = 0;
15823     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15824     if (r == -1)
15825       return -1;
15826   }
15827   {
15828     char fstype[] = "ext2";
15829     char device[] = "/dev/sda1";
15830     int r;
15831     suppress_error = 0;
15832     r = guestfs_mkfs (g, fstype, device);
15833     if (r == -1)
15834       return -1;
15835   }
15836   {
15837     char device[] = "/dev/sda1";
15838     char mountpoint[] = "/";
15839     int r;
15840     suppress_error = 0;
15841     r = guestfs_mount (g, device, mountpoint);
15842     if (r == -1)
15843       return -1;
15844   }
15845   /* TestOutputList for ls (0) */
15846   {
15847     char path[] = "/new";
15848     int r;
15849     suppress_error = 0;
15850     r = guestfs_touch (g, path);
15851     if (r == -1)
15852       return -1;
15853   }
15854   {
15855     char path[] = "/newer";
15856     int r;
15857     suppress_error = 0;
15858     r = guestfs_touch (g, path);
15859     if (r == -1)
15860       return -1;
15861   }
15862   {
15863     char path[] = "/newest";
15864     int r;
15865     suppress_error = 0;
15866     r = guestfs_touch (g, path);
15867     if (r == -1)
15868       return -1;
15869   }
15870   {
15871     char directory[] = "/";
15872     char **r;
15873     int i;
15874     suppress_error = 0;
15875     r = guestfs_ls (g, directory);
15876     if (r == NULL)
15877       return -1;
15878     if (!r[0]) {
15879       fprintf (stderr, "test_ls_0: short list returned from command\n");
15880       print_strings (r);
15881       return -1;
15882     }
15883     {
15884       char expected[] = "lost+found";
15885       if (strcmp (r[0], expected) != 0) {
15886         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15887         return -1;
15888       }
15889     }
15890     if (!r[1]) {
15891       fprintf (stderr, "test_ls_0: short list returned from command\n");
15892       print_strings (r);
15893       return -1;
15894     }
15895     {
15896       char expected[] = "new";
15897       if (strcmp (r[1], expected) != 0) {
15898         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15899         return -1;
15900       }
15901     }
15902     if (!r[2]) {
15903       fprintf (stderr, "test_ls_0: short list returned from command\n");
15904       print_strings (r);
15905       return -1;
15906     }
15907     {
15908       char expected[] = "newer";
15909       if (strcmp (r[2], expected) != 0) {
15910         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15911         return -1;
15912       }
15913     }
15914     if (!r[3]) {
15915       fprintf (stderr, "test_ls_0: short list returned from command\n");
15916       print_strings (r);
15917       return -1;
15918     }
15919     {
15920       char expected[] = "newest";
15921       if (strcmp (r[3], expected) != 0) {
15922         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15923         return -1;
15924       }
15925     }
15926     if (r[4] != NULL) {
15927       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15928       print_strings (r);
15929       return -1;
15930     }
15931     for (i = 0; r[i] != NULL; ++i)
15932       free (r[i]);
15933     free (r);
15934   }
15935   return 0;
15936 }
15937
15938 static int test_cat_0_skip (void)
15939 {
15940   const char *str;
15941
15942   str = getenv ("SKIP_TEST_CAT_0");
15943   if (str && strcmp (str, "1") == 0) return 1;
15944   str = getenv ("SKIP_TEST_CAT");
15945   if (str && strcmp (str, "1") == 0) return 1;
15946   return 0;
15947 }
15948
15949 static int test_cat_0 (void)
15950 {
15951   if (test_cat_0_skip ()) {
15952     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15953     return 0;
15954   }
15955
15956   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15957   {
15958     char device[] = "/dev/sda";
15959     int r;
15960     suppress_error = 0;
15961     r = guestfs_blockdev_setrw (g, device);
15962     if (r == -1)
15963       return -1;
15964   }
15965   {
15966     int r;
15967     suppress_error = 0;
15968     r = guestfs_umount_all (g);
15969     if (r == -1)
15970       return -1;
15971   }
15972   {
15973     int r;
15974     suppress_error = 0;
15975     r = guestfs_lvm_remove_all (g);
15976     if (r == -1)
15977       return -1;
15978   }
15979   {
15980     char device[] = "/dev/sda";
15981     char lines_0[] = ",";
15982     char *lines[] = {
15983       lines_0,
15984       NULL
15985     };
15986     int r;
15987     suppress_error = 0;
15988     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15989     if (r == -1)
15990       return -1;
15991   }
15992   {
15993     char fstype[] = "ext2";
15994     char device[] = "/dev/sda1";
15995     int r;
15996     suppress_error = 0;
15997     r = guestfs_mkfs (g, fstype, device);
15998     if (r == -1)
15999       return -1;
16000   }
16001   {
16002     char device[] = "/dev/sda1";
16003     char mountpoint[] = "/";
16004     int r;
16005     suppress_error = 0;
16006     r = guestfs_mount (g, device, mountpoint);
16007     if (r == -1)
16008       return -1;
16009   }
16010   /* TestOutput for cat (0) */
16011   char expected[] = "new file contents";
16012   {
16013     char path[] = "/new";
16014     char content[] = "new file contents";
16015     int r;
16016     suppress_error = 0;
16017     r = guestfs_write_file (g, path, content, 0);
16018     if (r == -1)
16019       return -1;
16020   }
16021   {
16022     char path[] = "/new";
16023     char *r;
16024     suppress_error = 0;
16025     r = guestfs_cat (g, path);
16026     if (r == NULL)
16027       return -1;
16028     if (strcmp (r, expected) != 0) {
16029       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
16030       return -1;
16031     }
16032     free (r);
16033   }
16034   return 0;
16035 }
16036
16037 static int test_touch_0_skip (void)
16038 {
16039   const char *str;
16040
16041   str = getenv ("SKIP_TEST_TOUCH_0");
16042   if (str && strcmp (str, "1") == 0) return 1;
16043   str = getenv ("SKIP_TEST_TOUCH");
16044   if (str && strcmp (str, "1") == 0) return 1;
16045   return 0;
16046 }
16047
16048 static int test_touch_0 (void)
16049 {
16050   if (test_touch_0_skip ()) {
16051     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
16052     return 0;
16053   }
16054
16055   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
16056   {
16057     char device[] = "/dev/sda";
16058     int r;
16059     suppress_error = 0;
16060     r = guestfs_blockdev_setrw (g, device);
16061     if (r == -1)
16062       return -1;
16063   }
16064   {
16065     int r;
16066     suppress_error = 0;
16067     r = guestfs_umount_all (g);
16068     if (r == -1)
16069       return -1;
16070   }
16071   {
16072     int r;
16073     suppress_error = 0;
16074     r = guestfs_lvm_remove_all (g);
16075     if (r == -1)
16076       return -1;
16077   }
16078   {
16079     char device[] = "/dev/sda";
16080     char lines_0[] = ",";
16081     char *lines[] = {
16082       lines_0,
16083       NULL
16084     };
16085     int r;
16086     suppress_error = 0;
16087     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16088     if (r == -1)
16089       return -1;
16090   }
16091   {
16092     char fstype[] = "ext2";
16093     char device[] = "/dev/sda1";
16094     int r;
16095     suppress_error = 0;
16096     r = guestfs_mkfs (g, fstype, device);
16097     if (r == -1)
16098       return -1;
16099   }
16100   {
16101     char device[] = "/dev/sda1";
16102     char mountpoint[] = "/";
16103     int r;
16104     suppress_error = 0;
16105     r = guestfs_mount (g, device, mountpoint);
16106     if (r == -1)
16107       return -1;
16108   }
16109   /* TestOutputTrue for touch (0) */
16110   {
16111     char path[] = "/new";
16112     int r;
16113     suppress_error = 0;
16114     r = guestfs_touch (g, path);
16115     if (r == -1)
16116       return -1;
16117   }
16118   {
16119     char path[] = "/new";
16120     int r;
16121     suppress_error = 0;
16122     r = guestfs_exists (g, path);
16123     if (r == -1)
16124       return -1;
16125     if (!r) {
16126       fprintf (stderr, "test_touch_0: expected true, got false\n");
16127       return -1;
16128     }
16129   }
16130   return 0;
16131 }
16132
16133 static int test_sync_0_skip (void)
16134 {
16135   const char *str;
16136
16137   str = getenv ("SKIP_TEST_SYNC_0");
16138   if (str && strcmp (str, "1") == 0) return 1;
16139   str = getenv ("SKIP_TEST_SYNC");
16140   if (str && strcmp (str, "1") == 0) return 1;
16141   return 0;
16142 }
16143
16144 static int test_sync_0 (void)
16145 {
16146   if (test_sync_0_skip ()) {
16147     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
16148     return 0;
16149   }
16150
16151   /* InitNone|InitEmpty for test_sync_0 */
16152   {
16153     char device[] = "/dev/sda";
16154     int r;
16155     suppress_error = 0;
16156     r = guestfs_blockdev_setrw (g, device);
16157     if (r == -1)
16158       return -1;
16159   }
16160   {
16161     int r;
16162     suppress_error = 0;
16163     r = guestfs_umount_all (g);
16164     if (r == -1)
16165       return -1;
16166   }
16167   {
16168     int r;
16169     suppress_error = 0;
16170     r = guestfs_lvm_remove_all (g);
16171     if (r == -1)
16172       return -1;
16173   }
16174   /* TestRun for sync (0) */
16175   {
16176     int r;
16177     suppress_error = 0;
16178     r = guestfs_sync (g);
16179     if (r == -1)
16180       return -1;
16181   }
16182   return 0;
16183 }
16184
16185 static int test_mount_0_skip (void)
16186 {
16187   const char *str;
16188
16189   str = getenv ("SKIP_TEST_MOUNT_0");
16190   if (str && strcmp (str, "1") == 0) return 1;
16191   str = getenv ("SKIP_TEST_MOUNT");
16192   if (str && strcmp (str, "1") == 0) return 1;
16193   return 0;
16194 }
16195
16196 static int test_mount_0 (void)
16197 {
16198   if (test_mount_0_skip ()) {
16199     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
16200     return 0;
16201   }
16202
16203   /* InitNone|InitEmpty for test_mount_0 */
16204   {
16205     char device[] = "/dev/sda";
16206     int r;
16207     suppress_error = 0;
16208     r = guestfs_blockdev_setrw (g, device);
16209     if (r == -1)
16210       return -1;
16211   }
16212   {
16213     int r;
16214     suppress_error = 0;
16215     r = guestfs_umount_all (g);
16216     if (r == -1)
16217       return -1;
16218   }
16219   {
16220     int r;
16221     suppress_error = 0;
16222     r = guestfs_lvm_remove_all (g);
16223     if (r == -1)
16224       return -1;
16225   }
16226   /* TestOutput for mount (0) */
16227   char expected[] = "new file contents";
16228   {
16229     char device[] = "/dev/sda";
16230     char lines_0[] = ",";
16231     char *lines[] = {
16232       lines_0,
16233       NULL
16234     };
16235     int r;
16236     suppress_error = 0;
16237     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16238     if (r == -1)
16239       return -1;
16240   }
16241   {
16242     char fstype[] = "ext2";
16243     char device[] = "/dev/sda1";
16244     int r;
16245     suppress_error = 0;
16246     r = guestfs_mkfs (g, fstype, device);
16247     if (r == -1)
16248       return -1;
16249   }
16250   {
16251     char device[] = "/dev/sda1";
16252     char mountpoint[] = "/";
16253     int r;
16254     suppress_error = 0;
16255     r = guestfs_mount (g, device, mountpoint);
16256     if (r == -1)
16257       return -1;
16258   }
16259   {
16260     char path[] = "/new";
16261     char content[] = "new file contents";
16262     int r;
16263     suppress_error = 0;
16264     r = guestfs_write_file (g, path, content, 0);
16265     if (r == -1)
16266       return -1;
16267   }
16268   {
16269     char path[] = "/new";
16270     char *r;
16271     suppress_error = 0;
16272     r = guestfs_cat (g, path);
16273     if (r == NULL)
16274       return -1;
16275     if (strcmp (r, expected) != 0) {
16276       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16277       return -1;
16278     }
16279     free (r);
16280   }
16281   return 0;
16282 }
16283
16284 int main (int argc, char *argv[])
16285 {
16286   char c = 0;
16287   int failed = 0;
16288   const char *filename;
16289   int fd;
16290   int nr_tests, test_num = 0;
16291
16292   no_test_warnings ();
16293
16294   g = guestfs_create ();
16295   if (g == NULL) {
16296     printf ("guestfs_create FAILED\n");
16297     exit (1);
16298   }
16299
16300   guestfs_set_error_handler (g, print_error, NULL);
16301
16302   guestfs_set_path (g, "../appliance");
16303
16304   filename = "test1.img";
16305   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16306   if (fd == -1) {
16307     perror (filename);
16308     exit (1);
16309   }
16310   if (lseek (fd, 524288000, SEEK_SET) == -1) {
16311     perror ("lseek");
16312     close (fd);
16313     unlink (filename);
16314     exit (1);
16315   }
16316   if (write (fd, &c, 1) == -1) {
16317     perror ("write");
16318     close (fd);
16319     unlink (filename);
16320     exit (1);
16321   }
16322   if (close (fd) == -1) {
16323     perror (filename);
16324     unlink (filename);
16325     exit (1);
16326   }
16327   if (guestfs_add_drive (g, filename) == -1) {
16328     printf ("guestfs_add_drive %s FAILED\n", filename);
16329     exit (1);
16330   }
16331
16332   filename = "test2.img";
16333   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16334   if (fd == -1) {
16335     perror (filename);
16336     exit (1);
16337   }
16338   if (lseek (fd, 52428800, SEEK_SET) == -1) {
16339     perror ("lseek");
16340     close (fd);
16341     unlink (filename);
16342     exit (1);
16343   }
16344   if (write (fd, &c, 1) == -1) {
16345     perror ("write");
16346     close (fd);
16347     unlink (filename);
16348     exit (1);
16349   }
16350   if (close (fd) == -1) {
16351     perror (filename);
16352     unlink (filename);
16353     exit (1);
16354   }
16355   if (guestfs_add_drive (g, filename) == -1) {
16356     printf ("guestfs_add_drive %s FAILED\n", filename);
16357     exit (1);
16358   }
16359
16360   filename = "test3.img";
16361   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16362   if (fd == -1) {
16363     perror (filename);
16364     exit (1);
16365   }
16366   if (lseek (fd, 10485760, SEEK_SET) == -1) {
16367     perror ("lseek");
16368     close (fd);
16369     unlink (filename);
16370     exit (1);
16371   }
16372   if (write (fd, &c, 1) == -1) {
16373     perror ("write");
16374     close (fd);
16375     unlink (filename);
16376     exit (1);
16377   }
16378   if (close (fd) == -1) {
16379     perror (filename);
16380     unlink (filename);
16381     exit (1);
16382   }
16383   if (guestfs_add_drive (g, filename) == -1) {
16384     printf ("guestfs_add_drive %s FAILED\n", filename);
16385     exit (1);
16386   }
16387
16388   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16389     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16390     exit (1);
16391   }
16392
16393   if (guestfs_launch (g) == -1) {
16394     printf ("guestfs_launch FAILED\n");
16395     exit (1);
16396   }
16397
16398   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
16399   alarm (600);
16400
16401   if (guestfs_wait_ready (g) == -1) {
16402     printf ("guestfs_wait_ready FAILED\n");
16403     exit (1);
16404   }
16405
16406   /* Cancel previous alarm. */
16407   alarm (0);
16408
16409   nr_tests = 152;
16410
16411   test_num++;
16412   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
16413   if (test_mkdtemp_0 () == -1) {
16414     printf ("test_mkdtemp_0 FAILED\n");
16415     failed++;
16416   }
16417   test_num++;
16418   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
16419   if (test_scrub_file_0 () == -1) {
16420     printf ("test_scrub_file_0 FAILED\n");
16421     failed++;
16422   }
16423   test_num++;
16424   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
16425   if (test_scrub_device_0 () == -1) {
16426     printf ("test_scrub_device_0 FAILED\n");
16427     failed++;
16428   }
16429   test_num++;
16430   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
16431   if (test_glob_expand_0 () == -1) {
16432     printf ("test_glob_expand_0 FAILED\n");
16433     failed++;
16434   }
16435   test_num++;
16436   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
16437   if (test_glob_expand_1 () == -1) {
16438     printf ("test_glob_expand_1 FAILED\n");
16439     failed++;
16440   }
16441   test_num++;
16442   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
16443   if (test_glob_expand_2 () == -1) {
16444     printf ("test_glob_expand_2 FAILED\n");
16445     failed++;
16446   }
16447   test_num++;
16448   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
16449   if (test_ntfs_3g_probe_0 () == -1) {
16450     printf ("test_ntfs_3g_probe_0 FAILED\n");
16451     failed++;
16452   }
16453   test_num++;
16454   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
16455   if (test_ntfs_3g_probe_1 () == -1) {
16456     printf ("test_ntfs_3g_probe_1 FAILED\n");
16457     failed++;
16458   }
16459   test_num++;
16460   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16461   if (test_sleep_0 () == -1) {
16462     printf ("test_sleep_0 FAILED\n");
16463     failed++;
16464   }
16465   test_num++;
16466   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16467   if (test_find_0 () == -1) {
16468     printf ("test_find_0 FAILED\n");
16469     failed++;
16470   }
16471   test_num++;
16472   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16473   if (test_find_1 () == -1) {
16474     printf ("test_find_1 FAILED\n");
16475     failed++;
16476   }
16477   test_num++;
16478   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16479   if (test_find_2 () == -1) {
16480     printf ("test_find_2 FAILED\n");
16481     failed++;
16482   }
16483   test_num++;
16484   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16485   if (test_lvresize_0 () == -1) {
16486     printf ("test_lvresize_0 FAILED\n");
16487     failed++;
16488   }
16489   test_num++;
16490   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16491   if (test_zerofree_0 () == -1) {
16492     printf ("test_zerofree_0 FAILED\n");
16493     failed++;
16494   }
16495   test_num++;
16496   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16497   if (test_hexdump_0 () == -1) {
16498     printf ("test_hexdump_0 FAILED\n");
16499     failed++;
16500   }
16501   test_num++;
16502   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16503   if (test_strings_e_0 () == -1) {
16504     printf ("test_strings_e_0 FAILED\n");
16505     failed++;
16506   }
16507   test_num++;
16508   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16509   if (test_strings_e_1 () == -1) {
16510     printf ("test_strings_e_1 FAILED\n");
16511     failed++;
16512   }
16513   test_num++;
16514   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16515   if (test_strings_0 () == -1) {
16516     printf ("test_strings_0 FAILED\n");
16517     failed++;
16518   }
16519   test_num++;
16520   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16521   if (test_strings_1 () == -1) {
16522     printf ("test_strings_1 FAILED\n");
16523     failed++;
16524   }
16525   test_num++;
16526   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16527   if (test_equal_0 () == -1) {
16528     printf ("test_equal_0 FAILED\n");
16529     failed++;
16530   }
16531   test_num++;
16532   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16533   if (test_equal_1 () == -1) {
16534     printf ("test_equal_1 FAILED\n");
16535     failed++;
16536   }
16537   test_num++;
16538   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16539   if (test_equal_2 () == -1) {
16540     printf ("test_equal_2 FAILED\n");
16541     failed++;
16542   }
16543   test_num++;
16544   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16545   if (test_ping_daemon_0 () == -1) {
16546     printf ("test_ping_daemon_0 FAILED\n");
16547     failed++;
16548   }
16549   test_num++;
16550   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16551   if (test_dmesg_0 () == -1) {
16552     printf ("test_dmesg_0 FAILED\n");
16553     failed++;
16554   }
16555   test_num++;
16556   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16557   if (test_drop_caches_0 () == -1) {
16558     printf ("test_drop_caches_0 FAILED\n");
16559     failed++;
16560   }
16561   test_num++;
16562   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16563   if (test_mv_0 () == -1) {
16564     printf ("test_mv_0 FAILED\n");
16565     failed++;
16566   }
16567   test_num++;
16568   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16569   if (test_mv_1 () == -1) {
16570     printf ("test_mv_1 FAILED\n");
16571     failed++;
16572   }
16573   test_num++;
16574   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16575   if (test_cp_a_0 () == -1) {
16576     printf ("test_cp_a_0 FAILED\n");
16577     failed++;
16578   }
16579   test_num++;
16580   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16581   if (test_cp_0 () == -1) {
16582     printf ("test_cp_0 FAILED\n");
16583     failed++;
16584   }
16585   test_num++;
16586   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16587   if (test_cp_1 () == -1) {
16588     printf ("test_cp_1 FAILED\n");
16589     failed++;
16590   }
16591   test_num++;
16592   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16593   if (test_cp_2 () == -1) {
16594     printf ("test_cp_2 FAILED\n");
16595     failed++;
16596   }
16597   test_num++;
16598   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16599   if (test_grub_install_0 () == -1) {
16600     printf ("test_grub_install_0 FAILED\n");
16601     failed++;
16602   }
16603   test_num++;
16604   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16605   if (test_zero_0 () == -1) {
16606     printf ("test_zero_0 FAILED\n");
16607     failed++;
16608   }
16609   test_num++;
16610   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16611   if (test_fsck_0 () == -1) {
16612     printf ("test_fsck_0 FAILED\n");
16613     failed++;
16614   }
16615   test_num++;
16616   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16617   if (test_fsck_1 () == -1) {
16618     printf ("test_fsck_1 FAILED\n");
16619     failed++;
16620   }
16621   test_num++;
16622   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16623   if (test_set_e2uuid_0 () == -1) {
16624     printf ("test_set_e2uuid_0 FAILED\n");
16625     failed++;
16626   }
16627   test_num++;
16628   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16629   if (test_set_e2uuid_1 () == -1) {
16630     printf ("test_set_e2uuid_1 FAILED\n");
16631     failed++;
16632   }
16633   test_num++;
16634   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16635   if (test_set_e2uuid_2 () == -1) {
16636     printf ("test_set_e2uuid_2 FAILED\n");
16637     failed++;
16638   }
16639   test_num++;
16640   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16641   if (test_set_e2uuid_3 () == -1) {
16642     printf ("test_set_e2uuid_3 FAILED\n");
16643     failed++;
16644   }
16645   test_num++;
16646   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16647   if (test_set_e2label_0 () == -1) {
16648     printf ("test_set_e2label_0 FAILED\n");
16649     failed++;
16650   }
16651   test_num++;
16652   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16653   if (test_pvremove_0 () == -1) {
16654     printf ("test_pvremove_0 FAILED\n");
16655     failed++;
16656   }
16657   test_num++;
16658   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16659   if (test_pvremove_1 () == -1) {
16660     printf ("test_pvremove_1 FAILED\n");
16661     failed++;
16662   }
16663   test_num++;
16664   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16665   if (test_pvremove_2 () == -1) {
16666     printf ("test_pvremove_2 FAILED\n");
16667     failed++;
16668   }
16669   test_num++;
16670   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16671   if (test_vgremove_0 () == -1) {
16672     printf ("test_vgremove_0 FAILED\n");
16673     failed++;
16674   }
16675   test_num++;
16676   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16677   if (test_vgremove_1 () == -1) {
16678     printf ("test_vgremove_1 FAILED\n");
16679     failed++;
16680   }
16681   test_num++;
16682   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16683   if (test_lvremove_0 () == -1) {
16684     printf ("test_lvremove_0 FAILED\n");
16685     failed++;
16686   }
16687   test_num++;
16688   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16689   if (test_lvremove_1 () == -1) {
16690     printf ("test_lvremove_1 FAILED\n");
16691     failed++;
16692   }
16693   test_num++;
16694   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16695   if (test_lvremove_2 () == -1) {
16696     printf ("test_lvremove_2 FAILED\n");
16697     failed++;
16698   }
16699   test_num++;
16700   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16701   if (test_mount_ro_0 () == -1) {
16702     printf ("test_mount_ro_0 FAILED\n");
16703     failed++;
16704   }
16705   test_num++;
16706   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16707   if (test_mount_ro_1 () == -1) {
16708     printf ("test_mount_ro_1 FAILED\n");
16709     failed++;
16710   }
16711   test_num++;
16712   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16713   if (test_tgz_in_0 () == -1) {
16714     printf ("test_tgz_in_0 FAILED\n");
16715     failed++;
16716   }
16717   test_num++;
16718   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16719   if (test_tar_in_0 () == -1) {
16720     printf ("test_tar_in_0 FAILED\n");
16721     failed++;
16722   }
16723   test_num++;
16724   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16725   if (test_checksum_0 () == -1) {
16726     printf ("test_checksum_0 FAILED\n");
16727     failed++;
16728   }
16729   test_num++;
16730   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16731   if (test_checksum_1 () == -1) {
16732     printf ("test_checksum_1 FAILED\n");
16733     failed++;
16734   }
16735   test_num++;
16736   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16737   if (test_checksum_2 () == -1) {
16738     printf ("test_checksum_2 FAILED\n");
16739     failed++;
16740   }
16741   test_num++;
16742   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16743   if (test_checksum_3 () == -1) {
16744     printf ("test_checksum_3 FAILED\n");
16745     failed++;
16746   }
16747   test_num++;
16748   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16749   if (test_checksum_4 () == -1) {
16750     printf ("test_checksum_4 FAILED\n");
16751     failed++;
16752   }
16753   test_num++;
16754   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16755   if (test_checksum_5 () == -1) {
16756     printf ("test_checksum_5 FAILED\n");
16757     failed++;
16758   }
16759   test_num++;
16760   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16761   if (test_checksum_6 () == -1) {
16762     printf ("test_checksum_6 FAILED\n");
16763     failed++;
16764   }
16765   test_num++;
16766   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16767   if (test_checksum_7 () == -1) {
16768     printf ("test_checksum_7 FAILED\n");
16769     failed++;
16770   }
16771   test_num++;
16772   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16773   if (test_checksum_8 () == -1) {
16774     printf ("test_checksum_8 FAILED\n");
16775     failed++;
16776   }
16777   test_num++;
16778   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16779   if (test_download_0 () == -1) {
16780     printf ("test_download_0 FAILED\n");
16781     failed++;
16782   }
16783   test_num++;
16784   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16785   if (test_upload_0 () == -1) {
16786     printf ("test_upload_0 FAILED\n");
16787     failed++;
16788   }
16789   test_num++;
16790   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16791   if (test_blockdev_rereadpt_0 () == -1) {
16792     printf ("test_blockdev_rereadpt_0 FAILED\n");
16793     failed++;
16794   }
16795   test_num++;
16796   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16797   if (test_blockdev_flushbufs_0 () == -1) {
16798     printf ("test_blockdev_flushbufs_0 FAILED\n");
16799     failed++;
16800   }
16801   test_num++;
16802   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16803   if (test_blockdev_getsize64_0 () == -1) {
16804     printf ("test_blockdev_getsize64_0 FAILED\n");
16805     failed++;
16806   }
16807   test_num++;
16808   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16809   if (test_blockdev_getsz_0 () == -1) {
16810     printf ("test_blockdev_getsz_0 FAILED\n");
16811     failed++;
16812   }
16813   test_num++;
16814   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16815   if (test_blockdev_getbsz_0 () == -1) {
16816     printf ("test_blockdev_getbsz_0 FAILED\n");
16817     failed++;
16818   }
16819   test_num++;
16820   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16821   if (test_blockdev_getss_0 () == -1) {
16822     printf ("test_blockdev_getss_0 FAILED\n");
16823     failed++;
16824   }
16825   test_num++;
16826   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16827   if (test_blockdev_getro_0 () == -1) {
16828     printf ("test_blockdev_getro_0 FAILED\n");
16829     failed++;
16830   }
16831   test_num++;
16832   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16833   if (test_blockdev_setrw_0 () == -1) {
16834     printf ("test_blockdev_setrw_0 FAILED\n");
16835     failed++;
16836   }
16837   test_num++;
16838   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16839   if (test_blockdev_setro_0 () == -1) {
16840     printf ("test_blockdev_setro_0 FAILED\n");
16841     failed++;
16842   }
16843   test_num++;
16844   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16845   if (test_statvfs_0 () == -1) {
16846     printf ("test_statvfs_0 FAILED\n");
16847     failed++;
16848   }
16849   test_num++;
16850   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16851   if (test_lstat_0 () == -1) {
16852     printf ("test_lstat_0 FAILED\n");
16853     failed++;
16854   }
16855   test_num++;
16856   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16857   if (test_stat_0 () == -1) {
16858     printf ("test_stat_0 FAILED\n");
16859     failed++;
16860   }
16861   test_num++;
16862   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16863   if (test_command_lines_0 () == -1) {
16864     printf ("test_command_lines_0 FAILED\n");
16865     failed++;
16866   }
16867   test_num++;
16868   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16869   if (test_command_lines_1 () == -1) {
16870     printf ("test_command_lines_1 FAILED\n");
16871     failed++;
16872   }
16873   test_num++;
16874   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16875   if (test_command_lines_2 () == -1) {
16876     printf ("test_command_lines_2 FAILED\n");
16877     failed++;
16878   }
16879   test_num++;
16880   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16881   if (test_command_lines_3 () == -1) {
16882     printf ("test_command_lines_3 FAILED\n");
16883     failed++;
16884   }
16885   test_num++;
16886   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16887   if (test_command_lines_4 () == -1) {
16888     printf ("test_command_lines_4 FAILED\n");
16889     failed++;
16890   }
16891   test_num++;
16892   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16893   if (test_command_lines_5 () == -1) {
16894     printf ("test_command_lines_5 FAILED\n");
16895     failed++;
16896   }
16897   test_num++;
16898   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16899   if (test_command_lines_6 () == -1) {
16900     printf ("test_command_lines_6 FAILED\n");
16901     failed++;
16902   }
16903   test_num++;
16904   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16905   if (test_command_lines_7 () == -1) {
16906     printf ("test_command_lines_7 FAILED\n");
16907     failed++;
16908   }
16909   test_num++;
16910   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16911   if (test_command_lines_8 () == -1) {
16912     printf ("test_command_lines_8 FAILED\n");
16913     failed++;
16914   }
16915   test_num++;
16916   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16917   if (test_command_lines_9 () == -1) {
16918     printf ("test_command_lines_9 FAILED\n");
16919     failed++;
16920   }
16921   test_num++;
16922   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16923   if (test_command_lines_10 () == -1) {
16924     printf ("test_command_lines_10 FAILED\n");
16925     failed++;
16926   }
16927   test_num++;
16928   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16929   if (test_command_0 () == -1) {
16930     printf ("test_command_0 FAILED\n");
16931     failed++;
16932   }
16933   test_num++;
16934   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16935   if (test_command_1 () == -1) {
16936     printf ("test_command_1 FAILED\n");
16937     failed++;
16938   }
16939   test_num++;
16940   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16941   if (test_command_2 () == -1) {
16942     printf ("test_command_2 FAILED\n");
16943     failed++;
16944   }
16945   test_num++;
16946   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16947   if (test_command_3 () == -1) {
16948     printf ("test_command_3 FAILED\n");
16949     failed++;
16950   }
16951   test_num++;
16952   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16953   if (test_command_4 () == -1) {
16954     printf ("test_command_4 FAILED\n");
16955     failed++;
16956   }
16957   test_num++;
16958   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16959   if (test_command_5 () == -1) {
16960     printf ("test_command_5 FAILED\n");
16961     failed++;
16962   }
16963   test_num++;
16964   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16965   if (test_command_6 () == -1) {
16966     printf ("test_command_6 FAILED\n");
16967     failed++;
16968   }
16969   test_num++;
16970   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16971   if (test_command_7 () == -1) {
16972     printf ("test_command_7 FAILED\n");
16973     failed++;
16974   }
16975   test_num++;
16976   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16977   if (test_command_8 () == -1) {
16978     printf ("test_command_8 FAILED\n");
16979     failed++;
16980   }
16981   test_num++;
16982   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16983   if (test_command_9 () == -1) {
16984     printf ("test_command_9 FAILED\n");
16985     failed++;
16986   }
16987   test_num++;
16988   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16989   if (test_command_10 () == -1) {
16990     printf ("test_command_10 FAILED\n");
16991     failed++;
16992   }
16993   test_num++;
16994   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16995   if (test_command_11 () == -1) {
16996     printf ("test_command_11 FAILED\n");
16997     failed++;
16998   }
16999   test_num++;
17000   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
17001   if (test_file_0 () == -1) {
17002     printf ("test_file_0 FAILED\n");
17003     failed++;
17004   }
17005   test_num++;
17006   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
17007   if (test_file_1 () == -1) {
17008     printf ("test_file_1 FAILED\n");
17009     failed++;
17010   }
17011   test_num++;
17012   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
17013   if (test_file_2 () == -1) {
17014     printf ("test_file_2 FAILED\n");
17015     failed++;
17016   }
17017   test_num++;
17018   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
17019   if (test_umount_all_0 () == -1) {
17020     printf ("test_umount_all_0 FAILED\n");
17021     failed++;
17022   }
17023   test_num++;
17024   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
17025   if (test_umount_all_1 () == -1) {
17026     printf ("test_umount_all_1 FAILED\n");
17027     failed++;
17028   }
17029   test_num++;
17030   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
17031   if (test_mounts_0 () == -1) {
17032     printf ("test_mounts_0 FAILED\n");
17033     failed++;
17034   }
17035   test_num++;
17036   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
17037   if (test_umount_0 () == -1) {
17038     printf ("test_umount_0 FAILED\n");
17039     failed++;
17040   }
17041   test_num++;
17042   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
17043   if (test_umount_1 () == -1) {
17044     printf ("test_umount_1 FAILED\n");
17045     failed++;
17046   }
17047   test_num++;
17048   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
17049   if (test_write_file_0 () == -1) {
17050     printf ("test_write_file_0 FAILED\n");
17051     failed++;
17052   }
17053   test_num++;
17054   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
17055   if (test_write_file_1 () == -1) {
17056     printf ("test_write_file_1 FAILED\n");
17057     failed++;
17058   }
17059   test_num++;
17060   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
17061   if (test_write_file_2 () == -1) {
17062     printf ("test_write_file_2 FAILED\n");
17063     failed++;
17064   }
17065   test_num++;
17066   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
17067   if (test_write_file_3 () == -1) {
17068     printf ("test_write_file_3 FAILED\n");
17069     failed++;
17070   }
17071   test_num++;
17072   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
17073   if (test_write_file_4 () == -1) {
17074     printf ("test_write_file_4 FAILED\n");
17075     failed++;
17076   }
17077   test_num++;
17078   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
17079   if (test_write_file_5 () == -1) {
17080     printf ("test_write_file_5 FAILED\n");
17081     failed++;
17082   }
17083   test_num++;
17084   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
17085   if (test_mkfs_0 () == -1) {
17086     printf ("test_mkfs_0 FAILED\n");
17087     failed++;
17088   }
17089   test_num++;
17090   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
17091   if (test_lvcreate_0 () == -1) {
17092     printf ("test_lvcreate_0 FAILED\n");
17093     failed++;
17094   }
17095   test_num++;
17096   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
17097   if (test_vgcreate_0 () == -1) {
17098     printf ("test_vgcreate_0 FAILED\n");
17099     failed++;
17100   }
17101   test_num++;
17102   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17103   if (test_pvcreate_0 () == -1) {
17104     printf ("test_pvcreate_0 FAILED\n");
17105     failed++;
17106   }
17107   test_num++;
17108   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17109   if (test_is_dir_0 () == -1) {
17110     printf ("test_is_dir_0 FAILED\n");
17111     failed++;
17112   }
17113   test_num++;
17114   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
17115   if (test_is_dir_1 () == -1) {
17116     printf ("test_is_dir_1 FAILED\n");
17117     failed++;
17118   }
17119   test_num++;
17120   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
17121   if (test_is_file_0 () == -1) {
17122     printf ("test_is_file_0 FAILED\n");
17123     failed++;
17124   }
17125   test_num++;
17126   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
17127   if (test_is_file_1 () == -1) {
17128     printf ("test_is_file_1 FAILED\n");
17129     failed++;
17130   }
17131   test_num++;
17132   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
17133   if (test_exists_0 () == -1) {
17134     printf ("test_exists_0 FAILED\n");
17135     failed++;
17136   }
17137   test_num++;
17138   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
17139   if (test_exists_1 () == -1) {
17140     printf ("test_exists_1 FAILED\n");
17141     failed++;
17142   }
17143   test_num++;
17144   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
17145   if (test_mkdir_p_0 () == -1) {
17146     printf ("test_mkdir_p_0 FAILED\n");
17147     failed++;
17148   }
17149   test_num++;
17150   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
17151   if (test_mkdir_p_1 () == -1) {
17152     printf ("test_mkdir_p_1 FAILED\n");
17153     failed++;
17154   }
17155   test_num++;
17156   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
17157   if (test_mkdir_p_2 () == -1) {
17158     printf ("test_mkdir_p_2 FAILED\n");
17159     failed++;
17160   }
17161   test_num++;
17162   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
17163   if (test_mkdir_p_3 () == -1) {
17164     printf ("test_mkdir_p_3 FAILED\n");
17165     failed++;
17166   }
17167   test_num++;
17168   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
17169   if (test_mkdir_p_4 () == -1) {
17170     printf ("test_mkdir_p_4 FAILED\n");
17171     failed++;
17172   }
17173   test_num++;
17174   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
17175   if (test_mkdir_0 () == -1) {
17176     printf ("test_mkdir_0 FAILED\n");
17177     failed++;
17178   }
17179   test_num++;
17180   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
17181   if (test_mkdir_1 () == -1) {
17182     printf ("test_mkdir_1 FAILED\n");
17183     failed++;
17184   }
17185   test_num++;
17186   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
17187   if (test_rm_rf_0 () == -1) {
17188     printf ("test_rm_rf_0 FAILED\n");
17189     failed++;
17190   }
17191   test_num++;
17192   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
17193   if (test_rmdir_0 () == -1) {
17194     printf ("test_rmdir_0 FAILED\n");
17195     failed++;
17196   }
17197   test_num++;
17198   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
17199   if (test_rmdir_1 () == -1) {
17200     printf ("test_rmdir_1 FAILED\n");
17201     failed++;
17202   }
17203   test_num++;
17204   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
17205   if (test_rmdir_2 () == -1) {
17206     printf ("test_rmdir_2 FAILED\n");
17207     failed++;
17208   }
17209   test_num++;
17210   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
17211   if (test_rm_0 () == -1) {
17212     printf ("test_rm_0 FAILED\n");
17213     failed++;
17214   }
17215   test_num++;
17216   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
17217   if (test_rm_1 () == -1) {
17218     printf ("test_rm_1 FAILED\n");
17219     failed++;
17220   }
17221   test_num++;
17222   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
17223   if (test_rm_2 () == -1) {
17224     printf ("test_rm_2 FAILED\n");
17225     failed++;
17226   }
17227   test_num++;
17228   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
17229   if (test_read_lines_0 () == -1) {
17230     printf ("test_read_lines_0 FAILED\n");
17231     failed++;
17232   }
17233   test_num++;
17234   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
17235   if (test_read_lines_1 () == -1) {
17236     printf ("test_read_lines_1 FAILED\n");
17237     failed++;
17238   }
17239   test_num++;
17240   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
17241   if (test_lvs_0 () == -1) {
17242     printf ("test_lvs_0 FAILED\n");
17243     failed++;
17244   }
17245   test_num++;
17246   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
17247   if (test_lvs_1 () == -1) {
17248     printf ("test_lvs_1 FAILED\n");
17249     failed++;
17250   }
17251   test_num++;
17252   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
17253   if (test_vgs_0 () == -1) {
17254     printf ("test_vgs_0 FAILED\n");
17255     failed++;
17256   }
17257   test_num++;
17258   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17259   if (test_vgs_1 () == -1) {
17260     printf ("test_vgs_1 FAILED\n");
17261     failed++;
17262   }
17263   test_num++;
17264   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17265   if (test_pvs_0 () == -1) {
17266     printf ("test_pvs_0 FAILED\n");
17267     failed++;
17268   }
17269   test_num++;
17270   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17271   if (test_pvs_1 () == -1) {
17272     printf ("test_pvs_1 FAILED\n");
17273     failed++;
17274   }
17275   test_num++;
17276   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17277   if (test_list_partitions_0 () == -1) {
17278     printf ("test_list_partitions_0 FAILED\n");
17279     failed++;
17280   }
17281   test_num++;
17282   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17283   if (test_list_partitions_1 () == -1) {
17284     printf ("test_list_partitions_1 FAILED\n");
17285     failed++;
17286   }
17287   test_num++;
17288   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17289   if (test_list_devices_0 () == -1) {
17290     printf ("test_list_devices_0 FAILED\n");
17291     failed++;
17292   }
17293   test_num++;
17294   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17295   if (test_ls_0 () == -1) {
17296     printf ("test_ls_0 FAILED\n");
17297     failed++;
17298   }
17299   test_num++;
17300   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17301   if (test_cat_0 () == -1) {
17302     printf ("test_cat_0 FAILED\n");
17303     failed++;
17304   }
17305   test_num++;
17306   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17307   if (test_touch_0 () == -1) {
17308     printf ("test_touch_0 FAILED\n");
17309     failed++;
17310   }
17311   test_num++;
17312   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17313   if (test_sync_0 () == -1) {
17314     printf ("test_sync_0 FAILED\n");
17315     failed++;
17316   }
17317   test_num++;
17318   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17319   if (test_mount_0 () == -1) {
17320     printf ("test_mount_0 FAILED\n");
17321     failed++;
17322   }
17323
17324   guestfs_close (g);
17325   unlink ("test1.img");
17326   unlink ("test2.img");
17327   unlink ("test3.img");
17328
17329   if (failed > 0) {
17330     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
17331     exit (1);
17332   }
17333
17334   exit (0);
17335 }