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_hexdump_1_skip (void)
1801 {
1802   const char *str;
1803
1804   str = getenv ("SKIP_TEST_HEXDUMP_1");
1805   if (str && strcmp (str, "1") == 0) return 1;
1806   str = getenv ("SKIP_TEST_HEXDUMP");
1807   if (str && strcmp (str, "1") == 0) return 1;
1808   return 0;
1809 }
1810
1811 static int test_hexdump_1 (void)
1812 {
1813   if (test_hexdump_1_skip ()) {
1814     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_1");
1815     return 0;
1816   }
1817
1818   /* InitBasicFS for test_hexdump_1: 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   /* TestRun for hexdump (1) */
1873   {
1874     char options[] = "ro";
1875     char vfstype[] = "squashfs";
1876     char device[] = "/dev/sdd";
1877     char mountpoint[] = "/";
1878     int r;
1879     suppress_error = 0;
1880     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1881     if (r == -1)
1882       return -1;
1883   }
1884   {
1885     char path[] = "/100krandom";
1886     char *r;
1887     suppress_error = 0;
1888     r = guestfs_hexdump (g, path);
1889     if (r == NULL)
1890       return -1;
1891     free (r);
1892   }
1893   return 0;
1894 }
1895
1896 static int test_strings_e_0_skip (void)
1897 {
1898   const char *str;
1899
1900   str = getenv ("SKIP_TEST_STRINGS_E_0");
1901   if (str && strcmp (str, "1") == 0) return 1;
1902   str = getenv ("SKIP_TEST_STRINGS_E");
1903   if (str && strcmp (str, "1") == 0) return 1;
1904   return 0;
1905 }
1906
1907 static int test_strings_e_0 (void)
1908 {
1909   if (test_strings_e_0_skip ()) {
1910     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1911     return 0;
1912   }
1913
1914   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1915   {
1916     char device[] = "/dev/sda";
1917     int r;
1918     suppress_error = 0;
1919     r = guestfs_blockdev_setrw (g, device);
1920     if (r == -1)
1921       return -1;
1922   }
1923   {
1924     int r;
1925     suppress_error = 0;
1926     r = guestfs_umount_all (g);
1927     if (r == -1)
1928       return -1;
1929   }
1930   {
1931     int r;
1932     suppress_error = 0;
1933     r = guestfs_lvm_remove_all (g);
1934     if (r == -1)
1935       return -1;
1936   }
1937   {
1938     char device[] = "/dev/sda";
1939     char lines_0[] = ",";
1940     char *lines[] = {
1941       lines_0,
1942       NULL
1943     };
1944     int r;
1945     suppress_error = 0;
1946     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1947     if (r == -1)
1948       return -1;
1949   }
1950   {
1951     char fstype[] = "ext2";
1952     char device[] = "/dev/sda1";
1953     int r;
1954     suppress_error = 0;
1955     r = guestfs_mkfs (g, fstype, device);
1956     if (r == -1)
1957       return -1;
1958   }
1959   {
1960     char device[] = "/dev/sda1";
1961     char mountpoint[] = "/";
1962     int r;
1963     suppress_error = 0;
1964     r = guestfs_mount (g, device, mountpoint);
1965     if (r == -1)
1966       return -1;
1967   }
1968   /* TestOutputList for strings_e (0) */
1969   {
1970     char path[] = "/new";
1971     char content[] = "hello\nworld\n";
1972     int r;
1973     suppress_error = 0;
1974     r = guestfs_write_file (g, path, content, 0);
1975     if (r == -1)
1976       return -1;
1977   }
1978   {
1979     char encoding[] = "b";
1980     char path[] = "/new";
1981     char **r;
1982     int i;
1983     suppress_error = 0;
1984     r = guestfs_strings_e (g, encoding, path);
1985     if (r == NULL)
1986       return -1;
1987     if (r[0] != NULL) {
1988       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1989       print_strings (r);
1990       return -1;
1991     }
1992     for (i = 0; r[i] != NULL; ++i)
1993       free (r[i]);
1994     free (r);
1995   }
1996   return 0;
1997 }
1998
1999 static int test_strings_e_1_skip (void)
2000 {
2001   const char *str;
2002
2003   str = getenv ("SKIP_TEST_STRINGS_E_1");
2004   if (str && strcmp (str, "1") == 0) return 1;
2005   str = getenv ("SKIP_TEST_STRINGS_E");
2006   if (str && strcmp (str, "1") == 0) return 1;
2007   return 0;
2008 }
2009
2010 static int test_strings_e_1 (void)
2011 {
2012   if (test_strings_e_1_skip ()) {
2013     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
2014     return 0;
2015   }
2016
2017   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
2018   return 0;
2019 }
2020
2021 static int test_strings_0_skip (void)
2022 {
2023   const char *str;
2024
2025   str = getenv ("SKIP_TEST_STRINGS_0");
2026   if (str && strcmp (str, "1") == 0) return 1;
2027   str = getenv ("SKIP_TEST_STRINGS");
2028   if (str && strcmp (str, "1") == 0) return 1;
2029   return 0;
2030 }
2031
2032 static int test_strings_0 (void)
2033 {
2034   if (test_strings_0_skip ()) {
2035     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
2036     return 0;
2037   }
2038
2039   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
2040   {
2041     char device[] = "/dev/sda";
2042     int r;
2043     suppress_error = 0;
2044     r = guestfs_blockdev_setrw (g, device);
2045     if (r == -1)
2046       return -1;
2047   }
2048   {
2049     int r;
2050     suppress_error = 0;
2051     r = guestfs_umount_all (g);
2052     if (r == -1)
2053       return -1;
2054   }
2055   {
2056     int r;
2057     suppress_error = 0;
2058     r = guestfs_lvm_remove_all (g);
2059     if (r == -1)
2060       return -1;
2061   }
2062   {
2063     char device[] = "/dev/sda";
2064     char lines_0[] = ",";
2065     char *lines[] = {
2066       lines_0,
2067       NULL
2068     };
2069     int r;
2070     suppress_error = 0;
2071     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2072     if (r == -1)
2073       return -1;
2074   }
2075   {
2076     char fstype[] = "ext2";
2077     char device[] = "/dev/sda1";
2078     int r;
2079     suppress_error = 0;
2080     r = guestfs_mkfs (g, fstype, device);
2081     if (r == -1)
2082       return -1;
2083   }
2084   {
2085     char device[] = "/dev/sda1";
2086     char mountpoint[] = "/";
2087     int r;
2088     suppress_error = 0;
2089     r = guestfs_mount (g, device, mountpoint);
2090     if (r == -1)
2091       return -1;
2092   }
2093   /* TestOutputList for strings (0) */
2094   {
2095     char path[] = "/new";
2096     char content[] = "hello\nworld\n";
2097     int r;
2098     suppress_error = 0;
2099     r = guestfs_write_file (g, path, content, 0);
2100     if (r == -1)
2101       return -1;
2102   }
2103   {
2104     char path[] = "/new";
2105     char **r;
2106     int i;
2107     suppress_error = 0;
2108     r = guestfs_strings (g, path);
2109     if (r == NULL)
2110       return -1;
2111     if (!r[0]) {
2112       fprintf (stderr, "test_strings_0: short list returned from command\n");
2113       print_strings (r);
2114       return -1;
2115     }
2116     {
2117       char expected[] = "hello";
2118       if (strcmp (r[0], expected) != 0) {
2119         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2120         return -1;
2121       }
2122     }
2123     if (!r[1]) {
2124       fprintf (stderr, "test_strings_0: short list returned from command\n");
2125       print_strings (r);
2126       return -1;
2127     }
2128     {
2129       char expected[] = "world";
2130       if (strcmp (r[1], expected) != 0) {
2131         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2132         return -1;
2133       }
2134     }
2135     if (r[2] != NULL) {
2136       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
2137       print_strings (r);
2138       return -1;
2139     }
2140     for (i = 0; r[i] != NULL; ++i)
2141       free (r[i]);
2142     free (r);
2143   }
2144   return 0;
2145 }
2146
2147 static int test_strings_1_skip (void)
2148 {
2149   const char *str;
2150
2151   str = getenv ("SKIP_TEST_STRINGS_1");
2152   if (str && strcmp (str, "1") == 0) return 1;
2153   str = getenv ("SKIP_TEST_STRINGS");
2154   if (str && strcmp (str, "1") == 0) return 1;
2155   return 0;
2156 }
2157
2158 static int test_strings_1 (void)
2159 {
2160   if (test_strings_1_skip ()) {
2161     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
2162     return 0;
2163   }
2164
2165   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
2166   {
2167     char device[] = "/dev/sda";
2168     int r;
2169     suppress_error = 0;
2170     r = guestfs_blockdev_setrw (g, device);
2171     if (r == -1)
2172       return -1;
2173   }
2174   {
2175     int r;
2176     suppress_error = 0;
2177     r = guestfs_umount_all (g);
2178     if (r == -1)
2179       return -1;
2180   }
2181   {
2182     int r;
2183     suppress_error = 0;
2184     r = guestfs_lvm_remove_all (g);
2185     if (r == -1)
2186       return -1;
2187   }
2188   {
2189     char device[] = "/dev/sda";
2190     char lines_0[] = ",";
2191     char *lines[] = {
2192       lines_0,
2193       NULL
2194     };
2195     int r;
2196     suppress_error = 0;
2197     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2198     if (r == -1)
2199       return -1;
2200   }
2201   {
2202     char fstype[] = "ext2";
2203     char device[] = "/dev/sda1";
2204     int r;
2205     suppress_error = 0;
2206     r = guestfs_mkfs (g, fstype, device);
2207     if (r == -1)
2208       return -1;
2209   }
2210   {
2211     char device[] = "/dev/sda1";
2212     char mountpoint[] = "/";
2213     int r;
2214     suppress_error = 0;
2215     r = guestfs_mount (g, device, mountpoint);
2216     if (r == -1)
2217       return -1;
2218   }
2219   /* TestOutputList for strings (1) */
2220   {
2221     char path[] = "/new";
2222     int r;
2223     suppress_error = 0;
2224     r = guestfs_touch (g, path);
2225     if (r == -1)
2226       return -1;
2227   }
2228   {
2229     char path[] = "/new";
2230     char **r;
2231     int i;
2232     suppress_error = 0;
2233     r = guestfs_strings (g, path);
2234     if (r == NULL)
2235       return -1;
2236     if (r[0] != NULL) {
2237       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
2238       print_strings (r);
2239       return -1;
2240     }
2241     for (i = 0; r[i] != NULL; ++i)
2242       free (r[i]);
2243     free (r);
2244   }
2245   return 0;
2246 }
2247
2248 static int test_equal_0_skip (void)
2249 {
2250   const char *str;
2251
2252   str = getenv ("SKIP_TEST_EQUAL_0");
2253   if (str && strcmp (str, "1") == 0) return 1;
2254   str = getenv ("SKIP_TEST_EQUAL");
2255   if (str && strcmp (str, "1") == 0) return 1;
2256   return 0;
2257 }
2258
2259 static int test_equal_0 (void)
2260 {
2261   if (test_equal_0_skip ()) {
2262     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
2263     return 0;
2264   }
2265
2266   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
2267   {
2268     char device[] = "/dev/sda";
2269     int r;
2270     suppress_error = 0;
2271     r = guestfs_blockdev_setrw (g, device);
2272     if (r == -1)
2273       return -1;
2274   }
2275   {
2276     int r;
2277     suppress_error = 0;
2278     r = guestfs_umount_all (g);
2279     if (r == -1)
2280       return -1;
2281   }
2282   {
2283     int r;
2284     suppress_error = 0;
2285     r = guestfs_lvm_remove_all (g);
2286     if (r == -1)
2287       return -1;
2288   }
2289   {
2290     char device[] = "/dev/sda";
2291     char lines_0[] = ",";
2292     char *lines[] = {
2293       lines_0,
2294       NULL
2295     };
2296     int r;
2297     suppress_error = 0;
2298     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2299     if (r == -1)
2300       return -1;
2301   }
2302   {
2303     char fstype[] = "ext2";
2304     char device[] = "/dev/sda1";
2305     int r;
2306     suppress_error = 0;
2307     r = guestfs_mkfs (g, fstype, device);
2308     if (r == -1)
2309       return -1;
2310   }
2311   {
2312     char device[] = "/dev/sda1";
2313     char mountpoint[] = "/";
2314     int r;
2315     suppress_error = 0;
2316     r = guestfs_mount (g, device, mountpoint);
2317     if (r == -1)
2318       return -1;
2319   }
2320   /* TestOutputTrue for equal (0) */
2321   {
2322     char path[] = "/file1";
2323     char content[] = "contents of a file";
2324     int r;
2325     suppress_error = 0;
2326     r = guestfs_write_file (g, path, content, 0);
2327     if (r == -1)
2328       return -1;
2329   }
2330   {
2331     char src[] = "/file1";
2332     char dest[] = "/file2";
2333     int r;
2334     suppress_error = 0;
2335     r = guestfs_cp (g, src, dest);
2336     if (r == -1)
2337       return -1;
2338   }
2339   {
2340     char file1[] = "/file1";
2341     char file2[] = "/file2";
2342     int r;
2343     suppress_error = 0;
2344     r = guestfs_equal (g, file1, file2);
2345     if (r == -1)
2346       return -1;
2347     if (!r) {
2348       fprintf (stderr, "test_equal_0: expected true, got false\n");
2349       return -1;
2350     }
2351   }
2352   return 0;
2353 }
2354
2355 static int test_equal_1_skip (void)
2356 {
2357   const char *str;
2358
2359   str = getenv ("SKIP_TEST_EQUAL_1");
2360   if (str && strcmp (str, "1") == 0) return 1;
2361   str = getenv ("SKIP_TEST_EQUAL");
2362   if (str && strcmp (str, "1") == 0) return 1;
2363   return 0;
2364 }
2365
2366 static int test_equal_1 (void)
2367 {
2368   if (test_equal_1_skip ()) {
2369     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
2370     return 0;
2371   }
2372
2373   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2374   {
2375     char device[] = "/dev/sda";
2376     int r;
2377     suppress_error = 0;
2378     r = guestfs_blockdev_setrw (g, device);
2379     if (r == -1)
2380       return -1;
2381   }
2382   {
2383     int r;
2384     suppress_error = 0;
2385     r = guestfs_umount_all (g);
2386     if (r == -1)
2387       return -1;
2388   }
2389   {
2390     int r;
2391     suppress_error = 0;
2392     r = guestfs_lvm_remove_all (g);
2393     if (r == -1)
2394       return -1;
2395   }
2396   {
2397     char device[] = "/dev/sda";
2398     char lines_0[] = ",";
2399     char *lines[] = {
2400       lines_0,
2401       NULL
2402     };
2403     int r;
2404     suppress_error = 0;
2405     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2406     if (r == -1)
2407       return -1;
2408   }
2409   {
2410     char fstype[] = "ext2";
2411     char device[] = "/dev/sda1";
2412     int r;
2413     suppress_error = 0;
2414     r = guestfs_mkfs (g, fstype, device);
2415     if (r == -1)
2416       return -1;
2417   }
2418   {
2419     char device[] = "/dev/sda1";
2420     char mountpoint[] = "/";
2421     int r;
2422     suppress_error = 0;
2423     r = guestfs_mount (g, device, mountpoint);
2424     if (r == -1)
2425       return -1;
2426   }
2427   /* TestOutputFalse for equal (1) */
2428   {
2429     char path[] = "/file1";
2430     char content[] = "contents of a file";
2431     int r;
2432     suppress_error = 0;
2433     r = guestfs_write_file (g, path, content, 0);
2434     if (r == -1)
2435       return -1;
2436   }
2437   {
2438     char path[] = "/file2";
2439     char content[] = "contents of another file";
2440     int r;
2441     suppress_error = 0;
2442     r = guestfs_write_file (g, path, content, 0);
2443     if (r == -1)
2444       return -1;
2445   }
2446   {
2447     char file1[] = "/file1";
2448     char file2[] = "/file2";
2449     int r;
2450     suppress_error = 0;
2451     r = guestfs_equal (g, file1, file2);
2452     if (r == -1)
2453       return -1;
2454     if (r) {
2455       fprintf (stderr, "test_equal_1: expected false, got true\n");
2456       return -1;
2457     }
2458   }
2459   return 0;
2460 }
2461
2462 static int test_equal_2_skip (void)
2463 {
2464   const char *str;
2465
2466   str = getenv ("SKIP_TEST_EQUAL_2");
2467   if (str && strcmp (str, "1") == 0) return 1;
2468   str = getenv ("SKIP_TEST_EQUAL");
2469   if (str && strcmp (str, "1") == 0) return 1;
2470   return 0;
2471 }
2472
2473 static int test_equal_2 (void)
2474 {
2475   if (test_equal_2_skip ()) {
2476     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
2477     return 0;
2478   }
2479
2480   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
2481   {
2482     char device[] = "/dev/sda";
2483     int r;
2484     suppress_error = 0;
2485     r = guestfs_blockdev_setrw (g, device);
2486     if (r == -1)
2487       return -1;
2488   }
2489   {
2490     int r;
2491     suppress_error = 0;
2492     r = guestfs_umount_all (g);
2493     if (r == -1)
2494       return -1;
2495   }
2496   {
2497     int r;
2498     suppress_error = 0;
2499     r = guestfs_lvm_remove_all (g);
2500     if (r == -1)
2501       return -1;
2502   }
2503   {
2504     char device[] = "/dev/sda";
2505     char lines_0[] = ",";
2506     char *lines[] = {
2507       lines_0,
2508       NULL
2509     };
2510     int r;
2511     suppress_error = 0;
2512     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2513     if (r == -1)
2514       return -1;
2515   }
2516   {
2517     char fstype[] = "ext2";
2518     char device[] = "/dev/sda1";
2519     int r;
2520     suppress_error = 0;
2521     r = guestfs_mkfs (g, fstype, device);
2522     if (r == -1)
2523       return -1;
2524   }
2525   {
2526     char device[] = "/dev/sda1";
2527     char mountpoint[] = "/";
2528     int r;
2529     suppress_error = 0;
2530     r = guestfs_mount (g, device, mountpoint);
2531     if (r == -1)
2532       return -1;
2533   }
2534   /* TestLastFail for equal (2) */
2535   {
2536     char file1[] = "/file1";
2537     char file2[] = "/file2";
2538     int r;
2539     suppress_error = 1;
2540     r = guestfs_equal (g, file1, file2);
2541     if (r != -1)
2542       return -1;
2543   }
2544   return 0;
2545 }
2546
2547 static int test_ping_daemon_0_skip (void)
2548 {
2549   const char *str;
2550
2551   str = getenv ("SKIP_TEST_PING_DAEMON_0");
2552   if (str && strcmp (str, "1") == 0) return 1;
2553   str = getenv ("SKIP_TEST_PING_DAEMON");
2554   if (str && strcmp (str, "1") == 0) return 1;
2555   return 0;
2556 }
2557
2558 static int test_ping_daemon_0 (void)
2559 {
2560   if (test_ping_daemon_0_skip ()) {
2561     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
2562     return 0;
2563   }
2564
2565   /* InitNone|InitEmpty for test_ping_daemon_0 */
2566   {
2567     char device[] = "/dev/sda";
2568     int r;
2569     suppress_error = 0;
2570     r = guestfs_blockdev_setrw (g, device);
2571     if (r == -1)
2572       return -1;
2573   }
2574   {
2575     int r;
2576     suppress_error = 0;
2577     r = guestfs_umount_all (g);
2578     if (r == -1)
2579       return -1;
2580   }
2581   {
2582     int r;
2583     suppress_error = 0;
2584     r = guestfs_lvm_remove_all (g);
2585     if (r == -1)
2586       return -1;
2587   }
2588   /* TestRun for ping_daemon (0) */
2589   {
2590     int r;
2591     suppress_error = 0;
2592     r = guestfs_ping_daemon (g);
2593     if (r == -1)
2594       return -1;
2595   }
2596   return 0;
2597 }
2598
2599 static int test_dmesg_0_skip (void)
2600 {
2601   const char *str;
2602
2603   str = getenv ("SKIP_TEST_DMESG_0");
2604   if (str && strcmp (str, "1") == 0) return 1;
2605   str = getenv ("SKIP_TEST_DMESG");
2606   if (str && strcmp (str, "1") == 0) return 1;
2607   return 0;
2608 }
2609
2610 static int test_dmesg_0 (void)
2611 {
2612   if (test_dmesg_0_skip ()) {
2613     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
2614     return 0;
2615   }
2616
2617   /* InitNone|InitEmpty for test_dmesg_0 */
2618   {
2619     char device[] = "/dev/sda";
2620     int r;
2621     suppress_error = 0;
2622     r = guestfs_blockdev_setrw (g, device);
2623     if (r == -1)
2624       return -1;
2625   }
2626   {
2627     int r;
2628     suppress_error = 0;
2629     r = guestfs_umount_all (g);
2630     if (r == -1)
2631       return -1;
2632   }
2633   {
2634     int r;
2635     suppress_error = 0;
2636     r = guestfs_lvm_remove_all (g);
2637     if (r == -1)
2638       return -1;
2639   }
2640   /* TestRun for dmesg (0) */
2641   {
2642     char *r;
2643     suppress_error = 0;
2644     r = guestfs_dmesg (g);
2645     if (r == NULL)
2646       return -1;
2647     free (r);
2648   }
2649   return 0;
2650 }
2651
2652 static int test_drop_caches_0_skip (void)
2653 {
2654   const char *str;
2655
2656   str = getenv ("SKIP_TEST_DROP_CACHES_0");
2657   if (str && strcmp (str, "1") == 0) return 1;
2658   str = getenv ("SKIP_TEST_DROP_CACHES");
2659   if (str && strcmp (str, "1") == 0) return 1;
2660   return 0;
2661 }
2662
2663 static int test_drop_caches_0 (void)
2664 {
2665   if (test_drop_caches_0_skip ()) {
2666     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
2667     return 0;
2668   }
2669
2670   /* InitNone|InitEmpty for test_drop_caches_0 */
2671   {
2672     char device[] = "/dev/sda";
2673     int r;
2674     suppress_error = 0;
2675     r = guestfs_blockdev_setrw (g, device);
2676     if (r == -1)
2677       return -1;
2678   }
2679   {
2680     int r;
2681     suppress_error = 0;
2682     r = guestfs_umount_all (g);
2683     if (r == -1)
2684       return -1;
2685   }
2686   {
2687     int r;
2688     suppress_error = 0;
2689     r = guestfs_lvm_remove_all (g);
2690     if (r == -1)
2691       return -1;
2692   }
2693   /* TestRun for drop_caches (0) */
2694   {
2695     int r;
2696     suppress_error = 0;
2697     r = guestfs_drop_caches (g, 3);
2698     if (r == -1)
2699       return -1;
2700   }
2701   return 0;
2702 }
2703
2704 static int test_mv_0_skip (void)
2705 {
2706   const char *str;
2707
2708   str = getenv ("SKIP_TEST_MV_0");
2709   if (str && strcmp (str, "1") == 0) return 1;
2710   str = getenv ("SKIP_TEST_MV");
2711   if (str && strcmp (str, "1") == 0) return 1;
2712   return 0;
2713 }
2714
2715 static int test_mv_0 (void)
2716 {
2717   if (test_mv_0_skip ()) {
2718     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2719     return 0;
2720   }
2721
2722   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2723   {
2724     char device[] = "/dev/sda";
2725     int r;
2726     suppress_error = 0;
2727     r = guestfs_blockdev_setrw (g, device);
2728     if (r == -1)
2729       return -1;
2730   }
2731   {
2732     int r;
2733     suppress_error = 0;
2734     r = guestfs_umount_all (g);
2735     if (r == -1)
2736       return -1;
2737   }
2738   {
2739     int r;
2740     suppress_error = 0;
2741     r = guestfs_lvm_remove_all (g);
2742     if (r == -1)
2743       return -1;
2744   }
2745   {
2746     char device[] = "/dev/sda";
2747     char lines_0[] = ",";
2748     char *lines[] = {
2749       lines_0,
2750       NULL
2751     };
2752     int r;
2753     suppress_error = 0;
2754     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2755     if (r == -1)
2756       return -1;
2757   }
2758   {
2759     char fstype[] = "ext2";
2760     char device[] = "/dev/sda1";
2761     int r;
2762     suppress_error = 0;
2763     r = guestfs_mkfs (g, fstype, device);
2764     if (r == -1)
2765       return -1;
2766   }
2767   {
2768     char device[] = "/dev/sda1";
2769     char mountpoint[] = "/";
2770     int r;
2771     suppress_error = 0;
2772     r = guestfs_mount (g, device, mountpoint);
2773     if (r == -1)
2774       return -1;
2775   }
2776   /* TestOutput for mv (0) */
2777   char expected[] = "file content";
2778   {
2779     char path[] = "/old";
2780     char content[] = "file content";
2781     int r;
2782     suppress_error = 0;
2783     r = guestfs_write_file (g, path, content, 0);
2784     if (r == -1)
2785       return -1;
2786   }
2787   {
2788     char src[] = "/old";
2789     char dest[] = "/new";
2790     int r;
2791     suppress_error = 0;
2792     r = guestfs_mv (g, src, dest);
2793     if (r == -1)
2794       return -1;
2795   }
2796   {
2797     char path[] = "/new";
2798     char *r;
2799     suppress_error = 0;
2800     r = guestfs_cat (g, path);
2801     if (r == NULL)
2802       return -1;
2803     if (strcmp (r, expected) != 0) {
2804       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2805       return -1;
2806     }
2807     free (r);
2808   }
2809   return 0;
2810 }
2811
2812 static int test_mv_1_skip (void)
2813 {
2814   const char *str;
2815
2816   str = getenv ("SKIP_TEST_MV_1");
2817   if (str && strcmp (str, "1") == 0) return 1;
2818   str = getenv ("SKIP_TEST_MV");
2819   if (str && strcmp (str, "1") == 0) return 1;
2820   return 0;
2821 }
2822
2823 static int test_mv_1 (void)
2824 {
2825   if (test_mv_1_skip ()) {
2826     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2827     return 0;
2828   }
2829
2830   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2831   {
2832     char device[] = "/dev/sda";
2833     int r;
2834     suppress_error = 0;
2835     r = guestfs_blockdev_setrw (g, device);
2836     if (r == -1)
2837       return -1;
2838   }
2839   {
2840     int r;
2841     suppress_error = 0;
2842     r = guestfs_umount_all (g);
2843     if (r == -1)
2844       return -1;
2845   }
2846   {
2847     int r;
2848     suppress_error = 0;
2849     r = guestfs_lvm_remove_all (g);
2850     if (r == -1)
2851       return -1;
2852   }
2853   {
2854     char device[] = "/dev/sda";
2855     char lines_0[] = ",";
2856     char *lines[] = {
2857       lines_0,
2858       NULL
2859     };
2860     int r;
2861     suppress_error = 0;
2862     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2863     if (r == -1)
2864       return -1;
2865   }
2866   {
2867     char fstype[] = "ext2";
2868     char device[] = "/dev/sda1";
2869     int r;
2870     suppress_error = 0;
2871     r = guestfs_mkfs (g, fstype, device);
2872     if (r == -1)
2873       return -1;
2874   }
2875   {
2876     char device[] = "/dev/sda1";
2877     char mountpoint[] = "/";
2878     int r;
2879     suppress_error = 0;
2880     r = guestfs_mount (g, device, mountpoint);
2881     if (r == -1)
2882       return -1;
2883   }
2884   /* TestOutputFalse for mv (1) */
2885   {
2886     char path[] = "/old";
2887     char content[] = "file content";
2888     int r;
2889     suppress_error = 0;
2890     r = guestfs_write_file (g, path, content, 0);
2891     if (r == -1)
2892       return -1;
2893   }
2894   {
2895     char src[] = "/old";
2896     char dest[] = "/new";
2897     int r;
2898     suppress_error = 0;
2899     r = guestfs_mv (g, src, dest);
2900     if (r == -1)
2901       return -1;
2902   }
2903   {
2904     char path[] = "/old";
2905     int r;
2906     suppress_error = 0;
2907     r = guestfs_is_file (g, path);
2908     if (r == -1)
2909       return -1;
2910     if (r) {
2911       fprintf (stderr, "test_mv_1: expected false, got true\n");
2912       return -1;
2913     }
2914   }
2915   return 0;
2916 }
2917
2918 static int test_cp_a_0_skip (void)
2919 {
2920   const char *str;
2921
2922   str = getenv ("SKIP_TEST_CP_A_0");
2923   if (str && strcmp (str, "1") == 0) return 1;
2924   str = getenv ("SKIP_TEST_CP_A");
2925   if (str && strcmp (str, "1") == 0) return 1;
2926   return 0;
2927 }
2928
2929 static int test_cp_a_0 (void)
2930 {
2931   if (test_cp_a_0_skip ()) {
2932     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2933     return 0;
2934   }
2935
2936   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2937   {
2938     char device[] = "/dev/sda";
2939     int r;
2940     suppress_error = 0;
2941     r = guestfs_blockdev_setrw (g, device);
2942     if (r == -1)
2943       return -1;
2944   }
2945   {
2946     int r;
2947     suppress_error = 0;
2948     r = guestfs_umount_all (g);
2949     if (r == -1)
2950       return -1;
2951   }
2952   {
2953     int r;
2954     suppress_error = 0;
2955     r = guestfs_lvm_remove_all (g);
2956     if (r == -1)
2957       return -1;
2958   }
2959   {
2960     char device[] = "/dev/sda";
2961     char lines_0[] = ",";
2962     char *lines[] = {
2963       lines_0,
2964       NULL
2965     };
2966     int r;
2967     suppress_error = 0;
2968     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2969     if (r == -1)
2970       return -1;
2971   }
2972   {
2973     char fstype[] = "ext2";
2974     char device[] = "/dev/sda1";
2975     int r;
2976     suppress_error = 0;
2977     r = guestfs_mkfs (g, fstype, device);
2978     if (r == -1)
2979       return -1;
2980   }
2981   {
2982     char device[] = "/dev/sda1";
2983     char mountpoint[] = "/";
2984     int r;
2985     suppress_error = 0;
2986     r = guestfs_mount (g, device, mountpoint);
2987     if (r == -1)
2988       return -1;
2989   }
2990   /* TestOutput for cp_a (0) */
2991   char expected[] = "file content";
2992   {
2993     char path[] = "/olddir";
2994     int r;
2995     suppress_error = 0;
2996     r = guestfs_mkdir (g, path);
2997     if (r == -1)
2998       return -1;
2999   }
3000   {
3001     char path[] = "/newdir";
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_mkdir (g, path);
3005     if (r == -1)
3006       return -1;
3007   }
3008   {
3009     char path[] = "/olddir/file";
3010     char content[] = "file content";
3011     int r;
3012     suppress_error = 0;
3013     r = guestfs_write_file (g, path, content, 0);
3014     if (r == -1)
3015       return -1;
3016   }
3017   {
3018     char src[] = "/olddir";
3019     char dest[] = "/newdir";
3020     int r;
3021     suppress_error = 0;
3022     r = guestfs_cp_a (g, src, dest);
3023     if (r == -1)
3024       return -1;
3025   }
3026   {
3027     char path[] = "/newdir/olddir/file";
3028     char *r;
3029     suppress_error = 0;
3030     r = guestfs_cat (g, path);
3031     if (r == NULL)
3032       return -1;
3033     if (strcmp (r, expected) != 0) {
3034       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
3035       return -1;
3036     }
3037     free (r);
3038   }
3039   return 0;
3040 }
3041
3042 static int test_cp_0_skip (void)
3043 {
3044   const char *str;
3045
3046   str = getenv ("SKIP_TEST_CP_0");
3047   if (str && strcmp (str, "1") == 0) return 1;
3048   str = getenv ("SKIP_TEST_CP");
3049   if (str && strcmp (str, "1") == 0) return 1;
3050   return 0;
3051 }
3052
3053 static int test_cp_0 (void)
3054 {
3055   if (test_cp_0_skip ()) {
3056     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
3057     return 0;
3058   }
3059
3060   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
3061   {
3062     char device[] = "/dev/sda";
3063     int r;
3064     suppress_error = 0;
3065     r = guestfs_blockdev_setrw (g, device);
3066     if (r == -1)
3067       return -1;
3068   }
3069   {
3070     int r;
3071     suppress_error = 0;
3072     r = guestfs_umount_all (g);
3073     if (r == -1)
3074       return -1;
3075   }
3076   {
3077     int r;
3078     suppress_error = 0;
3079     r = guestfs_lvm_remove_all (g);
3080     if (r == -1)
3081       return -1;
3082   }
3083   {
3084     char device[] = "/dev/sda";
3085     char lines_0[] = ",";
3086     char *lines[] = {
3087       lines_0,
3088       NULL
3089     };
3090     int r;
3091     suppress_error = 0;
3092     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3093     if (r == -1)
3094       return -1;
3095   }
3096   {
3097     char fstype[] = "ext2";
3098     char device[] = "/dev/sda1";
3099     int r;
3100     suppress_error = 0;
3101     r = guestfs_mkfs (g, fstype, device);
3102     if (r == -1)
3103       return -1;
3104   }
3105   {
3106     char device[] = "/dev/sda1";
3107     char mountpoint[] = "/";
3108     int r;
3109     suppress_error = 0;
3110     r = guestfs_mount (g, device, mountpoint);
3111     if (r == -1)
3112       return -1;
3113   }
3114   /* TestOutput for cp (0) */
3115   char expected[] = "file content";
3116   {
3117     char path[] = "/old";
3118     char content[] = "file content";
3119     int r;
3120     suppress_error = 0;
3121     r = guestfs_write_file (g, path, content, 0);
3122     if (r == -1)
3123       return -1;
3124   }
3125   {
3126     char src[] = "/old";
3127     char dest[] = "/new";
3128     int r;
3129     suppress_error = 0;
3130     r = guestfs_cp (g, src, dest);
3131     if (r == -1)
3132       return -1;
3133   }
3134   {
3135     char path[] = "/new";
3136     char *r;
3137     suppress_error = 0;
3138     r = guestfs_cat (g, path);
3139     if (r == NULL)
3140       return -1;
3141     if (strcmp (r, expected) != 0) {
3142       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
3143       return -1;
3144     }
3145     free (r);
3146   }
3147   return 0;
3148 }
3149
3150 static int test_cp_1_skip (void)
3151 {
3152   const char *str;
3153
3154   str = getenv ("SKIP_TEST_CP_1");
3155   if (str && strcmp (str, "1") == 0) return 1;
3156   str = getenv ("SKIP_TEST_CP");
3157   if (str && strcmp (str, "1") == 0) return 1;
3158   return 0;
3159 }
3160
3161 static int test_cp_1 (void)
3162 {
3163   if (test_cp_1_skip ()) {
3164     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
3165     return 0;
3166   }
3167
3168   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
3169   {
3170     char device[] = "/dev/sda";
3171     int r;
3172     suppress_error = 0;
3173     r = guestfs_blockdev_setrw (g, device);
3174     if (r == -1)
3175       return -1;
3176   }
3177   {
3178     int r;
3179     suppress_error = 0;
3180     r = guestfs_umount_all (g);
3181     if (r == -1)
3182       return -1;
3183   }
3184   {
3185     int r;
3186     suppress_error = 0;
3187     r = guestfs_lvm_remove_all (g);
3188     if (r == -1)
3189       return -1;
3190   }
3191   {
3192     char device[] = "/dev/sda";
3193     char lines_0[] = ",";
3194     char *lines[] = {
3195       lines_0,
3196       NULL
3197     };
3198     int r;
3199     suppress_error = 0;
3200     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3201     if (r == -1)
3202       return -1;
3203   }
3204   {
3205     char fstype[] = "ext2";
3206     char device[] = "/dev/sda1";
3207     int r;
3208     suppress_error = 0;
3209     r = guestfs_mkfs (g, fstype, device);
3210     if (r == -1)
3211       return -1;
3212   }
3213   {
3214     char device[] = "/dev/sda1";
3215     char mountpoint[] = "/";
3216     int r;
3217     suppress_error = 0;
3218     r = guestfs_mount (g, device, mountpoint);
3219     if (r == -1)
3220       return -1;
3221   }
3222   /* TestOutputTrue for cp (1) */
3223   {
3224     char path[] = "/old";
3225     char content[] = "file content";
3226     int r;
3227     suppress_error = 0;
3228     r = guestfs_write_file (g, path, content, 0);
3229     if (r == -1)
3230       return -1;
3231   }
3232   {
3233     char src[] = "/old";
3234     char dest[] = "/new";
3235     int r;
3236     suppress_error = 0;
3237     r = guestfs_cp (g, src, dest);
3238     if (r == -1)
3239       return -1;
3240   }
3241   {
3242     char path[] = "/old";
3243     int r;
3244     suppress_error = 0;
3245     r = guestfs_is_file (g, path);
3246     if (r == -1)
3247       return -1;
3248     if (!r) {
3249       fprintf (stderr, "test_cp_1: expected true, got false\n");
3250       return -1;
3251     }
3252   }
3253   return 0;
3254 }
3255
3256 static int test_cp_2_skip (void)
3257 {
3258   const char *str;
3259
3260   str = getenv ("SKIP_TEST_CP_2");
3261   if (str && strcmp (str, "1") == 0) return 1;
3262   str = getenv ("SKIP_TEST_CP");
3263   if (str && strcmp (str, "1") == 0) return 1;
3264   return 0;
3265 }
3266
3267 static int test_cp_2 (void)
3268 {
3269   if (test_cp_2_skip ()) {
3270     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
3271     return 0;
3272   }
3273
3274   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
3275   {
3276     char device[] = "/dev/sda";
3277     int r;
3278     suppress_error = 0;
3279     r = guestfs_blockdev_setrw (g, device);
3280     if (r == -1)
3281       return -1;
3282   }
3283   {
3284     int r;
3285     suppress_error = 0;
3286     r = guestfs_umount_all (g);
3287     if (r == -1)
3288       return -1;
3289   }
3290   {
3291     int r;
3292     suppress_error = 0;
3293     r = guestfs_lvm_remove_all (g);
3294     if (r == -1)
3295       return -1;
3296   }
3297   {
3298     char device[] = "/dev/sda";
3299     char lines_0[] = ",";
3300     char *lines[] = {
3301       lines_0,
3302       NULL
3303     };
3304     int r;
3305     suppress_error = 0;
3306     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3307     if (r == -1)
3308       return -1;
3309   }
3310   {
3311     char fstype[] = "ext2";
3312     char device[] = "/dev/sda1";
3313     int r;
3314     suppress_error = 0;
3315     r = guestfs_mkfs (g, fstype, device);
3316     if (r == -1)
3317       return -1;
3318   }
3319   {
3320     char device[] = "/dev/sda1";
3321     char mountpoint[] = "/";
3322     int r;
3323     suppress_error = 0;
3324     r = guestfs_mount (g, device, mountpoint);
3325     if (r == -1)
3326       return -1;
3327   }
3328   /* TestOutput for cp (2) */
3329   char expected[] = "file content";
3330   {
3331     char path[] = "/old";
3332     char content[] = "file content";
3333     int r;
3334     suppress_error = 0;
3335     r = guestfs_write_file (g, path, content, 0);
3336     if (r == -1)
3337       return -1;
3338   }
3339   {
3340     char path[] = "/dir";
3341     int r;
3342     suppress_error = 0;
3343     r = guestfs_mkdir (g, path);
3344     if (r == -1)
3345       return -1;
3346   }
3347   {
3348     char src[] = "/old";
3349     char dest[] = "/dir/new";
3350     int r;
3351     suppress_error = 0;
3352     r = guestfs_cp (g, src, dest);
3353     if (r == -1)
3354       return -1;
3355   }
3356   {
3357     char path[] = "/dir/new";
3358     char *r;
3359     suppress_error = 0;
3360     r = guestfs_cat (g, path);
3361     if (r == NULL)
3362       return -1;
3363     if (strcmp (r, expected) != 0) {
3364       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3365       return -1;
3366     }
3367     free (r);
3368   }
3369   return 0;
3370 }
3371
3372 static int test_grub_install_0_skip (void)
3373 {
3374   const char *str;
3375
3376   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3377   if (str && strcmp (str, "1") == 0) return 1;
3378   str = getenv ("SKIP_TEST_GRUB_INSTALL");
3379   if (str && strcmp (str, "1") == 0) return 1;
3380   return 0;
3381 }
3382
3383 static int test_grub_install_0 (void)
3384 {
3385   if (test_grub_install_0_skip ()) {
3386     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
3387     return 0;
3388   }
3389
3390   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3391   {
3392     char device[] = "/dev/sda";
3393     int r;
3394     suppress_error = 0;
3395     r = guestfs_blockdev_setrw (g, device);
3396     if (r == -1)
3397       return -1;
3398   }
3399   {
3400     int r;
3401     suppress_error = 0;
3402     r = guestfs_umount_all (g);
3403     if (r == -1)
3404       return -1;
3405   }
3406   {
3407     int r;
3408     suppress_error = 0;
3409     r = guestfs_lvm_remove_all (g);
3410     if (r == -1)
3411       return -1;
3412   }
3413   {
3414     char device[] = "/dev/sda";
3415     char lines_0[] = ",";
3416     char *lines[] = {
3417       lines_0,
3418       NULL
3419     };
3420     int r;
3421     suppress_error = 0;
3422     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3423     if (r == -1)
3424       return -1;
3425   }
3426   {
3427     char fstype[] = "ext2";
3428     char device[] = "/dev/sda1";
3429     int r;
3430     suppress_error = 0;
3431     r = guestfs_mkfs (g, fstype, device);
3432     if (r == -1)
3433       return -1;
3434   }
3435   {
3436     char device[] = "/dev/sda1";
3437     char mountpoint[] = "/";
3438     int r;
3439     suppress_error = 0;
3440     r = guestfs_mount (g, device, mountpoint);
3441     if (r == -1)
3442       return -1;
3443   }
3444   /* TestOutputTrue for grub_install (0) */
3445   {
3446     char root[] = "/";
3447     char device[] = "/dev/sda1";
3448     int r;
3449     suppress_error = 0;
3450     r = guestfs_grub_install (g, root, device);
3451     if (r == -1)
3452       return -1;
3453   }
3454   {
3455     char path[] = "/boot";
3456     int r;
3457     suppress_error = 0;
3458     r = guestfs_is_dir (g, path);
3459     if (r == -1)
3460       return -1;
3461     if (!r) {
3462       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3463       return -1;
3464     }
3465   }
3466   return 0;
3467 }
3468
3469 static int test_zero_0_skip (void)
3470 {
3471   const char *str;
3472
3473   str = getenv ("SKIP_TEST_ZERO_0");
3474   if (str && strcmp (str, "1") == 0) return 1;
3475   str = getenv ("SKIP_TEST_ZERO");
3476   if (str && strcmp (str, "1") == 0) return 1;
3477   return 0;
3478 }
3479
3480 static int test_zero_0 (void)
3481 {
3482   if (test_zero_0_skip ()) {
3483     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
3484     return 0;
3485   }
3486
3487   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3488   {
3489     char device[] = "/dev/sda";
3490     int r;
3491     suppress_error = 0;
3492     r = guestfs_blockdev_setrw (g, device);
3493     if (r == -1)
3494       return -1;
3495   }
3496   {
3497     int r;
3498     suppress_error = 0;
3499     r = guestfs_umount_all (g);
3500     if (r == -1)
3501       return -1;
3502   }
3503   {
3504     int r;
3505     suppress_error = 0;
3506     r = guestfs_lvm_remove_all (g);
3507     if (r == -1)
3508       return -1;
3509   }
3510   {
3511     char device[] = "/dev/sda";
3512     char lines_0[] = ",";
3513     char *lines[] = {
3514       lines_0,
3515       NULL
3516     };
3517     int r;
3518     suppress_error = 0;
3519     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3520     if (r == -1)
3521       return -1;
3522   }
3523   {
3524     char fstype[] = "ext2";
3525     char device[] = "/dev/sda1";
3526     int r;
3527     suppress_error = 0;
3528     r = guestfs_mkfs (g, fstype, device);
3529     if (r == -1)
3530       return -1;
3531   }
3532   {
3533     char device[] = "/dev/sda1";
3534     char mountpoint[] = "/";
3535     int r;
3536     suppress_error = 0;
3537     r = guestfs_mount (g, device, mountpoint);
3538     if (r == -1)
3539       return -1;
3540   }
3541   /* TestOutput for zero (0) */
3542   char expected[] = "data";
3543   {
3544     char pathordevice[] = "/dev/sda1";
3545     int r;
3546     suppress_error = 0;
3547     r = guestfs_umount (g, pathordevice);
3548     if (r == -1)
3549       return -1;
3550   }
3551   {
3552     char device[] = "/dev/sda1";
3553     int r;
3554     suppress_error = 0;
3555     r = guestfs_zero (g, device);
3556     if (r == -1)
3557       return -1;
3558   }
3559   {
3560     char path[] = "/dev/sda1";
3561     char *r;
3562     suppress_error = 0;
3563     r = guestfs_file (g, path);
3564     if (r == NULL)
3565       return -1;
3566     if (strcmp (r, expected) != 0) {
3567       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3568       return -1;
3569     }
3570     free (r);
3571   }
3572   return 0;
3573 }
3574
3575 static int test_fsck_0_skip (void)
3576 {
3577   const char *str;
3578
3579   str = getenv ("SKIP_TEST_FSCK_0");
3580   if (str && strcmp (str, "1") == 0) return 1;
3581   str = getenv ("SKIP_TEST_FSCK");
3582   if (str && strcmp (str, "1") == 0) return 1;
3583   return 0;
3584 }
3585
3586 static int test_fsck_0 (void)
3587 {
3588   if (test_fsck_0_skip ()) {
3589     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
3590     return 0;
3591   }
3592
3593   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
3594   {
3595     char device[] = "/dev/sda";
3596     int r;
3597     suppress_error = 0;
3598     r = guestfs_blockdev_setrw (g, device);
3599     if (r == -1)
3600       return -1;
3601   }
3602   {
3603     int r;
3604     suppress_error = 0;
3605     r = guestfs_umount_all (g);
3606     if (r == -1)
3607       return -1;
3608   }
3609   {
3610     int r;
3611     suppress_error = 0;
3612     r = guestfs_lvm_remove_all (g);
3613     if (r == -1)
3614       return -1;
3615   }
3616   {
3617     char device[] = "/dev/sda";
3618     char lines_0[] = ",";
3619     char *lines[] = {
3620       lines_0,
3621       NULL
3622     };
3623     int r;
3624     suppress_error = 0;
3625     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3626     if (r == -1)
3627       return -1;
3628   }
3629   {
3630     char fstype[] = "ext2";
3631     char device[] = "/dev/sda1";
3632     int r;
3633     suppress_error = 0;
3634     r = guestfs_mkfs (g, fstype, device);
3635     if (r == -1)
3636       return -1;
3637   }
3638   {
3639     char device[] = "/dev/sda1";
3640     char mountpoint[] = "/";
3641     int r;
3642     suppress_error = 0;
3643     r = guestfs_mount (g, device, mountpoint);
3644     if (r == -1)
3645       return -1;
3646   }
3647   /* TestOutputInt for fsck (0) */
3648   {
3649     char pathordevice[] = "/dev/sda1";
3650     int r;
3651     suppress_error = 0;
3652     r = guestfs_umount (g, pathordevice);
3653     if (r == -1)
3654       return -1;
3655   }
3656   {
3657     char fstype[] = "ext2";
3658     char device[] = "/dev/sda1";
3659     int r;
3660     suppress_error = 0;
3661     r = guestfs_fsck (g, fstype, device);
3662     if (r == -1)
3663       return -1;
3664     if (r != 0) {
3665       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
3666       return -1;
3667     }
3668   }
3669   return 0;
3670 }
3671
3672 static int test_fsck_1_skip (void)
3673 {
3674   const char *str;
3675
3676   str = getenv ("SKIP_TEST_FSCK_1");
3677   if (str && strcmp (str, "1") == 0) return 1;
3678   str = getenv ("SKIP_TEST_FSCK");
3679   if (str && strcmp (str, "1") == 0) return 1;
3680   return 0;
3681 }
3682
3683 static int test_fsck_1 (void)
3684 {
3685   if (test_fsck_1_skip ()) {
3686     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3687     return 0;
3688   }
3689
3690   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3691   {
3692     char device[] = "/dev/sda";
3693     int r;
3694     suppress_error = 0;
3695     r = guestfs_blockdev_setrw (g, device);
3696     if (r == -1)
3697       return -1;
3698   }
3699   {
3700     int r;
3701     suppress_error = 0;
3702     r = guestfs_umount_all (g);
3703     if (r == -1)
3704       return -1;
3705   }
3706   {
3707     int r;
3708     suppress_error = 0;
3709     r = guestfs_lvm_remove_all (g);
3710     if (r == -1)
3711       return -1;
3712   }
3713   {
3714     char device[] = "/dev/sda";
3715     char lines_0[] = ",";
3716     char *lines[] = {
3717       lines_0,
3718       NULL
3719     };
3720     int r;
3721     suppress_error = 0;
3722     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3723     if (r == -1)
3724       return -1;
3725   }
3726   {
3727     char fstype[] = "ext2";
3728     char device[] = "/dev/sda1";
3729     int r;
3730     suppress_error = 0;
3731     r = guestfs_mkfs (g, fstype, device);
3732     if (r == -1)
3733       return -1;
3734   }
3735   {
3736     char device[] = "/dev/sda1";
3737     char mountpoint[] = "/";
3738     int r;
3739     suppress_error = 0;
3740     r = guestfs_mount (g, device, mountpoint);
3741     if (r == -1)
3742       return -1;
3743   }
3744   /* TestOutputInt for fsck (1) */
3745   {
3746     char pathordevice[] = "/dev/sda1";
3747     int r;
3748     suppress_error = 0;
3749     r = guestfs_umount (g, pathordevice);
3750     if (r == -1)
3751       return -1;
3752   }
3753   {
3754     char device[] = "/dev/sda1";
3755     int r;
3756     suppress_error = 0;
3757     r = guestfs_zero (g, device);
3758     if (r == -1)
3759       return -1;
3760   }
3761   {
3762     char fstype[] = "ext2";
3763     char device[] = "/dev/sda1";
3764     int r;
3765     suppress_error = 0;
3766     r = guestfs_fsck (g, fstype, device);
3767     if (r == -1)
3768       return -1;
3769     if (r != 8) {
3770       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
3771       return -1;
3772     }
3773   }
3774   return 0;
3775 }
3776
3777 static int test_set_e2uuid_0_skip (void)
3778 {
3779   const char *str;
3780
3781   str = getenv ("SKIP_TEST_SET_E2UUID_0");
3782   if (str && strcmp (str, "1") == 0) return 1;
3783   str = getenv ("SKIP_TEST_SET_E2UUID");
3784   if (str && strcmp (str, "1") == 0) return 1;
3785   return 0;
3786 }
3787
3788 static int test_set_e2uuid_0 (void)
3789 {
3790   if (test_set_e2uuid_0_skip ()) {
3791     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3792     return 0;
3793   }
3794
3795   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3796   {
3797     char device[] = "/dev/sda";
3798     int r;
3799     suppress_error = 0;
3800     r = guestfs_blockdev_setrw (g, device);
3801     if (r == -1)
3802       return -1;
3803   }
3804   {
3805     int r;
3806     suppress_error = 0;
3807     r = guestfs_umount_all (g);
3808     if (r == -1)
3809       return -1;
3810   }
3811   {
3812     int r;
3813     suppress_error = 0;
3814     r = guestfs_lvm_remove_all (g);
3815     if (r == -1)
3816       return -1;
3817   }
3818   {
3819     char device[] = "/dev/sda";
3820     char lines_0[] = ",";
3821     char *lines[] = {
3822       lines_0,
3823       NULL
3824     };
3825     int r;
3826     suppress_error = 0;
3827     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3828     if (r == -1)
3829       return -1;
3830   }
3831   {
3832     char fstype[] = "ext2";
3833     char device[] = "/dev/sda1";
3834     int r;
3835     suppress_error = 0;
3836     r = guestfs_mkfs (g, fstype, device);
3837     if (r == -1)
3838       return -1;
3839   }
3840   {
3841     char device[] = "/dev/sda1";
3842     char mountpoint[] = "/";
3843     int r;
3844     suppress_error = 0;
3845     r = guestfs_mount (g, device, mountpoint);
3846     if (r == -1)
3847       return -1;
3848   }
3849   /* TestOutput for set_e2uuid (0) */
3850   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3851   {
3852     char device[] = "/dev/sda1";
3853     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3854     int r;
3855     suppress_error = 0;
3856     r = guestfs_set_e2uuid (g, device, uuid);
3857     if (r == -1)
3858       return -1;
3859   }
3860   {
3861     char device[] = "/dev/sda1";
3862     char *r;
3863     suppress_error = 0;
3864     r = guestfs_get_e2uuid (g, device);
3865     if (r == NULL)
3866       return -1;
3867     if (strcmp (r, expected) != 0) {
3868       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3869       return -1;
3870     }
3871     free (r);
3872   }
3873   return 0;
3874 }
3875
3876 static int test_set_e2uuid_1_skip (void)
3877 {
3878   const char *str;
3879
3880   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3881   if (str && strcmp (str, "1") == 0) return 1;
3882   str = getenv ("SKIP_TEST_SET_E2UUID");
3883   if (str && strcmp (str, "1") == 0) return 1;
3884   return 0;
3885 }
3886
3887 static int test_set_e2uuid_1 (void)
3888 {
3889   if (test_set_e2uuid_1_skip ()) {
3890     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3891     return 0;
3892   }
3893
3894   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3895   {
3896     char device[] = "/dev/sda";
3897     int r;
3898     suppress_error = 0;
3899     r = guestfs_blockdev_setrw (g, device);
3900     if (r == -1)
3901       return -1;
3902   }
3903   {
3904     int r;
3905     suppress_error = 0;
3906     r = guestfs_umount_all (g);
3907     if (r == -1)
3908       return -1;
3909   }
3910   {
3911     int r;
3912     suppress_error = 0;
3913     r = guestfs_lvm_remove_all (g);
3914     if (r == -1)
3915       return -1;
3916   }
3917   {
3918     char device[] = "/dev/sda";
3919     char lines_0[] = ",";
3920     char *lines[] = {
3921       lines_0,
3922       NULL
3923     };
3924     int r;
3925     suppress_error = 0;
3926     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3927     if (r == -1)
3928       return -1;
3929   }
3930   {
3931     char fstype[] = "ext2";
3932     char device[] = "/dev/sda1";
3933     int r;
3934     suppress_error = 0;
3935     r = guestfs_mkfs (g, fstype, device);
3936     if (r == -1)
3937       return -1;
3938   }
3939   {
3940     char device[] = "/dev/sda1";
3941     char mountpoint[] = "/";
3942     int r;
3943     suppress_error = 0;
3944     r = guestfs_mount (g, device, mountpoint);
3945     if (r == -1)
3946       return -1;
3947   }
3948   /* TestOutput for set_e2uuid (1) */
3949   char expected[] = "";
3950   {
3951     char device[] = "/dev/sda1";
3952     char uuid[] = "clear";
3953     int r;
3954     suppress_error = 0;
3955     r = guestfs_set_e2uuid (g, device, uuid);
3956     if (r == -1)
3957       return -1;
3958   }
3959   {
3960     char device[] = "/dev/sda1";
3961     char *r;
3962     suppress_error = 0;
3963     r = guestfs_get_e2uuid (g, device);
3964     if (r == NULL)
3965       return -1;
3966     if (strcmp (r, expected) != 0) {
3967       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3968       return -1;
3969     }
3970     free (r);
3971   }
3972   return 0;
3973 }
3974
3975 static int test_set_e2uuid_2_skip (void)
3976 {
3977   const char *str;
3978
3979   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3980   if (str && strcmp (str, "1") == 0) return 1;
3981   str = getenv ("SKIP_TEST_SET_E2UUID");
3982   if (str && strcmp (str, "1") == 0) return 1;
3983   return 0;
3984 }
3985
3986 static int test_set_e2uuid_2 (void)
3987 {
3988   if (test_set_e2uuid_2_skip ()) {
3989     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3990     return 0;
3991   }
3992
3993   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3994   {
3995     char device[] = "/dev/sda";
3996     int r;
3997     suppress_error = 0;
3998     r = guestfs_blockdev_setrw (g, device);
3999     if (r == -1)
4000       return -1;
4001   }
4002   {
4003     int r;
4004     suppress_error = 0;
4005     r = guestfs_umount_all (g);
4006     if (r == -1)
4007       return -1;
4008   }
4009   {
4010     int r;
4011     suppress_error = 0;
4012     r = guestfs_lvm_remove_all (g);
4013     if (r == -1)
4014       return -1;
4015   }
4016   {
4017     char device[] = "/dev/sda";
4018     char lines_0[] = ",";
4019     char *lines[] = {
4020       lines_0,
4021       NULL
4022     };
4023     int r;
4024     suppress_error = 0;
4025     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4026     if (r == -1)
4027       return -1;
4028   }
4029   {
4030     char fstype[] = "ext2";
4031     char device[] = "/dev/sda1";
4032     int r;
4033     suppress_error = 0;
4034     r = guestfs_mkfs (g, fstype, device);
4035     if (r == -1)
4036       return -1;
4037   }
4038   {
4039     char device[] = "/dev/sda1";
4040     char mountpoint[] = "/";
4041     int r;
4042     suppress_error = 0;
4043     r = guestfs_mount (g, device, mountpoint);
4044     if (r == -1)
4045       return -1;
4046   }
4047   /* TestRun for set_e2uuid (2) */
4048   {
4049     char device[] = "/dev/sda1";
4050     char uuid[] = "random";
4051     int r;
4052     suppress_error = 0;
4053     r = guestfs_set_e2uuid (g, device, uuid);
4054     if (r == -1)
4055       return -1;
4056   }
4057   return 0;
4058 }
4059
4060 static int test_set_e2uuid_3_skip (void)
4061 {
4062   const char *str;
4063
4064   str = getenv ("SKIP_TEST_SET_E2UUID_3");
4065   if (str && strcmp (str, "1") == 0) return 1;
4066   str = getenv ("SKIP_TEST_SET_E2UUID");
4067   if (str && strcmp (str, "1") == 0) return 1;
4068   return 0;
4069 }
4070
4071 static int test_set_e2uuid_3 (void)
4072 {
4073   if (test_set_e2uuid_3_skip ()) {
4074     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
4075     return 0;
4076   }
4077
4078   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
4079   {
4080     char device[] = "/dev/sda";
4081     int r;
4082     suppress_error = 0;
4083     r = guestfs_blockdev_setrw (g, device);
4084     if (r == -1)
4085       return -1;
4086   }
4087   {
4088     int r;
4089     suppress_error = 0;
4090     r = guestfs_umount_all (g);
4091     if (r == -1)
4092       return -1;
4093   }
4094   {
4095     int r;
4096     suppress_error = 0;
4097     r = guestfs_lvm_remove_all (g);
4098     if (r == -1)
4099       return -1;
4100   }
4101   {
4102     char device[] = "/dev/sda";
4103     char lines_0[] = ",";
4104     char *lines[] = {
4105       lines_0,
4106       NULL
4107     };
4108     int r;
4109     suppress_error = 0;
4110     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4111     if (r == -1)
4112       return -1;
4113   }
4114   {
4115     char fstype[] = "ext2";
4116     char device[] = "/dev/sda1";
4117     int r;
4118     suppress_error = 0;
4119     r = guestfs_mkfs (g, fstype, device);
4120     if (r == -1)
4121       return -1;
4122   }
4123   {
4124     char device[] = "/dev/sda1";
4125     char mountpoint[] = "/";
4126     int r;
4127     suppress_error = 0;
4128     r = guestfs_mount (g, device, mountpoint);
4129     if (r == -1)
4130       return -1;
4131   }
4132   /* TestRun for set_e2uuid (3) */
4133   {
4134     char device[] = "/dev/sda1";
4135     char uuid[] = "time";
4136     int r;
4137     suppress_error = 0;
4138     r = guestfs_set_e2uuid (g, device, uuid);
4139     if (r == -1)
4140       return -1;
4141   }
4142   return 0;
4143 }
4144
4145 static int test_set_e2label_0_skip (void)
4146 {
4147   const char *str;
4148
4149   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
4150   if (str && strcmp (str, "1") == 0) return 1;
4151   str = getenv ("SKIP_TEST_SET_E2LABEL");
4152   if (str && strcmp (str, "1") == 0) return 1;
4153   return 0;
4154 }
4155
4156 static int test_set_e2label_0 (void)
4157 {
4158   if (test_set_e2label_0_skip ()) {
4159     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
4160     return 0;
4161   }
4162
4163   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
4164   {
4165     char device[] = "/dev/sda";
4166     int r;
4167     suppress_error = 0;
4168     r = guestfs_blockdev_setrw (g, device);
4169     if (r == -1)
4170       return -1;
4171   }
4172   {
4173     int r;
4174     suppress_error = 0;
4175     r = guestfs_umount_all (g);
4176     if (r == -1)
4177       return -1;
4178   }
4179   {
4180     int r;
4181     suppress_error = 0;
4182     r = guestfs_lvm_remove_all (g);
4183     if (r == -1)
4184       return -1;
4185   }
4186   {
4187     char device[] = "/dev/sda";
4188     char lines_0[] = ",";
4189     char *lines[] = {
4190       lines_0,
4191       NULL
4192     };
4193     int r;
4194     suppress_error = 0;
4195     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4196     if (r == -1)
4197       return -1;
4198   }
4199   {
4200     char fstype[] = "ext2";
4201     char device[] = "/dev/sda1";
4202     int r;
4203     suppress_error = 0;
4204     r = guestfs_mkfs (g, fstype, device);
4205     if (r == -1)
4206       return -1;
4207   }
4208   {
4209     char device[] = "/dev/sda1";
4210     char mountpoint[] = "/";
4211     int r;
4212     suppress_error = 0;
4213     r = guestfs_mount (g, device, mountpoint);
4214     if (r == -1)
4215       return -1;
4216   }
4217   /* TestOutput for set_e2label (0) */
4218   char expected[] = "testlabel";
4219   {
4220     char device[] = "/dev/sda1";
4221     char label[] = "testlabel";
4222     int r;
4223     suppress_error = 0;
4224     r = guestfs_set_e2label (g, device, label);
4225     if (r == -1)
4226       return -1;
4227   }
4228   {
4229     char device[] = "/dev/sda1";
4230     char *r;
4231     suppress_error = 0;
4232     r = guestfs_get_e2label (g, device);
4233     if (r == NULL)
4234       return -1;
4235     if (strcmp (r, expected) != 0) {
4236       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
4237       return -1;
4238     }
4239     free (r);
4240   }
4241   return 0;
4242 }
4243
4244 static int test_pvremove_0_skip (void)
4245 {
4246   const char *str;
4247
4248   str = getenv ("SKIP_TEST_PVREMOVE_0");
4249   if (str && strcmp (str, "1") == 0) return 1;
4250   str = getenv ("SKIP_TEST_PVREMOVE");
4251   if (str && strcmp (str, "1") == 0) return 1;
4252   return 0;
4253 }
4254
4255 static int test_pvremove_0 (void)
4256 {
4257   if (test_pvremove_0_skip ()) {
4258     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
4259     return 0;
4260   }
4261
4262   /* InitNone|InitEmpty for test_pvremove_0 */
4263   {
4264     char device[] = "/dev/sda";
4265     int r;
4266     suppress_error = 0;
4267     r = guestfs_blockdev_setrw (g, device);
4268     if (r == -1)
4269       return -1;
4270   }
4271   {
4272     int r;
4273     suppress_error = 0;
4274     r = guestfs_umount_all (g);
4275     if (r == -1)
4276       return -1;
4277   }
4278   {
4279     int r;
4280     suppress_error = 0;
4281     r = guestfs_lvm_remove_all (g);
4282     if (r == -1)
4283       return -1;
4284   }
4285   /* TestOutputListOfDevices for pvremove (0) */
4286   {
4287     char device[] = "/dev/sda";
4288     char lines_0[] = ",";
4289     char *lines[] = {
4290       lines_0,
4291       NULL
4292     };
4293     int r;
4294     suppress_error = 0;
4295     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4296     if (r == -1)
4297       return -1;
4298   }
4299   {
4300     char device[] = "/dev/sda1";
4301     int r;
4302     suppress_error = 0;
4303     r = guestfs_pvcreate (g, device);
4304     if (r == -1)
4305       return -1;
4306   }
4307   {
4308     char volgroup[] = "VG";
4309     char physvols_0[] = "/dev/sda1";
4310     char *physvols[] = {
4311       physvols_0,
4312       NULL
4313     };
4314     int r;
4315     suppress_error = 0;
4316     r = guestfs_vgcreate (g, volgroup, physvols);
4317     if (r == -1)
4318       return -1;
4319   }
4320   {
4321     char logvol[] = "LV1";
4322     char volgroup[] = "VG";
4323     int r;
4324     suppress_error = 0;
4325     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4326     if (r == -1)
4327       return -1;
4328   }
4329   {
4330     char logvol[] = "LV2";
4331     char volgroup[] = "VG";
4332     int r;
4333     suppress_error = 0;
4334     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4335     if (r == -1)
4336       return -1;
4337   }
4338   {
4339     char vgname[] = "VG";
4340     int r;
4341     suppress_error = 0;
4342     r = guestfs_vgremove (g, vgname);
4343     if (r == -1)
4344       return -1;
4345   }
4346   {
4347     char device[] = "/dev/sda1";
4348     int r;
4349     suppress_error = 0;
4350     r = guestfs_pvremove (g, device);
4351     if (r == -1)
4352       return -1;
4353   }
4354   {
4355     char **r;
4356     int i;
4357     suppress_error = 0;
4358     r = guestfs_lvs (g);
4359     if (r == NULL)
4360       return -1;
4361     if (r[0] != NULL) {
4362       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
4363       print_strings (r);
4364       return -1;
4365     }
4366     for (i = 0; r[i] != NULL; ++i)
4367       free (r[i]);
4368     free (r);
4369   }
4370   return 0;
4371 }
4372
4373 static int test_pvremove_1_skip (void)
4374 {
4375   const char *str;
4376
4377   str = getenv ("SKIP_TEST_PVREMOVE_1");
4378   if (str && strcmp (str, "1") == 0) return 1;
4379   str = getenv ("SKIP_TEST_PVREMOVE");
4380   if (str && strcmp (str, "1") == 0) return 1;
4381   return 0;
4382 }
4383
4384 static int test_pvremove_1 (void)
4385 {
4386   if (test_pvremove_1_skip ()) {
4387     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
4388     return 0;
4389   }
4390
4391   /* InitNone|InitEmpty for test_pvremove_1 */
4392   {
4393     char device[] = "/dev/sda";
4394     int r;
4395     suppress_error = 0;
4396     r = guestfs_blockdev_setrw (g, device);
4397     if (r == -1)
4398       return -1;
4399   }
4400   {
4401     int r;
4402     suppress_error = 0;
4403     r = guestfs_umount_all (g);
4404     if (r == -1)
4405       return -1;
4406   }
4407   {
4408     int r;
4409     suppress_error = 0;
4410     r = guestfs_lvm_remove_all (g);
4411     if (r == -1)
4412       return -1;
4413   }
4414   /* TestOutputListOfDevices for pvremove (1) */
4415   {
4416     char device[] = "/dev/sda";
4417     char lines_0[] = ",";
4418     char *lines[] = {
4419       lines_0,
4420       NULL
4421     };
4422     int r;
4423     suppress_error = 0;
4424     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4425     if (r == -1)
4426       return -1;
4427   }
4428   {
4429     char device[] = "/dev/sda1";
4430     int r;
4431     suppress_error = 0;
4432     r = guestfs_pvcreate (g, device);
4433     if (r == -1)
4434       return -1;
4435   }
4436   {
4437     char volgroup[] = "VG";
4438     char physvols_0[] = "/dev/sda1";
4439     char *physvols[] = {
4440       physvols_0,
4441       NULL
4442     };
4443     int r;
4444     suppress_error = 0;
4445     r = guestfs_vgcreate (g, volgroup, physvols);
4446     if (r == -1)
4447       return -1;
4448   }
4449   {
4450     char logvol[] = "LV1";
4451     char volgroup[] = "VG";
4452     int r;
4453     suppress_error = 0;
4454     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4455     if (r == -1)
4456       return -1;
4457   }
4458   {
4459     char logvol[] = "LV2";
4460     char volgroup[] = "VG";
4461     int r;
4462     suppress_error = 0;
4463     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4464     if (r == -1)
4465       return -1;
4466   }
4467   {
4468     char vgname[] = "VG";
4469     int r;
4470     suppress_error = 0;
4471     r = guestfs_vgremove (g, vgname);
4472     if (r == -1)
4473       return -1;
4474   }
4475   {
4476     char device[] = "/dev/sda1";
4477     int r;
4478     suppress_error = 0;
4479     r = guestfs_pvremove (g, device);
4480     if (r == -1)
4481       return -1;
4482   }
4483   {
4484     char **r;
4485     int i;
4486     suppress_error = 0;
4487     r = guestfs_vgs (g);
4488     if (r == NULL)
4489       return -1;
4490     if (r[0] != NULL) {
4491       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
4492       print_strings (r);
4493       return -1;
4494     }
4495     for (i = 0; r[i] != NULL; ++i)
4496       free (r[i]);
4497     free (r);
4498   }
4499   return 0;
4500 }
4501
4502 static int test_pvremove_2_skip (void)
4503 {
4504   const char *str;
4505
4506   str = getenv ("SKIP_TEST_PVREMOVE_2");
4507   if (str && strcmp (str, "1") == 0) return 1;
4508   str = getenv ("SKIP_TEST_PVREMOVE");
4509   if (str && strcmp (str, "1") == 0) return 1;
4510   return 0;
4511 }
4512
4513 static int test_pvremove_2 (void)
4514 {
4515   if (test_pvremove_2_skip ()) {
4516     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
4517     return 0;
4518   }
4519
4520   /* InitNone|InitEmpty for test_pvremove_2 */
4521   {
4522     char device[] = "/dev/sda";
4523     int r;
4524     suppress_error = 0;
4525     r = guestfs_blockdev_setrw (g, device);
4526     if (r == -1)
4527       return -1;
4528   }
4529   {
4530     int r;
4531     suppress_error = 0;
4532     r = guestfs_umount_all (g);
4533     if (r == -1)
4534       return -1;
4535   }
4536   {
4537     int r;
4538     suppress_error = 0;
4539     r = guestfs_lvm_remove_all (g);
4540     if (r == -1)
4541       return -1;
4542   }
4543   /* TestOutputListOfDevices for pvremove (2) */
4544   {
4545     char device[] = "/dev/sda";
4546     char lines_0[] = ",";
4547     char *lines[] = {
4548       lines_0,
4549       NULL
4550     };
4551     int r;
4552     suppress_error = 0;
4553     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4554     if (r == -1)
4555       return -1;
4556   }
4557   {
4558     char device[] = "/dev/sda1";
4559     int r;
4560     suppress_error = 0;
4561     r = guestfs_pvcreate (g, device);
4562     if (r == -1)
4563       return -1;
4564   }
4565   {
4566     char volgroup[] = "VG";
4567     char physvols_0[] = "/dev/sda1";
4568     char *physvols[] = {
4569       physvols_0,
4570       NULL
4571     };
4572     int r;
4573     suppress_error = 0;
4574     r = guestfs_vgcreate (g, volgroup, physvols);
4575     if (r == -1)
4576       return -1;
4577   }
4578   {
4579     char logvol[] = "LV1";
4580     char volgroup[] = "VG";
4581     int r;
4582     suppress_error = 0;
4583     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4584     if (r == -1)
4585       return -1;
4586   }
4587   {
4588     char logvol[] = "LV2";
4589     char volgroup[] = "VG";
4590     int r;
4591     suppress_error = 0;
4592     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4593     if (r == -1)
4594       return -1;
4595   }
4596   {
4597     char vgname[] = "VG";
4598     int r;
4599     suppress_error = 0;
4600     r = guestfs_vgremove (g, vgname);
4601     if (r == -1)
4602       return -1;
4603   }
4604   {
4605     char device[] = "/dev/sda1";
4606     int r;
4607     suppress_error = 0;
4608     r = guestfs_pvremove (g, device);
4609     if (r == -1)
4610       return -1;
4611   }
4612   {
4613     char **r;
4614     int i;
4615     suppress_error = 0;
4616     r = guestfs_pvs (g);
4617     if (r == NULL)
4618       return -1;
4619     if (r[0] != NULL) {
4620       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
4621       print_strings (r);
4622       return -1;
4623     }
4624     for (i = 0; r[i] != NULL; ++i)
4625       free (r[i]);
4626     free (r);
4627   }
4628   return 0;
4629 }
4630
4631 static int test_vgremove_0_skip (void)
4632 {
4633   const char *str;
4634
4635   str = getenv ("SKIP_TEST_VGREMOVE_0");
4636   if (str && strcmp (str, "1") == 0) return 1;
4637   str = getenv ("SKIP_TEST_VGREMOVE");
4638   if (str && strcmp (str, "1") == 0) return 1;
4639   return 0;
4640 }
4641
4642 static int test_vgremove_0 (void)
4643 {
4644   if (test_vgremove_0_skip ()) {
4645     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
4646     return 0;
4647   }
4648
4649   /* InitNone|InitEmpty for test_vgremove_0 */
4650   {
4651     char device[] = "/dev/sda";
4652     int r;
4653     suppress_error = 0;
4654     r = guestfs_blockdev_setrw (g, device);
4655     if (r == -1)
4656       return -1;
4657   }
4658   {
4659     int r;
4660     suppress_error = 0;
4661     r = guestfs_umount_all (g);
4662     if (r == -1)
4663       return -1;
4664   }
4665   {
4666     int r;
4667     suppress_error = 0;
4668     r = guestfs_lvm_remove_all (g);
4669     if (r == -1)
4670       return -1;
4671   }
4672   /* TestOutputList for vgremove (0) */
4673   {
4674     char device[] = "/dev/sda";
4675     char lines_0[] = ",";
4676     char *lines[] = {
4677       lines_0,
4678       NULL
4679     };
4680     int r;
4681     suppress_error = 0;
4682     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4683     if (r == -1)
4684       return -1;
4685   }
4686   {
4687     char device[] = "/dev/sda1";
4688     int r;
4689     suppress_error = 0;
4690     r = guestfs_pvcreate (g, device);
4691     if (r == -1)
4692       return -1;
4693   }
4694   {
4695     char volgroup[] = "VG";
4696     char physvols_0[] = "/dev/sda1";
4697     char *physvols[] = {
4698       physvols_0,
4699       NULL
4700     };
4701     int r;
4702     suppress_error = 0;
4703     r = guestfs_vgcreate (g, volgroup, physvols);
4704     if (r == -1)
4705       return -1;
4706   }
4707   {
4708     char logvol[] = "LV1";
4709     char volgroup[] = "VG";
4710     int r;
4711     suppress_error = 0;
4712     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4713     if (r == -1)
4714       return -1;
4715   }
4716   {
4717     char logvol[] = "LV2";
4718     char volgroup[] = "VG";
4719     int r;
4720     suppress_error = 0;
4721     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4722     if (r == -1)
4723       return -1;
4724   }
4725   {
4726     char vgname[] = "VG";
4727     int r;
4728     suppress_error = 0;
4729     r = guestfs_vgremove (g, vgname);
4730     if (r == -1)
4731       return -1;
4732   }
4733   {
4734     char **r;
4735     int i;
4736     suppress_error = 0;
4737     r = guestfs_lvs (g);
4738     if (r == NULL)
4739       return -1;
4740     if (r[0] != NULL) {
4741       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4742       print_strings (r);
4743       return -1;
4744     }
4745     for (i = 0; r[i] != NULL; ++i)
4746       free (r[i]);
4747     free (r);
4748   }
4749   return 0;
4750 }
4751
4752 static int test_vgremove_1_skip (void)
4753 {
4754   const char *str;
4755
4756   str = getenv ("SKIP_TEST_VGREMOVE_1");
4757   if (str && strcmp (str, "1") == 0) return 1;
4758   str = getenv ("SKIP_TEST_VGREMOVE");
4759   if (str && strcmp (str, "1") == 0) return 1;
4760   return 0;
4761 }
4762
4763 static int test_vgremove_1 (void)
4764 {
4765   if (test_vgremove_1_skip ()) {
4766     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4767     return 0;
4768   }
4769
4770   /* InitNone|InitEmpty for test_vgremove_1 */
4771   {
4772     char device[] = "/dev/sda";
4773     int r;
4774     suppress_error = 0;
4775     r = guestfs_blockdev_setrw (g, device);
4776     if (r == -1)
4777       return -1;
4778   }
4779   {
4780     int r;
4781     suppress_error = 0;
4782     r = guestfs_umount_all (g);
4783     if (r == -1)
4784       return -1;
4785   }
4786   {
4787     int r;
4788     suppress_error = 0;
4789     r = guestfs_lvm_remove_all (g);
4790     if (r == -1)
4791       return -1;
4792   }
4793   /* TestOutputList for vgremove (1) */
4794   {
4795     char device[] = "/dev/sda";
4796     char lines_0[] = ",";
4797     char *lines[] = {
4798       lines_0,
4799       NULL
4800     };
4801     int r;
4802     suppress_error = 0;
4803     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4804     if (r == -1)
4805       return -1;
4806   }
4807   {
4808     char device[] = "/dev/sda1";
4809     int r;
4810     suppress_error = 0;
4811     r = guestfs_pvcreate (g, device);
4812     if (r == -1)
4813       return -1;
4814   }
4815   {
4816     char volgroup[] = "VG";
4817     char physvols_0[] = "/dev/sda1";
4818     char *physvols[] = {
4819       physvols_0,
4820       NULL
4821     };
4822     int r;
4823     suppress_error = 0;
4824     r = guestfs_vgcreate (g, volgroup, physvols);
4825     if (r == -1)
4826       return -1;
4827   }
4828   {
4829     char logvol[] = "LV1";
4830     char volgroup[] = "VG";
4831     int r;
4832     suppress_error = 0;
4833     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4834     if (r == -1)
4835       return -1;
4836   }
4837   {
4838     char logvol[] = "LV2";
4839     char volgroup[] = "VG";
4840     int r;
4841     suppress_error = 0;
4842     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4843     if (r == -1)
4844       return -1;
4845   }
4846   {
4847     char vgname[] = "VG";
4848     int r;
4849     suppress_error = 0;
4850     r = guestfs_vgremove (g, vgname);
4851     if (r == -1)
4852       return -1;
4853   }
4854   {
4855     char **r;
4856     int i;
4857     suppress_error = 0;
4858     r = guestfs_vgs (g);
4859     if (r == NULL)
4860       return -1;
4861     if (r[0] != NULL) {
4862       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4863       print_strings (r);
4864       return -1;
4865     }
4866     for (i = 0; r[i] != NULL; ++i)
4867       free (r[i]);
4868     free (r);
4869   }
4870   return 0;
4871 }
4872
4873 static int test_lvremove_0_skip (void)
4874 {
4875   const char *str;
4876
4877   str = getenv ("SKIP_TEST_LVREMOVE_0");
4878   if (str && strcmp (str, "1") == 0) return 1;
4879   str = getenv ("SKIP_TEST_LVREMOVE");
4880   if (str && strcmp (str, "1") == 0) return 1;
4881   return 0;
4882 }
4883
4884 static int test_lvremove_0 (void)
4885 {
4886   if (test_lvremove_0_skip ()) {
4887     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4888     return 0;
4889   }
4890
4891   /* InitNone|InitEmpty for test_lvremove_0 */
4892   {
4893     char device[] = "/dev/sda";
4894     int r;
4895     suppress_error = 0;
4896     r = guestfs_blockdev_setrw (g, device);
4897     if (r == -1)
4898       return -1;
4899   }
4900   {
4901     int r;
4902     suppress_error = 0;
4903     r = guestfs_umount_all (g);
4904     if (r == -1)
4905       return -1;
4906   }
4907   {
4908     int r;
4909     suppress_error = 0;
4910     r = guestfs_lvm_remove_all (g);
4911     if (r == -1)
4912       return -1;
4913   }
4914   /* TestOutputList for lvremove (0) */
4915   {
4916     char device[] = "/dev/sda";
4917     char lines_0[] = ",";
4918     char *lines[] = {
4919       lines_0,
4920       NULL
4921     };
4922     int r;
4923     suppress_error = 0;
4924     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4925     if (r == -1)
4926       return -1;
4927   }
4928   {
4929     char device[] = "/dev/sda1";
4930     int r;
4931     suppress_error = 0;
4932     r = guestfs_pvcreate (g, device);
4933     if (r == -1)
4934       return -1;
4935   }
4936   {
4937     char volgroup[] = "VG";
4938     char physvols_0[] = "/dev/sda1";
4939     char *physvols[] = {
4940       physvols_0,
4941       NULL
4942     };
4943     int r;
4944     suppress_error = 0;
4945     r = guestfs_vgcreate (g, volgroup, physvols);
4946     if (r == -1)
4947       return -1;
4948   }
4949   {
4950     char logvol[] = "LV1";
4951     char volgroup[] = "VG";
4952     int r;
4953     suppress_error = 0;
4954     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4955     if (r == -1)
4956       return -1;
4957   }
4958   {
4959     char logvol[] = "LV2";
4960     char volgroup[] = "VG";
4961     int r;
4962     suppress_error = 0;
4963     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4964     if (r == -1)
4965       return -1;
4966   }
4967   {
4968     char device[] = "/dev/VG/LV1";
4969     int r;
4970     suppress_error = 0;
4971     r = guestfs_lvremove (g, device);
4972     if (r == -1)
4973       return -1;
4974   }
4975   {
4976     char **r;
4977     int i;
4978     suppress_error = 0;
4979     r = guestfs_lvs (g);
4980     if (r == NULL)
4981       return -1;
4982     if (!r[0]) {
4983       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4984       print_strings (r);
4985       return -1;
4986     }
4987     {
4988       char expected[] = "/dev/VG/LV2";
4989       if (strcmp (r[0], expected) != 0) {
4990         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4991         return -1;
4992       }
4993     }
4994     if (r[1] != NULL) {
4995       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4996       print_strings (r);
4997       return -1;
4998     }
4999     for (i = 0; r[i] != NULL; ++i)
5000       free (r[i]);
5001     free (r);
5002   }
5003   return 0;
5004 }
5005
5006 static int test_lvremove_1_skip (void)
5007 {
5008   const char *str;
5009
5010   str = getenv ("SKIP_TEST_LVREMOVE_1");
5011   if (str && strcmp (str, "1") == 0) return 1;
5012   str = getenv ("SKIP_TEST_LVREMOVE");
5013   if (str && strcmp (str, "1") == 0) return 1;
5014   return 0;
5015 }
5016
5017 static int test_lvremove_1 (void)
5018 {
5019   if (test_lvremove_1_skip ()) {
5020     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
5021     return 0;
5022   }
5023
5024   /* InitNone|InitEmpty for test_lvremove_1 */
5025   {
5026     char device[] = "/dev/sda";
5027     int r;
5028     suppress_error = 0;
5029     r = guestfs_blockdev_setrw (g, device);
5030     if (r == -1)
5031       return -1;
5032   }
5033   {
5034     int r;
5035     suppress_error = 0;
5036     r = guestfs_umount_all (g);
5037     if (r == -1)
5038       return -1;
5039   }
5040   {
5041     int r;
5042     suppress_error = 0;
5043     r = guestfs_lvm_remove_all (g);
5044     if (r == -1)
5045       return -1;
5046   }
5047   /* TestOutputList for lvremove (1) */
5048   {
5049     char device[] = "/dev/sda";
5050     char lines_0[] = ",";
5051     char *lines[] = {
5052       lines_0,
5053       NULL
5054     };
5055     int r;
5056     suppress_error = 0;
5057     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5058     if (r == -1)
5059       return -1;
5060   }
5061   {
5062     char device[] = "/dev/sda1";
5063     int r;
5064     suppress_error = 0;
5065     r = guestfs_pvcreate (g, device);
5066     if (r == -1)
5067       return -1;
5068   }
5069   {
5070     char volgroup[] = "VG";
5071     char physvols_0[] = "/dev/sda1";
5072     char *physvols[] = {
5073       physvols_0,
5074       NULL
5075     };
5076     int r;
5077     suppress_error = 0;
5078     r = guestfs_vgcreate (g, volgroup, physvols);
5079     if (r == -1)
5080       return -1;
5081   }
5082   {
5083     char logvol[] = "LV1";
5084     char volgroup[] = "VG";
5085     int r;
5086     suppress_error = 0;
5087     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5088     if (r == -1)
5089       return -1;
5090   }
5091   {
5092     char logvol[] = "LV2";
5093     char volgroup[] = "VG";
5094     int r;
5095     suppress_error = 0;
5096     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5097     if (r == -1)
5098       return -1;
5099   }
5100   {
5101     char device[] = "/dev/VG";
5102     int r;
5103     suppress_error = 0;
5104     r = guestfs_lvremove (g, device);
5105     if (r == -1)
5106       return -1;
5107   }
5108   {
5109     char **r;
5110     int i;
5111     suppress_error = 0;
5112     r = guestfs_lvs (g);
5113     if (r == NULL)
5114       return -1;
5115     if (r[0] != NULL) {
5116       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
5117       print_strings (r);
5118       return -1;
5119     }
5120     for (i = 0; r[i] != NULL; ++i)
5121       free (r[i]);
5122     free (r);
5123   }
5124   return 0;
5125 }
5126
5127 static int test_lvremove_2_skip (void)
5128 {
5129   const char *str;
5130
5131   str = getenv ("SKIP_TEST_LVREMOVE_2");
5132   if (str && strcmp (str, "1") == 0) return 1;
5133   str = getenv ("SKIP_TEST_LVREMOVE");
5134   if (str && strcmp (str, "1") == 0) return 1;
5135   return 0;
5136 }
5137
5138 static int test_lvremove_2 (void)
5139 {
5140   if (test_lvremove_2_skip ()) {
5141     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
5142     return 0;
5143   }
5144
5145   /* InitNone|InitEmpty for test_lvremove_2 */
5146   {
5147     char device[] = "/dev/sda";
5148     int r;
5149     suppress_error = 0;
5150     r = guestfs_blockdev_setrw (g, device);
5151     if (r == -1)
5152       return -1;
5153   }
5154   {
5155     int r;
5156     suppress_error = 0;
5157     r = guestfs_umount_all (g);
5158     if (r == -1)
5159       return -1;
5160   }
5161   {
5162     int r;
5163     suppress_error = 0;
5164     r = guestfs_lvm_remove_all (g);
5165     if (r == -1)
5166       return -1;
5167   }
5168   /* TestOutputList for lvremove (2) */
5169   {
5170     char device[] = "/dev/sda";
5171     char lines_0[] = ",";
5172     char *lines[] = {
5173       lines_0,
5174       NULL
5175     };
5176     int r;
5177     suppress_error = 0;
5178     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5179     if (r == -1)
5180       return -1;
5181   }
5182   {
5183     char device[] = "/dev/sda1";
5184     int r;
5185     suppress_error = 0;
5186     r = guestfs_pvcreate (g, device);
5187     if (r == -1)
5188       return -1;
5189   }
5190   {
5191     char volgroup[] = "VG";
5192     char physvols_0[] = "/dev/sda1";
5193     char *physvols[] = {
5194       physvols_0,
5195       NULL
5196     };
5197     int r;
5198     suppress_error = 0;
5199     r = guestfs_vgcreate (g, volgroup, physvols);
5200     if (r == -1)
5201       return -1;
5202   }
5203   {
5204     char logvol[] = "LV1";
5205     char volgroup[] = "VG";
5206     int r;
5207     suppress_error = 0;
5208     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5209     if (r == -1)
5210       return -1;
5211   }
5212   {
5213     char logvol[] = "LV2";
5214     char volgroup[] = "VG";
5215     int r;
5216     suppress_error = 0;
5217     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5218     if (r == -1)
5219       return -1;
5220   }
5221   {
5222     char device[] = "/dev/VG";
5223     int r;
5224     suppress_error = 0;
5225     r = guestfs_lvremove (g, device);
5226     if (r == -1)
5227       return -1;
5228   }
5229   {
5230     char **r;
5231     int i;
5232     suppress_error = 0;
5233     r = guestfs_vgs (g);
5234     if (r == NULL)
5235       return -1;
5236     if (!r[0]) {
5237       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
5238       print_strings (r);
5239       return -1;
5240     }
5241     {
5242       char expected[] = "VG";
5243       if (strcmp (r[0], expected) != 0) {
5244         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5245         return -1;
5246       }
5247     }
5248     if (r[1] != NULL) {
5249       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
5250       print_strings (r);
5251       return -1;
5252     }
5253     for (i = 0; r[i] != NULL; ++i)
5254       free (r[i]);
5255     free (r);
5256   }
5257   return 0;
5258 }
5259
5260 static int test_mount_ro_0_skip (void)
5261 {
5262   const char *str;
5263
5264   str = getenv ("SKIP_TEST_MOUNT_RO_0");
5265   if (str && strcmp (str, "1") == 0) return 1;
5266   str = getenv ("SKIP_TEST_MOUNT_RO");
5267   if (str && strcmp (str, "1") == 0) return 1;
5268   return 0;
5269 }
5270
5271 static int test_mount_ro_0 (void)
5272 {
5273   if (test_mount_ro_0_skip ()) {
5274     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
5275     return 0;
5276   }
5277
5278   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
5279   {
5280     char device[] = "/dev/sda";
5281     int r;
5282     suppress_error = 0;
5283     r = guestfs_blockdev_setrw (g, device);
5284     if (r == -1)
5285       return -1;
5286   }
5287   {
5288     int r;
5289     suppress_error = 0;
5290     r = guestfs_umount_all (g);
5291     if (r == -1)
5292       return -1;
5293   }
5294   {
5295     int r;
5296     suppress_error = 0;
5297     r = guestfs_lvm_remove_all (g);
5298     if (r == -1)
5299       return -1;
5300   }
5301   {
5302     char device[] = "/dev/sda";
5303     char lines_0[] = ",";
5304     char *lines[] = {
5305       lines_0,
5306       NULL
5307     };
5308     int r;
5309     suppress_error = 0;
5310     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5311     if (r == -1)
5312       return -1;
5313   }
5314   {
5315     char fstype[] = "ext2";
5316     char device[] = "/dev/sda1";
5317     int r;
5318     suppress_error = 0;
5319     r = guestfs_mkfs (g, fstype, device);
5320     if (r == -1)
5321       return -1;
5322   }
5323   {
5324     char device[] = "/dev/sda1";
5325     char mountpoint[] = "/";
5326     int r;
5327     suppress_error = 0;
5328     r = guestfs_mount (g, device, mountpoint);
5329     if (r == -1)
5330       return -1;
5331   }
5332   /* TestLastFail for mount_ro (0) */
5333   {
5334     char pathordevice[] = "/";
5335     int r;
5336     suppress_error = 0;
5337     r = guestfs_umount (g, pathordevice);
5338     if (r == -1)
5339       return -1;
5340   }
5341   {
5342     char device[] = "/dev/sda1";
5343     char mountpoint[] = "/";
5344     int r;
5345     suppress_error = 0;
5346     r = guestfs_mount_ro (g, device, mountpoint);
5347     if (r == -1)
5348       return -1;
5349   }
5350   {
5351     char path[] = "/new";
5352     int r;
5353     suppress_error = 1;
5354     r = guestfs_touch (g, path);
5355     if (r != -1)
5356       return -1;
5357   }
5358   return 0;
5359 }
5360
5361 static int test_mount_ro_1_skip (void)
5362 {
5363   const char *str;
5364
5365   str = getenv ("SKIP_TEST_MOUNT_RO_1");
5366   if (str && strcmp (str, "1") == 0) return 1;
5367   str = getenv ("SKIP_TEST_MOUNT_RO");
5368   if (str && strcmp (str, "1") == 0) return 1;
5369   return 0;
5370 }
5371
5372 static int test_mount_ro_1 (void)
5373 {
5374   if (test_mount_ro_1_skip ()) {
5375     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
5376     return 0;
5377   }
5378
5379   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5380   {
5381     char device[] = "/dev/sda";
5382     int r;
5383     suppress_error = 0;
5384     r = guestfs_blockdev_setrw (g, device);
5385     if (r == -1)
5386       return -1;
5387   }
5388   {
5389     int r;
5390     suppress_error = 0;
5391     r = guestfs_umount_all (g);
5392     if (r == -1)
5393       return -1;
5394   }
5395   {
5396     int r;
5397     suppress_error = 0;
5398     r = guestfs_lvm_remove_all (g);
5399     if (r == -1)
5400       return -1;
5401   }
5402   {
5403     char device[] = "/dev/sda";
5404     char lines_0[] = ",";
5405     char *lines[] = {
5406       lines_0,
5407       NULL
5408     };
5409     int r;
5410     suppress_error = 0;
5411     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5412     if (r == -1)
5413       return -1;
5414   }
5415   {
5416     char fstype[] = "ext2";
5417     char device[] = "/dev/sda1";
5418     int r;
5419     suppress_error = 0;
5420     r = guestfs_mkfs (g, fstype, device);
5421     if (r == -1)
5422       return -1;
5423   }
5424   {
5425     char device[] = "/dev/sda1";
5426     char mountpoint[] = "/";
5427     int r;
5428     suppress_error = 0;
5429     r = guestfs_mount (g, device, mountpoint);
5430     if (r == -1)
5431       return -1;
5432   }
5433   /* TestOutput for mount_ro (1) */
5434   char expected[] = "data";
5435   {
5436     char path[] = "/new";
5437     char content[] = "data";
5438     int r;
5439     suppress_error = 0;
5440     r = guestfs_write_file (g, path, content, 0);
5441     if (r == -1)
5442       return -1;
5443   }
5444   {
5445     char pathordevice[] = "/";
5446     int r;
5447     suppress_error = 0;
5448     r = guestfs_umount (g, pathordevice);
5449     if (r == -1)
5450       return -1;
5451   }
5452   {
5453     char device[] = "/dev/sda1";
5454     char mountpoint[] = "/";
5455     int r;
5456     suppress_error = 0;
5457     r = guestfs_mount_ro (g, device, mountpoint);
5458     if (r == -1)
5459       return -1;
5460   }
5461   {
5462     char path[] = "/new";
5463     char *r;
5464     suppress_error = 0;
5465     r = guestfs_cat (g, path);
5466     if (r == NULL)
5467       return -1;
5468     if (strcmp (r, expected) != 0) {
5469       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5470       return -1;
5471     }
5472     free (r);
5473   }
5474   return 0;
5475 }
5476
5477 static int test_tgz_in_0_skip (void)
5478 {
5479   const char *str;
5480
5481   str = getenv ("SKIP_TEST_TGZ_IN_0");
5482   if (str && strcmp (str, "1") == 0) return 1;
5483   str = getenv ("SKIP_TEST_TGZ_IN");
5484   if (str && strcmp (str, "1") == 0) return 1;
5485   return 0;
5486 }
5487
5488 static int test_tgz_in_0 (void)
5489 {
5490   if (test_tgz_in_0_skip ()) {
5491     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
5492     return 0;
5493   }
5494
5495   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5496   {
5497     char device[] = "/dev/sda";
5498     int r;
5499     suppress_error = 0;
5500     r = guestfs_blockdev_setrw (g, device);
5501     if (r == -1)
5502       return -1;
5503   }
5504   {
5505     int r;
5506     suppress_error = 0;
5507     r = guestfs_umount_all (g);
5508     if (r == -1)
5509       return -1;
5510   }
5511   {
5512     int r;
5513     suppress_error = 0;
5514     r = guestfs_lvm_remove_all (g);
5515     if (r == -1)
5516       return -1;
5517   }
5518   {
5519     char device[] = "/dev/sda";
5520     char lines_0[] = ",";
5521     char *lines[] = {
5522       lines_0,
5523       NULL
5524     };
5525     int r;
5526     suppress_error = 0;
5527     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5528     if (r == -1)
5529       return -1;
5530   }
5531   {
5532     char fstype[] = "ext2";
5533     char device[] = "/dev/sda1";
5534     int r;
5535     suppress_error = 0;
5536     r = guestfs_mkfs (g, fstype, device);
5537     if (r == -1)
5538       return -1;
5539   }
5540   {
5541     char device[] = "/dev/sda1";
5542     char mountpoint[] = "/";
5543     int r;
5544     suppress_error = 0;
5545     r = guestfs_mount (g, device, mountpoint);
5546     if (r == -1)
5547       return -1;
5548   }
5549   /* TestOutput for tgz_in (0) */
5550   char expected[] = "hello\n";
5551   {
5552     char directory[] = "/";
5553     int r;
5554     suppress_error = 0;
5555     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5556     if (r == -1)
5557       return -1;
5558   }
5559   {
5560     char path[] = "/hello";
5561     char *r;
5562     suppress_error = 0;
5563     r = guestfs_cat (g, path);
5564     if (r == NULL)
5565       return -1;
5566     if (strcmp (r, expected) != 0) {
5567       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5568       return -1;
5569     }
5570     free (r);
5571   }
5572   return 0;
5573 }
5574
5575 static int test_tar_in_0_skip (void)
5576 {
5577   const char *str;
5578
5579   str = getenv ("SKIP_TEST_TAR_IN_0");
5580   if (str && strcmp (str, "1") == 0) return 1;
5581   str = getenv ("SKIP_TEST_TAR_IN");
5582   if (str && strcmp (str, "1") == 0) return 1;
5583   return 0;
5584 }
5585
5586 static int test_tar_in_0 (void)
5587 {
5588   if (test_tar_in_0_skip ()) {
5589     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5590     return 0;
5591   }
5592
5593   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5594   {
5595     char device[] = "/dev/sda";
5596     int r;
5597     suppress_error = 0;
5598     r = guestfs_blockdev_setrw (g, device);
5599     if (r == -1)
5600       return -1;
5601   }
5602   {
5603     int r;
5604     suppress_error = 0;
5605     r = guestfs_umount_all (g);
5606     if (r == -1)
5607       return -1;
5608   }
5609   {
5610     int r;
5611     suppress_error = 0;
5612     r = guestfs_lvm_remove_all (g);
5613     if (r == -1)
5614       return -1;
5615   }
5616   {
5617     char device[] = "/dev/sda";
5618     char lines_0[] = ",";
5619     char *lines[] = {
5620       lines_0,
5621       NULL
5622     };
5623     int r;
5624     suppress_error = 0;
5625     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5626     if (r == -1)
5627       return -1;
5628   }
5629   {
5630     char fstype[] = "ext2";
5631     char device[] = "/dev/sda1";
5632     int r;
5633     suppress_error = 0;
5634     r = guestfs_mkfs (g, fstype, device);
5635     if (r == -1)
5636       return -1;
5637   }
5638   {
5639     char device[] = "/dev/sda1";
5640     char mountpoint[] = "/";
5641     int r;
5642     suppress_error = 0;
5643     r = guestfs_mount (g, device, mountpoint);
5644     if (r == -1)
5645       return -1;
5646   }
5647   /* TestOutput for tar_in (0) */
5648   char expected[] = "hello\n";
5649   {
5650     char directory[] = "/";
5651     int r;
5652     suppress_error = 0;
5653     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5654     if (r == -1)
5655       return -1;
5656   }
5657   {
5658     char path[] = "/hello";
5659     char *r;
5660     suppress_error = 0;
5661     r = guestfs_cat (g, path);
5662     if (r == NULL)
5663       return -1;
5664     if (strcmp (r, expected) != 0) {
5665       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5666       return -1;
5667     }
5668     free (r);
5669   }
5670   return 0;
5671 }
5672
5673 static int test_checksum_0_skip (void)
5674 {
5675   const char *str;
5676
5677   str = getenv ("SKIP_TEST_CHECKSUM_0");
5678   if (str && strcmp (str, "1") == 0) return 1;
5679   str = getenv ("SKIP_TEST_CHECKSUM");
5680   if (str && strcmp (str, "1") == 0) return 1;
5681   return 0;
5682 }
5683
5684 static int test_checksum_0 (void)
5685 {
5686   if (test_checksum_0_skip ()) {
5687     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5688     return 0;
5689   }
5690
5691   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5692   {
5693     char device[] = "/dev/sda";
5694     int r;
5695     suppress_error = 0;
5696     r = guestfs_blockdev_setrw (g, device);
5697     if (r == -1)
5698       return -1;
5699   }
5700   {
5701     int r;
5702     suppress_error = 0;
5703     r = guestfs_umount_all (g);
5704     if (r == -1)
5705       return -1;
5706   }
5707   {
5708     int r;
5709     suppress_error = 0;
5710     r = guestfs_lvm_remove_all (g);
5711     if (r == -1)
5712       return -1;
5713   }
5714   {
5715     char device[] = "/dev/sda";
5716     char lines_0[] = ",";
5717     char *lines[] = {
5718       lines_0,
5719       NULL
5720     };
5721     int r;
5722     suppress_error = 0;
5723     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5724     if (r == -1)
5725       return -1;
5726   }
5727   {
5728     char fstype[] = "ext2";
5729     char device[] = "/dev/sda1";
5730     int r;
5731     suppress_error = 0;
5732     r = guestfs_mkfs (g, fstype, device);
5733     if (r == -1)
5734       return -1;
5735   }
5736   {
5737     char device[] = "/dev/sda1";
5738     char mountpoint[] = "/";
5739     int r;
5740     suppress_error = 0;
5741     r = guestfs_mount (g, device, mountpoint);
5742     if (r == -1)
5743       return -1;
5744   }
5745   /* TestOutput for checksum (0) */
5746   char expected[] = "935282863";
5747   {
5748     char path[] = "/new";
5749     char content[] = "test\n";
5750     int r;
5751     suppress_error = 0;
5752     r = guestfs_write_file (g, path, content, 0);
5753     if (r == -1)
5754       return -1;
5755   }
5756   {
5757     char csumtype[] = "crc";
5758     char path[] = "/new";
5759     char *r;
5760     suppress_error = 0;
5761     r = guestfs_checksum (g, csumtype, path);
5762     if (r == NULL)
5763       return -1;
5764     if (strcmp (r, expected) != 0) {
5765       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5766       return -1;
5767     }
5768     free (r);
5769   }
5770   return 0;
5771 }
5772
5773 static int test_checksum_1_skip (void)
5774 {
5775   const char *str;
5776
5777   str = getenv ("SKIP_TEST_CHECKSUM_1");
5778   if (str && strcmp (str, "1") == 0) return 1;
5779   str = getenv ("SKIP_TEST_CHECKSUM");
5780   if (str && strcmp (str, "1") == 0) return 1;
5781   return 0;
5782 }
5783
5784 static int test_checksum_1 (void)
5785 {
5786   if (test_checksum_1_skip ()) {
5787     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5788     return 0;
5789   }
5790
5791   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5792   {
5793     char device[] = "/dev/sda";
5794     int r;
5795     suppress_error = 0;
5796     r = guestfs_blockdev_setrw (g, device);
5797     if (r == -1)
5798       return -1;
5799   }
5800   {
5801     int r;
5802     suppress_error = 0;
5803     r = guestfs_umount_all (g);
5804     if (r == -1)
5805       return -1;
5806   }
5807   {
5808     int r;
5809     suppress_error = 0;
5810     r = guestfs_lvm_remove_all (g);
5811     if (r == -1)
5812       return -1;
5813   }
5814   {
5815     char device[] = "/dev/sda";
5816     char lines_0[] = ",";
5817     char *lines[] = {
5818       lines_0,
5819       NULL
5820     };
5821     int r;
5822     suppress_error = 0;
5823     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5824     if (r == -1)
5825       return -1;
5826   }
5827   {
5828     char fstype[] = "ext2";
5829     char device[] = "/dev/sda1";
5830     int r;
5831     suppress_error = 0;
5832     r = guestfs_mkfs (g, fstype, device);
5833     if (r == -1)
5834       return -1;
5835   }
5836   {
5837     char device[] = "/dev/sda1";
5838     char mountpoint[] = "/";
5839     int r;
5840     suppress_error = 0;
5841     r = guestfs_mount (g, device, mountpoint);
5842     if (r == -1)
5843       return -1;
5844   }
5845   /* TestLastFail for checksum (1) */
5846   {
5847     char csumtype[] = "crc";
5848     char path[] = "/new";
5849     char *r;
5850     suppress_error = 1;
5851     r = guestfs_checksum (g, csumtype, path);
5852     if (r != NULL)
5853       return -1;
5854     free (r);
5855   }
5856   return 0;
5857 }
5858
5859 static int test_checksum_2_skip (void)
5860 {
5861   const char *str;
5862
5863   str = getenv ("SKIP_TEST_CHECKSUM_2");
5864   if (str && strcmp (str, "1") == 0) return 1;
5865   str = getenv ("SKIP_TEST_CHECKSUM");
5866   if (str && strcmp (str, "1") == 0) return 1;
5867   return 0;
5868 }
5869
5870 static int test_checksum_2 (void)
5871 {
5872   if (test_checksum_2_skip ()) {
5873     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5874     return 0;
5875   }
5876
5877   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5878   {
5879     char device[] = "/dev/sda";
5880     int r;
5881     suppress_error = 0;
5882     r = guestfs_blockdev_setrw (g, device);
5883     if (r == -1)
5884       return -1;
5885   }
5886   {
5887     int r;
5888     suppress_error = 0;
5889     r = guestfs_umount_all (g);
5890     if (r == -1)
5891       return -1;
5892   }
5893   {
5894     int r;
5895     suppress_error = 0;
5896     r = guestfs_lvm_remove_all (g);
5897     if (r == -1)
5898       return -1;
5899   }
5900   {
5901     char device[] = "/dev/sda";
5902     char lines_0[] = ",";
5903     char *lines[] = {
5904       lines_0,
5905       NULL
5906     };
5907     int r;
5908     suppress_error = 0;
5909     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5910     if (r == -1)
5911       return -1;
5912   }
5913   {
5914     char fstype[] = "ext2";
5915     char device[] = "/dev/sda1";
5916     int r;
5917     suppress_error = 0;
5918     r = guestfs_mkfs (g, fstype, device);
5919     if (r == -1)
5920       return -1;
5921   }
5922   {
5923     char device[] = "/dev/sda1";
5924     char mountpoint[] = "/";
5925     int r;
5926     suppress_error = 0;
5927     r = guestfs_mount (g, device, mountpoint);
5928     if (r == -1)
5929       return -1;
5930   }
5931   /* TestOutput for checksum (2) */
5932   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5933   {
5934     char path[] = "/new";
5935     char content[] = "test\n";
5936     int r;
5937     suppress_error = 0;
5938     r = guestfs_write_file (g, path, content, 0);
5939     if (r == -1)
5940       return -1;
5941   }
5942   {
5943     char csumtype[] = "md5";
5944     char path[] = "/new";
5945     char *r;
5946     suppress_error = 0;
5947     r = guestfs_checksum (g, csumtype, path);
5948     if (r == NULL)
5949       return -1;
5950     if (strcmp (r, expected) != 0) {
5951       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5952       return -1;
5953     }
5954     free (r);
5955   }
5956   return 0;
5957 }
5958
5959 static int test_checksum_3_skip (void)
5960 {
5961   const char *str;
5962
5963   str = getenv ("SKIP_TEST_CHECKSUM_3");
5964   if (str && strcmp (str, "1") == 0) return 1;
5965   str = getenv ("SKIP_TEST_CHECKSUM");
5966   if (str && strcmp (str, "1") == 0) return 1;
5967   return 0;
5968 }
5969
5970 static int test_checksum_3 (void)
5971 {
5972   if (test_checksum_3_skip ()) {
5973     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5974     return 0;
5975   }
5976
5977   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5978   {
5979     char device[] = "/dev/sda";
5980     int r;
5981     suppress_error = 0;
5982     r = guestfs_blockdev_setrw (g, device);
5983     if (r == -1)
5984       return -1;
5985   }
5986   {
5987     int r;
5988     suppress_error = 0;
5989     r = guestfs_umount_all (g);
5990     if (r == -1)
5991       return -1;
5992   }
5993   {
5994     int r;
5995     suppress_error = 0;
5996     r = guestfs_lvm_remove_all (g);
5997     if (r == -1)
5998       return -1;
5999   }
6000   {
6001     char device[] = "/dev/sda";
6002     char lines_0[] = ",";
6003     char *lines[] = {
6004       lines_0,
6005       NULL
6006     };
6007     int r;
6008     suppress_error = 0;
6009     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6010     if (r == -1)
6011       return -1;
6012   }
6013   {
6014     char fstype[] = "ext2";
6015     char device[] = "/dev/sda1";
6016     int r;
6017     suppress_error = 0;
6018     r = guestfs_mkfs (g, fstype, device);
6019     if (r == -1)
6020       return -1;
6021   }
6022   {
6023     char device[] = "/dev/sda1";
6024     char mountpoint[] = "/";
6025     int r;
6026     suppress_error = 0;
6027     r = guestfs_mount (g, device, mountpoint);
6028     if (r == -1)
6029       return -1;
6030   }
6031   /* TestOutput for checksum (3) */
6032   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
6033   {
6034     char path[] = "/new";
6035     char content[] = "test\n";
6036     int r;
6037     suppress_error = 0;
6038     r = guestfs_write_file (g, path, content, 0);
6039     if (r == -1)
6040       return -1;
6041   }
6042   {
6043     char csumtype[] = "sha1";
6044     char path[] = "/new";
6045     char *r;
6046     suppress_error = 0;
6047     r = guestfs_checksum (g, csumtype, path);
6048     if (r == NULL)
6049       return -1;
6050     if (strcmp (r, expected) != 0) {
6051       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
6052       return -1;
6053     }
6054     free (r);
6055   }
6056   return 0;
6057 }
6058
6059 static int test_checksum_4_skip (void)
6060 {
6061   const char *str;
6062
6063   str = getenv ("SKIP_TEST_CHECKSUM_4");
6064   if (str && strcmp (str, "1") == 0) return 1;
6065   str = getenv ("SKIP_TEST_CHECKSUM");
6066   if (str && strcmp (str, "1") == 0) return 1;
6067   return 0;
6068 }
6069
6070 static int test_checksum_4 (void)
6071 {
6072   if (test_checksum_4_skip ()) {
6073     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
6074     return 0;
6075   }
6076
6077   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
6078   {
6079     char device[] = "/dev/sda";
6080     int r;
6081     suppress_error = 0;
6082     r = guestfs_blockdev_setrw (g, device);
6083     if (r == -1)
6084       return -1;
6085   }
6086   {
6087     int r;
6088     suppress_error = 0;
6089     r = guestfs_umount_all (g);
6090     if (r == -1)
6091       return -1;
6092   }
6093   {
6094     int r;
6095     suppress_error = 0;
6096     r = guestfs_lvm_remove_all (g);
6097     if (r == -1)
6098       return -1;
6099   }
6100   {
6101     char device[] = "/dev/sda";
6102     char lines_0[] = ",";
6103     char *lines[] = {
6104       lines_0,
6105       NULL
6106     };
6107     int r;
6108     suppress_error = 0;
6109     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6110     if (r == -1)
6111       return -1;
6112   }
6113   {
6114     char fstype[] = "ext2";
6115     char device[] = "/dev/sda1";
6116     int r;
6117     suppress_error = 0;
6118     r = guestfs_mkfs (g, fstype, device);
6119     if (r == -1)
6120       return -1;
6121   }
6122   {
6123     char device[] = "/dev/sda1";
6124     char mountpoint[] = "/";
6125     int r;
6126     suppress_error = 0;
6127     r = guestfs_mount (g, device, mountpoint);
6128     if (r == -1)
6129       return -1;
6130   }
6131   /* TestOutput for checksum (4) */
6132   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
6133   {
6134     char path[] = "/new";
6135     char content[] = "test\n";
6136     int r;
6137     suppress_error = 0;
6138     r = guestfs_write_file (g, path, content, 0);
6139     if (r == -1)
6140       return -1;
6141   }
6142   {
6143     char csumtype[] = "sha224";
6144     char path[] = "/new";
6145     char *r;
6146     suppress_error = 0;
6147     r = guestfs_checksum (g, csumtype, path);
6148     if (r == NULL)
6149       return -1;
6150     if (strcmp (r, expected) != 0) {
6151       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
6152       return -1;
6153     }
6154     free (r);
6155   }
6156   return 0;
6157 }
6158
6159 static int test_checksum_5_skip (void)
6160 {
6161   const char *str;
6162
6163   str = getenv ("SKIP_TEST_CHECKSUM_5");
6164   if (str && strcmp (str, "1") == 0) return 1;
6165   str = getenv ("SKIP_TEST_CHECKSUM");
6166   if (str && strcmp (str, "1") == 0) return 1;
6167   return 0;
6168 }
6169
6170 static int test_checksum_5 (void)
6171 {
6172   if (test_checksum_5_skip ()) {
6173     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
6174     return 0;
6175   }
6176
6177   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
6178   {
6179     char device[] = "/dev/sda";
6180     int r;
6181     suppress_error = 0;
6182     r = guestfs_blockdev_setrw (g, device);
6183     if (r == -1)
6184       return -1;
6185   }
6186   {
6187     int r;
6188     suppress_error = 0;
6189     r = guestfs_umount_all (g);
6190     if (r == -1)
6191       return -1;
6192   }
6193   {
6194     int r;
6195     suppress_error = 0;
6196     r = guestfs_lvm_remove_all (g);
6197     if (r == -1)
6198       return -1;
6199   }
6200   {
6201     char device[] = "/dev/sda";
6202     char lines_0[] = ",";
6203     char *lines[] = {
6204       lines_0,
6205       NULL
6206     };
6207     int r;
6208     suppress_error = 0;
6209     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6210     if (r == -1)
6211       return -1;
6212   }
6213   {
6214     char fstype[] = "ext2";
6215     char device[] = "/dev/sda1";
6216     int r;
6217     suppress_error = 0;
6218     r = guestfs_mkfs (g, fstype, device);
6219     if (r == -1)
6220       return -1;
6221   }
6222   {
6223     char device[] = "/dev/sda1";
6224     char mountpoint[] = "/";
6225     int r;
6226     suppress_error = 0;
6227     r = guestfs_mount (g, device, mountpoint);
6228     if (r == -1)
6229       return -1;
6230   }
6231   /* TestOutput for checksum (5) */
6232   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
6233   {
6234     char path[] = "/new";
6235     char content[] = "test\n";
6236     int r;
6237     suppress_error = 0;
6238     r = guestfs_write_file (g, path, content, 0);
6239     if (r == -1)
6240       return -1;
6241   }
6242   {
6243     char csumtype[] = "sha256";
6244     char path[] = "/new";
6245     char *r;
6246     suppress_error = 0;
6247     r = guestfs_checksum (g, csumtype, path);
6248     if (r == NULL)
6249       return -1;
6250     if (strcmp (r, expected) != 0) {
6251       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
6252       return -1;
6253     }
6254     free (r);
6255   }
6256   return 0;
6257 }
6258
6259 static int test_checksum_6_skip (void)
6260 {
6261   const char *str;
6262
6263   str = getenv ("SKIP_TEST_CHECKSUM_6");
6264   if (str && strcmp (str, "1") == 0) return 1;
6265   str = getenv ("SKIP_TEST_CHECKSUM");
6266   if (str && strcmp (str, "1") == 0) return 1;
6267   return 0;
6268 }
6269
6270 static int test_checksum_6 (void)
6271 {
6272   if (test_checksum_6_skip ()) {
6273     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
6274     return 0;
6275   }
6276
6277   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
6278   {
6279     char device[] = "/dev/sda";
6280     int r;
6281     suppress_error = 0;
6282     r = guestfs_blockdev_setrw (g, device);
6283     if (r == -1)
6284       return -1;
6285   }
6286   {
6287     int r;
6288     suppress_error = 0;
6289     r = guestfs_umount_all (g);
6290     if (r == -1)
6291       return -1;
6292   }
6293   {
6294     int r;
6295     suppress_error = 0;
6296     r = guestfs_lvm_remove_all (g);
6297     if (r == -1)
6298       return -1;
6299   }
6300   {
6301     char device[] = "/dev/sda";
6302     char lines_0[] = ",";
6303     char *lines[] = {
6304       lines_0,
6305       NULL
6306     };
6307     int r;
6308     suppress_error = 0;
6309     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6310     if (r == -1)
6311       return -1;
6312   }
6313   {
6314     char fstype[] = "ext2";
6315     char device[] = "/dev/sda1";
6316     int r;
6317     suppress_error = 0;
6318     r = guestfs_mkfs (g, fstype, device);
6319     if (r == -1)
6320       return -1;
6321   }
6322   {
6323     char device[] = "/dev/sda1";
6324     char mountpoint[] = "/";
6325     int r;
6326     suppress_error = 0;
6327     r = guestfs_mount (g, device, mountpoint);
6328     if (r == -1)
6329       return -1;
6330   }
6331   /* TestOutput for checksum (6) */
6332   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
6333   {
6334     char path[] = "/new";
6335     char content[] = "test\n";
6336     int r;
6337     suppress_error = 0;
6338     r = guestfs_write_file (g, path, content, 0);
6339     if (r == -1)
6340       return -1;
6341   }
6342   {
6343     char csumtype[] = "sha384";
6344     char path[] = "/new";
6345     char *r;
6346     suppress_error = 0;
6347     r = guestfs_checksum (g, csumtype, path);
6348     if (r == NULL)
6349       return -1;
6350     if (strcmp (r, expected) != 0) {
6351       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6352       return -1;
6353     }
6354     free (r);
6355   }
6356   return 0;
6357 }
6358
6359 static int test_checksum_7_skip (void)
6360 {
6361   const char *str;
6362
6363   str = getenv ("SKIP_TEST_CHECKSUM_7");
6364   if (str && strcmp (str, "1") == 0) return 1;
6365   str = getenv ("SKIP_TEST_CHECKSUM");
6366   if (str && strcmp (str, "1") == 0) return 1;
6367   return 0;
6368 }
6369
6370 static int test_checksum_7 (void)
6371 {
6372   if (test_checksum_7_skip ()) {
6373     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
6374     return 0;
6375   }
6376
6377   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6378   {
6379     char device[] = "/dev/sda";
6380     int r;
6381     suppress_error = 0;
6382     r = guestfs_blockdev_setrw (g, device);
6383     if (r == -1)
6384       return -1;
6385   }
6386   {
6387     int r;
6388     suppress_error = 0;
6389     r = guestfs_umount_all (g);
6390     if (r == -1)
6391       return -1;
6392   }
6393   {
6394     int r;
6395     suppress_error = 0;
6396     r = guestfs_lvm_remove_all (g);
6397     if (r == -1)
6398       return -1;
6399   }
6400   {
6401     char device[] = "/dev/sda";
6402     char lines_0[] = ",";
6403     char *lines[] = {
6404       lines_0,
6405       NULL
6406     };
6407     int r;
6408     suppress_error = 0;
6409     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6410     if (r == -1)
6411       return -1;
6412   }
6413   {
6414     char fstype[] = "ext2";
6415     char device[] = "/dev/sda1";
6416     int r;
6417     suppress_error = 0;
6418     r = guestfs_mkfs (g, fstype, device);
6419     if (r == -1)
6420       return -1;
6421   }
6422   {
6423     char device[] = "/dev/sda1";
6424     char mountpoint[] = "/";
6425     int r;
6426     suppress_error = 0;
6427     r = guestfs_mount (g, device, mountpoint);
6428     if (r == -1)
6429       return -1;
6430   }
6431   /* TestOutput for checksum (7) */
6432   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6433   {
6434     char path[] = "/new";
6435     char content[] = "test\n";
6436     int r;
6437     suppress_error = 0;
6438     r = guestfs_write_file (g, path, content, 0);
6439     if (r == -1)
6440       return -1;
6441   }
6442   {
6443     char csumtype[] = "sha512";
6444     char path[] = "/new";
6445     char *r;
6446     suppress_error = 0;
6447     r = guestfs_checksum (g, csumtype, path);
6448     if (r == NULL)
6449       return -1;
6450     if (strcmp (r, expected) != 0) {
6451       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6452       return -1;
6453     }
6454     free (r);
6455   }
6456   return 0;
6457 }
6458
6459 static int test_checksum_8_skip (void)
6460 {
6461   const char *str;
6462
6463   str = getenv ("SKIP_TEST_CHECKSUM_8");
6464   if (str && strcmp (str, "1") == 0) return 1;
6465   str = getenv ("SKIP_TEST_CHECKSUM");
6466   if (str && strcmp (str, "1") == 0) return 1;
6467   return 0;
6468 }
6469
6470 static int test_checksum_8 (void)
6471 {
6472   if (test_checksum_8_skip ()) {
6473     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
6474     return 0;
6475   }
6476
6477   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6478   {
6479     char device[] = "/dev/sda";
6480     int r;
6481     suppress_error = 0;
6482     r = guestfs_blockdev_setrw (g, device);
6483     if (r == -1)
6484       return -1;
6485   }
6486   {
6487     int r;
6488     suppress_error = 0;
6489     r = guestfs_umount_all (g);
6490     if (r == -1)
6491       return -1;
6492   }
6493   {
6494     int r;
6495     suppress_error = 0;
6496     r = guestfs_lvm_remove_all (g);
6497     if (r == -1)
6498       return -1;
6499   }
6500   {
6501     char device[] = "/dev/sda";
6502     char lines_0[] = ",";
6503     char *lines[] = {
6504       lines_0,
6505       NULL
6506     };
6507     int r;
6508     suppress_error = 0;
6509     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6510     if (r == -1)
6511       return -1;
6512   }
6513   {
6514     char fstype[] = "ext2";
6515     char device[] = "/dev/sda1";
6516     int r;
6517     suppress_error = 0;
6518     r = guestfs_mkfs (g, fstype, device);
6519     if (r == -1)
6520       return -1;
6521   }
6522   {
6523     char device[] = "/dev/sda1";
6524     char mountpoint[] = "/";
6525     int r;
6526     suppress_error = 0;
6527     r = guestfs_mount (g, device, mountpoint);
6528     if (r == -1)
6529       return -1;
6530   }
6531   /* TestOutput for checksum (8) */
6532   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6533   {
6534     char options[] = "ro";
6535     char vfstype[] = "squashfs";
6536     char device[] = "/dev/sdd";
6537     char mountpoint[] = "/";
6538     int r;
6539     suppress_error = 0;
6540     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
6541     if (r == -1)
6542       return -1;
6543   }
6544   {
6545     char csumtype[] = "md5";
6546     char path[] = "/known-3";
6547     char *r;
6548     suppress_error = 0;
6549     r = guestfs_checksum (g, csumtype, path);
6550     if (r == NULL)
6551       return -1;
6552     if (strcmp (r, expected) != 0) {
6553       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6554       return -1;
6555     }
6556     free (r);
6557   }
6558   return 0;
6559 }
6560
6561 static int test_download_0_skip (void)
6562 {
6563   const char *str;
6564
6565   str = getenv ("SKIP_TEST_DOWNLOAD_0");
6566   if (str && strcmp (str, "1") == 0) return 1;
6567   str = getenv ("SKIP_TEST_DOWNLOAD");
6568   if (str && strcmp (str, "1") == 0) return 1;
6569   return 0;
6570 }
6571
6572 static int test_download_0 (void)
6573 {
6574   if (test_download_0_skip ()) {
6575     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6576     return 0;
6577   }
6578
6579   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
6580   {
6581     char device[] = "/dev/sda";
6582     int r;
6583     suppress_error = 0;
6584     r = guestfs_blockdev_setrw (g, device);
6585     if (r == -1)
6586       return -1;
6587   }
6588   {
6589     int r;
6590     suppress_error = 0;
6591     r = guestfs_umount_all (g);
6592     if (r == -1)
6593       return -1;
6594   }
6595   {
6596     int r;
6597     suppress_error = 0;
6598     r = guestfs_lvm_remove_all (g);
6599     if (r == -1)
6600       return -1;
6601   }
6602   {
6603     char device[] = "/dev/sda";
6604     char lines_0[] = ",";
6605     char *lines[] = {
6606       lines_0,
6607       NULL
6608     };
6609     int r;
6610     suppress_error = 0;
6611     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6612     if (r == -1)
6613       return -1;
6614   }
6615   {
6616     char fstype[] = "ext2";
6617     char device[] = "/dev/sda1";
6618     int r;
6619     suppress_error = 0;
6620     r = guestfs_mkfs (g, fstype, device);
6621     if (r == -1)
6622       return -1;
6623   }
6624   {
6625     char device[] = "/dev/sda1";
6626     char mountpoint[] = "/";
6627     int r;
6628     suppress_error = 0;
6629     r = guestfs_mount (g, device, mountpoint);
6630     if (r == -1)
6631       return -1;
6632   }
6633   /* TestOutput for download (0) */
6634   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6635   {
6636     char remotefilename[] = "/COPYING.LIB";
6637     int r;
6638     suppress_error = 0;
6639     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6640     if (r == -1)
6641       return -1;
6642   }
6643   {
6644     char remotefilename[] = "/COPYING.LIB";
6645     int r;
6646     suppress_error = 0;
6647     r = guestfs_download (g, remotefilename, "testdownload.tmp");
6648     if (r == -1)
6649       return -1;
6650   }
6651   {
6652     char remotefilename[] = "/upload";
6653     int r;
6654     suppress_error = 0;
6655     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6656     if (r == -1)
6657       return -1;
6658   }
6659   {
6660     char csumtype[] = "md5";
6661     char path[] = "/upload";
6662     char *r;
6663     suppress_error = 0;
6664     r = guestfs_checksum (g, csumtype, path);
6665     if (r == NULL)
6666       return -1;
6667     if (strcmp (r, expected) != 0) {
6668       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6669       return -1;
6670     }
6671     free (r);
6672   }
6673   return 0;
6674 }
6675
6676 static int test_upload_0_skip (void)
6677 {
6678   const char *str;
6679
6680   str = getenv ("SKIP_TEST_UPLOAD_0");
6681   if (str && strcmp (str, "1") == 0) return 1;
6682   str = getenv ("SKIP_TEST_UPLOAD");
6683   if (str && strcmp (str, "1") == 0) return 1;
6684   return 0;
6685 }
6686
6687 static int test_upload_0 (void)
6688 {
6689   if (test_upload_0_skip ()) {
6690     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6691     return 0;
6692   }
6693
6694   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6695   {
6696     char device[] = "/dev/sda";
6697     int r;
6698     suppress_error = 0;
6699     r = guestfs_blockdev_setrw (g, device);
6700     if (r == -1)
6701       return -1;
6702   }
6703   {
6704     int r;
6705     suppress_error = 0;
6706     r = guestfs_umount_all (g);
6707     if (r == -1)
6708       return -1;
6709   }
6710   {
6711     int r;
6712     suppress_error = 0;
6713     r = guestfs_lvm_remove_all (g);
6714     if (r == -1)
6715       return -1;
6716   }
6717   {
6718     char device[] = "/dev/sda";
6719     char lines_0[] = ",";
6720     char *lines[] = {
6721       lines_0,
6722       NULL
6723     };
6724     int r;
6725     suppress_error = 0;
6726     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6727     if (r == -1)
6728       return -1;
6729   }
6730   {
6731     char fstype[] = "ext2";
6732     char device[] = "/dev/sda1";
6733     int r;
6734     suppress_error = 0;
6735     r = guestfs_mkfs (g, fstype, device);
6736     if (r == -1)
6737       return -1;
6738   }
6739   {
6740     char device[] = "/dev/sda1";
6741     char mountpoint[] = "/";
6742     int r;
6743     suppress_error = 0;
6744     r = guestfs_mount (g, device, mountpoint);
6745     if (r == -1)
6746       return -1;
6747   }
6748   /* TestOutput for upload (0) */
6749   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6750   {
6751     char remotefilename[] = "/COPYING.LIB";
6752     int r;
6753     suppress_error = 0;
6754     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6755     if (r == -1)
6756       return -1;
6757   }
6758   {
6759     char csumtype[] = "md5";
6760     char path[] = "/COPYING.LIB";
6761     char *r;
6762     suppress_error = 0;
6763     r = guestfs_checksum (g, csumtype, path);
6764     if (r == NULL)
6765       return -1;
6766     if (strcmp (r, expected) != 0) {
6767       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6768       return -1;
6769     }
6770     free (r);
6771   }
6772   return 0;
6773 }
6774
6775 static int test_blockdev_rereadpt_0_skip (void)
6776 {
6777   const char *str;
6778
6779   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6780   if (str && strcmp (str, "1") == 0) return 1;
6781   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6782   if (str && strcmp (str, "1") == 0) return 1;
6783   return 0;
6784 }
6785
6786 static int test_blockdev_rereadpt_0 (void)
6787 {
6788   if (test_blockdev_rereadpt_0_skip ()) {
6789     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6790     return 0;
6791   }
6792
6793   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6794   {
6795     char device[] = "/dev/sda";
6796     int r;
6797     suppress_error = 0;
6798     r = guestfs_blockdev_setrw (g, device);
6799     if (r == -1)
6800       return -1;
6801   }
6802   {
6803     int r;
6804     suppress_error = 0;
6805     r = guestfs_umount_all (g);
6806     if (r == -1)
6807       return -1;
6808   }
6809   {
6810     int r;
6811     suppress_error = 0;
6812     r = guestfs_lvm_remove_all (g);
6813     if (r == -1)
6814       return -1;
6815   }
6816   /* TestRun for blockdev_rereadpt (0) */
6817   {
6818     char device[] = "/dev/sda";
6819     int r;
6820     suppress_error = 0;
6821     r = guestfs_blockdev_rereadpt (g, device);
6822     if (r == -1)
6823       return -1;
6824   }
6825   return 0;
6826 }
6827
6828 static int test_blockdev_flushbufs_0_skip (void)
6829 {
6830   const char *str;
6831
6832   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6833   if (str && strcmp (str, "1") == 0) return 1;
6834   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6835   if (str && strcmp (str, "1") == 0) return 1;
6836   return 0;
6837 }
6838
6839 static int test_blockdev_flushbufs_0 (void)
6840 {
6841   if (test_blockdev_flushbufs_0_skip ()) {
6842     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6843     return 0;
6844   }
6845
6846   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6847   {
6848     char device[] = "/dev/sda";
6849     int r;
6850     suppress_error = 0;
6851     r = guestfs_blockdev_setrw (g, device);
6852     if (r == -1)
6853       return -1;
6854   }
6855   {
6856     int r;
6857     suppress_error = 0;
6858     r = guestfs_umount_all (g);
6859     if (r == -1)
6860       return -1;
6861   }
6862   {
6863     int r;
6864     suppress_error = 0;
6865     r = guestfs_lvm_remove_all (g);
6866     if (r == -1)
6867       return -1;
6868   }
6869   /* TestRun for blockdev_flushbufs (0) */
6870   {
6871     char device[] = "/dev/sda";
6872     int r;
6873     suppress_error = 0;
6874     r = guestfs_blockdev_flushbufs (g, device);
6875     if (r == -1)
6876       return -1;
6877   }
6878   return 0;
6879 }
6880
6881 static int test_blockdev_getsize64_0_skip (void)
6882 {
6883   const char *str;
6884
6885   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6886   if (str && strcmp (str, "1") == 0) return 1;
6887   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6888   if (str && strcmp (str, "1") == 0) return 1;
6889   return 0;
6890 }
6891
6892 static int test_blockdev_getsize64_0 (void)
6893 {
6894   if (test_blockdev_getsize64_0_skip ()) {
6895     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6896     return 0;
6897   }
6898
6899   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6900   {
6901     char device[] = "/dev/sda";
6902     int r;
6903     suppress_error = 0;
6904     r = guestfs_blockdev_setrw (g, device);
6905     if (r == -1)
6906       return -1;
6907   }
6908   {
6909     int r;
6910     suppress_error = 0;
6911     r = guestfs_umount_all (g);
6912     if (r == -1)
6913       return -1;
6914   }
6915   {
6916     int r;
6917     suppress_error = 0;
6918     r = guestfs_lvm_remove_all (g);
6919     if (r == -1)
6920       return -1;
6921   }
6922   /* TestOutputInt for blockdev_getsize64 (0) */
6923   {
6924     char device[] = "/dev/sda";
6925     int64_t r;
6926     suppress_error = 0;
6927     r = guestfs_blockdev_getsize64 (g, device);
6928     if (r == -1)
6929       return -1;
6930     if (r != 524288000) {
6931       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6932       return -1;
6933     }
6934   }
6935   return 0;
6936 }
6937
6938 static int test_blockdev_getsz_0_skip (void)
6939 {
6940   const char *str;
6941
6942   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6943   if (str && strcmp (str, "1") == 0) return 1;
6944   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6945   if (str && strcmp (str, "1") == 0) return 1;
6946   return 0;
6947 }
6948
6949 static int test_blockdev_getsz_0 (void)
6950 {
6951   if (test_blockdev_getsz_0_skip ()) {
6952     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6953     return 0;
6954   }
6955
6956   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6957   {
6958     char device[] = "/dev/sda";
6959     int r;
6960     suppress_error = 0;
6961     r = guestfs_blockdev_setrw (g, device);
6962     if (r == -1)
6963       return -1;
6964   }
6965   {
6966     int r;
6967     suppress_error = 0;
6968     r = guestfs_umount_all (g);
6969     if (r == -1)
6970       return -1;
6971   }
6972   {
6973     int r;
6974     suppress_error = 0;
6975     r = guestfs_lvm_remove_all (g);
6976     if (r == -1)
6977       return -1;
6978   }
6979   /* TestOutputInt for blockdev_getsz (0) */
6980   {
6981     char device[] = "/dev/sda";
6982     int64_t r;
6983     suppress_error = 0;
6984     r = guestfs_blockdev_getsz (g, device);
6985     if (r == -1)
6986       return -1;
6987     if (r != 1024000) {
6988       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6989       return -1;
6990     }
6991   }
6992   return 0;
6993 }
6994
6995 static int test_blockdev_getbsz_0_skip (void)
6996 {
6997   const char *str;
6998
6999   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
7000   if (str && strcmp (str, "1") == 0) return 1;
7001   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
7002   if (str && strcmp (str, "1") == 0) return 1;
7003   return 0;
7004 }
7005
7006 static int test_blockdev_getbsz_0 (void)
7007 {
7008   if (test_blockdev_getbsz_0_skip ()) {
7009     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
7010     return 0;
7011   }
7012
7013   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
7014   {
7015     char device[] = "/dev/sda";
7016     int r;
7017     suppress_error = 0;
7018     r = guestfs_blockdev_setrw (g, device);
7019     if (r == -1)
7020       return -1;
7021   }
7022   {
7023     int r;
7024     suppress_error = 0;
7025     r = guestfs_umount_all (g);
7026     if (r == -1)
7027       return -1;
7028   }
7029   {
7030     int r;
7031     suppress_error = 0;
7032     r = guestfs_lvm_remove_all (g);
7033     if (r == -1)
7034       return -1;
7035   }
7036   /* TestOutputInt for blockdev_getbsz (0) */
7037   {
7038     char device[] = "/dev/sda";
7039     int r;
7040     suppress_error = 0;
7041     r = guestfs_blockdev_getbsz (g, device);
7042     if (r == -1)
7043       return -1;
7044     if (r != 4096) {
7045       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
7046       return -1;
7047     }
7048   }
7049   return 0;
7050 }
7051
7052 static int test_blockdev_getss_0_skip (void)
7053 {
7054   const char *str;
7055
7056   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
7057   if (str && strcmp (str, "1") == 0) return 1;
7058   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
7059   if (str && strcmp (str, "1") == 0) return 1;
7060   return 0;
7061 }
7062
7063 static int test_blockdev_getss_0 (void)
7064 {
7065   if (test_blockdev_getss_0_skip ()) {
7066     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
7067     return 0;
7068   }
7069
7070   /* InitNone|InitEmpty for test_blockdev_getss_0 */
7071   {
7072     char device[] = "/dev/sda";
7073     int r;
7074     suppress_error = 0;
7075     r = guestfs_blockdev_setrw (g, device);
7076     if (r == -1)
7077       return -1;
7078   }
7079   {
7080     int r;
7081     suppress_error = 0;
7082     r = guestfs_umount_all (g);
7083     if (r == -1)
7084       return -1;
7085   }
7086   {
7087     int r;
7088     suppress_error = 0;
7089     r = guestfs_lvm_remove_all (g);
7090     if (r == -1)
7091       return -1;
7092   }
7093   /* TestOutputInt for blockdev_getss (0) */
7094   {
7095     char device[] = "/dev/sda";
7096     int r;
7097     suppress_error = 0;
7098     r = guestfs_blockdev_getss (g, device);
7099     if (r == -1)
7100       return -1;
7101     if (r != 512) {
7102       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
7103       return -1;
7104     }
7105   }
7106   return 0;
7107 }
7108
7109 static int test_blockdev_getro_0_skip (void)
7110 {
7111   const char *str;
7112
7113   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
7114   if (str && strcmp (str, "1") == 0) return 1;
7115   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
7116   if (str && strcmp (str, "1") == 0) return 1;
7117   return 0;
7118 }
7119
7120 static int test_blockdev_getro_0 (void)
7121 {
7122   if (test_blockdev_getro_0_skip ()) {
7123     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
7124     return 0;
7125   }
7126
7127   /* InitNone|InitEmpty for test_blockdev_getro_0 */
7128   {
7129     char device[] = "/dev/sda";
7130     int r;
7131     suppress_error = 0;
7132     r = guestfs_blockdev_setrw (g, device);
7133     if (r == -1)
7134       return -1;
7135   }
7136   {
7137     int r;
7138     suppress_error = 0;
7139     r = guestfs_umount_all (g);
7140     if (r == -1)
7141       return -1;
7142   }
7143   {
7144     int r;
7145     suppress_error = 0;
7146     r = guestfs_lvm_remove_all (g);
7147     if (r == -1)
7148       return -1;
7149   }
7150   /* TestOutputTrue for blockdev_getro (0) */
7151   {
7152     char device[] = "/dev/sda";
7153     int r;
7154     suppress_error = 0;
7155     r = guestfs_blockdev_setro (g, device);
7156     if (r == -1)
7157       return -1;
7158   }
7159   {
7160     char device[] = "/dev/sda";
7161     int r;
7162     suppress_error = 0;
7163     r = guestfs_blockdev_getro (g, device);
7164     if (r == -1)
7165       return -1;
7166     if (!r) {
7167       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
7168       return -1;
7169     }
7170   }
7171   return 0;
7172 }
7173
7174 static int test_blockdev_setrw_0_skip (void)
7175 {
7176   const char *str;
7177
7178   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
7179   if (str && strcmp (str, "1") == 0) return 1;
7180   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
7181   if (str && strcmp (str, "1") == 0) return 1;
7182   return 0;
7183 }
7184
7185 static int test_blockdev_setrw_0 (void)
7186 {
7187   if (test_blockdev_setrw_0_skip ()) {
7188     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
7189     return 0;
7190   }
7191
7192   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
7193   {
7194     char device[] = "/dev/sda";
7195     int r;
7196     suppress_error = 0;
7197     r = guestfs_blockdev_setrw (g, device);
7198     if (r == -1)
7199       return -1;
7200   }
7201   {
7202     int r;
7203     suppress_error = 0;
7204     r = guestfs_umount_all (g);
7205     if (r == -1)
7206       return -1;
7207   }
7208   {
7209     int r;
7210     suppress_error = 0;
7211     r = guestfs_lvm_remove_all (g);
7212     if (r == -1)
7213       return -1;
7214   }
7215   /* TestOutputFalse for blockdev_setrw (0) */
7216   {
7217     char device[] = "/dev/sda";
7218     int r;
7219     suppress_error = 0;
7220     r = guestfs_blockdev_setrw (g, device);
7221     if (r == -1)
7222       return -1;
7223   }
7224   {
7225     char device[] = "/dev/sda";
7226     int r;
7227     suppress_error = 0;
7228     r = guestfs_blockdev_getro (g, device);
7229     if (r == -1)
7230       return -1;
7231     if (r) {
7232       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
7233       return -1;
7234     }
7235   }
7236   return 0;
7237 }
7238
7239 static int test_blockdev_setro_0_skip (void)
7240 {
7241   const char *str;
7242
7243   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
7244   if (str && strcmp (str, "1") == 0) return 1;
7245   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
7246   if (str && strcmp (str, "1") == 0) return 1;
7247   return 0;
7248 }
7249
7250 static int test_blockdev_setro_0 (void)
7251 {
7252   if (test_blockdev_setro_0_skip ()) {
7253     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
7254     return 0;
7255   }
7256
7257   /* InitNone|InitEmpty for test_blockdev_setro_0 */
7258   {
7259     char device[] = "/dev/sda";
7260     int r;
7261     suppress_error = 0;
7262     r = guestfs_blockdev_setrw (g, device);
7263     if (r == -1)
7264       return -1;
7265   }
7266   {
7267     int r;
7268     suppress_error = 0;
7269     r = guestfs_umount_all (g);
7270     if (r == -1)
7271       return -1;
7272   }
7273   {
7274     int r;
7275     suppress_error = 0;
7276     r = guestfs_lvm_remove_all (g);
7277     if (r == -1)
7278       return -1;
7279   }
7280   /* TestOutputTrue for blockdev_setro (0) */
7281   {
7282     char device[] = "/dev/sda";
7283     int r;
7284     suppress_error = 0;
7285     r = guestfs_blockdev_setro (g, device);
7286     if (r == -1)
7287       return -1;
7288   }
7289   {
7290     char device[] = "/dev/sda";
7291     int r;
7292     suppress_error = 0;
7293     r = guestfs_blockdev_getro (g, device);
7294     if (r == -1)
7295       return -1;
7296     if (!r) {
7297       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
7298       return -1;
7299     }
7300   }
7301   return 0;
7302 }
7303
7304 static int test_statvfs_0_skip (void)
7305 {
7306   const char *str;
7307
7308   str = getenv ("SKIP_TEST_STATVFS_0");
7309   if (str && strcmp (str, "1") == 0) return 1;
7310   str = getenv ("SKIP_TEST_STATVFS");
7311   if (str && strcmp (str, "1") == 0) return 1;
7312   return 0;
7313 }
7314
7315 static int test_statvfs_0 (void)
7316 {
7317   if (test_statvfs_0_skip ()) {
7318     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
7319     return 0;
7320   }
7321
7322   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
7323   {
7324     char device[] = "/dev/sda";
7325     int r;
7326     suppress_error = 0;
7327     r = guestfs_blockdev_setrw (g, device);
7328     if (r == -1)
7329       return -1;
7330   }
7331   {
7332     int r;
7333     suppress_error = 0;
7334     r = guestfs_umount_all (g);
7335     if (r == -1)
7336       return -1;
7337   }
7338   {
7339     int r;
7340     suppress_error = 0;
7341     r = guestfs_lvm_remove_all (g);
7342     if (r == -1)
7343       return -1;
7344   }
7345   {
7346     char device[] = "/dev/sda";
7347     char lines_0[] = ",";
7348     char *lines[] = {
7349       lines_0,
7350       NULL
7351     };
7352     int r;
7353     suppress_error = 0;
7354     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7355     if (r == -1)
7356       return -1;
7357   }
7358   {
7359     char fstype[] = "ext2";
7360     char device[] = "/dev/sda1";
7361     int r;
7362     suppress_error = 0;
7363     r = guestfs_mkfs (g, fstype, device);
7364     if (r == -1)
7365       return -1;
7366   }
7367   {
7368     char device[] = "/dev/sda1";
7369     char mountpoint[] = "/";
7370     int r;
7371     suppress_error = 0;
7372     r = guestfs_mount (g, device, mountpoint);
7373     if (r == -1)
7374       return -1;
7375   }
7376   /* TestOutputStruct for statvfs (0) */
7377   {
7378     char path[] = "/";
7379     struct guestfs_statvfs *r;
7380     suppress_error = 0;
7381     r = guestfs_statvfs (g, path);
7382     if (r == NULL)
7383       return -1;
7384     if (r->bfree != 487702) {
7385       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7386                (int) r->bfree);
7387       return -1;
7388     }
7389     if (r->blocks != 490020) {
7390       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7391                (int) r->blocks);
7392       return -1;
7393     }
7394     if (r->bsize != 1024) {
7395       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7396                (int) r->bsize);
7397       return -1;
7398     }
7399     free (r);
7400   }
7401   return 0;
7402 }
7403
7404 static int test_lstat_0_skip (void)
7405 {
7406   const char *str;
7407
7408   str = getenv ("SKIP_TEST_LSTAT_0");
7409   if (str && strcmp (str, "1") == 0) return 1;
7410   str = getenv ("SKIP_TEST_LSTAT");
7411   if (str && strcmp (str, "1") == 0) return 1;
7412   return 0;
7413 }
7414
7415 static int test_lstat_0 (void)
7416 {
7417   if (test_lstat_0_skip ()) {
7418     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
7419     return 0;
7420   }
7421
7422   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7423   {
7424     char device[] = "/dev/sda";
7425     int r;
7426     suppress_error = 0;
7427     r = guestfs_blockdev_setrw (g, device);
7428     if (r == -1)
7429       return -1;
7430   }
7431   {
7432     int r;
7433     suppress_error = 0;
7434     r = guestfs_umount_all (g);
7435     if (r == -1)
7436       return -1;
7437   }
7438   {
7439     int r;
7440     suppress_error = 0;
7441     r = guestfs_lvm_remove_all (g);
7442     if (r == -1)
7443       return -1;
7444   }
7445   {
7446     char device[] = "/dev/sda";
7447     char lines_0[] = ",";
7448     char *lines[] = {
7449       lines_0,
7450       NULL
7451     };
7452     int r;
7453     suppress_error = 0;
7454     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7455     if (r == -1)
7456       return -1;
7457   }
7458   {
7459     char fstype[] = "ext2";
7460     char device[] = "/dev/sda1";
7461     int r;
7462     suppress_error = 0;
7463     r = guestfs_mkfs (g, fstype, device);
7464     if (r == -1)
7465       return -1;
7466   }
7467   {
7468     char device[] = "/dev/sda1";
7469     char mountpoint[] = "/";
7470     int r;
7471     suppress_error = 0;
7472     r = guestfs_mount (g, device, mountpoint);
7473     if (r == -1)
7474       return -1;
7475   }
7476   /* TestOutputStruct for lstat (0) */
7477   {
7478     char path[] = "/new";
7479     int r;
7480     suppress_error = 0;
7481     r = guestfs_touch (g, path);
7482     if (r == -1)
7483       return -1;
7484   }
7485   {
7486     char path[] = "/new";
7487     struct guestfs_stat *r;
7488     suppress_error = 0;
7489     r = guestfs_lstat (g, path);
7490     if (r == NULL)
7491       return -1;
7492     if (r->size != 0) {
7493       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7494                (int) r->size);
7495       return -1;
7496     }
7497     free (r);
7498   }
7499   return 0;
7500 }
7501
7502 static int test_stat_0_skip (void)
7503 {
7504   const char *str;
7505
7506   str = getenv ("SKIP_TEST_STAT_0");
7507   if (str && strcmp (str, "1") == 0) return 1;
7508   str = getenv ("SKIP_TEST_STAT");
7509   if (str && strcmp (str, "1") == 0) return 1;
7510   return 0;
7511 }
7512
7513 static int test_stat_0 (void)
7514 {
7515   if (test_stat_0_skip ()) {
7516     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7517     return 0;
7518   }
7519
7520   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7521   {
7522     char device[] = "/dev/sda";
7523     int r;
7524     suppress_error = 0;
7525     r = guestfs_blockdev_setrw (g, device);
7526     if (r == -1)
7527       return -1;
7528   }
7529   {
7530     int r;
7531     suppress_error = 0;
7532     r = guestfs_umount_all (g);
7533     if (r == -1)
7534       return -1;
7535   }
7536   {
7537     int r;
7538     suppress_error = 0;
7539     r = guestfs_lvm_remove_all (g);
7540     if (r == -1)
7541       return -1;
7542   }
7543   {
7544     char device[] = "/dev/sda";
7545     char lines_0[] = ",";
7546     char *lines[] = {
7547       lines_0,
7548       NULL
7549     };
7550     int r;
7551     suppress_error = 0;
7552     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7553     if (r == -1)
7554       return -1;
7555   }
7556   {
7557     char fstype[] = "ext2";
7558     char device[] = "/dev/sda1";
7559     int r;
7560     suppress_error = 0;
7561     r = guestfs_mkfs (g, fstype, device);
7562     if (r == -1)
7563       return -1;
7564   }
7565   {
7566     char device[] = "/dev/sda1";
7567     char mountpoint[] = "/";
7568     int r;
7569     suppress_error = 0;
7570     r = guestfs_mount (g, device, mountpoint);
7571     if (r == -1)
7572       return -1;
7573   }
7574   /* TestOutputStruct for stat (0) */
7575   {
7576     char path[] = "/new";
7577     int r;
7578     suppress_error = 0;
7579     r = guestfs_touch (g, path);
7580     if (r == -1)
7581       return -1;
7582   }
7583   {
7584     char path[] = "/new";
7585     struct guestfs_stat *r;
7586     suppress_error = 0;
7587     r = guestfs_stat (g, path);
7588     if (r == NULL)
7589       return -1;
7590     if (r->size != 0) {
7591       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7592                (int) r->size);
7593       return -1;
7594     }
7595     free (r);
7596   }
7597   return 0;
7598 }
7599
7600 static int test_command_lines_0_skip (void)
7601 {
7602   const char *str;
7603
7604   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7605   if (str && strcmp (str, "1") == 0) return 1;
7606   str = getenv ("SKIP_TEST_COMMAND_LINES");
7607   if (str && strcmp (str, "1") == 0) return 1;
7608   return 0;
7609 }
7610
7611 static int test_command_lines_0 (void)
7612 {
7613   if (test_command_lines_0_skip ()) {
7614     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7615     return 0;
7616   }
7617
7618   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7619   {
7620     char device[] = "/dev/sda";
7621     int r;
7622     suppress_error = 0;
7623     r = guestfs_blockdev_setrw (g, device);
7624     if (r == -1)
7625       return -1;
7626   }
7627   {
7628     int r;
7629     suppress_error = 0;
7630     r = guestfs_umount_all (g);
7631     if (r == -1)
7632       return -1;
7633   }
7634   {
7635     int r;
7636     suppress_error = 0;
7637     r = guestfs_lvm_remove_all (g);
7638     if (r == -1)
7639       return -1;
7640   }
7641   {
7642     char device[] = "/dev/sda";
7643     char lines_0[] = ",";
7644     char *lines[] = {
7645       lines_0,
7646       NULL
7647     };
7648     int r;
7649     suppress_error = 0;
7650     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7651     if (r == -1)
7652       return -1;
7653   }
7654   {
7655     char fstype[] = "ext2";
7656     char device[] = "/dev/sda1";
7657     int r;
7658     suppress_error = 0;
7659     r = guestfs_mkfs (g, fstype, device);
7660     if (r == -1)
7661       return -1;
7662   }
7663   {
7664     char device[] = "/dev/sda1";
7665     char mountpoint[] = "/";
7666     int r;
7667     suppress_error = 0;
7668     r = guestfs_mount (g, device, mountpoint);
7669     if (r == -1)
7670       return -1;
7671   }
7672   /* TestOutputList for command_lines (0) */
7673   {
7674     char remotefilename[] = "/test-command";
7675     int r;
7676     suppress_error = 0;
7677     r = guestfs_upload (g, "test-command", remotefilename);
7678     if (r == -1)
7679       return -1;
7680   }
7681   {
7682     char path[] = "/test-command";
7683     int r;
7684     suppress_error = 0;
7685     r = guestfs_chmod (g, 493, path);
7686     if (r == -1)
7687       return -1;
7688   }
7689   {
7690     char arguments_0[] = "/test-command";
7691     char arguments_1[] = "1";
7692     char *arguments[] = {
7693       arguments_0,
7694       arguments_1,
7695       NULL
7696     };
7697     char **r;
7698     int i;
7699     suppress_error = 0;
7700     r = guestfs_command_lines (g, arguments);
7701     if (r == NULL)
7702       return -1;
7703     if (!r[0]) {
7704       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7705       print_strings (r);
7706       return -1;
7707     }
7708     {
7709       char expected[] = "Result1";
7710       if (strcmp (r[0], expected) != 0) {
7711         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7712         return -1;
7713       }
7714     }
7715     if (r[1] != NULL) {
7716       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7717       print_strings (r);
7718       return -1;
7719     }
7720     for (i = 0; r[i] != NULL; ++i)
7721       free (r[i]);
7722     free (r);
7723   }
7724   return 0;
7725 }
7726
7727 static int test_command_lines_1_skip (void)
7728 {
7729   const char *str;
7730
7731   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7732   if (str && strcmp (str, "1") == 0) return 1;
7733   str = getenv ("SKIP_TEST_COMMAND_LINES");
7734   if (str && strcmp (str, "1") == 0) return 1;
7735   return 0;
7736 }
7737
7738 static int test_command_lines_1 (void)
7739 {
7740   if (test_command_lines_1_skip ()) {
7741     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7742     return 0;
7743   }
7744
7745   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7746   {
7747     char device[] = "/dev/sda";
7748     int r;
7749     suppress_error = 0;
7750     r = guestfs_blockdev_setrw (g, device);
7751     if (r == -1)
7752       return -1;
7753   }
7754   {
7755     int r;
7756     suppress_error = 0;
7757     r = guestfs_umount_all (g);
7758     if (r == -1)
7759       return -1;
7760   }
7761   {
7762     int r;
7763     suppress_error = 0;
7764     r = guestfs_lvm_remove_all (g);
7765     if (r == -1)
7766       return -1;
7767   }
7768   {
7769     char device[] = "/dev/sda";
7770     char lines_0[] = ",";
7771     char *lines[] = {
7772       lines_0,
7773       NULL
7774     };
7775     int r;
7776     suppress_error = 0;
7777     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7778     if (r == -1)
7779       return -1;
7780   }
7781   {
7782     char fstype[] = "ext2";
7783     char device[] = "/dev/sda1";
7784     int r;
7785     suppress_error = 0;
7786     r = guestfs_mkfs (g, fstype, device);
7787     if (r == -1)
7788       return -1;
7789   }
7790   {
7791     char device[] = "/dev/sda1";
7792     char mountpoint[] = "/";
7793     int r;
7794     suppress_error = 0;
7795     r = guestfs_mount (g, device, mountpoint);
7796     if (r == -1)
7797       return -1;
7798   }
7799   /* TestOutputList for command_lines (1) */
7800   {
7801     char remotefilename[] = "/test-command";
7802     int r;
7803     suppress_error = 0;
7804     r = guestfs_upload (g, "test-command", remotefilename);
7805     if (r == -1)
7806       return -1;
7807   }
7808   {
7809     char path[] = "/test-command";
7810     int r;
7811     suppress_error = 0;
7812     r = guestfs_chmod (g, 493, path);
7813     if (r == -1)
7814       return -1;
7815   }
7816   {
7817     char arguments_0[] = "/test-command";
7818     char arguments_1[] = "2";
7819     char *arguments[] = {
7820       arguments_0,
7821       arguments_1,
7822       NULL
7823     };
7824     char **r;
7825     int i;
7826     suppress_error = 0;
7827     r = guestfs_command_lines (g, arguments);
7828     if (r == NULL)
7829       return -1;
7830     if (!r[0]) {
7831       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7832       print_strings (r);
7833       return -1;
7834     }
7835     {
7836       char expected[] = "Result2";
7837       if (strcmp (r[0], expected) != 0) {
7838         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7839         return -1;
7840       }
7841     }
7842     if (r[1] != NULL) {
7843       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7844       print_strings (r);
7845       return -1;
7846     }
7847     for (i = 0; r[i] != NULL; ++i)
7848       free (r[i]);
7849     free (r);
7850   }
7851   return 0;
7852 }
7853
7854 static int test_command_lines_2_skip (void)
7855 {
7856   const char *str;
7857
7858   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7859   if (str && strcmp (str, "1") == 0) return 1;
7860   str = getenv ("SKIP_TEST_COMMAND_LINES");
7861   if (str && strcmp (str, "1") == 0) return 1;
7862   return 0;
7863 }
7864
7865 static int test_command_lines_2 (void)
7866 {
7867   if (test_command_lines_2_skip ()) {
7868     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7869     return 0;
7870   }
7871
7872   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7873   {
7874     char device[] = "/dev/sda";
7875     int r;
7876     suppress_error = 0;
7877     r = guestfs_blockdev_setrw (g, device);
7878     if (r == -1)
7879       return -1;
7880   }
7881   {
7882     int r;
7883     suppress_error = 0;
7884     r = guestfs_umount_all (g);
7885     if (r == -1)
7886       return -1;
7887   }
7888   {
7889     int r;
7890     suppress_error = 0;
7891     r = guestfs_lvm_remove_all (g);
7892     if (r == -1)
7893       return -1;
7894   }
7895   {
7896     char device[] = "/dev/sda";
7897     char lines_0[] = ",";
7898     char *lines[] = {
7899       lines_0,
7900       NULL
7901     };
7902     int r;
7903     suppress_error = 0;
7904     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7905     if (r == -1)
7906       return -1;
7907   }
7908   {
7909     char fstype[] = "ext2";
7910     char device[] = "/dev/sda1";
7911     int r;
7912     suppress_error = 0;
7913     r = guestfs_mkfs (g, fstype, device);
7914     if (r == -1)
7915       return -1;
7916   }
7917   {
7918     char device[] = "/dev/sda1";
7919     char mountpoint[] = "/";
7920     int r;
7921     suppress_error = 0;
7922     r = guestfs_mount (g, device, mountpoint);
7923     if (r == -1)
7924       return -1;
7925   }
7926   /* TestOutputList for command_lines (2) */
7927   {
7928     char remotefilename[] = "/test-command";
7929     int r;
7930     suppress_error = 0;
7931     r = guestfs_upload (g, "test-command", remotefilename);
7932     if (r == -1)
7933       return -1;
7934   }
7935   {
7936     char path[] = "/test-command";
7937     int r;
7938     suppress_error = 0;
7939     r = guestfs_chmod (g, 493, path);
7940     if (r == -1)
7941       return -1;
7942   }
7943   {
7944     char arguments_0[] = "/test-command";
7945     char arguments_1[] = "3";
7946     char *arguments[] = {
7947       arguments_0,
7948       arguments_1,
7949       NULL
7950     };
7951     char **r;
7952     int i;
7953     suppress_error = 0;
7954     r = guestfs_command_lines (g, arguments);
7955     if (r == NULL)
7956       return -1;
7957     if (!r[0]) {
7958       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7959       print_strings (r);
7960       return -1;
7961     }
7962     {
7963       char expected[] = "";
7964       if (strcmp (r[0], expected) != 0) {
7965         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7966         return -1;
7967       }
7968     }
7969     if (!r[1]) {
7970       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7971       print_strings (r);
7972       return -1;
7973     }
7974     {
7975       char expected[] = "Result3";
7976       if (strcmp (r[1], expected) != 0) {
7977         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7978         return -1;
7979       }
7980     }
7981     if (r[2] != NULL) {
7982       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7983       print_strings (r);
7984       return -1;
7985     }
7986     for (i = 0; r[i] != NULL; ++i)
7987       free (r[i]);
7988     free (r);
7989   }
7990   return 0;
7991 }
7992
7993 static int test_command_lines_3_skip (void)
7994 {
7995   const char *str;
7996
7997   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7998   if (str && strcmp (str, "1") == 0) return 1;
7999   str = getenv ("SKIP_TEST_COMMAND_LINES");
8000   if (str && strcmp (str, "1") == 0) return 1;
8001   return 0;
8002 }
8003
8004 static int test_command_lines_3 (void)
8005 {
8006   if (test_command_lines_3_skip ()) {
8007     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
8008     return 0;
8009   }
8010
8011   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
8012   {
8013     char device[] = "/dev/sda";
8014     int r;
8015     suppress_error = 0;
8016     r = guestfs_blockdev_setrw (g, device);
8017     if (r == -1)
8018       return -1;
8019   }
8020   {
8021     int r;
8022     suppress_error = 0;
8023     r = guestfs_umount_all (g);
8024     if (r == -1)
8025       return -1;
8026   }
8027   {
8028     int r;
8029     suppress_error = 0;
8030     r = guestfs_lvm_remove_all (g);
8031     if (r == -1)
8032       return -1;
8033   }
8034   {
8035     char device[] = "/dev/sda";
8036     char lines_0[] = ",";
8037     char *lines[] = {
8038       lines_0,
8039       NULL
8040     };
8041     int r;
8042     suppress_error = 0;
8043     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8044     if (r == -1)
8045       return -1;
8046   }
8047   {
8048     char fstype[] = "ext2";
8049     char device[] = "/dev/sda1";
8050     int r;
8051     suppress_error = 0;
8052     r = guestfs_mkfs (g, fstype, device);
8053     if (r == -1)
8054       return -1;
8055   }
8056   {
8057     char device[] = "/dev/sda1";
8058     char mountpoint[] = "/";
8059     int r;
8060     suppress_error = 0;
8061     r = guestfs_mount (g, device, mountpoint);
8062     if (r == -1)
8063       return -1;
8064   }
8065   /* TestOutputList for command_lines (3) */
8066   {
8067     char remotefilename[] = "/test-command";
8068     int r;
8069     suppress_error = 0;
8070     r = guestfs_upload (g, "test-command", remotefilename);
8071     if (r == -1)
8072       return -1;
8073   }
8074   {
8075     char path[] = "/test-command";
8076     int r;
8077     suppress_error = 0;
8078     r = guestfs_chmod (g, 493, path);
8079     if (r == -1)
8080       return -1;
8081   }
8082   {
8083     char arguments_0[] = "/test-command";
8084     char arguments_1[] = "4";
8085     char *arguments[] = {
8086       arguments_0,
8087       arguments_1,
8088       NULL
8089     };
8090     char **r;
8091     int i;
8092     suppress_error = 0;
8093     r = guestfs_command_lines (g, arguments);
8094     if (r == NULL)
8095       return -1;
8096     if (!r[0]) {
8097       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8098       print_strings (r);
8099       return -1;
8100     }
8101     {
8102       char expected[] = "";
8103       if (strcmp (r[0], expected) != 0) {
8104         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8105         return -1;
8106       }
8107     }
8108     if (!r[1]) {
8109       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8110       print_strings (r);
8111       return -1;
8112     }
8113     {
8114       char expected[] = "Result4";
8115       if (strcmp (r[1], expected) != 0) {
8116         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8117         return -1;
8118       }
8119     }
8120     if (r[2] != NULL) {
8121       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
8122       print_strings (r);
8123       return -1;
8124     }
8125     for (i = 0; r[i] != NULL; ++i)
8126       free (r[i]);
8127     free (r);
8128   }
8129   return 0;
8130 }
8131
8132 static int test_command_lines_4_skip (void)
8133 {
8134   const char *str;
8135
8136   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
8137   if (str && strcmp (str, "1") == 0) return 1;
8138   str = getenv ("SKIP_TEST_COMMAND_LINES");
8139   if (str && strcmp (str, "1") == 0) return 1;
8140   return 0;
8141 }
8142
8143 static int test_command_lines_4 (void)
8144 {
8145   if (test_command_lines_4_skip ()) {
8146     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
8147     return 0;
8148   }
8149
8150   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
8151   {
8152     char device[] = "/dev/sda";
8153     int r;
8154     suppress_error = 0;
8155     r = guestfs_blockdev_setrw (g, device);
8156     if (r == -1)
8157       return -1;
8158   }
8159   {
8160     int r;
8161     suppress_error = 0;
8162     r = guestfs_umount_all (g);
8163     if (r == -1)
8164       return -1;
8165   }
8166   {
8167     int r;
8168     suppress_error = 0;
8169     r = guestfs_lvm_remove_all (g);
8170     if (r == -1)
8171       return -1;
8172   }
8173   {
8174     char device[] = "/dev/sda";
8175     char lines_0[] = ",";
8176     char *lines[] = {
8177       lines_0,
8178       NULL
8179     };
8180     int r;
8181     suppress_error = 0;
8182     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8183     if (r == -1)
8184       return -1;
8185   }
8186   {
8187     char fstype[] = "ext2";
8188     char device[] = "/dev/sda1";
8189     int r;
8190     suppress_error = 0;
8191     r = guestfs_mkfs (g, fstype, device);
8192     if (r == -1)
8193       return -1;
8194   }
8195   {
8196     char device[] = "/dev/sda1";
8197     char mountpoint[] = "/";
8198     int r;
8199     suppress_error = 0;
8200     r = guestfs_mount (g, device, mountpoint);
8201     if (r == -1)
8202       return -1;
8203   }
8204   /* TestOutputList for command_lines (4) */
8205   {
8206     char remotefilename[] = "/test-command";
8207     int r;
8208     suppress_error = 0;
8209     r = guestfs_upload (g, "test-command", remotefilename);
8210     if (r == -1)
8211       return -1;
8212   }
8213   {
8214     char path[] = "/test-command";
8215     int r;
8216     suppress_error = 0;
8217     r = guestfs_chmod (g, 493, path);
8218     if (r == -1)
8219       return -1;
8220   }
8221   {
8222     char arguments_0[] = "/test-command";
8223     char arguments_1[] = "5";
8224     char *arguments[] = {
8225       arguments_0,
8226       arguments_1,
8227       NULL
8228     };
8229     char **r;
8230     int i;
8231     suppress_error = 0;
8232     r = guestfs_command_lines (g, arguments);
8233     if (r == NULL)
8234       return -1;
8235     if (!r[0]) {
8236       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8237       print_strings (r);
8238       return -1;
8239     }
8240     {
8241       char expected[] = "";
8242       if (strcmp (r[0], expected) != 0) {
8243         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8244         return -1;
8245       }
8246     }
8247     if (!r[1]) {
8248       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8249       print_strings (r);
8250       return -1;
8251     }
8252     {
8253       char expected[] = "Result5";
8254       if (strcmp (r[1], expected) != 0) {
8255         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8256         return -1;
8257       }
8258     }
8259     if (!r[2]) {
8260       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8261       print_strings (r);
8262       return -1;
8263     }
8264     {
8265       char expected[] = "";
8266       if (strcmp (r[2], expected) != 0) {
8267         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8268         return -1;
8269       }
8270     }
8271     if (r[3] != NULL) {
8272       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
8273       print_strings (r);
8274       return -1;
8275     }
8276     for (i = 0; r[i] != NULL; ++i)
8277       free (r[i]);
8278     free (r);
8279   }
8280   return 0;
8281 }
8282
8283 static int test_command_lines_5_skip (void)
8284 {
8285   const char *str;
8286
8287   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
8288   if (str && strcmp (str, "1") == 0) return 1;
8289   str = getenv ("SKIP_TEST_COMMAND_LINES");
8290   if (str && strcmp (str, "1") == 0) return 1;
8291   return 0;
8292 }
8293
8294 static int test_command_lines_5 (void)
8295 {
8296   if (test_command_lines_5_skip ()) {
8297     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
8298     return 0;
8299   }
8300
8301   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
8302   {
8303     char device[] = "/dev/sda";
8304     int r;
8305     suppress_error = 0;
8306     r = guestfs_blockdev_setrw (g, device);
8307     if (r == -1)
8308       return -1;
8309   }
8310   {
8311     int r;
8312     suppress_error = 0;
8313     r = guestfs_umount_all (g);
8314     if (r == -1)
8315       return -1;
8316   }
8317   {
8318     int r;
8319     suppress_error = 0;
8320     r = guestfs_lvm_remove_all (g);
8321     if (r == -1)
8322       return -1;
8323   }
8324   {
8325     char device[] = "/dev/sda";
8326     char lines_0[] = ",";
8327     char *lines[] = {
8328       lines_0,
8329       NULL
8330     };
8331     int r;
8332     suppress_error = 0;
8333     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8334     if (r == -1)
8335       return -1;
8336   }
8337   {
8338     char fstype[] = "ext2";
8339     char device[] = "/dev/sda1";
8340     int r;
8341     suppress_error = 0;
8342     r = guestfs_mkfs (g, fstype, device);
8343     if (r == -1)
8344       return -1;
8345   }
8346   {
8347     char device[] = "/dev/sda1";
8348     char mountpoint[] = "/";
8349     int r;
8350     suppress_error = 0;
8351     r = guestfs_mount (g, device, mountpoint);
8352     if (r == -1)
8353       return -1;
8354   }
8355   /* TestOutputList for command_lines (5) */
8356   {
8357     char remotefilename[] = "/test-command";
8358     int r;
8359     suppress_error = 0;
8360     r = guestfs_upload (g, "test-command", remotefilename);
8361     if (r == -1)
8362       return -1;
8363   }
8364   {
8365     char path[] = "/test-command";
8366     int r;
8367     suppress_error = 0;
8368     r = guestfs_chmod (g, 493, path);
8369     if (r == -1)
8370       return -1;
8371   }
8372   {
8373     char arguments_0[] = "/test-command";
8374     char arguments_1[] = "6";
8375     char *arguments[] = {
8376       arguments_0,
8377       arguments_1,
8378       NULL
8379     };
8380     char **r;
8381     int i;
8382     suppress_error = 0;
8383     r = guestfs_command_lines (g, arguments);
8384     if (r == NULL)
8385       return -1;
8386     if (!r[0]) {
8387       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8388       print_strings (r);
8389       return -1;
8390     }
8391     {
8392       char expected[] = "";
8393       if (strcmp (r[0], expected) != 0) {
8394         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8395         return -1;
8396       }
8397     }
8398     if (!r[1]) {
8399       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8400       print_strings (r);
8401       return -1;
8402     }
8403     {
8404       char expected[] = "";
8405       if (strcmp (r[1], expected) != 0) {
8406         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8407         return -1;
8408       }
8409     }
8410     if (!r[2]) {
8411       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8412       print_strings (r);
8413       return -1;
8414     }
8415     {
8416       char expected[] = "Result6";
8417       if (strcmp (r[2], expected) != 0) {
8418         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8419         return -1;
8420       }
8421     }
8422     if (!r[3]) {
8423       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8424       print_strings (r);
8425       return -1;
8426     }
8427     {
8428       char expected[] = "";
8429       if (strcmp (r[3], expected) != 0) {
8430         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8431         return -1;
8432       }
8433     }
8434     if (r[4] != NULL) {
8435       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8436       print_strings (r);
8437       return -1;
8438     }
8439     for (i = 0; r[i] != NULL; ++i)
8440       free (r[i]);
8441     free (r);
8442   }
8443   return 0;
8444 }
8445
8446 static int test_command_lines_6_skip (void)
8447 {
8448   const char *str;
8449
8450   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8451   if (str && strcmp (str, "1") == 0) return 1;
8452   str = getenv ("SKIP_TEST_COMMAND_LINES");
8453   if (str && strcmp (str, "1") == 0) return 1;
8454   return 0;
8455 }
8456
8457 static int test_command_lines_6 (void)
8458 {
8459   if (test_command_lines_6_skip ()) {
8460     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8461     return 0;
8462   }
8463
8464   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8465   {
8466     char device[] = "/dev/sda";
8467     int r;
8468     suppress_error = 0;
8469     r = guestfs_blockdev_setrw (g, device);
8470     if (r == -1)
8471       return -1;
8472   }
8473   {
8474     int r;
8475     suppress_error = 0;
8476     r = guestfs_umount_all (g);
8477     if (r == -1)
8478       return -1;
8479   }
8480   {
8481     int r;
8482     suppress_error = 0;
8483     r = guestfs_lvm_remove_all (g);
8484     if (r == -1)
8485       return -1;
8486   }
8487   {
8488     char device[] = "/dev/sda";
8489     char lines_0[] = ",";
8490     char *lines[] = {
8491       lines_0,
8492       NULL
8493     };
8494     int r;
8495     suppress_error = 0;
8496     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8497     if (r == -1)
8498       return -1;
8499   }
8500   {
8501     char fstype[] = "ext2";
8502     char device[] = "/dev/sda1";
8503     int r;
8504     suppress_error = 0;
8505     r = guestfs_mkfs (g, fstype, device);
8506     if (r == -1)
8507       return -1;
8508   }
8509   {
8510     char device[] = "/dev/sda1";
8511     char mountpoint[] = "/";
8512     int r;
8513     suppress_error = 0;
8514     r = guestfs_mount (g, device, mountpoint);
8515     if (r == -1)
8516       return -1;
8517   }
8518   /* TestOutputList for command_lines (6) */
8519   {
8520     char remotefilename[] = "/test-command";
8521     int r;
8522     suppress_error = 0;
8523     r = guestfs_upload (g, "test-command", remotefilename);
8524     if (r == -1)
8525       return -1;
8526   }
8527   {
8528     char path[] = "/test-command";
8529     int r;
8530     suppress_error = 0;
8531     r = guestfs_chmod (g, 493, path);
8532     if (r == -1)
8533       return -1;
8534   }
8535   {
8536     char arguments_0[] = "/test-command";
8537     char arguments_1[] = "7";
8538     char *arguments[] = {
8539       arguments_0,
8540       arguments_1,
8541       NULL
8542     };
8543     char **r;
8544     int i;
8545     suppress_error = 0;
8546     r = guestfs_command_lines (g, arguments);
8547     if (r == NULL)
8548       return -1;
8549     if (r[0] != NULL) {
8550       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8551       print_strings (r);
8552       return -1;
8553     }
8554     for (i = 0; r[i] != NULL; ++i)
8555       free (r[i]);
8556     free (r);
8557   }
8558   return 0;
8559 }
8560
8561 static int test_command_lines_7_skip (void)
8562 {
8563   const char *str;
8564
8565   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8566   if (str && strcmp (str, "1") == 0) return 1;
8567   str = getenv ("SKIP_TEST_COMMAND_LINES");
8568   if (str && strcmp (str, "1") == 0) return 1;
8569   return 0;
8570 }
8571
8572 static int test_command_lines_7 (void)
8573 {
8574   if (test_command_lines_7_skip ()) {
8575     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8576     return 0;
8577   }
8578
8579   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8580   {
8581     char device[] = "/dev/sda";
8582     int r;
8583     suppress_error = 0;
8584     r = guestfs_blockdev_setrw (g, device);
8585     if (r == -1)
8586       return -1;
8587   }
8588   {
8589     int r;
8590     suppress_error = 0;
8591     r = guestfs_umount_all (g);
8592     if (r == -1)
8593       return -1;
8594   }
8595   {
8596     int r;
8597     suppress_error = 0;
8598     r = guestfs_lvm_remove_all (g);
8599     if (r == -1)
8600       return -1;
8601   }
8602   {
8603     char device[] = "/dev/sda";
8604     char lines_0[] = ",";
8605     char *lines[] = {
8606       lines_0,
8607       NULL
8608     };
8609     int r;
8610     suppress_error = 0;
8611     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8612     if (r == -1)
8613       return -1;
8614   }
8615   {
8616     char fstype[] = "ext2";
8617     char device[] = "/dev/sda1";
8618     int r;
8619     suppress_error = 0;
8620     r = guestfs_mkfs (g, fstype, device);
8621     if (r == -1)
8622       return -1;
8623   }
8624   {
8625     char device[] = "/dev/sda1";
8626     char mountpoint[] = "/";
8627     int r;
8628     suppress_error = 0;
8629     r = guestfs_mount (g, device, mountpoint);
8630     if (r == -1)
8631       return -1;
8632   }
8633   /* TestOutputList for command_lines (7) */
8634   {
8635     char remotefilename[] = "/test-command";
8636     int r;
8637     suppress_error = 0;
8638     r = guestfs_upload (g, "test-command", remotefilename);
8639     if (r == -1)
8640       return -1;
8641   }
8642   {
8643     char path[] = "/test-command";
8644     int r;
8645     suppress_error = 0;
8646     r = guestfs_chmod (g, 493, path);
8647     if (r == -1)
8648       return -1;
8649   }
8650   {
8651     char arguments_0[] = "/test-command";
8652     char arguments_1[] = "8";
8653     char *arguments[] = {
8654       arguments_0,
8655       arguments_1,
8656       NULL
8657     };
8658     char **r;
8659     int i;
8660     suppress_error = 0;
8661     r = guestfs_command_lines (g, arguments);
8662     if (r == NULL)
8663       return -1;
8664     if (!r[0]) {
8665       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8666       print_strings (r);
8667       return -1;
8668     }
8669     {
8670       char expected[] = "";
8671       if (strcmp (r[0], expected) != 0) {
8672         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8673         return -1;
8674       }
8675     }
8676     if (r[1] != NULL) {
8677       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8678       print_strings (r);
8679       return -1;
8680     }
8681     for (i = 0; r[i] != NULL; ++i)
8682       free (r[i]);
8683     free (r);
8684   }
8685   return 0;
8686 }
8687
8688 static int test_command_lines_8_skip (void)
8689 {
8690   const char *str;
8691
8692   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8693   if (str && strcmp (str, "1") == 0) return 1;
8694   str = getenv ("SKIP_TEST_COMMAND_LINES");
8695   if (str && strcmp (str, "1") == 0) return 1;
8696   return 0;
8697 }
8698
8699 static int test_command_lines_8 (void)
8700 {
8701   if (test_command_lines_8_skip ()) {
8702     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8703     return 0;
8704   }
8705
8706   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8707   {
8708     char device[] = "/dev/sda";
8709     int r;
8710     suppress_error = 0;
8711     r = guestfs_blockdev_setrw (g, device);
8712     if (r == -1)
8713       return -1;
8714   }
8715   {
8716     int r;
8717     suppress_error = 0;
8718     r = guestfs_umount_all (g);
8719     if (r == -1)
8720       return -1;
8721   }
8722   {
8723     int r;
8724     suppress_error = 0;
8725     r = guestfs_lvm_remove_all (g);
8726     if (r == -1)
8727       return -1;
8728   }
8729   {
8730     char device[] = "/dev/sda";
8731     char lines_0[] = ",";
8732     char *lines[] = {
8733       lines_0,
8734       NULL
8735     };
8736     int r;
8737     suppress_error = 0;
8738     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8739     if (r == -1)
8740       return -1;
8741   }
8742   {
8743     char fstype[] = "ext2";
8744     char device[] = "/dev/sda1";
8745     int r;
8746     suppress_error = 0;
8747     r = guestfs_mkfs (g, fstype, device);
8748     if (r == -1)
8749       return -1;
8750   }
8751   {
8752     char device[] = "/dev/sda1";
8753     char mountpoint[] = "/";
8754     int r;
8755     suppress_error = 0;
8756     r = guestfs_mount (g, device, mountpoint);
8757     if (r == -1)
8758       return -1;
8759   }
8760   /* TestOutputList for command_lines (8) */
8761   {
8762     char remotefilename[] = "/test-command";
8763     int r;
8764     suppress_error = 0;
8765     r = guestfs_upload (g, "test-command", remotefilename);
8766     if (r == -1)
8767       return -1;
8768   }
8769   {
8770     char path[] = "/test-command";
8771     int r;
8772     suppress_error = 0;
8773     r = guestfs_chmod (g, 493, path);
8774     if (r == -1)
8775       return -1;
8776   }
8777   {
8778     char arguments_0[] = "/test-command";
8779     char arguments_1[] = "9";
8780     char *arguments[] = {
8781       arguments_0,
8782       arguments_1,
8783       NULL
8784     };
8785     char **r;
8786     int i;
8787     suppress_error = 0;
8788     r = guestfs_command_lines (g, arguments);
8789     if (r == NULL)
8790       return -1;
8791     if (!r[0]) {
8792       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8793       print_strings (r);
8794       return -1;
8795     }
8796     {
8797       char expected[] = "";
8798       if (strcmp (r[0], expected) != 0) {
8799         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8800         return -1;
8801       }
8802     }
8803     if (!r[1]) {
8804       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8805       print_strings (r);
8806       return -1;
8807     }
8808     {
8809       char expected[] = "";
8810       if (strcmp (r[1], expected) != 0) {
8811         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8812         return -1;
8813       }
8814     }
8815     if (r[2] != NULL) {
8816       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8817       print_strings (r);
8818       return -1;
8819     }
8820     for (i = 0; r[i] != NULL; ++i)
8821       free (r[i]);
8822     free (r);
8823   }
8824   return 0;
8825 }
8826
8827 static int test_command_lines_9_skip (void)
8828 {
8829   const char *str;
8830
8831   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8832   if (str && strcmp (str, "1") == 0) return 1;
8833   str = getenv ("SKIP_TEST_COMMAND_LINES");
8834   if (str && strcmp (str, "1") == 0) return 1;
8835   return 0;
8836 }
8837
8838 static int test_command_lines_9 (void)
8839 {
8840   if (test_command_lines_9_skip ()) {
8841     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8842     return 0;
8843   }
8844
8845   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8846   {
8847     char device[] = "/dev/sda";
8848     int r;
8849     suppress_error = 0;
8850     r = guestfs_blockdev_setrw (g, device);
8851     if (r == -1)
8852       return -1;
8853   }
8854   {
8855     int r;
8856     suppress_error = 0;
8857     r = guestfs_umount_all (g);
8858     if (r == -1)
8859       return -1;
8860   }
8861   {
8862     int r;
8863     suppress_error = 0;
8864     r = guestfs_lvm_remove_all (g);
8865     if (r == -1)
8866       return -1;
8867   }
8868   {
8869     char device[] = "/dev/sda";
8870     char lines_0[] = ",";
8871     char *lines[] = {
8872       lines_0,
8873       NULL
8874     };
8875     int r;
8876     suppress_error = 0;
8877     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8878     if (r == -1)
8879       return -1;
8880   }
8881   {
8882     char fstype[] = "ext2";
8883     char device[] = "/dev/sda1";
8884     int r;
8885     suppress_error = 0;
8886     r = guestfs_mkfs (g, fstype, device);
8887     if (r == -1)
8888       return -1;
8889   }
8890   {
8891     char device[] = "/dev/sda1";
8892     char mountpoint[] = "/";
8893     int r;
8894     suppress_error = 0;
8895     r = guestfs_mount (g, device, mountpoint);
8896     if (r == -1)
8897       return -1;
8898   }
8899   /* TestOutputList for command_lines (9) */
8900   {
8901     char remotefilename[] = "/test-command";
8902     int r;
8903     suppress_error = 0;
8904     r = guestfs_upload (g, "test-command", remotefilename);
8905     if (r == -1)
8906       return -1;
8907   }
8908   {
8909     char path[] = "/test-command";
8910     int r;
8911     suppress_error = 0;
8912     r = guestfs_chmod (g, 493, path);
8913     if (r == -1)
8914       return -1;
8915   }
8916   {
8917     char arguments_0[] = "/test-command";
8918     char arguments_1[] = "10";
8919     char *arguments[] = {
8920       arguments_0,
8921       arguments_1,
8922       NULL
8923     };
8924     char **r;
8925     int i;
8926     suppress_error = 0;
8927     r = guestfs_command_lines (g, arguments);
8928     if (r == NULL)
8929       return -1;
8930     if (!r[0]) {
8931       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8932       print_strings (r);
8933       return -1;
8934     }
8935     {
8936       char expected[] = "Result10-1";
8937       if (strcmp (r[0], expected) != 0) {
8938         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8939         return -1;
8940       }
8941     }
8942     if (!r[1]) {
8943       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8944       print_strings (r);
8945       return -1;
8946     }
8947     {
8948       char expected[] = "Result10-2";
8949       if (strcmp (r[1], expected) != 0) {
8950         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8951         return -1;
8952       }
8953     }
8954     if (r[2] != NULL) {
8955       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8956       print_strings (r);
8957       return -1;
8958     }
8959     for (i = 0; r[i] != NULL; ++i)
8960       free (r[i]);
8961     free (r);
8962   }
8963   return 0;
8964 }
8965
8966 static int test_command_lines_10_skip (void)
8967 {
8968   const char *str;
8969
8970   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8971   if (str && strcmp (str, "1") == 0) return 1;
8972   str = getenv ("SKIP_TEST_COMMAND_LINES");
8973   if (str && strcmp (str, "1") == 0) return 1;
8974   return 0;
8975 }
8976
8977 static int test_command_lines_10 (void)
8978 {
8979   if (test_command_lines_10_skip ()) {
8980     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8981     return 0;
8982   }
8983
8984   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8985   {
8986     char device[] = "/dev/sda";
8987     int r;
8988     suppress_error = 0;
8989     r = guestfs_blockdev_setrw (g, device);
8990     if (r == -1)
8991       return -1;
8992   }
8993   {
8994     int r;
8995     suppress_error = 0;
8996     r = guestfs_umount_all (g);
8997     if (r == -1)
8998       return -1;
8999   }
9000   {
9001     int r;
9002     suppress_error = 0;
9003     r = guestfs_lvm_remove_all (g);
9004     if (r == -1)
9005       return -1;
9006   }
9007   {
9008     char device[] = "/dev/sda";
9009     char lines_0[] = ",";
9010     char *lines[] = {
9011       lines_0,
9012       NULL
9013     };
9014     int r;
9015     suppress_error = 0;
9016     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9017     if (r == -1)
9018       return -1;
9019   }
9020   {
9021     char fstype[] = "ext2";
9022     char device[] = "/dev/sda1";
9023     int r;
9024     suppress_error = 0;
9025     r = guestfs_mkfs (g, fstype, device);
9026     if (r == -1)
9027       return -1;
9028   }
9029   {
9030     char device[] = "/dev/sda1";
9031     char mountpoint[] = "/";
9032     int r;
9033     suppress_error = 0;
9034     r = guestfs_mount (g, device, mountpoint);
9035     if (r == -1)
9036       return -1;
9037   }
9038   /* TestOutputList for command_lines (10) */
9039   {
9040     char remotefilename[] = "/test-command";
9041     int r;
9042     suppress_error = 0;
9043     r = guestfs_upload (g, "test-command", remotefilename);
9044     if (r == -1)
9045       return -1;
9046   }
9047   {
9048     char path[] = "/test-command";
9049     int r;
9050     suppress_error = 0;
9051     r = guestfs_chmod (g, 493, path);
9052     if (r == -1)
9053       return -1;
9054   }
9055   {
9056     char arguments_0[] = "/test-command";
9057     char arguments_1[] = "11";
9058     char *arguments[] = {
9059       arguments_0,
9060       arguments_1,
9061       NULL
9062     };
9063     char **r;
9064     int i;
9065     suppress_error = 0;
9066     r = guestfs_command_lines (g, arguments);
9067     if (r == NULL)
9068       return -1;
9069     if (!r[0]) {
9070       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
9071       print_strings (r);
9072       return -1;
9073     }
9074     {
9075       char expected[] = "Result11-1";
9076       if (strcmp (r[0], expected) != 0) {
9077         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9078         return -1;
9079       }
9080     }
9081     if (!r[1]) {
9082       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
9083       print_strings (r);
9084       return -1;
9085     }
9086     {
9087       char expected[] = "Result11-2";
9088       if (strcmp (r[1], expected) != 0) {
9089         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9090         return -1;
9091       }
9092     }
9093     if (r[2] != NULL) {
9094       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
9095       print_strings (r);
9096       return -1;
9097     }
9098     for (i = 0; r[i] != NULL; ++i)
9099       free (r[i]);
9100     free (r);
9101   }
9102   return 0;
9103 }
9104
9105 static int test_command_0_skip (void)
9106 {
9107   const char *str;
9108
9109   str = getenv ("SKIP_TEST_COMMAND_0");
9110   if (str && strcmp (str, "1") == 0) return 1;
9111   str = getenv ("SKIP_TEST_COMMAND");
9112   if (str && strcmp (str, "1") == 0) return 1;
9113   return 0;
9114 }
9115
9116 static int test_command_0 (void)
9117 {
9118   if (test_command_0_skip ()) {
9119     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
9120     return 0;
9121   }
9122
9123   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
9124   {
9125     char device[] = "/dev/sda";
9126     int r;
9127     suppress_error = 0;
9128     r = guestfs_blockdev_setrw (g, device);
9129     if (r == -1)
9130       return -1;
9131   }
9132   {
9133     int r;
9134     suppress_error = 0;
9135     r = guestfs_umount_all (g);
9136     if (r == -1)
9137       return -1;
9138   }
9139   {
9140     int r;
9141     suppress_error = 0;
9142     r = guestfs_lvm_remove_all (g);
9143     if (r == -1)
9144       return -1;
9145   }
9146   {
9147     char device[] = "/dev/sda";
9148     char lines_0[] = ",";
9149     char *lines[] = {
9150       lines_0,
9151       NULL
9152     };
9153     int r;
9154     suppress_error = 0;
9155     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9156     if (r == -1)
9157       return -1;
9158   }
9159   {
9160     char fstype[] = "ext2";
9161     char device[] = "/dev/sda1";
9162     int r;
9163     suppress_error = 0;
9164     r = guestfs_mkfs (g, fstype, device);
9165     if (r == -1)
9166       return -1;
9167   }
9168   {
9169     char device[] = "/dev/sda1";
9170     char mountpoint[] = "/";
9171     int r;
9172     suppress_error = 0;
9173     r = guestfs_mount (g, device, mountpoint);
9174     if (r == -1)
9175       return -1;
9176   }
9177   /* TestOutput for command (0) */
9178   char expected[] = "Result1";
9179   {
9180     char remotefilename[] = "/test-command";
9181     int r;
9182     suppress_error = 0;
9183     r = guestfs_upload (g, "test-command", remotefilename);
9184     if (r == -1)
9185       return -1;
9186   }
9187   {
9188     char path[] = "/test-command";
9189     int r;
9190     suppress_error = 0;
9191     r = guestfs_chmod (g, 493, path);
9192     if (r == -1)
9193       return -1;
9194   }
9195   {
9196     char arguments_0[] = "/test-command";
9197     char arguments_1[] = "1";
9198     char *arguments[] = {
9199       arguments_0,
9200       arguments_1,
9201       NULL
9202     };
9203     char *r;
9204     suppress_error = 0;
9205     r = guestfs_command (g, arguments);
9206     if (r == NULL)
9207       return -1;
9208     if (strcmp (r, expected) != 0) {
9209       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
9210       return -1;
9211     }
9212     free (r);
9213   }
9214   return 0;
9215 }
9216
9217 static int test_command_1_skip (void)
9218 {
9219   const char *str;
9220
9221   str = getenv ("SKIP_TEST_COMMAND_1");
9222   if (str && strcmp (str, "1") == 0) return 1;
9223   str = getenv ("SKIP_TEST_COMMAND");
9224   if (str && strcmp (str, "1") == 0) return 1;
9225   return 0;
9226 }
9227
9228 static int test_command_1 (void)
9229 {
9230   if (test_command_1_skip ()) {
9231     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
9232     return 0;
9233   }
9234
9235   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
9236   {
9237     char device[] = "/dev/sda";
9238     int r;
9239     suppress_error = 0;
9240     r = guestfs_blockdev_setrw (g, device);
9241     if (r == -1)
9242       return -1;
9243   }
9244   {
9245     int r;
9246     suppress_error = 0;
9247     r = guestfs_umount_all (g);
9248     if (r == -1)
9249       return -1;
9250   }
9251   {
9252     int r;
9253     suppress_error = 0;
9254     r = guestfs_lvm_remove_all (g);
9255     if (r == -1)
9256       return -1;
9257   }
9258   {
9259     char device[] = "/dev/sda";
9260     char lines_0[] = ",";
9261     char *lines[] = {
9262       lines_0,
9263       NULL
9264     };
9265     int r;
9266     suppress_error = 0;
9267     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9268     if (r == -1)
9269       return -1;
9270   }
9271   {
9272     char fstype[] = "ext2";
9273     char device[] = "/dev/sda1";
9274     int r;
9275     suppress_error = 0;
9276     r = guestfs_mkfs (g, fstype, device);
9277     if (r == -1)
9278       return -1;
9279   }
9280   {
9281     char device[] = "/dev/sda1";
9282     char mountpoint[] = "/";
9283     int r;
9284     suppress_error = 0;
9285     r = guestfs_mount (g, device, mountpoint);
9286     if (r == -1)
9287       return -1;
9288   }
9289   /* TestOutput for command (1) */
9290   char expected[] = "Result2\n";
9291   {
9292     char remotefilename[] = "/test-command";
9293     int r;
9294     suppress_error = 0;
9295     r = guestfs_upload (g, "test-command", remotefilename);
9296     if (r == -1)
9297       return -1;
9298   }
9299   {
9300     char path[] = "/test-command";
9301     int r;
9302     suppress_error = 0;
9303     r = guestfs_chmod (g, 493, path);
9304     if (r == -1)
9305       return -1;
9306   }
9307   {
9308     char arguments_0[] = "/test-command";
9309     char arguments_1[] = "2";
9310     char *arguments[] = {
9311       arguments_0,
9312       arguments_1,
9313       NULL
9314     };
9315     char *r;
9316     suppress_error = 0;
9317     r = guestfs_command (g, arguments);
9318     if (r == NULL)
9319       return -1;
9320     if (strcmp (r, expected) != 0) {
9321       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
9322       return -1;
9323     }
9324     free (r);
9325   }
9326   return 0;
9327 }
9328
9329 static int test_command_2_skip (void)
9330 {
9331   const char *str;
9332
9333   str = getenv ("SKIP_TEST_COMMAND_2");
9334   if (str && strcmp (str, "1") == 0) return 1;
9335   str = getenv ("SKIP_TEST_COMMAND");
9336   if (str && strcmp (str, "1") == 0) return 1;
9337   return 0;
9338 }
9339
9340 static int test_command_2 (void)
9341 {
9342   if (test_command_2_skip ()) {
9343     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
9344     return 0;
9345   }
9346
9347   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9348   {
9349     char device[] = "/dev/sda";
9350     int r;
9351     suppress_error = 0;
9352     r = guestfs_blockdev_setrw (g, device);
9353     if (r == -1)
9354       return -1;
9355   }
9356   {
9357     int r;
9358     suppress_error = 0;
9359     r = guestfs_umount_all (g);
9360     if (r == -1)
9361       return -1;
9362   }
9363   {
9364     int r;
9365     suppress_error = 0;
9366     r = guestfs_lvm_remove_all (g);
9367     if (r == -1)
9368       return -1;
9369   }
9370   {
9371     char device[] = "/dev/sda";
9372     char lines_0[] = ",";
9373     char *lines[] = {
9374       lines_0,
9375       NULL
9376     };
9377     int r;
9378     suppress_error = 0;
9379     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9380     if (r == -1)
9381       return -1;
9382   }
9383   {
9384     char fstype[] = "ext2";
9385     char device[] = "/dev/sda1";
9386     int r;
9387     suppress_error = 0;
9388     r = guestfs_mkfs (g, fstype, device);
9389     if (r == -1)
9390       return -1;
9391   }
9392   {
9393     char device[] = "/dev/sda1";
9394     char mountpoint[] = "/";
9395     int r;
9396     suppress_error = 0;
9397     r = guestfs_mount (g, device, mountpoint);
9398     if (r == -1)
9399       return -1;
9400   }
9401   /* TestOutput for command (2) */
9402   char expected[] = "\nResult3";
9403   {
9404     char remotefilename[] = "/test-command";
9405     int r;
9406     suppress_error = 0;
9407     r = guestfs_upload (g, "test-command", remotefilename);
9408     if (r == -1)
9409       return -1;
9410   }
9411   {
9412     char path[] = "/test-command";
9413     int r;
9414     suppress_error = 0;
9415     r = guestfs_chmod (g, 493, path);
9416     if (r == -1)
9417       return -1;
9418   }
9419   {
9420     char arguments_0[] = "/test-command";
9421     char arguments_1[] = "3";
9422     char *arguments[] = {
9423       arguments_0,
9424       arguments_1,
9425       NULL
9426     };
9427     char *r;
9428     suppress_error = 0;
9429     r = guestfs_command (g, arguments);
9430     if (r == NULL)
9431       return -1;
9432     if (strcmp (r, expected) != 0) {
9433       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9434       return -1;
9435     }
9436     free (r);
9437   }
9438   return 0;
9439 }
9440
9441 static int test_command_3_skip (void)
9442 {
9443   const char *str;
9444
9445   str = getenv ("SKIP_TEST_COMMAND_3");
9446   if (str && strcmp (str, "1") == 0) return 1;
9447   str = getenv ("SKIP_TEST_COMMAND");
9448   if (str && strcmp (str, "1") == 0) return 1;
9449   return 0;
9450 }
9451
9452 static int test_command_3 (void)
9453 {
9454   if (test_command_3_skip ()) {
9455     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9456     return 0;
9457   }
9458
9459   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9460   {
9461     char device[] = "/dev/sda";
9462     int r;
9463     suppress_error = 0;
9464     r = guestfs_blockdev_setrw (g, device);
9465     if (r == -1)
9466       return -1;
9467   }
9468   {
9469     int r;
9470     suppress_error = 0;
9471     r = guestfs_umount_all (g);
9472     if (r == -1)
9473       return -1;
9474   }
9475   {
9476     int r;
9477     suppress_error = 0;
9478     r = guestfs_lvm_remove_all (g);
9479     if (r == -1)
9480       return -1;
9481   }
9482   {
9483     char device[] = "/dev/sda";
9484     char lines_0[] = ",";
9485     char *lines[] = {
9486       lines_0,
9487       NULL
9488     };
9489     int r;
9490     suppress_error = 0;
9491     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9492     if (r == -1)
9493       return -1;
9494   }
9495   {
9496     char fstype[] = "ext2";
9497     char device[] = "/dev/sda1";
9498     int r;
9499     suppress_error = 0;
9500     r = guestfs_mkfs (g, fstype, device);
9501     if (r == -1)
9502       return -1;
9503   }
9504   {
9505     char device[] = "/dev/sda1";
9506     char mountpoint[] = "/";
9507     int r;
9508     suppress_error = 0;
9509     r = guestfs_mount (g, device, mountpoint);
9510     if (r == -1)
9511       return -1;
9512   }
9513   /* TestOutput for command (3) */
9514   char expected[] = "\nResult4\n";
9515   {
9516     char remotefilename[] = "/test-command";
9517     int r;
9518     suppress_error = 0;
9519     r = guestfs_upload (g, "test-command", remotefilename);
9520     if (r == -1)
9521       return -1;
9522   }
9523   {
9524     char path[] = "/test-command";
9525     int r;
9526     suppress_error = 0;
9527     r = guestfs_chmod (g, 493, path);
9528     if (r == -1)
9529       return -1;
9530   }
9531   {
9532     char arguments_0[] = "/test-command";
9533     char arguments_1[] = "4";
9534     char *arguments[] = {
9535       arguments_0,
9536       arguments_1,
9537       NULL
9538     };
9539     char *r;
9540     suppress_error = 0;
9541     r = guestfs_command (g, arguments);
9542     if (r == NULL)
9543       return -1;
9544     if (strcmp (r, expected) != 0) {
9545       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9546       return -1;
9547     }
9548     free (r);
9549   }
9550   return 0;
9551 }
9552
9553 static int test_command_4_skip (void)
9554 {
9555   const char *str;
9556
9557   str = getenv ("SKIP_TEST_COMMAND_4");
9558   if (str && strcmp (str, "1") == 0) return 1;
9559   str = getenv ("SKIP_TEST_COMMAND");
9560   if (str && strcmp (str, "1") == 0) return 1;
9561   return 0;
9562 }
9563
9564 static int test_command_4 (void)
9565 {
9566   if (test_command_4_skip ()) {
9567     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9568     return 0;
9569   }
9570
9571   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9572   {
9573     char device[] = "/dev/sda";
9574     int r;
9575     suppress_error = 0;
9576     r = guestfs_blockdev_setrw (g, device);
9577     if (r == -1)
9578       return -1;
9579   }
9580   {
9581     int r;
9582     suppress_error = 0;
9583     r = guestfs_umount_all (g);
9584     if (r == -1)
9585       return -1;
9586   }
9587   {
9588     int r;
9589     suppress_error = 0;
9590     r = guestfs_lvm_remove_all (g);
9591     if (r == -1)
9592       return -1;
9593   }
9594   {
9595     char device[] = "/dev/sda";
9596     char lines_0[] = ",";
9597     char *lines[] = {
9598       lines_0,
9599       NULL
9600     };
9601     int r;
9602     suppress_error = 0;
9603     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9604     if (r == -1)
9605       return -1;
9606   }
9607   {
9608     char fstype[] = "ext2";
9609     char device[] = "/dev/sda1";
9610     int r;
9611     suppress_error = 0;
9612     r = guestfs_mkfs (g, fstype, device);
9613     if (r == -1)
9614       return -1;
9615   }
9616   {
9617     char device[] = "/dev/sda1";
9618     char mountpoint[] = "/";
9619     int r;
9620     suppress_error = 0;
9621     r = guestfs_mount (g, device, mountpoint);
9622     if (r == -1)
9623       return -1;
9624   }
9625   /* TestOutput for command (4) */
9626   char expected[] = "\nResult5\n\n";
9627   {
9628     char remotefilename[] = "/test-command";
9629     int r;
9630     suppress_error = 0;
9631     r = guestfs_upload (g, "test-command", remotefilename);
9632     if (r == -1)
9633       return -1;
9634   }
9635   {
9636     char path[] = "/test-command";
9637     int r;
9638     suppress_error = 0;
9639     r = guestfs_chmod (g, 493, path);
9640     if (r == -1)
9641       return -1;
9642   }
9643   {
9644     char arguments_0[] = "/test-command";
9645     char arguments_1[] = "5";
9646     char *arguments[] = {
9647       arguments_0,
9648       arguments_1,
9649       NULL
9650     };
9651     char *r;
9652     suppress_error = 0;
9653     r = guestfs_command (g, arguments);
9654     if (r == NULL)
9655       return -1;
9656     if (strcmp (r, expected) != 0) {
9657       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9658       return -1;
9659     }
9660     free (r);
9661   }
9662   return 0;
9663 }
9664
9665 static int test_command_5_skip (void)
9666 {
9667   const char *str;
9668
9669   str = getenv ("SKIP_TEST_COMMAND_5");
9670   if (str && strcmp (str, "1") == 0) return 1;
9671   str = getenv ("SKIP_TEST_COMMAND");
9672   if (str && strcmp (str, "1") == 0) return 1;
9673   return 0;
9674 }
9675
9676 static int test_command_5 (void)
9677 {
9678   if (test_command_5_skip ()) {
9679     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9680     return 0;
9681   }
9682
9683   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9684   {
9685     char device[] = "/dev/sda";
9686     int r;
9687     suppress_error = 0;
9688     r = guestfs_blockdev_setrw (g, device);
9689     if (r == -1)
9690       return -1;
9691   }
9692   {
9693     int r;
9694     suppress_error = 0;
9695     r = guestfs_umount_all (g);
9696     if (r == -1)
9697       return -1;
9698   }
9699   {
9700     int r;
9701     suppress_error = 0;
9702     r = guestfs_lvm_remove_all (g);
9703     if (r == -1)
9704       return -1;
9705   }
9706   {
9707     char device[] = "/dev/sda";
9708     char lines_0[] = ",";
9709     char *lines[] = {
9710       lines_0,
9711       NULL
9712     };
9713     int r;
9714     suppress_error = 0;
9715     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9716     if (r == -1)
9717       return -1;
9718   }
9719   {
9720     char fstype[] = "ext2";
9721     char device[] = "/dev/sda1";
9722     int r;
9723     suppress_error = 0;
9724     r = guestfs_mkfs (g, fstype, device);
9725     if (r == -1)
9726       return -1;
9727   }
9728   {
9729     char device[] = "/dev/sda1";
9730     char mountpoint[] = "/";
9731     int r;
9732     suppress_error = 0;
9733     r = guestfs_mount (g, device, mountpoint);
9734     if (r == -1)
9735       return -1;
9736   }
9737   /* TestOutput for command (5) */
9738   char expected[] = "\n\nResult6\n\n";
9739   {
9740     char remotefilename[] = "/test-command";
9741     int r;
9742     suppress_error = 0;
9743     r = guestfs_upload (g, "test-command", remotefilename);
9744     if (r == -1)
9745       return -1;
9746   }
9747   {
9748     char path[] = "/test-command";
9749     int r;
9750     suppress_error = 0;
9751     r = guestfs_chmod (g, 493, path);
9752     if (r == -1)
9753       return -1;
9754   }
9755   {
9756     char arguments_0[] = "/test-command";
9757     char arguments_1[] = "6";
9758     char *arguments[] = {
9759       arguments_0,
9760       arguments_1,
9761       NULL
9762     };
9763     char *r;
9764     suppress_error = 0;
9765     r = guestfs_command (g, arguments);
9766     if (r == NULL)
9767       return -1;
9768     if (strcmp (r, expected) != 0) {
9769       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9770       return -1;
9771     }
9772     free (r);
9773   }
9774   return 0;
9775 }
9776
9777 static int test_command_6_skip (void)
9778 {
9779   const char *str;
9780
9781   str = getenv ("SKIP_TEST_COMMAND_6");
9782   if (str && strcmp (str, "1") == 0) return 1;
9783   str = getenv ("SKIP_TEST_COMMAND");
9784   if (str && strcmp (str, "1") == 0) return 1;
9785   return 0;
9786 }
9787
9788 static int test_command_6 (void)
9789 {
9790   if (test_command_6_skip ()) {
9791     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9792     return 0;
9793   }
9794
9795   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9796   {
9797     char device[] = "/dev/sda";
9798     int r;
9799     suppress_error = 0;
9800     r = guestfs_blockdev_setrw (g, device);
9801     if (r == -1)
9802       return -1;
9803   }
9804   {
9805     int r;
9806     suppress_error = 0;
9807     r = guestfs_umount_all (g);
9808     if (r == -1)
9809       return -1;
9810   }
9811   {
9812     int r;
9813     suppress_error = 0;
9814     r = guestfs_lvm_remove_all (g);
9815     if (r == -1)
9816       return -1;
9817   }
9818   {
9819     char device[] = "/dev/sda";
9820     char lines_0[] = ",";
9821     char *lines[] = {
9822       lines_0,
9823       NULL
9824     };
9825     int r;
9826     suppress_error = 0;
9827     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9828     if (r == -1)
9829       return -1;
9830   }
9831   {
9832     char fstype[] = "ext2";
9833     char device[] = "/dev/sda1";
9834     int r;
9835     suppress_error = 0;
9836     r = guestfs_mkfs (g, fstype, device);
9837     if (r == -1)
9838       return -1;
9839   }
9840   {
9841     char device[] = "/dev/sda1";
9842     char mountpoint[] = "/";
9843     int r;
9844     suppress_error = 0;
9845     r = guestfs_mount (g, device, mountpoint);
9846     if (r == -1)
9847       return -1;
9848   }
9849   /* TestOutput for command (6) */
9850   char expected[] = "";
9851   {
9852     char remotefilename[] = "/test-command";
9853     int r;
9854     suppress_error = 0;
9855     r = guestfs_upload (g, "test-command", remotefilename);
9856     if (r == -1)
9857       return -1;
9858   }
9859   {
9860     char path[] = "/test-command";
9861     int r;
9862     suppress_error = 0;
9863     r = guestfs_chmod (g, 493, path);
9864     if (r == -1)
9865       return -1;
9866   }
9867   {
9868     char arguments_0[] = "/test-command";
9869     char arguments_1[] = "7";
9870     char *arguments[] = {
9871       arguments_0,
9872       arguments_1,
9873       NULL
9874     };
9875     char *r;
9876     suppress_error = 0;
9877     r = guestfs_command (g, arguments);
9878     if (r == NULL)
9879       return -1;
9880     if (strcmp (r, expected) != 0) {
9881       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9882       return -1;
9883     }
9884     free (r);
9885   }
9886   return 0;
9887 }
9888
9889 static int test_command_7_skip (void)
9890 {
9891   const char *str;
9892
9893   str = getenv ("SKIP_TEST_COMMAND_7");
9894   if (str && strcmp (str, "1") == 0) return 1;
9895   str = getenv ("SKIP_TEST_COMMAND");
9896   if (str && strcmp (str, "1") == 0) return 1;
9897   return 0;
9898 }
9899
9900 static int test_command_7 (void)
9901 {
9902   if (test_command_7_skip ()) {
9903     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9904     return 0;
9905   }
9906
9907   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9908   {
9909     char device[] = "/dev/sda";
9910     int r;
9911     suppress_error = 0;
9912     r = guestfs_blockdev_setrw (g, device);
9913     if (r == -1)
9914       return -1;
9915   }
9916   {
9917     int r;
9918     suppress_error = 0;
9919     r = guestfs_umount_all (g);
9920     if (r == -1)
9921       return -1;
9922   }
9923   {
9924     int r;
9925     suppress_error = 0;
9926     r = guestfs_lvm_remove_all (g);
9927     if (r == -1)
9928       return -1;
9929   }
9930   {
9931     char device[] = "/dev/sda";
9932     char lines_0[] = ",";
9933     char *lines[] = {
9934       lines_0,
9935       NULL
9936     };
9937     int r;
9938     suppress_error = 0;
9939     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9940     if (r == -1)
9941       return -1;
9942   }
9943   {
9944     char fstype[] = "ext2";
9945     char device[] = "/dev/sda1";
9946     int r;
9947     suppress_error = 0;
9948     r = guestfs_mkfs (g, fstype, device);
9949     if (r == -1)
9950       return -1;
9951   }
9952   {
9953     char device[] = "/dev/sda1";
9954     char mountpoint[] = "/";
9955     int r;
9956     suppress_error = 0;
9957     r = guestfs_mount (g, device, mountpoint);
9958     if (r == -1)
9959       return -1;
9960   }
9961   /* TestOutput for command (7) */
9962   char expected[] = "\n";
9963   {
9964     char remotefilename[] = "/test-command";
9965     int r;
9966     suppress_error = 0;
9967     r = guestfs_upload (g, "test-command", remotefilename);
9968     if (r == -1)
9969       return -1;
9970   }
9971   {
9972     char path[] = "/test-command";
9973     int r;
9974     suppress_error = 0;
9975     r = guestfs_chmod (g, 493, path);
9976     if (r == -1)
9977       return -1;
9978   }
9979   {
9980     char arguments_0[] = "/test-command";
9981     char arguments_1[] = "8";
9982     char *arguments[] = {
9983       arguments_0,
9984       arguments_1,
9985       NULL
9986     };
9987     char *r;
9988     suppress_error = 0;
9989     r = guestfs_command (g, arguments);
9990     if (r == NULL)
9991       return -1;
9992     if (strcmp (r, expected) != 0) {
9993       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9994       return -1;
9995     }
9996     free (r);
9997   }
9998   return 0;
9999 }
10000
10001 static int test_command_8_skip (void)
10002 {
10003   const char *str;
10004
10005   str = getenv ("SKIP_TEST_COMMAND_8");
10006   if (str && strcmp (str, "1") == 0) return 1;
10007   str = getenv ("SKIP_TEST_COMMAND");
10008   if (str && strcmp (str, "1") == 0) return 1;
10009   return 0;
10010 }
10011
10012 static int test_command_8 (void)
10013 {
10014   if (test_command_8_skip ()) {
10015     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
10016     return 0;
10017   }
10018
10019   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
10020   {
10021     char device[] = "/dev/sda";
10022     int r;
10023     suppress_error = 0;
10024     r = guestfs_blockdev_setrw (g, device);
10025     if (r == -1)
10026       return -1;
10027   }
10028   {
10029     int r;
10030     suppress_error = 0;
10031     r = guestfs_umount_all (g);
10032     if (r == -1)
10033       return -1;
10034   }
10035   {
10036     int r;
10037     suppress_error = 0;
10038     r = guestfs_lvm_remove_all (g);
10039     if (r == -1)
10040       return -1;
10041   }
10042   {
10043     char device[] = "/dev/sda";
10044     char lines_0[] = ",";
10045     char *lines[] = {
10046       lines_0,
10047       NULL
10048     };
10049     int r;
10050     suppress_error = 0;
10051     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10052     if (r == -1)
10053       return -1;
10054   }
10055   {
10056     char fstype[] = "ext2";
10057     char device[] = "/dev/sda1";
10058     int r;
10059     suppress_error = 0;
10060     r = guestfs_mkfs (g, fstype, device);
10061     if (r == -1)
10062       return -1;
10063   }
10064   {
10065     char device[] = "/dev/sda1";
10066     char mountpoint[] = "/";
10067     int r;
10068     suppress_error = 0;
10069     r = guestfs_mount (g, device, mountpoint);
10070     if (r == -1)
10071       return -1;
10072   }
10073   /* TestOutput for command (8) */
10074   char expected[] = "\n\n";
10075   {
10076     char remotefilename[] = "/test-command";
10077     int r;
10078     suppress_error = 0;
10079     r = guestfs_upload (g, "test-command", remotefilename);
10080     if (r == -1)
10081       return -1;
10082   }
10083   {
10084     char path[] = "/test-command";
10085     int r;
10086     suppress_error = 0;
10087     r = guestfs_chmod (g, 493, path);
10088     if (r == -1)
10089       return -1;
10090   }
10091   {
10092     char arguments_0[] = "/test-command";
10093     char arguments_1[] = "9";
10094     char *arguments[] = {
10095       arguments_0,
10096       arguments_1,
10097       NULL
10098     };
10099     char *r;
10100     suppress_error = 0;
10101     r = guestfs_command (g, arguments);
10102     if (r == NULL)
10103       return -1;
10104     if (strcmp (r, expected) != 0) {
10105       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
10106       return -1;
10107     }
10108     free (r);
10109   }
10110   return 0;
10111 }
10112
10113 static int test_command_9_skip (void)
10114 {
10115   const char *str;
10116
10117   str = getenv ("SKIP_TEST_COMMAND_9");
10118   if (str && strcmp (str, "1") == 0) return 1;
10119   str = getenv ("SKIP_TEST_COMMAND");
10120   if (str && strcmp (str, "1") == 0) return 1;
10121   return 0;
10122 }
10123
10124 static int test_command_9 (void)
10125 {
10126   if (test_command_9_skip ()) {
10127     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
10128     return 0;
10129   }
10130
10131   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
10132   {
10133     char device[] = "/dev/sda";
10134     int r;
10135     suppress_error = 0;
10136     r = guestfs_blockdev_setrw (g, device);
10137     if (r == -1)
10138       return -1;
10139   }
10140   {
10141     int r;
10142     suppress_error = 0;
10143     r = guestfs_umount_all (g);
10144     if (r == -1)
10145       return -1;
10146   }
10147   {
10148     int r;
10149     suppress_error = 0;
10150     r = guestfs_lvm_remove_all (g);
10151     if (r == -1)
10152       return -1;
10153   }
10154   {
10155     char device[] = "/dev/sda";
10156     char lines_0[] = ",";
10157     char *lines[] = {
10158       lines_0,
10159       NULL
10160     };
10161     int r;
10162     suppress_error = 0;
10163     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10164     if (r == -1)
10165       return -1;
10166   }
10167   {
10168     char fstype[] = "ext2";
10169     char device[] = "/dev/sda1";
10170     int r;
10171     suppress_error = 0;
10172     r = guestfs_mkfs (g, fstype, device);
10173     if (r == -1)
10174       return -1;
10175   }
10176   {
10177     char device[] = "/dev/sda1";
10178     char mountpoint[] = "/";
10179     int r;
10180     suppress_error = 0;
10181     r = guestfs_mount (g, device, mountpoint);
10182     if (r == -1)
10183       return -1;
10184   }
10185   /* TestOutput for command (9) */
10186   char expected[] = "Result10-1\nResult10-2\n";
10187   {
10188     char remotefilename[] = "/test-command";
10189     int r;
10190     suppress_error = 0;
10191     r = guestfs_upload (g, "test-command", remotefilename);
10192     if (r == -1)
10193       return -1;
10194   }
10195   {
10196     char path[] = "/test-command";
10197     int r;
10198     suppress_error = 0;
10199     r = guestfs_chmod (g, 493, path);
10200     if (r == -1)
10201       return -1;
10202   }
10203   {
10204     char arguments_0[] = "/test-command";
10205     char arguments_1[] = "10";
10206     char *arguments[] = {
10207       arguments_0,
10208       arguments_1,
10209       NULL
10210     };
10211     char *r;
10212     suppress_error = 0;
10213     r = guestfs_command (g, arguments);
10214     if (r == NULL)
10215       return -1;
10216     if (strcmp (r, expected) != 0) {
10217       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
10218       return -1;
10219     }
10220     free (r);
10221   }
10222   return 0;
10223 }
10224
10225 static int test_command_10_skip (void)
10226 {
10227   const char *str;
10228
10229   str = getenv ("SKIP_TEST_COMMAND_10");
10230   if (str && strcmp (str, "1") == 0) return 1;
10231   str = getenv ("SKIP_TEST_COMMAND");
10232   if (str && strcmp (str, "1") == 0) return 1;
10233   return 0;
10234 }
10235
10236 static int test_command_10 (void)
10237 {
10238   if (test_command_10_skip ()) {
10239     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
10240     return 0;
10241   }
10242
10243   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
10244   {
10245     char device[] = "/dev/sda";
10246     int r;
10247     suppress_error = 0;
10248     r = guestfs_blockdev_setrw (g, device);
10249     if (r == -1)
10250       return -1;
10251   }
10252   {
10253     int r;
10254     suppress_error = 0;
10255     r = guestfs_umount_all (g);
10256     if (r == -1)
10257       return -1;
10258   }
10259   {
10260     int r;
10261     suppress_error = 0;
10262     r = guestfs_lvm_remove_all (g);
10263     if (r == -1)
10264       return -1;
10265   }
10266   {
10267     char device[] = "/dev/sda";
10268     char lines_0[] = ",";
10269     char *lines[] = {
10270       lines_0,
10271       NULL
10272     };
10273     int r;
10274     suppress_error = 0;
10275     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10276     if (r == -1)
10277       return -1;
10278   }
10279   {
10280     char fstype[] = "ext2";
10281     char device[] = "/dev/sda1";
10282     int r;
10283     suppress_error = 0;
10284     r = guestfs_mkfs (g, fstype, device);
10285     if (r == -1)
10286       return -1;
10287   }
10288   {
10289     char device[] = "/dev/sda1";
10290     char mountpoint[] = "/";
10291     int r;
10292     suppress_error = 0;
10293     r = guestfs_mount (g, device, mountpoint);
10294     if (r == -1)
10295       return -1;
10296   }
10297   /* TestOutput for command (10) */
10298   char expected[] = "Result11-1\nResult11-2";
10299   {
10300     char remotefilename[] = "/test-command";
10301     int r;
10302     suppress_error = 0;
10303     r = guestfs_upload (g, "test-command", remotefilename);
10304     if (r == -1)
10305       return -1;
10306   }
10307   {
10308     char path[] = "/test-command";
10309     int r;
10310     suppress_error = 0;
10311     r = guestfs_chmod (g, 493, path);
10312     if (r == -1)
10313       return -1;
10314   }
10315   {
10316     char arguments_0[] = "/test-command";
10317     char arguments_1[] = "11";
10318     char *arguments[] = {
10319       arguments_0,
10320       arguments_1,
10321       NULL
10322     };
10323     char *r;
10324     suppress_error = 0;
10325     r = guestfs_command (g, arguments);
10326     if (r == NULL)
10327       return -1;
10328     if (strcmp (r, expected) != 0) {
10329       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
10330       return -1;
10331     }
10332     free (r);
10333   }
10334   return 0;
10335 }
10336
10337 static int test_command_11_skip (void)
10338 {
10339   const char *str;
10340
10341   str = getenv ("SKIP_TEST_COMMAND_11");
10342   if (str && strcmp (str, "1") == 0) return 1;
10343   str = getenv ("SKIP_TEST_COMMAND");
10344   if (str && strcmp (str, "1") == 0) return 1;
10345   return 0;
10346 }
10347
10348 static int test_command_11 (void)
10349 {
10350   if (test_command_11_skip ()) {
10351     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
10352     return 0;
10353   }
10354
10355   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10356   {
10357     char device[] = "/dev/sda";
10358     int r;
10359     suppress_error = 0;
10360     r = guestfs_blockdev_setrw (g, device);
10361     if (r == -1)
10362       return -1;
10363   }
10364   {
10365     int r;
10366     suppress_error = 0;
10367     r = guestfs_umount_all (g);
10368     if (r == -1)
10369       return -1;
10370   }
10371   {
10372     int r;
10373     suppress_error = 0;
10374     r = guestfs_lvm_remove_all (g);
10375     if (r == -1)
10376       return -1;
10377   }
10378   {
10379     char device[] = "/dev/sda";
10380     char lines_0[] = ",";
10381     char *lines[] = {
10382       lines_0,
10383       NULL
10384     };
10385     int r;
10386     suppress_error = 0;
10387     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10388     if (r == -1)
10389       return -1;
10390   }
10391   {
10392     char fstype[] = "ext2";
10393     char device[] = "/dev/sda1";
10394     int r;
10395     suppress_error = 0;
10396     r = guestfs_mkfs (g, fstype, device);
10397     if (r == -1)
10398       return -1;
10399   }
10400   {
10401     char device[] = "/dev/sda1";
10402     char mountpoint[] = "/";
10403     int r;
10404     suppress_error = 0;
10405     r = guestfs_mount (g, device, mountpoint);
10406     if (r == -1)
10407       return -1;
10408   }
10409   /* TestLastFail for command (11) */
10410   {
10411     char remotefilename[] = "/test-command";
10412     int r;
10413     suppress_error = 0;
10414     r = guestfs_upload (g, "test-command", remotefilename);
10415     if (r == -1)
10416       return -1;
10417   }
10418   {
10419     char path[] = "/test-command";
10420     int r;
10421     suppress_error = 0;
10422     r = guestfs_chmod (g, 493, path);
10423     if (r == -1)
10424       return -1;
10425   }
10426   {
10427     char arguments_0[] = "/test-command";
10428     char *arguments[] = {
10429       arguments_0,
10430       NULL
10431     };
10432     char *r;
10433     suppress_error = 1;
10434     r = guestfs_command (g, arguments);
10435     if (r != NULL)
10436       return -1;
10437     free (r);
10438   }
10439   return 0;
10440 }
10441
10442 static int test_file_0_skip (void)
10443 {
10444   const char *str;
10445
10446   str = getenv ("SKIP_TEST_FILE_0");
10447   if (str && strcmp (str, "1") == 0) return 1;
10448   str = getenv ("SKIP_TEST_FILE");
10449   if (str && strcmp (str, "1") == 0) return 1;
10450   return 0;
10451 }
10452
10453 static int test_file_0 (void)
10454 {
10455   if (test_file_0_skip ()) {
10456     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10457     return 0;
10458   }
10459
10460   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10461   {
10462     char device[] = "/dev/sda";
10463     int r;
10464     suppress_error = 0;
10465     r = guestfs_blockdev_setrw (g, device);
10466     if (r == -1)
10467       return -1;
10468   }
10469   {
10470     int r;
10471     suppress_error = 0;
10472     r = guestfs_umount_all (g);
10473     if (r == -1)
10474       return -1;
10475   }
10476   {
10477     int r;
10478     suppress_error = 0;
10479     r = guestfs_lvm_remove_all (g);
10480     if (r == -1)
10481       return -1;
10482   }
10483   {
10484     char device[] = "/dev/sda";
10485     char lines_0[] = ",";
10486     char *lines[] = {
10487       lines_0,
10488       NULL
10489     };
10490     int r;
10491     suppress_error = 0;
10492     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10493     if (r == -1)
10494       return -1;
10495   }
10496   {
10497     char fstype[] = "ext2";
10498     char device[] = "/dev/sda1";
10499     int r;
10500     suppress_error = 0;
10501     r = guestfs_mkfs (g, fstype, device);
10502     if (r == -1)
10503       return -1;
10504   }
10505   {
10506     char device[] = "/dev/sda1";
10507     char mountpoint[] = "/";
10508     int r;
10509     suppress_error = 0;
10510     r = guestfs_mount (g, device, mountpoint);
10511     if (r == -1)
10512       return -1;
10513   }
10514   /* TestOutput for file (0) */
10515   char expected[] = "empty";
10516   {
10517     char path[] = "/new";
10518     int r;
10519     suppress_error = 0;
10520     r = guestfs_touch (g, path);
10521     if (r == -1)
10522       return -1;
10523   }
10524   {
10525     char path[] = "/new";
10526     char *r;
10527     suppress_error = 0;
10528     r = guestfs_file (g, path);
10529     if (r == NULL)
10530       return -1;
10531     if (strcmp (r, expected) != 0) {
10532       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10533       return -1;
10534     }
10535     free (r);
10536   }
10537   return 0;
10538 }
10539
10540 static int test_file_1_skip (void)
10541 {
10542   const char *str;
10543
10544   str = getenv ("SKIP_TEST_FILE_1");
10545   if (str && strcmp (str, "1") == 0) return 1;
10546   str = getenv ("SKIP_TEST_FILE");
10547   if (str && strcmp (str, "1") == 0) return 1;
10548   return 0;
10549 }
10550
10551 static int test_file_1 (void)
10552 {
10553   if (test_file_1_skip ()) {
10554     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10555     return 0;
10556   }
10557
10558   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10559   {
10560     char device[] = "/dev/sda";
10561     int r;
10562     suppress_error = 0;
10563     r = guestfs_blockdev_setrw (g, device);
10564     if (r == -1)
10565       return -1;
10566   }
10567   {
10568     int r;
10569     suppress_error = 0;
10570     r = guestfs_umount_all (g);
10571     if (r == -1)
10572       return -1;
10573   }
10574   {
10575     int r;
10576     suppress_error = 0;
10577     r = guestfs_lvm_remove_all (g);
10578     if (r == -1)
10579       return -1;
10580   }
10581   {
10582     char device[] = "/dev/sda";
10583     char lines_0[] = ",";
10584     char *lines[] = {
10585       lines_0,
10586       NULL
10587     };
10588     int r;
10589     suppress_error = 0;
10590     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10591     if (r == -1)
10592       return -1;
10593   }
10594   {
10595     char fstype[] = "ext2";
10596     char device[] = "/dev/sda1";
10597     int r;
10598     suppress_error = 0;
10599     r = guestfs_mkfs (g, fstype, device);
10600     if (r == -1)
10601       return -1;
10602   }
10603   {
10604     char device[] = "/dev/sda1";
10605     char mountpoint[] = "/";
10606     int r;
10607     suppress_error = 0;
10608     r = guestfs_mount (g, device, mountpoint);
10609     if (r == -1)
10610       return -1;
10611   }
10612   /* TestOutput for file (1) */
10613   char expected[] = "ASCII text";
10614   {
10615     char path[] = "/new";
10616     char content[] = "some content\n";
10617     int r;
10618     suppress_error = 0;
10619     r = guestfs_write_file (g, path, content, 0);
10620     if (r == -1)
10621       return -1;
10622   }
10623   {
10624     char path[] = "/new";
10625     char *r;
10626     suppress_error = 0;
10627     r = guestfs_file (g, path);
10628     if (r == NULL)
10629       return -1;
10630     if (strcmp (r, expected) != 0) {
10631       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10632       return -1;
10633     }
10634     free (r);
10635   }
10636   return 0;
10637 }
10638
10639 static int test_file_2_skip (void)
10640 {
10641   const char *str;
10642
10643   str = getenv ("SKIP_TEST_FILE_2");
10644   if (str && strcmp (str, "1") == 0) return 1;
10645   str = getenv ("SKIP_TEST_FILE");
10646   if (str && strcmp (str, "1") == 0) return 1;
10647   return 0;
10648 }
10649
10650 static int test_file_2 (void)
10651 {
10652   if (test_file_2_skip ()) {
10653     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10654     return 0;
10655   }
10656
10657   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10658   {
10659     char device[] = "/dev/sda";
10660     int r;
10661     suppress_error = 0;
10662     r = guestfs_blockdev_setrw (g, device);
10663     if (r == -1)
10664       return -1;
10665   }
10666   {
10667     int r;
10668     suppress_error = 0;
10669     r = guestfs_umount_all (g);
10670     if (r == -1)
10671       return -1;
10672   }
10673   {
10674     int r;
10675     suppress_error = 0;
10676     r = guestfs_lvm_remove_all (g);
10677     if (r == -1)
10678       return -1;
10679   }
10680   {
10681     char device[] = "/dev/sda";
10682     char lines_0[] = ",";
10683     char *lines[] = {
10684       lines_0,
10685       NULL
10686     };
10687     int r;
10688     suppress_error = 0;
10689     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10690     if (r == -1)
10691       return -1;
10692   }
10693   {
10694     char fstype[] = "ext2";
10695     char device[] = "/dev/sda1";
10696     int r;
10697     suppress_error = 0;
10698     r = guestfs_mkfs (g, fstype, device);
10699     if (r == -1)
10700       return -1;
10701   }
10702   {
10703     char device[] = "/dev/sda1";
10704     char mountpoint[] = "/";
10705     int r;
10706     suppress_error = 0;
10707     r = guestfs_mount (g, device, mountpoint);
10708     if (r == -1)
10709       return -1;
10710   }
10711   /* TestLastFail for file (2) */
10712   {
10713     char path[] = "/nofile";
10714     char *r;
10715     suppress_error = 1;
10716     r = guestfs_file (g, path);
10717     if (r != NULL)
10718       return -1;
10719     free (r);
10720   }
10721   return 0;
10722 }
10723
10724 static int test_umount_all_0_skip (void)
10725 {
10726   const char *str;
10727
10728   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10729   if (str && strcmp (str, "1") == 0) return 1;
10730   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10731   if (str && strcmp (str, "1") == 0) return 1;
10732   return 0;
10733 }
10734
10735 static int test_umount_all_0 (void)
10736 {
10737   if (test_umount_all_0_skip ()) {
10738     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10739     return 0;
10740   }
10741
10742   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10743   {
10744     char device[] = "/dev/sda";
10745     int r;
10746     suppress_error = 0;
10747     r = guestfs_blockdev_setrw (g, device);
10748     if (r == -1)
10749       return -1;
10750   }
10751   {
10752     int r;
10753     suppress_error = 0;
10754     r = guestfs_umount_all (g);
10755     if (r == -1)
10756       return -1;
10757   }
10758   {
10759     int r;
10760     suppress_error = 0;
10761     r = guestfs_lvm_remove_all (g);
10762     if (r == -1)
10763       return -1;
10764   }
10765   {
10766     char device[] = "/dev/sda";
10767     char lines_0[] = ",";
10768     char *lines[] = {
10769       lines_0,
10770       NULL
10771     };
10772     int r;
10773     suppress_error = 0;
10774     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10775     if (r == -1)
10776       return -1;
10777   }
10778   {
10779     char fstype[] = "ext2";
10780     char device[] = "/dev/sda1";
10781     int r;
10782     suppress_error = 0;
10783     r = guestfs_mkfs (g, fstype, device);
10784     if (r == -1)
10785       return -1;
10786   }
10787   {
10788     char device[] = "/dev/sda1";
10789     char mountpoint[] = "/";
10790     int r;
10791     suppress_error = 0;
10792     r = guestfs_mount (g, device, mountpoint);
10793     if (r == -1)
10794       return -1;
10795   }
10796   /* TestOutputList for umount_all (0) */
10797   {
10798     int r;
10799     suppress_error = 0;
10800     r = guestfs_umount_all (g);
10801     if (r == -1)
10802       return -1;
10803   }
10804   {
10805     char **r;
10806     int i;
10807     suppress_error = 0;
10808     r = guestfs_mounts (g);
10809     if (r == NULL)
10810       return -1;
10811     if (r[0] != NULL) {
10812       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10813       print_strings (r);
10814       return -1;
10815     }
10816     for (i = 0; r[i] != NULL; ++i)
10817       free (r[i]);
10818     free (r);
10819   }
10820   return 0;
10821 }
10822
10823 static int test_umount_all_1_skip (void)
10824 {
10825   const char *str;
10826
10827   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10828   if (str && strcmp (str, "1") == 0) return 1;
10829   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10830   if (str && strcmp (str, "1") == 0) return 1;
10831   return 0;
10832 }
10833
10834 static int test_umount_all_1 (void)
10835 {
10836   if (test_umount_all_1_skip ()) {
10837     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10838     return 0;
10839   }
10840
10841   /* InitNone|InitEmpty for test_umount_all_1 */
10842   {
10843     char device[] = "/dev/sda";
10844     int r;
10845     suppress_error = 0;
10846     r = guestfs_blockdev_setrw (g, device);
10847     if (r == -1)
10848       return -1;
10849   }
10850   {
10851     int r;
10852     suppress_error = 0;
10853     r = guestfs_umount_all (g);
10854     if (r == -1)
10855       return -1;
10856   }
10857   {
10858     int r;
10859     suppress_error = 0;
10860     r = guestfs_lvm_remove_all (g);
10861     if (r == -1)
10862       return -1;
10863   }
10864   /* TestOutputList for umount_all (1) */
10865   {
10866     char device[] = "/dev/sda";
10867     char lines_0[] = ",10";
10868     char lines_1[] = ",20";
10869     char lines_2[] = ",";
10870     char *lines[] = {
10871       lines_0,
10872       lines_1,
10873       lines_2,
10874       NULL
10875     };
10876     int r;
10877     suppress_error = 0;
10878     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10879     if (r == -1)
10880       return -1;
10881   }
10882   {
10883     char fstype[] = "ext2";
10884     char device[] = "/dev/sda1";
10885     int r;
10886     suppress_error = 0;
10887     r = guestfs_mkfs (g, fstype, device);
10888     if (r == -1)
10889       return -1;
10890   }
10891   {
10892     char fstype[] = "ext2";
10893     char device[] = "/dev/sda2";
10894     int r;
10895     suppress_error = 0;
10896     r = guestfs_mkfs (g, fstype, device);
10897     if (r == -1)
10898       return -1;
10899   }
10900   {
10901     char fstype[] = "ext2";
10902     char device[] = "/dev/sda3";
10903     int r;
10904     suppress_error = 0;
10905     r = guestfs_mkfs (g, fstype, device);
10906     if (r == -1)
10907       return -1;
10908   }
10909   {
10910     char device[] = "/dev/sda1";
10911     char mountpoint[] = "/";
10912     int r;
10913     suppress_error = 0;
10914     r = guestfs_mount (g, device, mountpoint);
10915     if (r == -1)
10916       return -1;
10917   }
10918   {
10919     char path[] = "/mp1";
10920     int r;
10921     suppress_error = 0;
10922     r = guestfs_mkdir (g, path);
10923     if (r == -1)
10924       return -1;
10925   }
10926   {
10927     char device[] = "/dev/sda2";
10928     char mountpoint[] = "/mp1";
10929     int r;
10930     suppress_error = 0;
10931     r = guestfs_mount (g, device, mountpoint);
10932     if (r == -1)
10933       return -1;
10934   }
10935   {
10936     char path[] = "/mp1/mp2";
10937     int r;
10938     suppress_error = 0;
10939     r = guestfs_mkdir (g, path);
10940     if (r == -1)
10941       return -1;
10942   }
10943   {
10944     char device[] = "/dev/sda3";
10945     char mountpoint[] = "/mp1/mp2";
10946     int r;
10947     suppress_error = 0;
10948     r = guestfs_mount (g, device, mountpoint);
10949     if (r == -1)
10950       return -1;
10951   }
10952   {
10953     char path[] = "/mp1/mp2/mp3";
10954     int r;
10955     suppress_error = 0;
10956     r = guestfs_mkdir (g, path);
10957     if (r == -1)
10958       return -1;
10959   }
10960   {
10961     int r;
10962     suppress_error = 0;
10963     r = guestfs_umount_all (g);
10964     if (r == -1)
10965       return -1;
10966   }
10967   {
10968     char **r;
10969     int i;
10970     suppress_error = 0;
10971     r = guestfs_mounts (g);
10972     if (r == NULL)
10973       return -1;
10974     if (r[0] != NULL) {
10975       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10976       print_strings (r);
10977       return -1;
10978     }
10979     for (i = 0; r[i] != NULL; ++i)
10980       free (r[i]);
10981     free (r);
10982   }
10983   return 0;
10984 }
10985
10986 static int test_mounts_0_skip (void)
10987 {
10988   const char *str;
10989
10990   str = getenv ("SKIP_TEST_MOUNTS_0");
10991   if (str && strcmp (str, "1") == 0) return 1;
10992   str = getenv ("SKIP_TEST_MOUNTS");
10993   if (str && strcmp (str, "1") == 0) return 1;
10994   return 0;
10995 }
10996
10997 static int test_mounts_0 (void)
10998 {
10999   if (test_mounts_0_skip ()) {
11000     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
11001     return 0;
11002   }
11003
11004   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
11005   {
11006     char device[] = "/dev/sda";
11007     int r;
11008     suppress_error = 0;
11009     r = guestfs_blockdev_setrw (g, device);
11010     if (r == -1)
11011       return -1;
11012   }
11013   {
11014     int r;
11015     suppress_error = 0;
11016     r = guestfs_umount_all (g);
11017     if (r == -1)
11018       return -1;
11019   }
11020   {
11021     int r;
11022     suppress_error = 0;
11023     r = guestfs_lvm_remove_all (g);
11024     if (r == -1)
11025       return -1;
11026   }
11027   {
11028     char device[] = "/dev/sda";
11029     char lines_0[] = ",";
11030     char *lines[] = {
11031       lines_0,
11032       NULL
11033     };
11034     int r;
11035     suppress_error = 0;
11036     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11037     if (r == -1)
11038       return -1;
11039   }
11040   {
11041     char fstype[] = "ext2";
11042     char device[] = "/dev/sda1";
11043     int r;
11044     suppress_error = 0;
11045     r = guestfs_mkfs (g, fstype, device);
11046     if (r == -1)
11047       return -1;
11048   }
11049   {
11050     char device[] = "/dev/sda1";
11051     char mountpoint[] = "/";
11052     int r;
11053     suppress_error = 0;
11054     r = guestfs_mount (g, device, mountpoint);
11055     if (r == -1)
11056       return -1;
11057   }
11058   /* TestOutputListOfDevices for mounts (0) */
11059   {
11060     char **r;
11061     int i;
11062     suppress_error = 0;
11063     r = guestfs_mounts (g);
11064     if (r == NULL)
11065       return -1;
11066     if (!r[0]) {
11067       fprintf (stderr, "test_mounts_0: short list returned from command\n");
11068       print_strings (r);
11069       return -1;
11070     }
11071     {
11072       char expected[] = "/dev/sda1";
11073       r[0][5] = 's';
11074       if (strcmp (r[0], expected) != 0) {
11075         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11076         return -1;
11077       }
11078     }
11079     if (r[1] != NULL) {
11080       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
11081       print_strings (r);
11082       return -1;
11083     }
11084     for (i = 0; r[i] != NULL; ++i)
11085       free (r[i]);
11086     free (r);
11087   }
11088   return 0;
11089 }
11090
11091 static int test_umount_0_skip (void)
11092 {
11093   const char *str;
11094
11095   str = getenv ("SKIP_TEST_UMOUNT_0");
11096   if (str && strcmp (str, "1") == 0) return 1;
11097   str = getenv ("SKIP_TEST_UMOUNT");
11098   if (str && strcmp (str, "1") == 0) return 1;
11099   return 0;
11100 }
11101
11102 static int test_umount_0 (void)
11103 {
11104   if (test_umount_0_skip ()) {
11105     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
11106     return 0;
11107   }
11108
11109   /* InitNone|InitEmpty for test_umount_0 */
11110   {
11111     char device[] = "/dev/sda";
11112     int r;
11113     suppress_error = 0;
11114     r = guestfs_blockdev_setrw (g, device);
11115     if (r == -1)
11116       return -1;
11117   }
11118   {
11119     int r;
11120     suppress_error = 0;
11121     r = guestfs_umount_all (g);
11122     if (r == -1)
11123       return -1;
11124   }
11125   {
11126     int r;
11127     suppress_error = 0;
11128     r = guestfs_lvm_remove_all (g);
11129     if (r == -1)
11130       return -1;
11131   }
11132   /* TestOutputListOfDevices for umount (0) */
11133   {
11134     char device[] = "/dev/sda";
11135     char lines_0[] = ",";
11136     char *lines[] = {
11137       lines_0,
11138       NULL
11139     };
11140     int r;
11141     suppress_error = 0;
11142     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11143     if (r == -1)
11144       return -1;
11145   }
11146   {
11147     char fstype[] = "ext2";
11148     char device[] = "/dev/sda1";
11149     int r;
11150     suppress_error = 0;
11151     r = guestfs_mkfs (g, fstype, device);
11152     if (r == -1)
11153       return -1;
11154   }
11155   {
11156     char device[] = "/dev/sda1";
11157     char mountpoint[] = "/";
11158     int r;
11159     suppress_error = 0;
11160     r = guestfs_mount (g, device, mountpoint);
11161     if (r == -1)
11162       return -1;
11163   }
11164   {
11165     char **r;
11166     int i;
11167     suppress_error = 0;
11168     r = guestfs_mounts (g);
11169     if (r == NULL)
11170       return -1;
11171     if (!r[0]) {
11172       fprintf (stderr, "test_umount_0: short list returned from command\n");
11173       print_strings (r);
11174       return -1;
11175     }
11176     {
11177       char expected[] = "/dev/sda1";
11178       r[0][5] = 's';
11179       if (strcmp (r[0], expected) != 0) {
11180         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11181         return -1;
11182       }
11183     }
11184     if (r[1] != NULL) {
11185       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
11186       print_strings (r);
11187       return -1;
11188     }
11189     for (i = 0; r[i] != NULL; ++i)
11190       free (r[i]);
11191     free (r);
11192   }
11193   return 0;
11194 }
11195
11196 static int test_umount_1_skip (void)
11197 {
11198   const char *str;
11199
11200   str = getenv ("SKIP_TEST_UMOUNT_1");
11201   if (str && strcmp (str, "1") == 0) return 1;
11202   str = getenv ("SKIP_TEST_UMOUNT");
11203   if (str && strcmp (str, "1") == 0) return 1;
11204   return 0;
11205 }
11206
11207 static int test_umount_1 (void)
11208 {
11209   if (test_umount_1_skip ()) {
11210     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
11211     return 0;
11212   }
11213
11214   /* InitNone|InitEmpty for test_umount_1 */
11215   {
11216     char device[] = "/dev/sda";
11217     int r;
11218     suppress_error = 0;
11219     r = guestfs_blockdev_setrw (g, device);
11220     if (r == -1)
11221       return -1;
11222   }
11223   {
11224     int r;
11225     suppress_error = 0;
11226     r = guestfs_umount_all (g);
11227     if (r == -1)
11228       return -1;
11229   }
11230   {
11231     int r;
11232     suppress_error = 0;
11233     r = guestfs_lvm_remove_all (g);
11234     if (r == -1)
11235       return -1;
11236   }
11237   /* TestOutputList for umount (1) */
11238   {
11239     char device[] = "/dev/sda";
11240     char lines_0[] = ",";
11241     char *lines[] = {
11242       lines_0,
11243       NULL
11244     };
11245     int r;
11246     suppress_error = 0;
11247     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11248     if (r == -1)
11249       return -1;
11250   }
11251   {
11252     char fstype[] = "ext2";
11253     char device[] = "/dev/sda1";
11254     int r;
11255     suppress_error = 0;
11256     r = guestfs_mkfs (g, fstype, device);
11257     if (r == -1)
11258       return -1;
11259   }
11260   {
11261     char device[] = "/dev/sda1";
11262     char mountpoint[] = "/";
11263     int r;
11264     suppress_error = 0;
11265     r = guestfs_mount (g, device, mountpoint);
11266     if (r == -1)
11267       return -1;
11268   }
11269   {
11270     char pathordevice[] = "/";
11271     int r;
11272     suppress_error = 0;
11273     r = guestfs_umount (g, pathordevice);
11274     if (r == -1)
11275       return -1;
11276   }
11277   {
11278     char **r;
11279     int i;
11280     suppress_error = 0;
11281     r = guestfs_mounts (g);
11282     if (r == NULL)
11283       return -1;
11284     if (r[0] != NULL) {
11285       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
11286       print_strings (r);
11287       return -1;
11288     }
11289     for (i = 0; r[i] != NULL; ++i)
11290       free (r[i]);
11291     free (r);
11292   }
11293   return 0;
11294 }
11295
11296 static int test_write_file_0_skip (void)
11297 {
11298   const char *str;
11299
11300   str = getenv ("SKIP_TEST_WRITE_FILE_0");
11301   if (str && strcmp (str, "1") == 0) return 1;
11302   str = getenv ("SKIP_TEST_WRITE_FILE");
11303   if (str && strcmp (str, "1") == 0) return 1;
11304   return 0;
11305 }
11306
11307 static int test_write_file_0 (void)
11308 {
11309   if (test_write_file_0_skip ()) {
11310     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
11311     return 0;
11312   }
11313
11314   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
11315   {
11316     char device[] = "/dev/sda";
11317     int r;
11318     suppress_error = 0;
11319     r = guestfs_blockdev_setrw (g, device);
11320     if (r == -1)
11321       return -1;
11322   }
11323   {
11324     int r;
11325     suppress_error = 0;
11326     r = guestfs_umount_all (g);
11327     if (r == -1)
11328       return -1;
11329   }
11330   {
11331     int r;
11332     suppress_error = 0;
11333     r = guestfs_lvm_remove_all (g);
11334     if (r == -1)
11335       return -1;
11336   }
11337   {
11338     char device[] = "/dev/sda";
11339     char lines_0[] = ",";
11340     char *lines[] = {
11341       lines_0,
11342       NULL
11343     };
11344     int r;
11345     suppress_error = 0;
11346     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11347     if (r == -1)
11348       return -1;
11349   }
11350   {
11351     char fstype[] = "ext2";
11352     char device[] = "/dev/sda1";
11353     int r;
11354     suppress_error = 0;
11355     r = guestfs_mkfs (g, fstype, device);
11356     if (r == -1)
11357       return -1;
11358   }
11359   {
11360     char device[] = "/dev/sda1";
11361     char mountpoint[] = "/";
11362     int r;
11363     suppress_error = 0;
11364     r = guestfs_mount (g, device, mountpoint);
11365     if (r == -1)
11366       return -1;
11367   }
11368   /* TestOutput for write_file (0) */
11369   char expected[] = "new file contents";
11370   {
11371     char path[] = "/new";
11372     char content[] = "new file contents";
11373     int r;
11374     suppress_error = 0;
11375     r = guestfs_write_file (g, path, content, 0);
11376     if (r == -1)
11377       return -1;
11378   }
11379   {
11380     char path[] = "/new";
11381     char *r;
11382     suppress_error = 0;
11383     r = guestfs_cat (g, path);
11384     if (r == NULL)
11385       return -1;
11386     if (strcmp (r, expected) != 0) {
11387       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11388       return -1;
11389     }
11390     free (r);
11391   }
11392   return 0;
11393 }
11394
11395 static int test_write_file_1_skip (void)
11396 {
11397   const char *str;
11398
11399   str = getenv ("SKIP_TEST_WRITE_FILE_1");
11400   if (str && strcmp (str, "1") == 0) return 1;
11401   str = getenv ("SKIP_TEST_WRITE_FILE");
11402   if (str && strcmp (str, "1") == 0) return 1;
11403   return 0;
11404 }
11405
11406 static int test_write_file_1 (void)
11407 {
11408   if (test_write_file_1_skip ()) {
11409     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11410     return 0;
11411   }
11412
11413   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11414   {
11415     char device[] = "/dev/sda";
11416     int r;
11417     suppress_error = 0;
11418     r = guestfs_blockdev_setrw (g, device);
11419     if (r == -1)
11420       return -1;
11421   }
11422   {
11423     int r;
11424     suppress_error = 0;
11425     r = guestfs_umount_all (g);
11426     if (r == -1)
11427       return -1;
11428   }
11429   {
11430     int r;
11431     suppress_error = 0;
11432     r = guestfs_lvm_remove_all (g);
11433     if (r == -1)
11434       return -1;
11435   }
11436   {
11437     char device[] = "/dev/sda";
11438     char lines_0[] = ",";
11439     char *lines[] = {
11440       lines_0,
11441       NULL
11442     };
11443     int r;
11444     suppress_error = 0;
11445     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11446     if (r == -1)
11447       return -1;
11448   }
11449   {
11450     char fstype[] = "ext2";
11451     char device[] = "/dev/sda1";
11452     int r;
11453     suppress_error = 0;
11454     r = guestfs_mkfs (g, fstype, device);
11455     if (r == -1)
11456       return -1;
11457   }
11458   {
11459     char device[] = "/dev/sda1";
11460     char mountpoint[] = "/";
11461     int r;
11462     suppress_error = 0;
11463     r = guestfs_mount (g, device, mountpoint);
11464     if (r == -1)
11465       return -1;
11466   }
11467   /* TestOutput for write_file (1) */
11468   char expected[] = "\nnew file contents\n";
11469   {
11470     char path[] = "/new";
11471     char content[] = "\nnew file contents\n";
11472     int r;
11473     suppress_error = 0;
11474     r = guestfs_write_file (g, path, content, 0);
11475     if (r == -1)
11476       return -1;
11477   }
11478   {
11479     char path[] = "/new";
11480     char *r;
11481     suppress_error = 0;
11482     r = guestfs_cat (g, path);
11483     if (r == NULL)
11484       return -1;
11485     if (strcmp (r, expected) != 0) {
11486       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11487       return -1;
11488     }
11489     free (r);
11490   }
11491   return 0;
11492 }
11493
11494 static int test_write_file_2_skip (void)
11495 {
11496   const char *str;
11497
11498   str = getenv ("SKIP_TEST_WRITE_FILE_2");
11499   if (str && strcmp (str, "1") == 0) return 1;
11500   str = getenv ("SKIP_TEST_WRITE_FILE");
11501   if (str && strcmp (str, "1") == 0) return 1;
11502   return 0;
11503 }
11504
11505 static int test_write_file_2 (void)
11506 {
11507   if (test_write_file_2_skip ()) {
11508     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11509     return 0;
11510   }
11511
11512   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11513   {
11514     char device[] = "/dev/sda";
11515     int r;
11516     suppress_error = 0;
11517     r = guestfs_blockdev_setrw (g, device);
11518     if (r == -1)
11519       return -1;
11520   }
11521   {
11522     int r;
11523     suppress_error = 0;
11524     r = guestfs_umount_all (g);
11525     if (r == -1)
11526       return -1;
11527   }
11528   {
11529     int r;
11530     suppress_error = 0;
11531     r = guestfs_lvm_remove_all (g);
11532     if (r == -1)
11533       return -1;
11534   }
11535   {
11536     char device[] = "/dev/sda";
11537     char lines_0[] = ",";
11538     char *lines[] = {
11539       lines_0,
11540       NULL
11541     };
11542     int r;
11543     suppress_error = 0;
11544     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11545     if (r == -1)
11546       return -1;
11547   }
11548   {
11549     char fstype[] = "ext2";
11550     char device[] = "/dev/sda1";
11551     int r;
11552     suppress_error = 0;
11553     r = guestfs_mkfs (g, fstype, device);
11554     if (r == -1)
11555       return -1;
11556   }
11557   {
11558     char device[] = "/dev/sda1";
11559     char mountpoint[] = "/";
11560     int r;
11561     suppress_error = 0;
11562     r = guestfs_mount (g, device, mountpoint);
11563     if (r == -1)
11564       return -1;
11565   }
11566   /* TestOutput for write_file (2) */
11567   char expected[] = "\n\n";
11568   {
11569     char path[] = "/new";
11570     char content[] = "\n\n";
11571     int r;
11572     suppress_error = 0;
11573     r = guestfs_write_file (g, path, content, 0);
11574     if (r == -1)
11575       return -1;
11576   }
11577   {
11578     char path[] = "/new";
11579     char *r;
11580     suppress_error = 0;
11581     r = guestfs_cat (g, path);
11582     if (r == NULL)
11583       return -1;
11584     if (strcmp (r, expected) != 0) {
11585       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11586       return -1;
11587     }
11588     free (r);
11589   }
11590   return 0;
11591 }
11592
11593 static int test_write_file_3_skip (void)
11594 {
11595   const char *str;
11596
11597   str = getenv ("SKIP_TEST_WRITE_FILE_3");
11598   if (str && strcmp (str, "1") == 0) return 1;
11599   str = getenv ("SKIP_TEST_WRITE_FILE");
11600   if (str && strcmp (str, "1") == 0) return 1;
11601   return 0;
11602 }
11603
11604 static int test_write_file_3 (void)
11605 {
11606   if (test_write_file_3_skip ()) {
11607     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11608     return 0;
11609   }
11610
11611   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11612   {
11613     char device[] = "/dev/sda";
11614     int r;
11615     suppress_error = 0;
11616     r = guestfs_blockdev_setrw (g, device);
11617     if (r == -1)
11618       return -1;
11619   }
11620   {
11621     int r;
11622     suppress_error = 0;
11623     r = guestfs_umount_all (g);
11624     if (r == -1)
11625       return -1;
11626   }
11627   {
11628     int r;
11629     suppress_error = 0;
11630     r = guestfs_lvm_remove_all (g);
11631     if (r == -1)
11632       return -1;
11633   }
11634   {
11635     char device[] = "/dev/sda";
11636     char lines_0[] = ",";
11637     char *lines[] = {
11638       lines_0,
11639       NULL
11640     };
11641     int r;
11642     suppress_error = 0;
11643     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11644     if (r == -1)
11645       return -1;
11646   }
11647   {
11648     char fstype[] = "ext2";
11649     char device[] = "/dev/sda1";
11650     int r;
11651     suppress_error = 0;
11652     r = guestfs_mkfs (g, fstype, device);
11653     if (r == -1)
11654       return -1;
11655   }
11656   {
11657     char device[] = "/dev/sda1";
11658     char mountpoint[] = "/";
11659     int r;
11660     suppress_error = 0;
11661     r = guestfs_mount (g, device, mountpoint);
11662     if (r == -1)
11663       return -1;
11664   }
11665   /* TestOutput for write_file (3) */
11666   char expected[] = "";
11667   {
11668     char path[] = "/new";
11669     char content[] = "";
11670     int r;
11671     suppress_error = 0;
11672     r = guestfs_write_file (g, path, content, 0);
11673     if (r == -1)
11674       return -1;
11675   }
11676   {
11677     char path[] = "/new";
11678     char *r;
11679     suppress_error = 0;
11680     r = guestfs_cat (g, path);
11681     if (r == NULL)
11682       return -1;
11683     if (strcmp (r, expected) != 0) {
11684       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11685       return -1;
11686     }
11687     free (r);
11688   }
11689   return 0;
11690 }
11691
11692 static int test_write_file_4_skip (void)
11693 {
11694   const char *str;
11695
11696   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11697   if (str && strcmp (str, "1") == 0) return 1;
11698   str = getenv ("SKIP_TEST_WRITE_FILE");
11699   if (str && strcmp (str, "1") == 0) return 1;
11700   return 0;
11701 }
11702
11703 static int test_write_file_4 (void)
11704 {
11705   if (test_write_file_4_skip ()) {
11706     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11707     return 0;
11708   }
11709
11710   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11711   {
11712     char device[] = "/dev/sda";
11713     int r;
11714     suppress_error = 0;
11715     r = guestfs_blockdev_setrw (g, device);
11716     if (r == -1)
11717       return -1;
11718   }
11719   {
11720     int r;
11721     suppress_error = 0;
11722     r = guestfs_umount_all (g);
11723     if (r == -1)
11724       return -1;
11725   }
11726   {
11727     int r;
11728     suppress_error = 0;
11729     r = guestfs_lvm_remove_all (g);
11730     if (r == -1)
11731       return -1;
11732   }
11733   {
11734     char device[] = "/dev/sda";
11735     char lines_0[] = ",";
11736     char *lines[] = {
11737       lines_0,
11738       NULL
11739     };
11740     int r;
11741     suppress_error = 0;
11742     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11743     if (r == -1)
11744       return -1;
11745   }
11746   {
11747     char fstype[] = "ext2";
11748     char device[] = "/dev/sda1";
11749     int r;
11750     suppress_error = 0;
11751     r = guestfs_mkfs (g, fstype, device);
11752     if (r == -1)
11753       return -1;
11754   }
11755   {
11756     char device[] = "/dev/sda1";
11757     char mountpoint[] = "/";
11758     int r;
11759     suppress_error = 0;
11760     r = guestfs_mount (g, device, mountpoint);
11761     if (r == -1)
11762       return -1;
11763   }
11764   /* TestOutput for write_file (4) */
11765   char expected[] = "\n\n\n";
11766   {
11767     char path[] = "/new";
11768     char content[] = "\n\n\n";
11769     int r;
11770     suppress_error = 0;
11771     r = guestfs_write_file (g, path, content, 0);
11772     if (r == -1)
11773       return -1;
11774   }
11775   {
11776     char path[] = "/new";
11777     char *r;
11778     suppress_error = 0;
11779     r = guestfs_cat (g, path);
11780     if (r == NULL)
11781       return -1;
11782     if (strcmp (r, expected) != 0) {
11783       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11784       return -1;
11785     }
11786     free (r);
11787   }
11788   return 0;
11789 }
11790
11791 static int test_write_file_5_skip (void)
11792 {
11793   const char *str;
11794
11795   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11796   if (str && strcmp (str, "1") == 0) return 1;
11797   str = getenv ("SKIP_TEST_WRITE_FILE");
11798   if (str && strcmp (str, "1") == 0) return 1;
11799   return 0;
11800 }
11801
11802 static int test_write_file_5 (void)
11803 {
11804   if (test_write_file_5_skip ()) {
11805     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11806     return 0;
11807   }
11808
11809   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11810   {
11811     char device[] = "/dev/sda";
11812     int r;
11813     suppress_error = 0;
11814     r = guestfs_blockdev_setrw (g, device);
11815     if (r == -1)
11816       return -1;
11817   }
11818   {
11819     int r;
11820     suppress_error = 0;
11821     r = guestfs_umount_all (g);
11822     if (r == -1)
11823       return -1;
11824   }
11825   {
11826     int r;
11827     suppress_error = 0;
11828     r = guestfs_lvm_remove_all (g);
11829     if (r == -1)
11830       return -1;
11831   }
11832   {
11833     char device[] = "/dev/sda";
11834     char lines_0[] = ",";
11835     char *lines[] = {
11836       lines_0,
11837       NULL
11838     };
11839     int r;
11840     suppress_error = 0;
11841     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11842     if (r == -1)
11843       return -1;
11844   }
11845   {
11846     char fstype[] = "ext2";
11847     char device[] = "/dev/sda1";
11848     int r;
11849     suppress_error = 0;
11850     r = guestfs_mkfs (g, fstype, device);
11851     if (r == -1)
11852       return -1;
11853   }
11854   {
11855     char device[] = "/dev/sda1";
11856     char mountpoint[] = "/";
11857     int r;
11858     suppress_error = 0;
11859     r = guestfs_mount (g, device, mountpoint);
11860     if (r == -1)
11861       return -1;
11862   }
11863   /* TestOutput for write_file (5) */
11864   char expected[] = "\n";
11865   {
11866     char path[] = "/new";
11867     char content[] = "\n";
11868     int r;
11869     suppress_error = 0;
11870     r = guestfs_write_file (g, path, content, 0);
11871     if (r == -1)
11872       return -1;
11873   }
11874   {
11875     char path[] = "/new";
11876     char *r;
11877     suppress_error = 0;
11878     r = guestfs_cat (g, path);
11879     if (r == NULL)
11880       return -1;
11881     if (strcmp (r, expected) != 0) {
11882       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11883       return -1;
11884     }
11885     free (r);
11886   }
11887   return 0;
11888 }
11889
11890 static int test_mkfs_0_skip (void)
11891 {
11892   const char *str;
11893
11894   str = getenv ("SKIP_TEST_MKFS_0");
11895   if (str && strcmp (str, "1") == 0) return 1;
11896   str = getenv ("SKIP_TEST_MKFS");
11897   if (str && strcmp (str, "1") == 0) return 1;
11898   return 0;
11899 }
11900
11901 static int test_mkfs_0 (void)
11902 {
11903   if (test_mkfs_0_skip ()) {
11904     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11905     return 0;
11906   }
11907
11908   /* InitNone|InitEmpty for test_mkfs_0 */
11909   {
11910     char device[] = "/dev/sda";
11911     int r;
11912     suppress_error = 0;
11913     r = guestfs_blockdev_setrw (g, device);
11914     if (r == -1)
11915       return -1;
11916   }
11917   {
11918     int r;
11919     suppress_error = 0;
11920     r = guestfs_umount_all (g);
11921     if (r == -1)
11922       return -1;
11923   }
11924   {
11925     int r;
11926     suppress_error = 0;
11927     r = guestfs_lvm_remove_all (g);
11928     if (r == -1)
11929       return -1;
11930   }
11931   /* TestOutput for mkfs (0) */
11932   char expected[] = "new file contents";
11933   {
11934     char device[] = "/dev/sda";
11935     char lines_0[] = ",";
11936     char *lines[] = {
11937       lines_0,
11938       NULL
11939     };
11940     int r;
11941     suppress_error = 0;
11942     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11943     if (r == -1)
11944       return -1;
11945   }
11946   {
11947     char fstype[] = "ext2";
11948     char device[] = "/dev/sda1";
11949     int r;
11950     suppress_error = 0;
11951     r = guestfs_mkfs (g, fstype, device);
11952     if (r == -1)
11953       return -1;
11954   }
11955   {
11956     char device[] = "/dev/sda1";
11957     char mountpoint[] = "/";
11958     int r;
11959     suppress_error = 0;
11960     r = guestfs_mount (g, device, mountpoint);
11961     if (r == -1)
11962       return -1;
11963   }
11964   {
11965     char path[] = "/new";
11966     char content[] = "new file contents";
11967     int r;
11968     suppress_error = 0;
11969     r = guestfs_write_file (g, path, content, 0);
11970     if (r == -1)
11971       return -1;
11972   }
11973   {
11974     char path[] = "/new";
11975     char *r;
11976     suppress_error = 0;
11977     r = guestfs_cat (g, path);
11978     if (r == NULL)
11979       return -1;
11980     if (strcmp (r, expected) != 0) {
11981       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11982       return -1;
11983     }
11984     free (r);
11985   }
11986   return 0;
11987 }
11988
11989 static int test_lvcreate_0_skip (void)
11990 {
11991   const char *str;
11992
11993   str = getenv ("SKIP_TEST_LVCREATE_0");
11994   if (str && strcmp (str, "1") == 0) return 1;
11995   str = getenv ("SKIP_TEST_LVCREATE");
11996   if (str && strcmp (str, "1") == 0) return 1;
11997   return 0;
11998 }
11999
12000 static int test_lvcreate_0 (void)
12001 {
12002   if (test_lvcreate_0_skip ()) {
12003     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
12004     return 0;
12005   }
12006
12007   /* InitNone|InitEmpty for test_lvcreate_0 */
12008   {
12009     char device[] = "/dev/sda";
12010     int r;
12011     suppress_error = 0;
12012     r = guestfs_blockdev_setrw (g, device);
12013     if (r == -1)
12014       return -1;
12015   }
12016   {
12017     int r;
12018     suppress_error = 0;
12019     r = guestfs_umount_all (g);
12020     if (r == -1)
12021       return -1;
12022   }
12023   {
12024     int r;
12025     suppress_error = 0;
12026     r = guestfs_lvm_remove_all (g);
12027     if (r == -1)
12028       return -1;
12029   }
12030   /* TestOutputList for lvcreate (0) */
12031   {
12032     char device[] = "/dev/sda";
12033     char lines_0[] = ",10";
12034     char lines_1[] = ",20";
12035     char lines_2[] = ",";
12036     char *lines[] = {
12037       lines_0,
12038       lines_1,
12039       lines_2,
12040       NULL
12041     };
12042     int r;
12043     suppress_error = 0;
12044     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12045     if (r == -1)
12046       return -1;
12047   }
12048   {
12049     char device[] = "/dev/sda1";
12050     int r;
12051     suppress_error = 0;
12052     r = guestfs_pvcreate (g, device);
12053     if (r == -1)
12054       return -1;
12055   }
12056   {
12057     char device[] = "/dev/sda2";
12058     int r;
12059     suppress_error = 0;
12060     r = guestfs_pvcreate (g, device);
12061     if (r == -1)
12062       return -1;
12063   }
12064   {
12065     char device[] = "/dev/sda3";
12066     int r;
12067     suppress_error = 0;
12068     r = guestfs_pvcreate (g, device);
12069     if (r == -1)
12070       return -1;
12071   }
12072   {
12073     char volgroup[] = "VG1";
12074     char physvols_0[] = "/dev/sda1";
12075     char physvols_1[] = "/dev/sda2";
12076     char *physvols[] = {
12077       physvols_0,
12078       physvols_1,
12079       NULL
12080     };
12081     int r;
12082     suppress_error = 0;
12083     r = guestfs_vgcreate (g, volgroup, physvols);
12084     if (r == -1)
12085       return -1;
12086   }
12087   {
12088     char volgroup[] = "VG2";
12089     char physvols_0[] = "/dev/sda3";
12090     char *physvols[] = {
12091       physvols_0,
12092       NULL
12093     };
12094     int r;
12095     suppress_error = 0;
12096     r = guestfs_vgcreate (g, volgroup, physvols);
12097     if (r == -1)
12098       return -1;
12099   }
12100   {
12101     char logvol[] = "LV1";
12102     char volgroup[] = "VG1";
12103     int r;
12104     suppress_error = 0;
12105     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12106     if (r == -1)
12107       return -1;
12108   }
12109   {
12110     char logvol[] = "LV2";
12111     char volgroup[] = "VG1";
12112     int r;
12113     suppress_error = 0;
12114     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12115     if (r == -1)
12116       return -1;
12117   }
12118   {
12119     char logvol[] = "LV3";
12120     char volgroup[] = "VG2";
12121     int r;
12122     suppress_error = 0;
12123     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12124     if (r == -1)
12125       return -1;
12126   }
12127   {
12128     char logvol[] = "LV4";
12129     char volgroup[] = "VG2";
12130     int r;
12131     suppress_error = 0;
12132     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12133     if (r == -1)
12134       return -1;
12135   }
12136   {
12137     char logvol[] = "LV5";
12138     char volgroup[] = "VG2";
12139     int r;
12140     suppress_error = 0;
12141     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12142     if (r == -1)
12143       return -1;
12144   }
12145   {
12146     char **r;
12147     int i;
12148     suppress_error = 0;
12149     r = guestfs_lvs (g);
12150     if (r == NULL)
12151       return -1;
12152     if (!r[0]) {
12153       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12154       print_strings (r);
12155       return -1;
12156     }
12157     {
12158       char expected[] = "/dev/VG1/LV1";
12159       if (strcmp (r[0], expected) != 0) {
12160         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12161         return -1;
12162       }
12163     }
12164     if (!r[1]) {
12165       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12166       print_strings (r);
12167       return -1;
12168     }
12169     {
12170       char expected[] = "/dev/VG1/LV2";
12171       if (strcmp (r[1], expected) != 0) {
12172         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12173         return -1;
12174       }
12175     }
12176     if (!r[2]) {
12177       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12178       print_strings (r);
12179       return -1;
12180     }
12181     {
12182       char expected[] = "/dev/VG2/LV3";
12183       if (strcmp (r[2], expected) != 0) {
12184         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12185         return -1;
12186       }
12187     }
12188     if (!r[3]) {
12189       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12190       print_strings (r);
12191       return -1;
12192     }
12193     {
12194       char expected[] = "/dev/VG2/LV4";
12195       if (strcmp (r[3], expected) != 0) {
12196         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12197         return -1;
12198       }
12199     }
12200     if (!r[4]) {
12201       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12202       print_strings (r);
12203       return -1;
12204     }
12205     {
12206       char expected[] = "/dev/VG2/LV5";
12207       if (strcmp (r[4], expected) != 0) {
12208         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
12209         return -1;
12210       }
12211     }
12212     if (r[5] != NULL) {
12213       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
12214       print_strings (r);
12215       return -1;
12216     }
12217     for (i = 0; r[i] != NULL; ++i)
12218       free (r[i]);
12219     free (r);
12220   }
12221   return 0;
12222 }
12223
12224 static int test_vgcreate_0_skip (void)
12225 {
12226   const char *str;
12227
12228   str = getenv ("SKIP_TEST_VGCREATE_0");
12229   if (str && strcmp (str, "1") == 0) return 1;
12230   str = getenv ("SKIP_TEST_VGCREATE");
12231   if (str && strcmp (str, "1") == 0) return 1;
12232   return 0;
12233 }
12234
12235 static int test_vgcreate_0 (void)
12236 {
12237   if (test_vgcreate_0_skip ()) {
12238     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
12239     return 0;
12240   }
12241
12242   /* InitNone|InitEmpty for test_vgcreate_0 */
12243   {
12244     char device[] = "/dev/sda";
12245     int r;
12246     suppress_error = 0;
12247     r = guestfs_blockdev_setrw (g, device);
12248     if (r == -1)
12249       return -1;
12250   }
12251   {
12252     int r;
12253     suppress_error = 0;
12254     r = guestfs_umount_all (g);
12255     if (r == -1)
12256       return -1;
12257   }
12258   {
12259     int r;
12260     suppress_error = 0;
12261     r = guestfs_lvm_remove_all (g);
12262     if (r == -1)
12263       return -1;
12264   }
12265   /* TestOutputList for vgcreate (0) */
12266   {
12267     char device[] = "/dev/sda";
12268     char lines_0[] = ",10";
12269     char lines_1[] = ",20";
12270     char lines_2[] = ",";
12271     char *lines[] = {
12272       lines_0,
12273       lines_1,
12274       lines_2,
12275       NULL
12276     };
12277     int r;
12278     suppress_error = 0;
12279     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12280     if (r == -1)
12281       return -1;
12282   }
12283   {
12284     char device[] = "/dev/sda1";
12285     int r;
12286     suppress_error = 0;
12287     r = guestfs_pvcreate (g, device);
12288     if (r == -1)
12289       return -1;
12290   }
12291   {
12292     char device[] = "/dev/sda2";
12293     int r;
12294     suppress_error = 0;
12295     r = guestfs_pvcreate (g, device);
12296     if (r == -1)
12297       return -1;
12298   }
12299   {
12300     char device[] = "/dev/sda3";
12301     int r;
12302     suppress_error = 0;
12303     r = guestfs_pvcreate (g, device);
12304     if (r == -1)
12305       return -1;
12306   }
12307   {
12308     char volgroup[] = "VG1";
12309     char physvols_0[] = "/dev/sda1";
12310     char physvols_1[] = "/dev/sda2";
12311     char *physvols[] = {
12312       physvols_0,
12313       physvols_1,
12314       NULL
12315     };
12316     int r;
12317     suppress_error = 0;
12318     r = guestfs_vgcreate (g, volgroup, physvols);
12319     if (r == -1)
12320       return -1;
12321   }
12322   {
12323     char volgroup[] = "VG2";
12324     char physvols_0[] = "/dev/sda3";
12325     char *physvols[] = {
12326       physvols_0,
12327       NULL
12328     };
12329     int r;
12330     suppress_error = 0;
12331     r = guestfs_vgcreate (g, volgroup, physvols);
12332     if (r == -1)
12333       return -1;
12334   }
12335   {
12336     char **r;
12337     int i;
12338     suppress_error = 0;
12339     r = guestfs_vgs (g);
12340     if (r == NULL)
12341       return -1;
12342     if (!r[0]) {
12343       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12344       print_strings (r);
12345       return -1;
12346     }
12347     {
12348       char expected[] = "VG1";
12349       if (strcmp (r[0], expected) != 0) {
12350         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12351         return -1;
12352       }
12353     }
12354     if (!r[1]) {
12355       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12356       print_strings (r);
12357       return -1;
12358     }
12359     {
12360       char expected[] = "VG2";
12361       if (strcmp (r[1], expected) != 0) {
12362         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12363         return -1;
12364       }
12365     }
12366     if (r[2] != NULL) {
12367       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12368       print_strings (r);
12369       return -1;
12370     }
12371     for (i = 0; r[i] != NULL; ++i)
12372       free (r[i]);
12373     free (r);
12374   }
12375   return 0;
12376 }
12377
12378 static int test_pvcreate_0_skip (void)
12379 {
12380   const char *str;
12381
12382   str = getenv ("SKIP_TEST_PVCREATE_0");
12383   if (str && strcmp (str, "1") == 0) return 1;
12384   str = getenv ("SKIP_TEST_PVCREATE");
12385   if (str && strcmp (str, "1") == 0) return 1;
12386   return 0;
12387 }
12388
12389 static int test_pvcreate_0 (void)
12390 {
12391   if (test_pvcreate_0_skip ()) {
12392     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12393     return 0;
12394   }
12395
12396   /* InitNone|InitEmpty for test_pvcreate_0 */
12397   {
12398     char device[] = "/dev/sda";
12399     int r;
12400     suppress_error = 0;
12401     r = guestfs_blockdev_setrw (g, device);
12402     if (r == -1)
12403       return -1;
12404   }
12405   {
12406     int r;
12407     suppress_error = 0;
12408     r = guestfs_umount_all (g);
12409     if (r == -1)
12410       return -1;
12411   }
12412   {
12413     int r;
12414     suppress_error = 0;
12415     r = guestfs_lvm_remove_all (g);
12416     if (r == -1)
12417       return -1;
12418   }
12419   /* TestOutputListOfDevices for pvcreate (0) */
12420   {
12421     char device[] = "/dev/sda";
12422     char lines_0[] = ",10";
12423     char lines_1[] = ",20";
12424     char lines_2[] = ",";
12425     char *lines[] = {
12426       lines_0,
12427       lines_1,
12428       lines_2,
12429       NULL
12430     };
12431     int r;
12432     suppress_error = 0;
12433     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12434     if (r == -1)
12435       return -1;
12436   }
12437   {
12438     char device[] = "/dev/sda1";
12439     int r;
12440     suppress_error = 0;
12441     r = guestfs_pvcreate (g, device);
12442     if (r == -1)
12443       return -1;
12444   }
12445   {
12446     char device[] = "/dev/sda2";
12447     int r;
12448     suppress_error = 0;
12449     r = guestfs_pvcreate (g, device);
12450     if (r == -1)
12451       return -1;
12452   }
12453   {
12454     char device[] = "/dev/sda3";
12455     int r;
12456     suppress_error = 0;
12457     r = guestfs_pvcreate (g, device);
12458     if (r == -1)
12459       return -1;
12460   }
12461   {
12462     char **r;
12463     int i;
12464     suppress_error = 0;
12465     r = guestfs_pvs (g);
12466     if (r == NULL)
12467       return -1;
12468     if (!r[0]) {
12469       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12470       print_strings (r);
12471       return -1;
12472     }
12473     {
12474       char expected[] = "/dev/sda1";
12475       r[0][5] = 's';
12476       if (strcmp (r[0], expected) != 0) {
12477         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12478         return -1;
12479       }
12480     }
12481     if (!r[1]) {
12482       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12483       print_strings (r);
12484       return -1;
12485     }
12486     {
12487       char expected[] = "/dev/sda2";
12488       r[1][5] = 's';
12489       if (strcmp (r[1], expected) != 0) {
12490         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12491         return -1;
12492       }
12493     }
12494     if (!r[2]) {
12495       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12496       print_strings (r);
12497       return -1;
12498     }
12499     {
12500       char expected[] = "/dev/sda3";
12501       r[2][5] = 's';
12502       if (strcmp (r[2], expected) != 0) {
12503         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12504         return -1;
12505       }
12506     }
12507     if (r[3] != NULL) {
12508       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12509       print_strings (r);
12510       return -1;
12511     }
12512     for (i = 0; r[i] != NULL; ++i)
12513       free (r[i]);
12514     free (r);
12515   }
12516   return 0;
12517 }
12518
12519 static int test_is_dir_0_skip (void)
12520 {
12521   const char *str;
12522
12523   str = getenv ("SKIP_TEST_IS_DIR_0");
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_0 (void)
12531 {
12532   if (test_is_dir_0_skip ()) {
12533     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12534     return 0;
12535   }
12536
12537   /* InitBasicFS for test_is_dir_0: 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   /* TestOutputFalse for is_dir (0) */
12592   {
12593     char path[] = "/new";
12594     int r;
12595     suppress_error = 0;
12596     r = guestfs_touch (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_0: expected false, got true\n");
12609       return -1;
12610     }
12611   }
12612   return 0;
12613 }
12614
12615 static int test_is_dir_1_skip (void)
12616 {
12617   const char *str;
12618
12619   str = getenv ("SKIP_TEST_IS_DIR_1");
12620   if (str && strcmp (str, "1") == 0) return 1;
12621   str = getenv ("SKIP_TEST_IS_DIR");
12622   if (str && strcmp (str, "1") == 0) return 1;
12623   return 0;
12624 }
12625
12626 static int test_is_dir_1 (void)
12627 {
12628   if (test_is_dir_1_skip ()) {
12629     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12630     return 0;
12631   }
12632
12633   /* InitBasicFS for test_is_dir_1: 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_dir (1) */
12688   {
12689     char path[] = "/new";
12690     int r;
12691     suppress_error = 0;
12692     r = guestfs_mkdir (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_dir (g, path);
12701     if (r == -1)
12702       return -1;
12703     if (!r) {
12704       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12705       return -1;
12706     }
12707   }
12708   return 0;
12709 }
12710
12711 static int test_is_file_0_skip (void)
12712 {
12713   const char *str;
12714
12715   str = getenv ("SKIP_TEST_IS_FILE_0");
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_0 (void)
12723 {
12724   if (test_is_file_0_skip ()) {
12725     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12726     return 0;
12727   }
12728
12729   /* InitBasicFS for test_is_file_0: 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   /* TestOutputTrue for is_file (0) */
12784   {
12785     char path[] = "/new";
12786     int r;
12787     suppress_error = 0;
12788     r = guestfs_touch (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_0: expected true, got false\n");
12801       return -1;
12802     }
12803   }
12804   return 0;
12805 }
12806
12807 static int test_is_file_1_skip (void)
12808 {
12809   const char *str;
12810
12811   str = getenv ("SKIP_TEST_IS_FILE_1");
12812   if (str && strcmp (str, "1") == 0) return 1;
12813   str = getenv ("SKIP_TEST_IS_FILE");
12814   if (str && strcmp (str, "1") == 0) return 1;
12815   return 0;
12816 }
12817
12818 static int test_is_file_1 (void)
12819 {
12820   if (test_is_file_1_skip ()) {
12821     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12822     return 0;
12823   }
12824
12825   /* InitBasicFS for test_is_file_1: 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   /* TestOutputFalse for is_file (1) */
12880   {
12881     char path[] = "/new";
12882     int r;
12883     suppress_error = 0;
12884     r = guestfs_mkdir (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_is_file (g, path);
12893     if (r == -1)
12894       return -1;
12895     if (r) {
12896       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12897       return -1;
12898     }
12899   }
12900   return 0;
12901 }
12902
12903 static int test_exists_0_skip (void)
12904 {
12905   const char *str;
12906
12907   str = getenv ("SKIP_TEST_EXISTS_0");
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_0 (void)
12915 {
12916   if (test_exists_0_skip ()) {
12917     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12918     return 0;
12919   }
12920
12921   /* InitBasicFS for test_exists_0: 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 (0) */
12976   {
12977     char path[] = "/new";
12978     int r;
12979     suppress_error = 0;
12980     r = guestfs_touch (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_0: expected true, got false\n");
12993       return -1;
12994     }
12995   }
12996   return 0;
12997 }
12998
12999 static int test_exists_1_skip (void)
13000 {
13001   const char *str;
13002
13003   str = getenv ("SKIP_TEST_EXISTS_1");
13004   if (str && strcmp (str, "1") == 0) return 1;
13005   str = getenv ("SKIP_TEST_EXISTS");
13006   if (str && strcmp (str, "1") == 0) return 1;
13007   return 0;
13008 }
13009
13010 static int test_exists_1 (void)
13011 {
13012   if (test_exists_1_skip ()) {
13013     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
13014     return 0;
13015   }
13016
13017   /* InitBasicFS for test_exists_1: 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 exists (1) */
13072   {
13073     char path[] = "/new";
13074     int r;
13075     suppress_error = 0;
13076     r = guestfs_mkdir (g, path);
13077     if (r == -1)
13078       return -1;
13079   }
13080   {
13081     char path[] = "/new";
13082     int r;
13083     suppress_error = 0;
13084     r = guestfs_exists (g, path);
13085     if (r == -1)
13086       return -1;
13087     if (!r) {
13088       fprintf (stderr, "test_exists_1: expected true, got false\n");
13089       return -1;
13090     }
13091   }
13092   return 0;
13093 }
13094
13095 static int test_mkdir_p_0_skip (void)
13096 {
13097   const char *str;
13098
13099   str = getenv ("SKIP_TEST_MKDIR_P_0");
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_0 (void)
13107 {
13108   if (test_mkdir_p_0_skip ()) {
13109     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
13110     return 0;
13111   }
13112
13113   /* InitBasicFS for test_mkdir_p_0: 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 (0) */
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/bar";
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_0: expected true, got false\n");
13185       return -1;
13186     }
13187   }
13188   return 0;
13189 }
13190
13191 static int test_mkdir_p_1_skip (void)
13192 {
13193   const char *str;
13194
13195   str = getenv ("SKIP_TEST_MKDIR_P_1");
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_1 (void)
13203 {
13204   if (test_mkdir_p_1_skip ()) {
13205     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
13206     return 0;
13207   }
13208
13209   /* InitBasicFS for test_mkdir_p_1: 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 (1) */
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/foo";
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_1: expected true, got false\n");
13281       return -1;
13282     }
13283   }
13284   return 0;
13285 }
13286
13287 static int test_mkdir_p_2_skip (void)
13288 {
13289   const char *str;
13290
13291   str = getenv ("SKIP_TEST_MKDIR_P_2");
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_2 (void)
13299 {
13300   if (test_mkdir_p_2_skip ()) {
13301     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
13302     return 0;
13303   }
13304
13305   /* InitBasicFS for test_mkdir_p_2: 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   /* TestOutputTrue for mkdir_p (2) */
13360   {
13361     char path[] = "/new/foo/bar";
13362     int r;
13363     suppress_error = 0;
13364     r = guestfs_mkdir_p (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_is_dir (g, path);
13373     if (r == -1)
13374       return -1;
13375     if (!r) {
13376       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13377       return -1;
13378     }
13379   }
13380   return 0;
13381 }
13382
13383 static int test_mkdir_p_3_skip (void)
13384 {
13385   const char *str;
13386
13387   str = getenv ("SKIP_TEST_MKDIR_P_3");
13388   if (str && strcmp (str, "1") == 0) return 1;
13389   str = getenv ("SKIP_TEST_MKDIR_P");
13390   if (str && strcmp (str, "1") == 0) return 1;
13391   return 0;
13392 }
13393
13394 static int test_mkdir_p_3 (void)
13395 {
13396   if (test_mkdir_p_3_skip ()) {
13397     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13398     return 0;
13399   }
13400
13401   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13402   {
13403     char device[] = "/dev/sda";
13404     int r;
13405     suppress_error = 0;
13406     r = guestfs_blockdev_setrw (g, device);
13407     if (r == -1)
13408       return -1;
13409   }
13410   {
13411     int r;
13412     suppress_error = 0;
13413     r = guestfs_umount_all (g);
13414     if (r == -1)
13415       return -1;
13416   }
13417   {
13418     int r;
13419     suppress_error = 0;
13420     r = guestfs_lvm_remove_all (g);
13421     if (r == -1)
13422       return -1;
13423   }
13424   {
13425     char device[] = "/dev/sda";
13426     char lines_0[] = ",";
13427     char *lines[] = {
13428       lines_0,
13429       NULL
13430     };
13431     int r;
13432     suppress_error = 0;
13433     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13434     if (r == -1)
13435       return -1;
13436   }
13437   {
13438     char fstype[] = "ext2";
13439     char device[] = "/dev/sda1";
13440     int r;
13441     suppress_error = 0;
13442     r = guestfs_mkfs (g, fstype, device);
13443     if (r == -1)
13444       return -1;
13445   }
13446   {
13447     char device[] = "/dev/sda1";
13448     char mountpoint[] = "/";
13449     int r;
13450     suppress_error = 0;
13451     r = guestfs_mount (g, device, mountpoint);
13452     if (r == -1)
13453       return -1;
13454   }
13455   /* TestRun for mkdir_p (3) */
13456   {
13457     char path[] = "/new";
13458     int r;
13459     suppress_error = 0;
13460     r = guestfs_mkdir (g, path);
13461     if (r == -1)
13462       return -1;
13463   }
13464   {
13465     char path[] = "/new";
13466     int r;
13467     suppress_error = 0;
13468     r = guestfs_mkdir_p (g, path);
13469     if (r == -1)
13470       return -1;
13471   }
13472   return 0;
13473 }
13474
13475 static int test_mkdir_p_4_skip (void)
13476 {
13477   const char *str;
13478
13479   str = getenv ("SKIP_TEST_MKDIR_P_4");
13480   if (str && strcmp (str, "1") == 0) return 1;
13481   str = getenv ("SKIP_TEST_MKDIR_P");
13482   if (str && strcmp (str, "1") == 0) return 1;
13483   return 0;
13484 }
13485
13486 static int test_mkdir_p_4 (void)
13487 {
13488   if (test_mkdir_p_4_skip ()) {
13489     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13490     return 0;
13491   }
13492
13493   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13494   {
13495     char device[] = "/dev/sda";
13496     int r;
13497     suppress_error = 0;
13498     r = guestfs_blockdev_setrw (g, device);
13499     if (r == -1)
13500       return -1;
13501   }
13502   {
13503     int r;
13504     suppress_error = 0;
13505     r = guestfs_umount_all (g);
13506     if (r == -1)
13507       return -1;
13508   }
13509   {
13510     int r;
13511     suppress_error = 0;
13512     r = guestfs_lvm_remove_all (g);
13513     if (r == -1)
13514       return -1;
13515   }
13516   {
13517     char device[] = "/dev/sda";
13518     char lines_0[] = ",";
13519     char *lines[] = {
13520       lines_0,
13521       NULL
13522     };
13523     int r;
13524     suppress_error = 0;
13525     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13526     if (r == -1)
13527       return -1;
13528   }
13529   {
13530     char fstype[] = "ext2";
13531     char device[] = "/dev/sda1";
13532     int r;
13533     suppress_error = 0;
13534     r = guestfs_mkfs (g, fstype, device);
13535     if (r == -1)
13536       return -1;
13537   }
13538   {
13539     char device[] = "/dev/sda1";
13540     char mountpoint[] = "/";
13541     int r;
13542     suppress_error = 0;
13543     r = guestfs_mount (g, device, mountpoint);
13544     if (r == -1)
13545       return -1;
13546   }
13547   /* TestLastFail for mkdir_p (4) */
13548   {
13549     char path[] = "/new";
13550     int r;
13551     suppress_error = 0;
13552     r = guestfs_touch (g, path);
13553     if (r == -1)
13554       return -1;
13555   }
13556   {
13557     char path[] = "/new";
13558     int r;
13559     suppress_error = 1;
13560     r = guestfs_mkdir_p (g, path);
13561     if (r != -1)
13562       return -1;
13563   }
13564   return 0;
13565 }
13566
13567 static int test_mkdir_0_skip (void)
13568 {
13569   const char *str;
13570
13571   str = getenv ("SKIP_TEST_MKDIR_0");
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_0 (void)
13579 {
13580   if (test_mkdir_0_skip ()) {
13581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13582     return 0;
13583   }
13584
13585   /* InitBasicFS for test_mkdir_0: 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   /* TestOutputTrue for mkdir (0) */
13640   {
13641     char path[] = "/new";
13642     int r;
13643     suppress_error = 0;
13644     r = guestfs_mkdir (g, path);
13645     if (r == -1)
13646       return -1;
13647   }
13648   {
13649     char path[] = "/new";
13650     int r;
13651     suppress_error = 0;
13652     r = guestfs_is_dir (g, path);
13653     if (r == -1)
13654       return -1;
13655     if (!r) {
13656       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13657       return -1;
13658     }
13659   }
13660   return 0;
13661 }
13662
13663 static int test_mkdir_1_skip (void)
13664 {
13665   const char *str;
13666
13667   str = getenv ("SKIP_TEST_MKDIR_1");
13668   if (str && strcmp (str, "1") == 0) return 1;
13669   str = getenv ("SKIP_TEST_MKDIR");
13670   if (str && strcmp (str, "1") == 0) return 1;
13671   return 0;
13672 }
13673
13674 static int test_mkdir_1 (void)
13675 {
13676   if (test_mkdir_1_skip ()) {
13677     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13678     return 0;
13679   }
13680
13681   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13682   {
13683     char device[] = "/dev/sda";
13684     int r;
13685     suppress_error = 0;
13686     r = guestfs_blockdev_setrw (g, device);
13687     if (r == -1)
13688       return -1;
13689   }
13690   {
13691     int r;
13692     suppress_error = 0;
13693     r = guestfs_umount_all (g);
13694     if (r == -1)
13695       return -1;
13696   }
13697   {
13698     int r;
13699     suppress_error = 0;
13700     r = guestfs_lvm_remove_all (g);
13701     if (r == -1)
13702       return -1;
13703   }
13704   {
13705     char device[] = "/dev/sda";
13706     char lines_0[] = ",";
13707     char *lines[] = {
13708       lines_0,
13709       NULL
13710     };
13711     int r;
13712     suppress_error = 0;
13713     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13714     if (r == -1)
13715       return -1;
13716   }
13717   {
13718     char fstype[] = "ext2";
13719     char device[] = "/dev/sda1";
13720     int r;
13721     suppress_error = 0;
13722     r = guestfs_mkfs (g, fstype, device);
13723     if (r == -1)
13724       return -1;
13725   }
13726   {
13727     char device[] = "/dev/sda1";
13728     char mountpoint[] = "/";
13729     int r;
13730     suppress_error = 0;
13731     r = guestfs_mount (g, device, mountpoint);
13732     if (r == -1)
13733       return -1;
13734   }
13735   /* TestLastFail for mkdir (1) */
13736   {
13737     char path[] = "/new/foo/bar";
13738     int r;
13739     suppress_error = 1;
13740     r = guestfs_mkdir (g, path);
13741     if (r != -1)
13742       return -1;
13743   }
13744   return 0;
13745 }
13746
13747 static int test_rm_rf_0_skip (void)
13748 {
13749   const char *str;
13750
13751   str = getenv ("SKIP_TEST_RM_RF_0");
13752   if (str && strcmp (str, "1") == 0) return 1;
13753   str = getenv ("SKIP_TEST_RM_RF");
13754   if (str && strcmp (str, "1") == 0) return 1;
13755   return 0;
13756 }
13757
13758 static int test_rm_rf_0 (void)
13759 {
13760   if (test_rm_rf_0_skip ()) {
13761     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13762     return 0;
13763   }
13764
13765   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13766   {
13767     char device[] = "/dev/sda";
13768     int r;
13769     suppress_error = 0;
13770     r = guestfs_blockdev_setrw (g, device);
13771     if (r == -1)
13772       return -1;
13773   }
13774   {
13775     int r;
13776     suppress_error = 0;
13777     r = guestfs_umount_all (g);
13778     if (r == -1)
13779       return -1;
13780   }
13781   {
13782     int r;
13783     suppress_error = 0;
13784     r = guestfs_lvm_remove_all (g);
13785     if (r == -1)
13786       return -1;
13787   }
13788   {
13789     char device[] = "/dev/sda";
13790     char lines_0[] = ",";
13791     char *lines[] = {
13792       lines_0,
13793       NULL
13794     };
13795     int r;
13796     suppress_error = 0;
13797     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13798     if (r == -1)
13799       return -1;
13800   }
13801   {
13802     char fstype[] = "ext2";
13803     char device[] = "/dev/sda1";
13804     int r;
13805     suppress_error = 0;
13806     r = guestfs_mkfs (g, fstype, device);
13807     if (r == -1)
13808       return -1;
13809   }
13810   {
13811     char device[] = "/dev/sda1";
13812     char mountpoint[] = "/";
13813     int r;
13814     suppress_error = 0;
13815     r = guestfs_mount (g, device, mountpoint);
13816     if (r == -1)
13817       return -1;
13818   }
13819   /* TestOutputFalse for rm_rf (0) */
13820   {
13821     char path[] = "/new";
13822     int r;
13823     suppress_error = 0;
13824     r = guestfs_mkdir (g, path);
13825     if (r == -1)
13826       return -1;
13827   }
13828   {
13829     char path[] = "/new/foo";
13830     int r;
13831     suppress_error = 0;
13832     r = guestfs_mkdir (g, path);
13833     if (r == -1)
13834       return -1;
13835   }
13836   {
13837     char path[] = "/new/foo/bar";
13838     int r;
13839     suppress_error = 0;
13840     r = guestfs_touch (g, path);
13841     if (r == -1)
13842       return -1;
13843   }
13844   {
13845     char path[] = "/new";
13846     int r;
13847     suppress_error = 0;
13848     r = guestfs_rm_rf (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_exists (g, path);
13857     if (r == -1)
13858       return -1;
13859     if (r) {
13860       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13861       return -1;
13862     }
13863   }
13864   return 0;
13865 }
13866
13867 static int test_rmdir_0_skip (void)
13868 {
13869   const char *str;
13870
13871   str = getenv ("SKIP_TEST_RMDIR_0");
13872   if (str && strcmp (str, "1") == 0) return 1;
13873   str = getenv ("SKIP_TEST_RMDIR");
13874   if (str && strcmp (str, "1") == 0) return 1;
13875   return 0;
13876 }
13877
13878 static int test_rmdir_0 (void)
13879 {
13880   if (test_rmdir_0_skip ()) {
13881     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13882     return 0;
13883   }
13884
13885   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13886   {
13887     char device[] = "/dev/sda";
13888     int r;
13889     suppress_error = 0;
13890     r = guestfs_blockdev_setrw (g, device);
13891     if (r == -1)
13892       return -1;
13893   }
13894   {
13895     int r;
13896     suppress_error = 0;
13897     r = guestfs_umount_all (g);
13898     if (r == -1)
13899       return -1;
13900   }
13901   {
13902     int r;
13903     suppress_error = 0;
13904     r = guestfs_lvm_remove_all (g);
13905     if (r == -1)
13906       return -1;
13907   }
13908   {
13909     char device[] = "/dev/sda";
13910     char lines_0[] = ",";
13911     char *lines[] = {
13912       lines_0,
13913       NULL
13914     };
13915     int r;
13916     suppress_error = 0;
13917     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13918     if (r == -1)
13919       return -1;
13920   }
13921   {
13922     char fstype[] = "ext2";
13923     char device[] = "/dev/sda1";
13924     int r;
13925     suppress_error = 0;
13926     r = guestfs_mkfs (g, fstype, device);
13927     if (r == -1)
13928       return -1;
13929   }
13930   {
13931     char device[] = "/dev/sda1";
13932     char mountpoint[] = "/";
13933     int r;
13934     suppress_error = 0;
13935     r = guestfs_mount (g, device, mountpoint);
13936     if (r == -1)
13937       return -1;
13938   }
13939   /* TestRun for rmdir (0) */
13940   {
13941     char path[] = "/new";
13942     int r;
13943     suppress_error = 0;
13944     r = guestfs_mkdir (g, path);
13945     if (r == -1)
13946       return -1;
13947   }
13948   {
13949     char path[] = "/new";
13950     int r;
13951     suppress_error = 0;
13952     r = guestfs_rmdir (g, path);
13953     if (r == -1)
13954       return -1;
13955   }
13956   return 0;
13957 }
13958
13959 static int test_rmdir_1_skip (void)
13960 {
13961   const char *str;
13962
13963   str = getenv ("SKIP_TEST_RMDIR_1");
13964   if (str && strcmp (str, "1") == 0) return 1;
13965   str = getenv ("SKIP_TEST_RMDIR");
13966   if (str && strcmp (str, "1") == 0) return 1;
13967   return 0;
13968 }
13969
13970 static int test_rmdir_1 (void)
13971 {
13972   if (test_rmdir_1_skip ()) {
13973     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13974     return 0;
13975   }
13976
13977   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13978   {
13979     char device[] = "/dev/sda";
13980     int r;
13981     suppress_error = 0;
13982     r = guestfs_blockdev_setrw (g, device);
13983     if (r == -1)
13984       return -1;
13985   }
13986   {
13987     int r;
13988     suppress_error = 0;
13989     r = guestfs_umount_all (g);
13990     if (r == -1)
13991       return -1;
13992   }
13993   {
13994     int r;
13995     suppress_error = 0;
13996     r = guestfs_lvm_remove_all (g);
13997     if (r == -1)
13998       return -1;
13999   }
14000   {
14001     char device[] = "/dev/sda";
14002     char lines_0[] = ",";
14003     char *lines[] = {
14004       lines_0,
14005       NULL
14006     };
14007     int r;
14008     suppress_error = 0;
14009     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14010     if (r == -1)
14011       return -1;
14012   }
14013   {
14014     char fstype[] = "ext2";
14015     char device[] = "/dev/sda1";
14016     int r;
14017     suppress_error = 0;
14018     r = guestfs_mkfs (g, fstype, device);
14019     if (r == -1)
14020       return -1;
14021   }
14022   {
14023     char device[] = "/dev/sda1";
14024     char mountpoint[] = "/";
14025     int r;
14026     suppress_error = 0;
14027     r = guestfs_mount (g, device, mountpoint);
14028     if (r == -1)
14029       return -1;
14030   }
14031   /* TestLastFail for rmdir (1) */
14032   {
14033     char path[] = "/new";
14034     int r;
14035     suppress_error = 1;
14036     r = guestfs_rmdir (g, path);
14037     if (r != -1)
14038       return -1;
14039   }
14040   return 0;
14041 }
14042
14043 static int test_rmdir_2_skip (void)
14044 {
14045   const char *str;
14046
14047   str = getenv ("SKIP_TEST_RMDIR_2");
14048   if (str && strcmp (str, "1") == 0) return 1;
14049   str = getenv ("SKIP_TEST_RMDIR");
14050   if (str && strcmp (str, "1") == 0) return 1;
14051   return 0;
14052 }
14053
14054 static int test_rmdir_2 (void)
14055 {
14056   if (test_rmdir_2_skip ()) {
14057     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
14058     return 0;
14059   }
14060
14061   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
14062   {
14063     char device[] = "/dev/sda";
14064     int r;
14065     suppress_error = 0;
14066     r = guestfs_blockdev_setrw (g, device);
14067     if (r == -1)
14068       return -1;
14069   }
14070   {
14071     int r;
14072     suppress_error = 0;
14073     r = guestfs_umount_all (g);
14074     if (r == -1)
14075       return -1;
14076   }
14077   {
14078     int r;
14079     suppress_error = 0;
14080     r = guestfs_lvm_remove_all (g);
14081     if (r == -1)
14082       return -1;
14083   }
14084   {
14085     char device[] = "/dev/sda";
14086     char lines_0[] = ",";
14087     char *lines[] = {
14088       lines_0,
14089       NULL
14090     };
14091     int r;
14092     suppress_error = 0;
14093     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14094     if (r == -1)
14095       return -1;
14096   }
14097   {
14098     char fstype[] = "ext2";
14099     char device[] = "/dev/sda1";
14100     int r;
14101     suppress_error = 0;
14102     r = guestfs_mkfs (g, fstype, device);
14103     if (r == -1)
14104       return -1;
14105   }
14106   {
14107     char device[] = "/dev/sda1";
14108     char mountpoint[] = "/";
14109     int r;
14110     suppress_error = 0;
14111     r = guestfs_mount (g, device, mountpoint);
14112     if (r == -1)
14113       return -1;
14114   }
14115   /* TestLastFail for rmdir (2) */
14116   {
14117     char path[] = "/new";
14118     int r;
14119     suppress_error = 0;
14120     r = guestfs_touch (g, path);
14121     if (r == -1)
14122       return -1;
14123   }
14124   {
14125     char path[] = "/new";
14126     int r;
14127     suppress_error = 1;
14128     r = guestfs_rmdir (g, path);
14129     if (r != -1)
14130       return -1;
14131   }
14132   return 0;
14133 }
14134
14135 static int test_rm_0_skip (void)
14136 {
14137   const char *str;
14138
14139   str = getenv ("SKIP_TEST_RM_0");
14140   if (str && strcmp (str, "1") == 0) return 1;
14141   str = getenv ("SKIP_TEST_RM");
14142   if (str && strcmp (str, "1") == 0) return 1;
14143   return 0;
14144 }
14145
14146 static int test_rm_0 (void)
14147 {
14148   if (test_rm_0_skip ()) {
14149     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
14150     return 0;
14151   }
14152
14153   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
14154   {
14155     char device[] = "/dev/sda";
14156     int r;
14157     suppress_error = 0;
14158     r = guestfs_blockdev_setrw (g, device);
14159     if (r == -1)
14160       return -1;
14161   }
14162   {
14163     int r;
14164     suppress_error = 0;
14165     r = guestfs_umount_all (g);
14166     if (r == -1)
14167       return -1;
14168   }
14169   {
14170     int r;
14171     suppress_error = 0;
14172     r = guestfs_lvm_remove_all (g);
14173     if (r == -1)
14174       return -1;
14175   }
14176   {
14177     char device[] = "/dev/sda";
14178     char lines_0[] = ",";
14179     char *lines[] = {
14180       lines_0,
14181       NULL
14182     };
14183     int r;
14184     suppress_error = 0;
14185     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14186     if (r == -1)
14187       return -1;
14188   }
14189   {
14190     char fstype[] = "ext2";
14191     char device[] = "/dev/sda1";
14192     int r;
14193     suppress_error = 0;
14194     r = guestfs_mkfs (g, fstype, device);
14195     if (r == -1)
14196       return -1;
14197   }
14198   {
14199     char device[] = "/dev/sda1";
14200     char mountpoint[] = "/";
14201     int r;
14202     suppress_error = 0;
14203     r = guestfs_mount (g, device, mountpoint);
14204     if (r == -1)
14205       return -1;
14206   }
14207   /* TestRun for rm (0) */
14208   {
14209     char path[] = "/new";
14210     int r;
14211     suppress_error = 0;
14212     r = guestfs_touch (g, path);
14213     if (r == -1)
14214       return -1;
14215   }
14216   {
14217     char path[] = "/new";
14218     int r;
14219     suppress_error = 0;
14220     r = guestfs_rm (g, path);
14221     if (r == -1)
14222       return -1;
14223   }
14224   return 0;
14225 }
14226
14227 static int test_rm_1_skip (void)
14228 {
14229   const char *str;
14230
14231   str = getenv ("SKIP_TEST_RM_1");
14232   if (str && strcmp (str, "1") == 0) return 1;
14233   str = getenv ("SKIP_TEST_RM");
14234   if (str && strcmp (str, "1") == 0) return 1;
14235   return 0;
14236 }
14237
14238 static int test_rm_1 (void)
14239 {
14240   if (test_rm_1_skip ()) {
14241     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
14242     return 0;
14243   }
14244
14245   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14246   {
14247     char device[] = "/dev/sda";
14248     int r;
14249     suppress_error = 0;
14250     r = guestfs_blockdev_setrw (g, device);
14251     if (r == -1)
14252       return -1;
14253   }
14254   {
14255     int r;
14256     suppress_error = 0;
14257     r = guestfs_umount_all (g);
14258     if (r == -1)
14259       return -1;
14260   }
14261   {
14262     int r;
14263     suppress_error = 0;
14264     r = guestfs_lvm_remove_all (g);
14265     if (r == -1)
14266       return -1;
14267   }
14268   {
14269     char device[] = "/dev/sda";
14270     char lines_0[] = ",";
14271     char *lines[] = {
14272       lines_0,
14273       NULL
14274     };
14275     int r;
14276     suppress_error = 0;
14277     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14278     if (r == -1)
14279       return -1;
14280   }
14281   {
14282     char fstype[] = "ext2";
14283     char device[] = "/dev/sda1";
14284     int r;
14285     suppress_error = 0;
14286     r = guestfs_mkfs (g, fstype, device);
14287     if (r == -1)
14288       return -1;
14289   }
14290   {
14291     char device[] = "/dev/sda1";
14292     char mountpoint[] = "/";
14293     int r;
14294     suppress_error = 0;
14295     r = guestfs_mount (g, device, mountpoint);
14296     if (r == -1)
14297       return -1;
14298   }
14299   /* TestLastFail for rm (1) */
14300   {
14301     char path[] = "/new";
14302     int r;
14303     suppress_error = 1;
14304     r = guestfs_rm (g, path);
14305     if (r != -1)
14306       return -1;
14307   }
14308   return 0;
14309 }
14310
14311 static int test_rm_2_skip (void)
14312 {
14313   const char *str;
14314
14315   str = getenv ("SKIP_TEST_RM_2");
14316   if (str && strcmp (str, "1") == 0) return 1;
14317   str = getenv ("SKIP_TEST_RM");
14318   if (str && strcmp (str, "1") == 0) return 1;
14319   return 0;
14320 }
14321
14322 static int test_rm_2 (void)
14323 {
14324   if (test_rm_2_skip ()) {
14325     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
14326     return 0;
14327   }
14328
14329   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
14330   {
14331     char device[] = "/dev/sda";
14332     int r;
14333     suppress_error = 0;
14334     r = guestfs_blockdev_setrw (g, device);
14335     if (r == -1)
14336       return -1;
14337   }
14338   {
14339     int r;
14340     suppress_error = 0;
14341     r = guestfs_umount_all (g);
14342     if (r == -1)
14343       return -1;
14344   }
14345   {
14346     int r;
14347     suppress_error = 0;
14348     r = guestfs_lvm_remove_all (g);
14349     if (r == -1)
14350       return -1;
14351   }
14352   {
14353     char device[] = "/dev/sda";
14354     char lines_0[] = ",";
14355     char *lines[] = {
14356       lines_0,
14357       NULL
14358     };
14359     int r;
14360     suppress_error = 0;
14361     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14362     if (r == -1)
14363       return -1;
14364   }
14365   {
14366     char fstype[] = "ext2";
14367     char device[] = "/dev/sda1";
14368     int r;
14369     suppress_error = 0;
14370     r = guestfs_mkfs (g, fstype, device);
14371     if (r == -1)
14372       return -1;
14373   }
14374   {
14375     char device[] = "/dev/sda1";
14376     char mountpoint[] = "/";
14377     int r;
14378     suppress_error = 0;
14379     r = guestfs_mount (g, device, mountpoint);
14380     if (r == -1)
14381       return -1;
14382   }
14383   /* TestLastFail for rm (2) */
14384   {
14385     char path[] = "/new";
14386     int r;
14387     suppress_error = 0;
14388     r = guestfs_mkdir (g, path);
14389     if (r == -1)
14390       return -1;
14391   }
14392   {
14393     char path[] = "/new";
14394     int r;
14395     suppress_error = 1;
14396     r = guestfs_rm (g, path);
14397     if (r != -1)
14398       return -1;
14399   }
14400   return 0;
14401 }
14402
14403 static int test_read_lines_0_skip (void)
14404 {
14405   const char *str;
14406
14407   str = getenv ("SKIP_TEST_READ_LINES_0");
14408   if (str && strcmp (str, "1") == 0) return 1;
14409   str = getenv ("SKIP_TEST_READ_LINES");
14410   if (str && strcmp (str, "1") == 0) return 1;
14411   return 0;
14412 }
14413
14414 static int test_read_lines_0 (void)
14415 {
14416   if (test_read_lines_0_skip ()) {
14417     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14418     return 0;
14419   }
14420
14421   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14422   {
14423     char device[] = "/dev/sda";
14424     int r;
14425     suppress_error = 0;
14426     r = guestfs_blockdev_setrw (g, device);
14427     if (r == -1)
14428       return -1;
14429   }
14430   {
14431     int r;
14432     suppress_error = 0;
14433     r = guestfs_umount_all (g);
14434     if (r == -1)
14435       return -1;
14436   }
14437   {
14438     int r;
14439     suppress_error = 0;
14440     r = guestfs_lvm_remove_all (g);
14441     if (r == -1)
14442       return -1;
14443   }
14444   {
14445     char device[] = "/dev/sda";
14446     char lines_0[] = ",";
14447     char *lines[] = {
14448       lines_0,
14449       NULL
14450     };
14451     int r;
14452     suppress_error = 0;
14453     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14454     if (r == -1)
14455       return -1;
14456   }
14457   {
14458     char fstype[] = "ext2";
14459     char device[] = "/dev/sda1";
14460     int r;
14461     suppress_error = 0;
14462     r = guestfs_mkfs (g, fstype, device);
14463     if (r == -1)
14464       return -1;
14465   }
14466   {
14467     char device[] = "/dev/sda1";
14468     char mountpoint[] = "/";
14469     int r;
14470     suppress_error = 0;
14471     r = guestfs_mount (g, device, mountpoint);
14472     if (r == -1)
14473       return -1;
14474   }
14475   /* TestOutputList for read_lines (0) */
14476   {
14477     char path[] = "/new";
14478     char content[] = "line1\r\nline2\nline3";
14479     int r;
14480     suppress_error = 0;
14481     r = guestfs_write_file (g, path, content, 0);
14482     if (r == -1)
14483       return -1;
14484   }
14485   {
14486     char path[] = "/new";
14487     char **r;
14488     int i;
14489     suppress_error = 0;
14490     r = guestfs_read_lines (g, path);
14491     if (r == NULL)
14492       return -1;
14493     if (!r[0]) {
14494       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14495       print_strings (r);
14496       return -1;
14497     }
14498     {
14499       char expected[] = "line1";
14500       if (strcmp (r[0], expected) != 0) {
14501         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14502         return -1;
14503       }
14504     }
14505     if (!r[1]) {
14506       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14507       print_strings (r);
14508       return -1;
14509     }
14510     {
14511       char expected[] = "line2";
14512       if (strcmp (r[1], expected) != 0) {
14513         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14514         return -1;
14515       }
14516     }
14517     if (!r[2]) {
14518       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14519       print_strings (r);
14520       return -1;
14521     }
14522     {
14523       char expected[] = "line3";
14524       if (strcmp (r[2], expected) != 0) {
14525         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14526         return -1;
14527       }
14528     }
14529     if (r[3] != NULL) {
14530       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14531       print_strings (r);
14532       return -1;
14533     }
14534     for (i = 0; r[i] != NULL; ++i)
14535       free (r[i]);
14536     free (r);
14537   }
14538   return 0;
14539 }
14540
14541 static int test_read_lines_1_skip (void)
14542 {
14543   const char *str;
14544
14545   str = getenv ("SKIP_TEST_READ_LINES_1");
14546   if (str && strcmp (str, "1") == 0) return 1;
14547   str = getenv ("SKIP_TEST_READ_LINES");
14548   if (str && strcmp (str, "1") == 0) return 1;
14549   return 0;
14550 }
14551
14552 static int test_read_lines_1 (void)
14553 {
14554   if (test_read_lines_1_skip ()) {
14555     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14556     return 0;
14557   }
14558
14559   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14560   {
14561     char device[] = "/dev/sda";
14562     int r;
14563     suppress_error = 0;
14564     r = guestfs_blockdev_setrw (g, device);
14565     if (r == -1)
14566       return -1;
14567   }
14568   {
14569     int r;
14570     suppress_error = 0;
14571     r = guestfs_umount_all (g);
14572     if (r == -1)
14573       return -1;
14574   }
14575   {
14576     int r;
14577     suppress_error = 0;
14578     r = guestfs_lvm_remove_all (g);
14579     if (r == -1)
14580       return -1;
14581   }
14582   {
14583     char device[] = "/dev/sda";
14584     char lines_0[] = ",";
14585     char *lines[] = {
14586       lines_0,
14587       NULL
14588     };
14589     int r;
14590     suppress_error = 0;
14591     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14592     if (r == -1)
14593       return -1;
14594   }
14595   {
14596     char fstype[] = "ext2";
14597     char device[] = "/dev/sda1";
14598     int r;
14599     suppress_error = 0;
14600     r = guestfs_mkfs (g, fstype, device);
14601     if (r == -1)
14602       return -1;
14603   }
14604   {
14605     char device[] = "/dev/sda1";
14606     char mountpoint[] = "/";
14607     int r;
14608     suppress_error = 0;
14609     r = guestfs_mount (g, device, mountpoint);
14610     if (r == -1)
14611       return -1;
14612   }
14613   /* TestOutputList for read_lines (1) */
14614   {
14615     char path[] = "/new";
14616     char content[] = "";
14617     int r;
14618     suppress_error = 0;
14619     r = guestfs_write_file (g, path, content, 0);
14620     if (r == -1)
14621       return -1;
14622   }
14623   {
14624     char path[] = "/new";
14625     char **r;
14626     int i;
14627     suppress_error = 0;
14628     r = guestfs_read_lines (g, path);
14629     if (r == NULL)
14630       return -1;
14631     if (r[0] != NULL) {
14632       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14633       print_strings (r);
14634       return -1;
14635     }
14636     for (i = 0; r[i] != NULL; ++i)
14637       free (r[i]);
14638     free (r);
14639   }
14640   return 0;
14641 }
14642
14643 static int test_lvs_0_skip (void)
14644 {
14645   const char *str;
14646
14647   str = getenv ("SKIP_TEST_LVS_0");
14648   if (str && strcmp (str, "1") == 0) return 1;
14649   str = getenv ("SKIP_TEST_LVS");
14650   if (str && strcmp (str, "1") == 0) return 1;
14651   return 0;
14652 }
14653
14654 static int test_lvs_0 (void)
14655 {
14656   if (test_lvs_0_skip ()) {
14657     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14658     return 0;
14659   }
14660
14661   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14662   {
14663     char device[] = "/dev/sda";
14664     int r;
14665     suppress_error = 0;
14666     r = guestfs_blockdev_setrw (g, device);
14667     if (r == -1)
14668       return -1;
14669   }
14670   {
14671     int r;
14672     suppress_error = 0;
14673     r = guestfs_umount_all (g);
14674     if (r == -1)
14675       return -1;
14676   }
14677   {
14678     int r;
14679     suppress_error = 0;
14680     r = guestfs_lvm_remove_all (g);
14681     if (r == -1)
14682       return -1;
14683   }
14684   {
14685     char device[] = "/dev/sda";
14686     char lines_0[] = ",";
14687     char *lines[] = {
14688       lines_0,
14689       NULL
14690     };
14691     int r;
14692     suppress_error = 0;
14693     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14694     if (r == -1)
14695       return -1;
14696   }
14697   {
14698     char device[] = "/dev/sda1";
14699     int r;
14700     suppress_error = 0;
14701     r = guestfs_pvcreate (g, device);
14702     if (r == -1)
14703       return -1;
14704   }
14705   {
14706     char volgroup[] = "VG";
14707     char physvols_0[] = "/dev/sda1";
14708     char *physvols[] = {
14709       physvols_0,
14710       NULL
14711     };
14712     int r;
14713     suppress_error = 0;
14714     r = guestfs_vgcreate (g, volgroup, physvols);
14715     if (r == -1)
14716       return -1;
14717   }
14718   {
14719     char logvol[] = "LV";
14720     char volgroup[] = "VG";
14721     int r;
14722     suppress_error = 0;
14723     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14724     if (r == -1)
14725       return -1;
14726   }
14727   {
14728     char fstype[] = "ext2";
14729     char device[] = "/dev/VG/LV";
14730     int r;
14731     suppress_error = 0;
14732     r = guestfs_mkfs (g, fstype, device);
14733     if (r == -1)
14734       return -1;
14735   }
14736   {
14737     char device[] = "/dev/VG/LV";
14738     char mountpoint[] = "/";
14739     int r;
14740     suppress_error = 0;
14741     r = guestfs_mount (g, device, mountpoint);
14742     if (r == -1)
14743       return -1;
14744   }
14745   /* TestOutputList for lvs (0) */
14746   {
14747     char **r;
14748     int i;
14749     suppress_error = 0;
14750     r = guestfs_lvs (g);
14751     if (r == NULL)
14752       return -1;
14753     if (!r[0]) {
14754       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14755       print_strings (r);
14756       return -1;
14757     }
14758     {
14759       char expected[] = "/dev/VG/LV";
14760       if (strcmp (r[0], expected) != 0) {
14761         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14762         return -1;
14763       }
14764     }
14765     if (r[1] != NULL) {
14766       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14767       print_strings (r);
14768       return -1;
14769     }
14770     for (i = 0; r[i] != NULL; ++i)
14771       free (r[i]);
14772     free (r);
14773   }
14774   return 0;
14775 }
14776
14777 static int test_lvs_1_skip (void)
14778 {
14779   const char *str;
14780
14781   str = getenv ("SKIP_TEST_LVS_1");
14782   if (str && strcmp (str, "1") == 0) return 1;
14783   str = getenv ("SKIP_TEST_LVS");
14784   if (str && strcmp (str, "1") == 0) return 1;
14785   return 0;
14786 }
14787
14788 static int test_lvs_1 (void)
14789 {
14790   if (test_lvs_1_skip ()) {
14791     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14792     return 0;
14793   }
14794
14795   /* InitNone|InitEmpty for test_lvs_1 */
14796   {
14797     char device[] = "/dev/sda";
14798     int r;
14799     suppress_error = 0;
14800     r = guestfs_blockdev_setrw (g, device);
14801     if (r == -1)
14802       return -1;
14803   }
14804   {
14805     int r;
14806     suppress_error = 0;
14807     r = guestfs_umount_all (g);
14808     if (r == -1)
14809       return -1;
14810   }
14811   {
14812     int r;
14813     suppress_error = 0;
14814     r = guestfs_lvm_remove_all (g);
14815     if (r == -1)
14816       return -1;
14817   }
14818   /* TestOutputList for lvs (1) */
14819   {
14820     char device[] = "/dev/sda";
14821     char lines_0[] = ",10";
14822     char lines_1[] = ",20";
14823     char lines_2[] = ",";
14824     char *lines[] = {
14825       lines_0,
14826       lines_1,
14827       lines_2,
14828       NULL
14829     };
14830     int r;
14831     suppress_error = 0;
14832     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14833     if (r == -1)
14834       return -1;
14835   }
14836   {
14837     char device[] = "/dev/sda1";
14838     int r;
14839     suppress_error = 0;
14840     r = guestfs_pvcreate (g, device);
14841     if (r == -1)
14842       return -1;
14843   }
14844   {
14845     char device[] = "/dev/sda2";
14846     int r;
14847     suppress_error = 0;
14848     r = guestfs_pvcreate (g, device);
14849     if (r == -1)
14850       return -1;
14851   }
14852   {
14853     char device[] = "/dev/sda3";
14854     int r;
14855     suppress_error = 0;
14856     r = guestfs_pvcreate (g, device);
14857     if (r == -1)
14858       return -1;
14859   }
14860   {
14861     char volgroup[] = "VG1";
14862     char physvols_0[] = "/dev/sda1";
14863     char physvols_1[] = "/dev/sda2";
14864     char *physvols[] = {
14865       physvols_0,
14866       physvols_1,
14867       NULL
14868     };
14869     int r;
14870     suppress_error = 0;
14871     r = guestfs_vgcreate (g, volgroup, physvols);
14872     if (r == -1)
14873       return -1;
14874   }
14875   {
14876     char volgroup[] = "VG2";
14877     char physvols_0[] = "/dev/sda3";
14878     char *physvols[] = {
14879       physvols_0,
14880       NULL
14881     };
14882     int r;
14883     suppress_error = 0;
14884     r = guestfs_vgcreate (g, volgroup, physvols);
14885     if (r == -1)
14886       return -1;
14887   }
14888   {
14889     char logvol[] = "LV1";
14890     char volgroup[] = "VG1";
14891     int r;
14892     suppress_error = 0;
14893     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14894     if (r == -1)
14895       return -1;
14896   }
14897   {
14898     char logvol[] = "LV2";
14899     char volgroup[] = "VG1";
14900     int r;
14901     suppress_error = 0;
14902     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14903     if (r == -1)
14904       return -1;
14905   }
14906   {
14907     char logvol[] = "LV3";
14908     char volgroup[] = "VG2";
14909     int r;
14910     suppress_error = 0;
14911     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14912     if (r == -1)
14913       return -1;
14914   }
14915   {
14916     char **r;
14917     int i;
14918     suppress_error = 0;
14919     r = guestfs_lvs (g);
14920     if (r == NULL)
14921       return -1;
14922     if (!r[0]) {
14923       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14924       print_strings (r);
14925       return -1;
14926     }
14927     {
14928       char expected[] = "/dev/VG1/LV1";
14929       if (strcmp (r[0], expected) != 0) {
14930         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14931         return -1;
14932       }
14933     }
14934     if (!r[1]) {
14935       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14936       print_strings (r);
14937       return -1;
14938     }
14939     {
14940       char expected[] = "/dev/VG1/LV2";
14941       if (strcmp (r[1], expected) != 0) {
14942         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14943         return -1;
14944       }
14945     }
14946     if (!r[2]) {
14947       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14948       print_strings (r);
14949       return -1;
14950     }
14951     {
14952       char expected[] = "/dev/VG2/LV3";
14953       if (strcmp (r[2], expected) != 0) {
14954         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14955         return -1;
14956       }
14957     }
14958     if (r[3] != NULL) {
14959       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14960       print_strings (r);
14961       return -1;
14962     }
14963     for (i = 0; r[i] != NULL; ++i)
14964       free (r[i]);
14965     free (r);
14966   }
14967   return 0;
14968 }
14969
14970 static int test_vgs_0_skip (void)
14971 {
14972   const char *str;
14973
14974   str = getenv ("SKIP_TEST_VGS_0");
14975   if (str && strcmp (str, "1") == 0) return 1;
14976   str = getenv ("SKIP_TEST_VGS");
14977   if (str && strcmp (str, "1") == 0) return 1;
14978   return 0;
14979 }
14980
14981 static int test_vgs_0 (void)
14982 {
14983   if (test_vgs_0_skip ()) {
14984     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14985     return 0;
14986   }
14987
14988   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14989   {
14990     char device[] = "/dev/sda";
14991     int r;
14992     suppress_error = 0;
14993     r = guestfs_blockdev_setrw (g, device);
14994     if (r == -1)
14995       return -1;
14996   }
14997   {
14998     int r;
14999     suppress_error = 0;
15000     r = guestfs_umount_all (g);
15001     if (r == -1)
15002       return -1;
15003   }
15004   {
15005     int r;
15006     suppress_error = 0;
15007     r = guestfs_lvm_remove_all (g);
15008     if (r == -1)
15009       return -1;
15010   }
15011   {
15012     char device[] = "/dev/sda";
15013     char lines_0[] = ",";
15014     char *lines[] = {
15015       lines_0,
15016       NULL
15017     };
15018     int r;
15019     suppress_error = 0;
15020     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15021     if (r == -1)
15022       return -1;
15023   }
15024   {
15025     char device[] = "/dev/sda1";
15026     int r;
15027     suppress_error = 0;
15028     r = guestfs_pvcreate (g, device);
15029     if (r == -1)
15030       return -1;
15031   }
15032   {
15033     char volgroup[] = "VG";
15034     char physvols_0[] = "/dev/sda1";
15035     char *physvols[] = {
15036       physvols_0,
15037       NULL
15038     };
15039     int r;
15040     suppress_error = 0;
15041     r = guestfs_vgcreate (g, volgroup, physvols);
15042     if (r == -1)
15043       return -1;
15044   }
15045   {
15046     char logvol[] = "LV";
15047     char volgroup[] = "VG";
15048     int r;
15049     suppress_error = 0;
15050     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15051     if (r == -1)
15052       return -1;
15053   }
15054   {
15055     char fstype[] = "ext2";
15056     char device[] = "/dev/VG/LV";
15057     int r;
15058     suppress_error = 0;
15059     r = guestfs_mkfs (g, fstype, device);
15060     if (r == -1)
15061       return -1;
15062   }
15063   {
15064     char device[] = "/dev/VG/LV";
15065     char mountpoint[] = "/";
15066     int r;
15067     suppress_error = 0;
15068     r = guestfs_mount (g, device, mountpoint);
15069     if (r == -1)
15070       return -1;
15071   }
15072   /* TestOutputList for vgs (0) */
15073   {
15074     char **r;
15075     int i;
15076     suppress_error = 0;
15077     r = guestfs_vgs (g);
15078     if (r == NULL)
15079       return -1;
15080     if (!r[0]) {
15081       fprintf (stderr, "test_vgs_0: short list returned from command\n");
15082       print_strings (r);
15083       return -1;
15084     }
15085     {
15086       char expected[] = "VG";
15087       if (strcmp (r[0], expected) != 0) {
15088         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15089         return -1;
15090       }
15091     }
15092     if (r[1] != NULL) {
15093       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
15094       print_strings (r);
15095       return -1;
15096     }
15097     for (i = 0; r[i] != NULL; ++i)
15098       free (r[i]);
15099     free (r);
15100   }
15101   return 0;
15102 }
15103
15104 static int test_vgs_1_skip (void)
15105 {
15106   const char *str;
15107
15108   str = getenv ("SKIP_TEST_VGS_1");
15109   if (str && strcmp (str, "1") == 0) return 1;
15110   str = getenv ("SKIP_TEST_VGS");
15111   if (str && strcmp (str, "1") == 0) return 1;
15112   return 0;
15113 }
15114
15115 static int test_vgs_1 (void)
15116 {
15117   if (test_vgs_1_skip ()) {
15118     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
15119     return 0;
15120   }
15121
15122   /* InitNone|InitEmpty for test_vgs_1 */
15123   {
15124     char device[] = "/dev/sda";
15125     int r;
15126     suppress_error = 0;
15127     r = guestfs_blockdev_setrw (g, device);
15128     if (r == -1)
15129       return -1;
15130   }
15131   {
15132     int r;
15133     suppress_error = 0;
15134     r = guestfs_umount_all (g);
15135     if (r == -1)
15136       return -1;
15137   }
15138   {
15139     int r;
15140     suppress_error = 0;
15141     r = guestfs_lvm_remove_all (g);
15142     if (r == -1)
15143       return -1;
15144   }
15145   /* TestOutputList for vgs (1) */
15146   {
15147     char device[] = "/dev/sda";
15148     char lines_0[] = ",10";
15149     char lines_1[] = ",20";
15150     char lines_2[] = ",";
15151     char *lines[] = {
15152       lines_0,
15153       lines_1,
15154       lines_2,
15155       NULL
15156     };
15157     int r;
15158     suppress_error = 0;
15159     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15160     if (r == -1)
15161       return -1;
15162   }
15163   {
15164     char device[] = "/dev/sda1";
15165     int r;
15166     suppress_error = 0;
15167     r = guestfs_pvcreate (g, device);
15168     if (r == -1)
15169       return -1;
15170   }
15171   {
15172     char device[] = "/dev/sda2";
15173     int r;
15174     suppress_error = 0;
15175     r = guestfs_pvcreate (g, device);
15176     if (r == -1)
15177       return -1;
15178   }
15179   {
15180     char device[] = "/dev/sda3";
15181     int r;
15182     suppress_error = 0;
15183     r = guestfs_pvcreate (g, device);
15184     if (r == -1)
15185       return -1;
15186   }
15187   {
15188     char volgroup[] = "VG1";
15189     char physvols_0[] = "/dev/sda1";
15190     char physvols_1[] = "/dev/sda2";
15191     char *physvols[] = {
15192       physvols_0,
15193       physvols_1,
15194       NULL
15195     };
15196     int r;
15197     suppress_error = 0;
15198     r = guestfs_vgcreate (g, volgroup, physvols);
15199     if (r == -1)
15200       return -1;
15201   }
15202   {
15203     char volgroup[] = "VG2";
15204     char physvols_0[] = "/dev/sda3";
15205     char *physvols[] = {
15206       physvols_0,
15207       NULL
15208     };
15209     int r;
15210     suppress_error = 0;
15211     r = guestfs_vgcreate (g, volgroup, physvols);
15212     if (r == -1)
15213       return -1;
15214   }
15215   {
15216     char **r;
15217     int i;
15218     suppress_error = 0;
15219     r = guestfs_vgs (g);
15220     if (r == NULL)
15221       return -1;
15222     if (!r[0]) {
15223       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15224       print_strings (r);
15225       return -1;
15226     }
15227     {
15228       char expected[] = "VG1";
15229       if (strcmp (r[0], expected) != 0) {
15230         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15231         return -1;
15232       }
15233     }
15234     if (!r[1]) {
15235       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15236       print_strings (r);
15237       return -1;
15238     }
15239     {
15240       char expected[] = "VG2";
15241       if (strcmp (r[1], expected) != 0) {
15242         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15243         return -1;
15244       }
15245     }
15246     if (r[2] != NULL) {
15247       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15248       print_strings (r);
15249       return -1;
15250     }
15251     for (i = 0; r[i] != NULL; ++i)
15252       free (r[i]);
15253     free (r);
15254   }
15255   return 0;
15256 }
15257
15258 static int test_pvs_0_skip (void)
15259 {
15260   const char *str;
15261
15262   str = getenv ("SKIP_TEST_PVS_0");
15263   if (str && strcmp (str, "1") == 0) return 1;
15264   str = getenv ("SKIP_TEST_PVS");
15265   if (str && strcmp (str, "1") == 0) return 1;
15266   return 0;
15267 }
15268
15269 static int test_pvs_0 (void)
15270 {
15271   if (test_pvs_0_skip ()) {
15272     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
15273     return 0;
15274   }
15275
15276   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
15277   {
15278     char device[] = "/dev/sda";
15279     int r;
15280     suppress_error = 0;
15281     r = guestfs_blockdev_setrw (g, device);
15282     if (r == -1)
15283       return -1;
15284   }
15285   {
15286     int r;
15287     suppress_error = 0;
15288     r = guestfs_umount_all (g);
15289     if (r == -1)
15290       return -1;
15291   }
15292   {
15293     int r;
15294     suppress_error = 0;
15295     r = guestfs_lvm_remove_all (g);
15296     if (r == -1)
15297       return -1;
15298   }
15299   {
15300     char device[] = "/dev/sda";
15301     char lines_0[] = ",";
15302     char *lines[] = {
15303       lines_0,
15304       NULL
15305     };
15306     int r;
15307     suppress_error = 0;
15308     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15309     if (r == -1)
15310       return -1;
15311   }
15312   {
15313     char device[] = "/dev/sda1";
15314     int r;
15315     suppress_error = 0;
15316     r = guestfs_pvcreate (g, device);
15317     if (r == -1)
15318       return -1;
15319   }
15320   {
15321     char volgroup[] = "VG";
15322     char physvols_0[] = "/dev/sda1";
15323     char *physvols[] = {
15324       physvols_0,
15325       NULL
15326     };
15327     int r;
15328     suppress_error = 0;
15329     r = guestfs_vgcreate (g, volgroup, physvols);
15330     if (r == -1)
15331       return -1;
15332   }
15333   {
15334     char logvol[] = "LV";
15335     char volgroup[] = "VG";
15336     int r;
15337     suppress_error = 0;
15338     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15339     if (r == -1)
15340       return -1;
15341   }
15342   {
15343     char fstype[] = "ext2";
15344     char device[] = "/dev/VG/LV";
15345     int r;
15346     suppress_error = 0;
15347     r = guestfs_mkfs (g, fstype, device);
15348     if (r == -1)
15349       return -1;
15350   }
15351   {
15352     char device[] = "/dev/VG/LV";
15353     char mountpoint[] = "/";
15354     int r;
15355     suppress_error = 0;
15356     r = guestfs_mount (g, device, mountpoint);
15357     if (r == -1)
15358       return -1;
15359   }
15360   /* TestOutputListOfDevices for pvs (0) */
15361   {
15362     char **r;
15363     int i;
15364     suppress_error = 0;
15365     r = guestfs_pvs (g);
15366     if (r == NULL)
15367       return -1;
15368     if (!r[0]) {
15369       fprintf (stderr, "test_pvs_0: short list returned from command\n");
15370       print_strings (r);
15371       return -1;
15372     }
15373     {
15374       char expected[] = "/dev/sda1";
15375       r[0][5] = 's';
15376       if (strcmp (r[0], expected) != 0) {
15377         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15378         return -1;
15379       }
15380     }
15381     if (r[1] != NULL) {
15382       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15383       print_strings (r);
15384       return -1;
15385     }
15386     for (i = 0; r[i] != NULL; ++i)
15387       free (r[i]);
15388     free (r);
15389   }
15390   return 0;
15391 }
15392
15393 static int test_pvs_1_skip (void)
15394 {
15395   const char *str;
15396
15397   str = getenv ("SKIP_TEST_PVS_1");
15398   if (str && strcmp (str, "1") == 0) return 1;
15399   str = getenv ("SKIP_TEST_PVS");
15400   if (str && strcmp (str, "1") == 0) return 1;
15401   return 0;
15402 }
15403
15404 static int test_pvs_1 (void)
15405 {
15406   if (test_pvs_1_skip ()) {
15407     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15408     return 0;
15409   }
15410
15411   /* InitNone|InitEmpty for test_pvs_1 */
15412   {
15413     char device[] = "/dev/sda";
15414     int r;
15415     suppress_error = 0;
15416     r = guestfs_blockdev_setrw (g, device);
15417     if (r == -1)
15418       return -1;
15419   }
15420   {
15421     int r;
15422     suppress_error = 0;
15423     r = guestfs_umount_all (g);
15424     if (r == -1)
15425       return -1;
15426   }
15427   {
15428     int r;
15429     suppress_error = 0;
15430     r = guestfs_lvm_remove_all (g);
15431     if (r == -1)
15432       return -1;
15433   }
15434   /* TestOutputListOfDevices for pvs (1) */
15435   {
15436     char device[] = "/dev/sda";
15437     char lines_0[] = ",10";
15438     char lines_1[] = ",20";
15439     char lines_2[] = ",";
15440     char *lines[] = {
15441       lines_0,
15442       lines_1,
15443       lines_2,
15444       NULL
15445     };
15446     int r;
15447     suppress_error = 0;
15448     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15449     if (r == -1)
15450       return -1;
15451   }
15452   {
15453     char device[] = "/dev/sda1";
15454     int r;
15455     suppress_error = 0;
15456     r = guestfs_pvcreate (g, device);
15457     if (r == -1)
15458       return -1;
15459   }
15460   {
15461     char device[] = "/dev/sda2";
15462     int r;
15463     suppress_error = 0;
15464     r = guestfs_pvcreate (g, device);
15465     if (r == -1)
15466       return -1;
15467   }
15468   {
15469     char device[] = "/dev/sda3";
15470     int r;
15471     suppress_error = 0;
15472     r = guestfs_pvcreate (g, device);
15473     if (r == -1)
15474       return -1;
15475   }
15476   {
15477     char **r;
15478     int i;
15479     suppress_error = 0;
15480     r = guestfs_pvs (g);
15481     if (r == NULL)
15482       return -1;
15483     if (!r[0]) {
15484       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15485       print_strings (r);
15486       return -1;
15487     }
15488     {
15489       char expected[] = "/dev/sda1";
15490       r[0][5] = 's';
15491       if (strcmp (r[0], expected) != 0) {
15492         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15493         return -1;
15494       }
15495     }
15496     if (!r[1]) {
15497       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15498       print_strings (r);
15499       return -1;
15500     }
15501     {
15502       char expected[] = "/dev/sda2";
15503       r[1][5] = 's';
15504       if (strcmp (r[1], expected) != 0) {
15505         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15506         return -1;
15507       }
15508     }
15509     if (!r[2]) {
15510       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15511       print_strings (r);
15512       return -1;
15513     }
15514     {
15515       char expected[] = "/dev/sda3";
15516       r[2][5] = 's';
15517       if (strcmp (r[2], expected) != 0) {
15518         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15519         return -1;
15520       }
15521     }
15522     if (r[3] != NULL) {
15523       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15524       print_strings (r);
15525       return -1;
15526     }
15527     for (i = 0; r[i] != NULL; ++i)
15528       free (r[i]);
15529     free (r);
15530   }
15531   return 0;
15532 }
15533
15534 static int test_list_partitions_0_skip (void)
15535 {
15536   const char *str;
15537
15538   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15539   if (str && strcmp (str, "1") == 0) return 1;
15540   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15541   if (str && strcmp (str, "1") == 0) return 1;
15542   return 0;
15543 }
15544
15545 static int test_list_partitions_0 (void)
15546 {
15547   if (test_list_partitions_0_skip ()) {
15548     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15549     return 0;
15550   }
15551
15552   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15553   {
15554     char device[] = "/dev/sda";
15555     int r;
15556     suppress_error = 0;
15557     r = guestfs_blockdev_setrw (g, device);
15558     if (r == -1)
15559       return -1;
15560   }
15561   {
15562     int r;
15563     suppress_error = 0;
15564     r = guestfs_umount_all (g);
15565     if (r == -1)
15566       return -1;
15567   }
15568   {
15569     int r;
15570     suppress_error = 0;
15571     r = guestfs_lvm_remove_all (g);
15572     if (r == -1)
15573       return -1;
15574   }
15575   {
15576     char device[] = "/dev/sda";
15577     char lines_0[] = ",";
15578     char *lines[] = {
15579       lines_0,
15580       NULL
15581     };
15582     int r;
15583     suppress_error = 0;
15584     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15585     if (r == -1)
15586       return -1;
15587   }
15588   {
15589     char fstype[] = "ext2";
15590     char device[] = "/dev/sda1";
15591     int r;
15592     suppress_error = 0;
15593     r = guestfs_mkfs (g, fstype, device);
15594     if (r == -1)
15595       return -1;
15596   }
15597   {
15598     char device[] = "/dev/sda1";
15599     char mountpoint[] = "/";
15600     int r;
15601     suppress_error = 0;
15602     r = guestfs_mount (g, device, mountpoint);
15603     if (r == -1)
15604       return -1;
15605   }
15606   /* TestOutputListOfDevices for list_partitions (0) */
15607   {
15608     char **r;
15609     int i;
15610     suppress_error = 0;
15611     r = guestfs_list_partitions (g);
15612     if (r == NULL)
15613       return -1;
15614     if (!r[0]) {
15615       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15616       print_strings (r);
15617       return -1;
15618     }
15619     {
15620       char expected[] = "/dev/sda1";
15621       r[0][5] = 's';
15622       if (strcmp (r[0], expected) != 0) {
15623         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15624         return -1;
15625       }
15626     }
15627     if (r[1] != NULL) {
15628       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15629       print_strings (r);
15630       return -1;
15631     }
15632     for (i = 0; r[i] != NULL; ++i)
15633       free (r[i]);
15634     free (r);
15635   }
15636   return 0;
15637 }
15638
15639 static int test_list_partitions_1_skip (void)
15640 {
15641   const char *str;
15642
15643   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15644   if (str && strcmp (str, "1") == 0) return 1;
15645   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15646   if (str && strcmp (str, "1") == 0) return 1;
15647   return 0;
15648 }
15649
15650 static int test_list_partitions_1 (void)
15651 {
15652   if (test_list_partitions_1_skip ()) {
15653     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15654     return 0;
15655   }
15656
15657   /* InitNone|InitEmpty for test_list_partitions_1 */
15658   {
15659     char device[] = "/dev/sda";
15660     int r;
15661     suppress_error = 0;
15662     r = guestfs_blockdev_setrw (g, device);
15663     if (r == -1)
15664       return -1;
15665   }
15666   {
15667     int r;
15668     suppress_error = 0;
15669     r = guestfs_umount_all (g);
15670     if (r == -1)
15671       return -1;
15672   }
15673   {
15674     int r;
15675     suppress_error = 0;
15676     r = guestfs_lvm_remove_all (g);
15677     if (r == -1)
15678       return -1;
15679   }
15680   /* TestOutputListOfDevices for list_partitions (1) */
15681   {
15682     char device[] = "/dev/sda";
15683     char lines_0[] = ",10";
15684     char lines_1[] = ",20";
15685     char lines_2[] = ",";
15686     char *lines[] = {
15687       lines_0,
15688       lines_1,
15689       lines_2,
15690       NULL
15691     };
15692     int r;
15693     suppress_error = 0;
15694     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15695     if (r == -1)
15696       return -1;
15697   }
15698   {
15699     char **r;
15700     int i;
15701     suppress_error = 0;
15702     r = guestfs_list_partitions (g);
15703     if (r == NULL)
15704       return -1;
15705     if (!r[0]) {
15706       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15707       print_strings (r);
15708       return -1;
15709     }
15710     {
15711       char expected[] = "/dev/sda1";
15712       r[0][5] = 's';
15713       if (strcmp (r[0], expected) != 0) {
15714         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15715         return -1;
15716       }
15717     }
15718     if (!r[1]) {
15719       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15720       print_strings (r);
15721       return -1;
15722     }
15723     {
15724       char expected[] = "/dev/sda2";
15725       r[1][5] = 's';
15726       if (strcmp (r[1], expected) != 0) {
15727         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15728         return -1;
15729       }
15730     }
15731     if (!r[2]) {
15732       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15733       print_strings (r);
15734       return -1;
15735     }
15736     {
15737       char expected[] = "/dev/sda3";
15738       r[2][5] = 's';
15739       if (strcmp (r[2], expected) != 0) {
15740         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15741         return -1;
15742       }
15743     }
15744     if (r[3] != NULL) {
15745       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15746       print_strings (r);
15747       return -1;
15748     }
15749     for (i = 0; r[i] != NULL; ++i)
15750       free (r[i]);
15751     free (r);
15752   }
15753   return 0;
15754 }
15755
15756 static int test_list_devices_0_skip (void)
15757 {
15758   const char *str;
15759
15760   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15761   if (str && strcmp (str, "1") == 0) return 1;
15762   str = getenv ("SKIP_TEST_LIST_DEVICES");
15763   if (str && strcmp (str, "1") == 0) return 1;
15764   return 0;
15765 }
15766
15767 static int test_list_devices_0 (void)
15768 {
15769   if (test_list_devices_0_skip ()) {
15770     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15771     return 0;
15772   }
15773
15774   /* InitNone|InitEmpty for test_list_devices_0 */
15775   {
15776     char device[] = "/dev/sda";
15777     int r;
15778     suppress_error = 0;
15779     r = guestfs_blockdev_setrw (g, device);
15780     if (r == -1)
15781       return -1;
15782   }
15783   {
15784     int r;
15785     suppress_error = 0;
15786     r = guestfs_umount_all (g);
15787     if (r == -1)
15788       return -1;
15789   }
15790   {
15791     int r;
15792     suppress_error = 0;
15793     r = guestfs_lvm_remove_all (g);
15794     if (r == -1)
15795       return -1;
15796   }
15797   /* TestOutputListOfDevices for list_devices (0) */
15798   {
15799     char **r;
15800     int i;
15801     suppress_error = 0;
15802     r = guestfs_list_devices (g);
15803     if (r == NULL)
15804       return -1;
15805     if (!r[0]) {
15806       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15807       print_strings (r);
15808       return -1;
15809     }
15810     {
15811       char expected[] = "/dev/sda";
15812       r[0][5] = 's';
15813       if (strcmp (r[0], expected) != 0) {
15814         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15815         return -1;
15816       }
15817     }
15818     if (!r[1]) {
15819       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15820       print_strings (r);
15821       return -1;
15822     }
15823     {
15824       char expected[] = "/dev/sdb";
15825       r[1][5] = 's';
15826       if (strcmp (r[1], expected) != 0) {
15827         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15828         return -1;
15829       }
15830     }
15831     if (!r[2]) {
15832       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15833       print_strings (r);
15834       return -1;
15835     }
15836     {
15837       char expected[] = "/dev/sdc";
15838       r[2][5] = 's';
15839       if (strcmp (r[2], expected) != 0) {
15840         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15841         return -1;
15842       }
15843     }
15844     if (!r[3]) {
15845       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15846       print_strings (r);
15847       return -1;
15848     }
15849     {
15850       char expected[] = "/dev/sdd";
15851       r[3][5] = 's';
15852       if (strcmp (r[3], expected) != 0) {
15853         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15854         return -1;
15855       }
15856     }
15857     if (r[4] != NULL) {
15858       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15859       print_strings (r);
15860       return -1;
15861     }
15862     for (i = 0; r[i] != NULL; ++i)
15863       free (r[i]);
15864     free (r);
15865   }
15866   return 0;
15867 }
15868
15869 static int test_ls_0_skip (void)
15870 {
15871   const char *str;
15872
15873   str = getenv ("SKIP_TEST_LS_0");
15874   if (str && strcmp (str, "1") == 0) return 1;
15875   str = getenv ("SKIP_TEST_LS");
15876   if (str && strcmp (str, "1") == 0) return 1;
15877   return 0;
15878 }
15879
15880 static int test_ls_0 (void)
15881 {
15882   if (test_ls_0_skip ()) {
15883     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15884     return 0;
15885   }
15886
15887   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15888   {
15889     char device[] = "/dev/sda";
15890     int r;
15891     suppress_error = 0;
15892     r = guestfs_blockdev_setrw (g, device);
15893     if (r == -1)
15894       return -1;
15895   }
15896   {
15897     int r;
15898     suppress_error = 0;
15899     r = guestfs_umount_all (g);
15900     if (r == -1)
15901       return -1;
15902   }
15903   {
15904     int r;
15905     suppress_error = 0;
15906     r = guestfs_lvm_remove_all (g);
15907     if (r == -1)
15908       return -1;
15909   }
15910   {
15911     char device[] = "/dev/sda";
15912     char lines_0[] = ",";
15913     char *lines[] = {
15914       lines_0,
15915       NULL
15916     };
15917     int r;
15918     suppress_error = 0;
15919     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15920     if (r == -1)
15921       return -1;
15922   }
15923   {
15924     char fstype[] = "ext2";
15925     char device[] = "/dev/sda1";
15926     int r;
15927     suppress_error = 0;
15928     r = guestfs_mkfs (g, fstype, device);
15929     if (r == -1)
15930       return -1;
15931   }
15932   {
15933     char device[] = "/dev/sda1";
15934     char mountpoint[] = "/";
15935     int r;
15936     suppress_error = 0;
15937     r = guestfs_mount (g, device, mountpoint);
15938     if (r == -1)
15939       return -1;
15940   }
15941   /* TestOutputList for ls (0) */
15942   {
15943     char path[] = "/new";
15944     int r;
15945     suppress_error = 0;
15946     r = guestfs_touch (g, path);
15947     if (r == -1)
15948       return -1;
15949   }
15950   {
15951     char path[] = "/newer";
15952     int r;
15953     suppress_error = 0;
15954     r = guestfs_touch (g, path);
15955     if (r == -1)
15956       return -1;
15957   }
15958   {
15959     char path[] = "/newest";
15960     int r;
15961     suppress_error = 0;
15962     r = guestfs_touch (g, path);
15963     if (r == -1)
15964       return -1;
15965   }
15966   {
15967     char directory[] = "/";
15968     char **r;
15969     int i;
15970     suppress_error = 0;
15971     r = guestfs_ls (g, directory);
15972     if (r == NULL)
15973       return -1;
15974     if (!r[0]) {
15975       fprintf (stderr, "test_ls_0: short list returned from command\n");
15976       print_strings (r);
15977       return -1;
15978     }
15979     {
15980       char expected[] = "lost+found";
15981       if (strcmp (r[0], expected) != 0) {
15982         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15983         return -1;
15984       }
15985     }
15986     if (!r[1]) {
15987       fprintf (stderr, "test_ls_0: short list returned from command\n");
15988       print_strings (r);
15989       return -1;
15990     }
15991     {
15992       char expected[] = "new";
15993       if (strcmp (r[1], expected) != 0) {
15994         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15995         return -1;
15996       }
15997     }
15998     if (!r[2]) {
15999       fprintf (stderr, "test_ls_0: short list returned from command\n");
16000       print_strings (r);
16001       return -1;
16002     }
16003     {
16004       char expected[] = "newer";
16005       if (strcmp (r[2], expected) != 0) {
16006         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16007         return -1;
16008       }
16009     }
16010     if (!r[3]) {
16011       fprintf (stderr, "test_ls_0: short list returned from command\n");
16012       print_strings (r);
16013       return -1;
16014     }
16015     {
16016       char expected[] = "newest";
16017       if (strcmp (r[3], expected) != 0) {
16018         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
16019         return -1;
16020       }
16021     }
16022     if (r[4] != NULL) {
16023       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
16024       print_strings (r);
16025       return -1;
16026     }
16027     for (i = 0; r[i] != NULL; ++i)
16028       free (r[i]);
16029     free (r);
16030   }
16031   return 0;
16032 }
16033
16034 static int test_cat_0_skip (void)
16035 {
16036   const char *str;
16037
16038   str = getenv ("SKIP_TEST_CAT_0");
16039   if (str && strcmp (str, "1") == 0) return 1;
16040   str = getenv ("SKIP_TEST_CAT");
16041   if (str && strcmp (str, "1") == 0) return 1;
16042   return 0;
16043 }
16044
16045 static int test_cat_0 (void)
16046 {
16047   if (test_cat_0_skip ()) {
16048     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
16049     return 0;
16050   }
16051
16052   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
16053   {
16054     char device[] = "/dev/sda";
16055     int r;
16056     suppress_error = 0;
16057     r = guestfs_blockdev_setrw (g, device);
16058     if (r == -1)
16059       return -1;
16060   }
16061   {
16062     int r;
16063     suppress_error = 0;
16064     r = guestfs_umount_all (g);
16065     if (r == -1)
16066       return -1;
16067   }
16068   {
16069     int r;
16070     suppress_error = 0;
16071     r = guestfs_lvm_remove_all (g);
16072     if (r == -1)
16073       return -1;
16074   }
16075   {
16076     char device[] = "/dev/sda";
16077     char lines_0[] = ",";
16078     char *lines[] = {
16079       lines_0,
16080       NULL
16081     };
16082     int r;
16083     suppress_error = 0;
16084     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16085     if (r == -1)
16086       return -1;
16087   }
16088   {
16089     char fstype[] = "ext2";
16090     char device[] = "/dev/sda1";
16091     int r;
16092     suppress_error = 0;
16093     r = guestfs_mkfs (g, fstype, device);
16094     if (r == -1)
16095       return -1;
16096   }
16097   {
16098     char device[] = "/dev/sda1";
16099     char mountpoint[] = "/";
16100     int r;
16101     suppress_error = 0;
16102     r = guestfs_mount (g, device, mountpoint);
16103     if (r == -1)
16104       return -1;
16105   }
16106   /* TestOutput for cat (0) */
16107   char expected[] = "new file contents";
16108   {
16109     char path[] = "/new";
16110     char content[] = "new file contents";
16111     int r;
16112     suppress_error = 0;
16113     r = guestfs_write_file (g, path, content, 0);
16114     if (r == -1)
16115       return -1;
16116   }
16117   {
16118     char path[] = "/new";
16119     char *r;
16120     suppress_error = 0;
16121     r = guestfs_cat (g, path);
16122     if (r == NULL)
16123       return -1;
16124     if (strcmp (r, expected) != 0) {
16125       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
16126       return -1;
16127     }
16128     free (r);
16129   }
16130   return 0;
16131 }
16132
16133 static int test_touch_0_skip (void)
16134 {
16135   const char *str;
16136
16137   str = getenv ("SKIP_TEST_TOUCH_0");
16138   if (str && strcmp (str, "1") == 0) return 1;
16139   str = getenv ("SKIP_TEST_TOUCH");
16140   if (str && strcmp (str, "1") == 0) return 1;
16141   return 0;
16142 }
16143
16144 static int test_touch_0 (void)
16145 {
16146   if (test_touch_0_skip ()) {
16147     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
16148     return 0;
16149   }
16150
16151   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
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   {
16175     char device[] = "/dev/sda";
16176     char lines_0[] = ",";
16177     char *lines[] = {
16178       lines_0,
16179       NULL
16180     };
16181     int r;
16182     suppress_error = 0;
16183     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16184     if (r == -1)
16185       return -1;
16186   }
16187   {
16188     char fstype[] = "ext2";
16189     char device[] = "/dev/sda1";
16190     int r;
16191     suppress_error = 0;
16192     r = guestfs_mkfs (g, fstype, device);
16193     if (r == -1)
16194       return -1;
16195   }
16196   {
16197     char device[] = "/dev/sda1";
16198     char mountpoint[] = "/";
16199     int r;
16200     suppress_error = 0;
16201     r = guestfs_mount (g, device, mountpoint);
16202     if (r == -1)
16203       return -1;
16204   }
16205   /* TestOutputTrue for touch (0) */
16206   {
16207     char path[] = "/new";
16208     int r;
16209     suppress_error = 0;
16210     r = guestfs_touch (g, path);
16211     if (r == -1)
16212       return -1;
16213   }
16214   {
16215     char path[] = "/new";
16216     int r;
16217     suppress_error = 0;
16218     r = guestfs_exists (g, path);
16219     if (r == -1)
16220       return -1;
16221     if (!r) {
16222       fprintf (stderr, "test_touch_0: expected true, got false\n");
16223       return -1;
16224     }
16225   }
16226   return 0;
16227 }
16228
16229 static int test_sync_0_skip (void)
16230 {
16231   const char *str;
16232
16233   str = getenv ("SKIP_TEST_SYNC_0");
16234   if (str && strcmp (str, "1") == 0) return 1;
16235   str = getenv ("SKIP_TEST_SYNC");
16236   if (str && strcmp (str, "1") == 0) return 1;
16237   return 0;
16238 }
16239
16240 static int test_sync_0 (void)
16241 {
16242   if (test_sync_0_skip ()) {
16243     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
16244     return 0;
16245   }
16246
16247   /* InitNone|InitEmpty for test_sync_0 */
16248   {
16249     char device[] = "/dev/sda";
16250     int r;
16251     suppress_error = 0;
16252     r = guestfs_blockdev_setrw (g, device);
16253     if (r == -1)
16254       return -1;
16255   }
16256   {
16257     int r;
16258     suppress_error = 0;
16259     r = guestfs_umount_all (g);
16260     if (r == -1)
16261       return -1;
16262   }
16263   {
16264     int r;
16265     suppress_error = 0;
16266     r = guestfs_lvm_remove_all (g);
16267     if (r == -1)
16268       return -1;
16269   }
16270   /* TestRun for sync (0) */
16271   {
16272     int r;
16273     suppress_error = 0;
16274     r = guestfs_sync (g);
16275     if (r == -1)
16276       return -1;
16277   }
16278   return 0;
16279 }
16280
16281 static int test_mount_0_skip (void)
16282 {
16283   const char *str;
16284
16285   str = getenv ("SKIP_TEST_MOUNT_0");
16286   if (str && strcmp (str, "1") == 0) return 1;
16287   str = getenv ("SKIP_TEST_MOUNT");
16288   if (str && strcmp (str, "1") == 0) return 1;
16289   return 0;
16290 }
16291
16292 static int test_mount_0 (void)
16293 {
16294   if (test_mount_0_skip ()) {
16295     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
16296     return 0;
16297   }
16298
16299   /* InitNone|InitEmpty for test_mount_0 */
16300   {
16301     char device[] = "/dev/sda";
16302     int r;
16303     suppress_error = 0;
16304     r = guestfs_blockdev_setrw (g, device);
16305     if (r == -1)
16306       return -1;
16307   }
16308   {
16309     int r;
16310     suppress_error = 0;
16311     r = guestfs_umount_all (g);
16312     if (r == -1)
16313       return -1;
16314   }
16315   {
16316     int r;
16317     suppress_error = 0;
16318     r = guestfs_lvm_remove_all (g);
16319     if (r == -1)
16320       return -1;
16321   }
16322   /* TestOutput for mount (0) */
16323   char expected[] = "new file contents";
16324   {
16325     char device[] = "/dev/sda";
16326     char lines_0[] = ",";
16327     char *lines[] = {
16328       lines_0,
16329       NULL
16330     };
16331     int r;
16332     suppress_error = 0;
16333     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16334     if (r == -1)
16335       return -1;
16336   }
16337   {
16338     char fstype[] = "ext2";
16339     char device[] = "/dev/sda1";
16340     int r;
16341     suppress_error = 0;
16342     r = guestfs_mkfs (g, fstype, device);
16343     if (r == -1)
16344       return -1;
16345   }
16346   {
16347     char device[] = "/dev/sda1";
16348     char mountpoint[] = "/";
16349     int r;
16350     suppress_error = 0;
16351     r = guestfs_mount (g, device, mountpoint);
16352     if (r == -1)
16353       return -1;
16354   }
16355   {
16356     char path[] = "/new";
16357     char content[] = "new file contents";
16358     int r;
16359     suppress_error = 0;
16360     r = guestfs_write_file (g, path, content, 0);
16361     if (r == -1)
16362       return -1;
16363   }
16364   {
16365     char path[] = "/new";
16366     char *r;
16367     suppress_error = 0;
16368     r = guestfs_cat (g, path);
16369     if (r == NULL)
16370       return -1;
16371     if (strcmp (r, expected) != 0) {
16372       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16373       return -1;
16374     }
16375     free (r);
16376   }
16377   return 0;
16378 }
16379
16380 int main (int argc, char *argv[])
16381 {
16382   char c = 0;
16383   int failed = 0;
16384   const char *filename;
16385   int fd;
16386   int nr_tests, test_num = 0;
16387
16388   no_test_warnings ();
16389
16390   g = guestfs_create ();
16391   if (g == NULL) {
16392     printf ("guestfs_create FAILED\n");
16393     exit (1);
16394   }
16395
16396   guestfs_set_error_handler (g, print_error, NULL);
16397
16398   guestfs_set_path (g, "../appliance");
16399
16400   filename = "test1.img";
16401   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16402   if (fd == -1) {
16403     perror (filename);
16404     exit (1);
16405   }
16406   if (lseek (fd, 524288000, SEEK_SET) == -1) {
16407     perror ("lseek");
16408     close (fd);
16409     unlink (filename);
16410     exit (1);
16411   }
16412   if (write (fd, &c, 1) == -1) {
16413     perror ("write");
16414     close (fd);
16415     unlink (filename);
16416     exit (1);
16417   }
16418   if (close (fd) == -1) {
16419     perror (filename);
16420     unlink (filename);
16421     exit (1);
16422   }
16423   if (guestfs_add_drive (g, filename) == -1) {
16424     printf ("guestfs_add_drive %s FAILED\n", filename);
16425     exit (1);
16426   }
16427
16428   filename = "test2.img";
16429   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16430   if (fd == -1) {
16431     perror (filename);
16432     exit (1);
16433   }
16434   if (lseek (fd, 52428800, SEEK_SET) == -1) {
16435     perror ("lseek");
16436     close (fd);
16437     unlink (filename);
16438     exit (1);
16439   }
16440   if (write (fd, &c, 1) == -1) {
16441     perror ("write");
16442     close (fd);
16443     unlink (filename);
16444     exit (1);
16445   }
16446   if (close (fd) == -1) {
16447     perror (filename);
16448     unlink (filename);
16449     exit (1);
16450   }
16451   if (guestfs_add_drive (g, filename) == -1) {
16452     printf ("guestfs_add_drive %s FAILED\n", filename);
16453     exit (1);
16454   }
16455
16456   filename = "test3.img";
16457   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16458   if (fd == -1) {
16459     perror (filename);
16460     exit (1);
16461   }
16462   if (lseek (fd, 10485760, SEEK_SET) == -1) {
16463     perror ("lseek");
16464     close (fd);
16465     unlink (filename);
16466     exit (1);
16467   }
16468   if (write (fd, &c, 1) == -1) {
16469     perror ("write");
16470     close (fd);
16471     unlink (filename);
16472     exit (1);
16473   }
16474   if (close (fd) == -1) {
16475     perror (filename);
16476     unlink (filename);
16477     exit (1);
16478   }
16479   if (guestfs_add_drive (g, filename) == -1) {
16480     printf ("guestfs_add_drive %s FAILED\n", filename);
16481     exit (1);
16482   }
16483
16484   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16485     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16486     exit (1);
16487   }
16488
16489   if (guestfs_launch (g) == -1) {
16490     printf ("guestfs_launch FAILED\n");
16491     exit (1);
16492   }
16493
16494   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
16495   alarm (600);
16496
16497   if (guestfs_wait_ready (g) == -1) {
16498     printf ("guestfs_wait_ready FAILED\n");
16499     exit (1);
16500   }
16501
16502   /* Cancel previous alarm. */
16503   alarm (0);
16504
16505   nr_tests = 153;
16506
16507   test_num++;
16508   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
16509   if (test_mkdtemp_0 () == -1) {
16510     printf ("test_mkdtemp_0 FAILED\n");
16511     failed++;
16512   }
16513   test_num++;
16514   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
16515   if (test_scrub_file_0 () == -1) {
16516     printf ("test_scrub_file_0 FAILED\n");
16517     failed++;
16518   }
16519   test_num++;
16520   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
16521   if (test_scrub_device_0 () == -1) {
16522     printf ("test_scrub_device_0 FAILED\n");
16523     failed++;
16524   }
16525   test_num++;
16526   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
16527   if (test_glob_expand_0 () == -1) {
16528     printf ("test_glob_expand_0 FAILED\n");
16529     failed++;
16530   }
16531   test_num++;
16532   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
16533   if (test_glob_expand_1 () == -1) {
16534     printf ("test_glob_expand_1 FAILED\n");
16535     failed++;
16536   }
16537   test_num++;
16538   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
16539   if (test_glob_expand_2 () == -1) {
16540     printf ("test_glob_expand_2 FAILED\n");
16541     failed++;
16542   }
16543   test_num++;
16544   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
16545   if (test_ntfs_3g_probe_0 () == -1) {
16546     printf ("test_ntfs_3g_probe_0 FAILED\n");
16547     failed++;
16548   }
16549   test_num++;
16550   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
16551   if (test_ntfs_3g_probe_1 () == -1) {
16552     printf ("test_ntfs_3g_probe_1 FAILED\n");
16553     failed++;
16554   }
16555   test_num++;
16556   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16557   if (test_sleep_0 () == -1) {
16558     printf ("test_sleep_0 FAILED\n");
16559     failed++;
16560   }
16561   test_num++;
16562   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16563   if (test_find_0 () == -1) {
16564     printf ("test_find_0 FAILED\n");
16565     failed++;
16566   }
16567   test_num++;
16568   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16569   if (test_find_1 () == -1) {
16570     printf ("test_find_1 FAILED\n");
16571     failed++;
16572   }
16573   test_num++;
16574   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16575   if (test_find_2 () == -1) {
16576     printf ("test_find_2 FAILED\n");
16577     failed++;
16578   }
16579   test_num++;
16580   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16581   if (test_lvresize_0 () == -1) {
16582     printf ("test_lvresize_0 FAILED\n");
16583     failed++;
16584   }
16585   test_num++;
16586   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16587   if (test_zerofree_0 () == -1) {
16588     printf ("test_zerofree_0 FAILED\n");
16589     failed++;
16590   }
16591   test_num++;
16592   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16593   if (test_hexdump_0 () == -1) {
16594     printf ("test_hexdump_0 FAILED\n");
16595     failed++;
16596   }
16597   test_num++;
16598   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
16599   if (test_hexdump_1 () == -1) {
16600     printf ("test_hexdump_1 FAILED\n");
16601     failed++;
16602   }
16603   test_num++;
16604   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16605   if (test_strings_e_0 () == -1) {
16606     printf ("test_strings_e_0 FAILED\n");
16607     failed++;
16608   }
16609   test_num++;
16610   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16611   if (test_strings_e_1 () == -1) {
16612     printf ("test_strings_e_1 FAILED\n");
16613     failed++;
16614   }
16615   test_num++;
16616   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16617   if (test_strings_0 () == -1) {
16618     printf ("test_strings_0 FAILED\n");
16619     failed++;
16620   }
16621   test_num++;
16622   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16623   if (test_strings_1 () == -1) {
16624     printf ("test_strings_1 FAILED\n");
16625     failed++;
16626   }
16627   test_num++;
16628   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16629   if (test_equal_0 () == -1) {
16630     printf ("test_equal_0 FAILED\n");
16631     failed++;
16632   }
16633   test_num++;
16634   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16635   if (test_equal_1 () == -1) {
16636     printf ("test_equal_1 FAILED\n");
16637     failed++;
16638   }
16639   test_num++;
16640   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16641   if (test_equal_2 () == -1) {
16642     printf ("test_equal_2 FAILED\n");
16643     failed++;
16644   }
16645   test_num++;
16646   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16647   if (test_ping_daemon_0 () == -1) {
16648     printf ("test_ping_daemon_0 FAILED\n");
16649     failed++;
16650   }
16651   test_num++;
16652   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16653   if (test_dmesg_0 () == -1) {
16654     printf ("test_dmesg_0 FAILED\n");
16655     failed++;
16656   }
16657   test_num++;
16658   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16659   if (test_drop_caches_0 () == -1) {
16660     printf ("test_drop_caches_0 FAILED\n");
16661     failed++;
16662   }
16663   test_num++;
16664   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16665   if (test_mv_0 () == -1) {
16666     printf ("test_mv_0 FAILED\n");
16667     failed++;
16668   }
16669   test_num++;
16670   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16671   if (test_mv_1 () == -1) {
16672     printf ("test_mv_1 FAILED\n");
16673     failed++;
16674   }
16675   test_num++;
16676   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16677   if (test_cp_a_0 () == -1) {
16678     printf ("test_cp_a_0 FAILED\n");
16679     failed++;
16680   }
16681   test_num++;
16682   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16683   if (test_cp_0 () == -1) {
16684     printf ("test_cp_0 FAILED\n");
16685     failed++;
16686   }
16687   test_num++;
16688   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16689   if (test_cp_1 () == -1) {
16690     printf ("test_cp_1 FAILED\n");
16691     failed++;
16692   }
16693   test_num++;
16694   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16695   if (test_cp_2 () == -1) {
16696     printf ("test_cp_2 FAILED\n");
16697     failed++;
16698   }
16699   test_num++;
16700   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16701   if (test_grub_install_0 () == -1) {
16702     printf ("test_grub_install_0 FAILED\n");
16703     failed++;
16704   }
16705   test_num++;
16706   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16707   if (test_zero_0 () == -1) {
16708     printf ("test_zero_0 FAILED\n");
16709     failed++;
16710   }
16711   test_num++;
16712   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16713   if (test_fsck_0 () == -1) {
16714     printf ("test_fsck_0 FAILED\n");
16715     failed++;
16716   }
16717   test_num++;
16718   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16719   if (test_fsck_1 () == -1) {
16720     printf ("test_fsck_1 FAILED\n");
16721     failed++;
16722   }
16723   test_num++;
16724   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16725   if (test_set_e2uuid_0 () == -1) {
16726     printf ("test_set_e2uuid_0 FAILED\n");
16727     failed++;
16728   }
16729   test_num++;
16730   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16731   if (test_set_e2uuid_1 () == -1) {
16732     printf ("test_set_e2uuid_1 FAILED\n");
16733     failed++;
16734   }
16735   test_num++;
16736   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16737   if (test_set_e2uuid_2 () == -1) {
16738     printf ("test_set_e2uuid_2 FAILED\n");
16739     failed++;
16740   }
16741   test_num++;
16742   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16743   if (test_set_e2uuid_3 () == -1) {
16744     printf ("test_set_e2uuid_3 FAILED\n");
16745     failed++;
16746   }
16747   test_num++;
16748   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16749   if (test_set_e2label_0 () == -1) {
16750     printf ("test_set_e2label_0 FAILED\n");
16751     failed++;
16752   }
16753   test_num++;
16754   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16755   if (test_pvremove_0 () == -1) {
16756     printf ("test_pvremove_0 FAILED\n");
16757     failed++;
16758   }
16759   test_num++;
16760   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16761   if (test_pvremove_1 () == -1) {
16762     printf ("test_pvremove_1 FAILED\n");
16763     failed++;
16764   }
16765   test_num++;
16766   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16767   if (test_pvremove_2 () == -1) {
16768     printf ("test_pvremove_2 FAILED\n");
16769     failed++;
16770   }
16771   test_num++;
16772   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16773   if (test_vgremove_0 () == -1) {
16774     printf ("test_vgremove_0 FAILED\n");
16775     failed++;
16776   }
16777   test_num++;
16778   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16779   if (test_vgremove_1 () == -1) {
16780     printf ("test_vgremove_1 FAILED\n");
16781     failed++;
16782   }
16783   test_num++;
16784   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16785   if (test_lvremove_0 () == -1) {
16786     printf ("test_lvremove_0 FAILED\n");
16787     failed++;
16788   }
16789   test_num++;
16790   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16791   if (test_lvremove_1 () == -1) {
16792     printf ("test_lvremove_1 FAILED\n");
16793     failed++;
16794   }
16795   test_num++;
16796   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16797   if (test_lvremove_2 () == -1) {
16798     printf ("test_lvremove_2 FAILED\n");
16799     failed++;
16800   }
16801   test_num++;
16802   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16803   if (test_mount_ro_0 () == -1) {
16804     printf ("test_mount_ro_0 FAILED\n");
16805     failed++;
16806   }
16807   test_num++;
16808   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16809   if (test_mount_ro_1 () == -1) {
16810     printf ("test_mount_ro_1 FAILED\n");
16811     failed++;
16812   }
16813   test_num++;
16814   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16815   if (test_tgz_in_0 () == -1) {
16816     printf ("test_tgz_in_0 FAILED\n");
16817     failed++;
16818   }
16819   test_num++;
16820   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16821   if (test_tar_in_0 () == -1) {
16822     printf ("test_tar_in_0 FAILED\n");
16823     failed++;
16824   }
16825   test_num++;
16826   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16827   if (test_checksum_0 () == -1) {
16828     printf ("test_checksum_0 FAILED\n");
16829     failed++;
16830   }
16831   test_num++;
16832   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16833   if (test_checksum_1 () == -1) {
16834     printf ("test_checksum_1 FAILED\n");
16835     failed++;
16836   }
16837   test_num++;
16838   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16839   if (test_checksum_2 () == -1) {
16840     printf ("test_checksum_2 FAILED\n");
16841     failed++;
16842   }
16843   test_num++;
16844   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16845   if (test_checksum_3 () == -1) {
16846     printf ("test_checksum_3 FAILED\n");
16847     failed++;
16848   }
16849   test_num++;
16850   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16851   if (test_checksum_4 () == -1) {
16852     printf ("test_checksum_4 FAILED\n");
16853     failed++;
16854   }
16855   test_num++;
16856   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16857   if (test_checksum_5 () == -1) {
16858     printf ("test_checksum_5 FAILED\n");
16859     failed++;
16860   }
16861   test_num++;
16862   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16863   if (test_checksum_6 () == -1) {
16864     printf ("test_checksum_6 FAILED\n");
16865     failed++;
16866   }
16867   test_num++;
16868   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16869   if (test_checksum_7 () == -1) {
16870     printf ("test_checksum_7 FAILED\n");
16871     failed++;
16872   }
16873   test_num++;
16874   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16875   if (test_checksum_8 () == -1) {
16876     printf ("test_checksum_8 FAILED\n");
16877     failed++;
16878   }
16879   test_num++;
16880   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16881   if (test_download_0 () == -1) {
16882     printf ("test_download_0 FAILED\n");
16883     failed++;
16884   }
16885   test_num++;
16886   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16887   if (test_upload_0 () == -1) {
16888     printf ("test_upload_0 FAILED\n");
16889     failed++;
16890   }
16891   test_num++;
16892   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16893   if (test_blockdev_rereadpt_0 () == -1) {
16894     printf ("test_blockdev_rereadpt_0 FAILED\n");
16895     failed++;
16896   }
16897   test_num++;
16898   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16899   if (test_blockdev_flushbufs_0 () == -1) {
16900     printf ("test_blockdev_flushbufs_0 FAILED\n");
16901     failed++;
16902   }
16903   test_num++;
16904   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16905   if (test_blockdev_getsize64_0 () == -1) {
16906     printf ("test_blockdev_getsize64_0 FAILED\n");
16907     failed++;
16908   }
16909   test_num++;
16910   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16911   if (test_blockdev_getsz_0 () == -1) {
16912     printf ("test_blockdev_getsz_0 FAILED\n");
16913     failed++;
16914   }
16915   test_num++;
16916   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16917   if (test_blockdev_getbsz_0 () == -1) {
16918     printf ("test_blockdev_getbsz_0 FAILED\n");
16919     failed++;
16920   }
16921   test_num++;
16922   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16923   if (test_blockdev_getss_0 () == -1) {
16924     printf ("test_blockdev_getss_0 FAILED\n");
16925     failed++;
16926   }
16927   test_num++;
16928   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16929   if (test_blockdev_getro_0 () == -1) {
16930     printf ("test_blockdev_getro_0 FAILED\n");
16931     failed++;
16932   }
16933   test_num++;
16934   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16935   if (test_blockdev_setrw_0 () == -1) {
16936     printf ("test_blockdev_setrw_0 FAILED\n");
16937     failed++;
16938   }
16939   test_num++;
16940   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16941   if (test_blockdev_setro_0 () == -1) {
16942     printf ("test_blockdev_setro_0 FAILED\n");
16943     failed++;
16944   }
16945   test_num++;
16946   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16947   if (test_statvfs_0 () == -1) {
16948     printf ("test_statvfs_0 FAILED\n");
16949     failed++;
16950   }
16951   test_num++;
16952   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16953   if (test_lstat_0 () == -1) {
16954     printf ("test_lstat_0 FAILED\n");
16955     failed++;
16956   }
16957   test_num++;
16958   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16959   if (test_stat_0 () == -1) {
16960     printf ("test_stat_0 FAILED\n");
16961     failed++;
16962   }
16963   test_num++;
16964   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16965   if (test_command_lines_0 () == -1) {
16966     printf ("test_command_lines_0 FAILED\n");
16967     failed++;
16968   }
16969   test_num++;
16970   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16971   if (test_command_lines_1 () == -1) {
16972     printf ("test_command_lines_1 FAILED\n");
16973     failed++;
16974   }
16975   test_num++;
16976   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16977   if (test_command_lines_2 () == -1) {
16978     printf ("test_command_lines_2 FAILED\n");
16979     failed++;
16980   }
16981   test_num++;
16982   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16983   if (test_command_lines_3 () == -1) {
16984     printf ("test_command_lines_3 FAILED\n");
16985     failed++;
16986   }
16987   test_num++;
16988   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16989   if (test_command_lines_4 () == -1) {
16990     printf ("test_command_lines_4 FAILED\n");
16991     failed++;
16992   }
16993   test_num++;
16994   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16995   if (test_command_lines_5 () == -1) {
16996     printf ("test_command_lines_5 FAILED\n");
16997     failed++;
16998   }
16999   test_num++;
17000   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
17001   if (test_command_lines_6 () == -1) {
17002     printf ("test_command_lines_6 FAILED\n");
17003     failed++;
17004   }
17005   test_num++;
17006   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
17007   if (test_command_lines_7 () == -1) {
17008     printf ("test_command_lines_7 FAILED\n");
17009     failed++;
17010   }
17011   test_num++;
17012   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
17013   if (test_command_lines_8 () == -1) {
17014     printf ("test_command_lines_8 FAILED\n");
17015     failed++;
17016   }
17017   test_num++;
17018   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
17019   if (test_command_lines_9 () == -1) {
17020     printf ("test_command_lines_9 FAILED\n");
17021     failed++;
17022   }
17023   test_num++;
17024   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
17025   if (test_command_lines_10 () == -1) {
17026     printf ("test_command_lines_10 FAILED\n");
17027     failed++;
17028   }
17029   test_num++;
17030   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
17031   if (test_command_0 () == -1) {
17032     printf ("test_command_0 FAILED\n");
17033     failed++;
17034   }
17035   test_num++;
17036   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
17037   if (test_command_1 () == -1) {
17038     printf ("test_command_1 FAILED\n");
17039     failed++;
17040   }
17041   test_num++;
17042   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
17043   if (test_command_2 () == -1) {
17044     printf ("test_command_2 FAILED\n");
17045     failed++;
17046   }
17047   test_num++;
17048   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
17049   if (test_command_3 () == -1) {
17050     printf ("test_command_3 FAILED\n");
17051     failed++;
17052   }
17053   test_num++;
17054   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
17055   if (test_command_4 () == -1) {
17056     printf ("test_command_4 FAILED\n");
17057     failed++;
17058   }
17059   test_num++;
17060   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
17061   if (test_command_5 () == -1) {
17062     printf ("test_command_5 FAILED\n");
17063     failed++;
17064   }
17065   test_num++;
17066   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
17067   if (test_command_6 () == -1) {
17068     printf ("test_command_6 FAILED\n");
17069     failed++;
17070   }
17071   test_num++;
17072   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
17073   if (test_command_7 () == -1) {
17074     printf ("test_command_7 FAILED\n");
17075     failed++;
17076   }
17077   test_num++;
17078   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
17079   if (test_command_8 () == -1) {
17080     printf ("test_command_8 FAILED\n");
17081     failed++;
17082   }
17083   test_num++;
17084   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
17085   if (test_command_9 () == -1) {
17086     printf ("test_command_9 FAILED\n");
17087     failed++;
17088   }
17089   test_num++;
17090   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
17091   if (test_command_10 () == -1) {
17092     printf ("test_command_10 FAILED\n");
17093     failed++;
17094   }
17095   test_num++;
17096   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
17097   if (test_command_11 () == -1) {
17098     printf ("test_command_11 FAILED\n");
17099     failed++;
17100   }
17101   test_num++;
17102   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
17103   if (test_file_0 () == -1) {
17104     printf ("test_file_0 FAILED\n");
17105     failed++;
17106   }
17107   test_num++;
17108   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
17109   if (test_file_1 () == -1) {
17110     printf ("test_file_1 FAILED\n");
17111     failed++;
17112   }
17113   test_num++;
17114   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
17115   if (test_file_2 () == -1) {
17116     printf ("test_file_2 FAILED\n");
17117     failed++;
17118   }
17119   test_num++;
17120   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
17121   if (test_umount_all_0 () == -1) {
17122     printf ("test_umount_all_0 FAILED\n");
17123     failed++;
17124   }
17125   test_num++;
17126   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
17127   if (test_umount_all_1 () == -1) {
17128     printf ("test_umount_all_1 FAILED\n");
17129     failed++;
17130   }
17131   test_num++;
17132   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
17133   if (test_mounts_0 () == -1) {
17134     printf ("test_mounts_0 FAILED\n");
17135     failed++;
17136   }
17137   test_num++;
17138   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
17139   if (test_umount_0 () == -1) {
17140     printf ("test_umount_0 FAILED\n");
17141     failed++;
17142   }
17143   test_num++;
17144   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
17145   if (test_umount_1 () == -1) {
17146     printf ("test_umount_1 FAILED\n");
17147     failed++;
17148   }
17149   test_num++;
17150   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
17151   if (test_write_file_0 () == -1) {
17152     printf ("test_write_file_0 FAILED\n");
17153     failed++;
17154   }
17155   test_num++;
17156   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
17157   if (test_write_file_1 () == -1) {
17158     printf ("test_write_file_1 FAILED\n");
17159     failed++;
17160   }
17161   test_num++;
17162   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
17163   if (test_write_file_2 () == -1) {
17164     printf ("test_write_file_2 FAILED\n");
17165     failed++;
17166   }
17167   test_num++;
17168   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
17169   if (test_write_file_3 () == -1) {
17170     printf ("test_write_file_3 FAILED\n");
17171     failed++;
17172   }
17173   test_num++;
17174   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
17175   if (test_write_file_4 () == -1) {
17176     printf ("test_write_file_4 FAILED\n");
17177     failed++;
17178   }
17179   test_num++;
17180   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
17181   if (test_write_file_5 () == -1) {
17182     printf ("test_write_file_5 FAILED\n");
17183     failed++;
17184   }
17185   test_num++;
17186   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
17187   if (test_mkfs_0 () == -1) {
17188     printf ("test_mkfs_0 FAILED\n");
17189     failed++;
17190   }
17191   test_num++;
17192   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
17193   if (test_lvcreate_0 () == -1) {
17194     printf ("test_lvcreate_0 FAILED\n");
17195     failed++;
17196   }
17197   test_num++;
17198   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
17199   if (test_vgcreate_0 () == -1) {
17200     printf ("test_vgcreate_0 FAILED\n");
17201     failed++;
17202   }
17203   test_num++;
17204   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17205   if (test_pvcreate_0 () == -1) {
17206     printf ("test_pvcreate_0 FAILED\n");
17207     failed++;
17208   }
17209   test_num++;
17210   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17211   if (test_is_dir_0 () == -1) {
17212     printf ("test_is_dir_0 FAILED\n");
17213     failed++;
17214   }
17215   test_num++;
17216   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
17217   if (test_is_dir_1 () == -1) {
17218     printf ("test_is_dir_1 FAILED\n");
17219     failed++;
17220   }
17221   test_num++;
17222   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
17223   if (test_is_file_0 () == -1) {
17224     printf ("test_is_file_0 FAILED\n");
17225     failed++;
17226   }
17227   test_num++;
17228   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
17229   if (test_is_file_1 () == -1) {
17230     printf ("test_is_file_1 FAILED\n");
17231     failed++;
17232   }
17233   test_num++;
17234   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
17235   if (test_exists_0 () == -1) {
17236     printf ("test_exists_0 FAILED\n");
17237     failed++;
17238   }
17239   test_num++;
17240   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
17241   if (test_exists_1 () == -1) {
17242     printf ("test_exists_1 FAILED\n");
17243     failed++;
17244   }
17245   test_num++;
17246   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
17247   if (test_mkdir_p_0 () == -1) {
17248     printf ("test_mkdir_p_0 FAILED\n");
17249     failed++;
17250   }
17251   test_num++;
17252   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
17253   if (test_mkdir_p_1 () == -1) {
17254     printf ("test_mkdir_p_1 FAILED\n");
17255     failed++;
17256   }
17257   test_num++;
17258   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
17259   if (test_mkdir_p_2 () == -1) {
17260     printf ("test_mkdir_p_2 FAILED\n");
17261     failed++;
17262   }
17263   test_num++;
17264   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
17265   if (test_mkdir_p_3 () == -1) {
17266     printf ("test_mkdir_p_3 FAILED\n");
17267     failed++;
17268   }
17269   test_num++;
17270   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
17271   if (test_mkdir_p_4 () == -1) {
17272     printf ("test_mkdir_p_4 FAILED\n");
17273     failed++;
17274   }
17275   test_num++;
17276   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
17277   if (test_mkdir_0 () == -1) {
17278     printf ("test_mkdir_0 FAILED\n");
17279     failed++;
17280   }
17281   test_num++;
17282   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
17283   if (test_mkdir_1 () == -1) {
17284     printf ("test_mkdir_1 FAILED\n");
17285     failed++;
17286   }
17287   test_num++;
17288   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
17289   if (test_rm_rf_0 () == -1) {
17290     printf ("test_rm_rf_0 FAILED\n");
17291     failed++;
17292   }
17293   test_num++;
17294   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
17295   if (test_rmdir_0 () == -1) {
17296     printf ("test_rmdir_0 FAILED\n");
17297     failed++;
17298   }
17299   test_num++;
17300   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
17301   if (test_rmdir_1 () == -1) {
17302     printf ("test_rmdir_1 FAILED\n");
17303     failed++;
17304   }
17305   test_num++;
17306   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
17307   if (test_rmdir_2 () == -1) {
17308     printf ("test_rmdir_2 FAILED\n");
17309     failed++;
17310   }
17311   test_num++;
17312   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
17313   if (test_rm_0 () == -1) {
17314     printf ("test_rm_0 FAILED\n");
17315     failed++;
17316   }
17317   test_num++;
17318   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
17319   if (test_rm_1 () == -1) {
17320     printf ("test_rm_1 FAILED\n");
17321     failed++;
17322   }
17323   test_num++;
17324   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
17325   if (test_rm_2 () == -1) {
17326     printf ("test_rm_2 FAILED\n");
17327     failed++;
17328   }
17329   test_num++;
17330   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
17331   if (test_read_lines_0 () == -1) {
17332     printf ("test_read_lines_0 FAILED\n");
17333     failed++;
17334   }
17335   test_num++;
17336   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
17337   if (test_read_lines_1 () == -1) {
17338     printf ("test_read_lines_1 FAILED\n");
17339     failed++;
17340   }
17341   test_num++;
17342   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
17343   if (test_lvs_0 () == -1) {
17344     printf ("test_lvs_0 FAILED\n");
17345     failed++;
17346   }
17347   test_num++;
17348   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
17349   if (test_lvs_1 () == -1) {
17350     printf ("test_lvs_1 FAILED\n");
17351     failed++;
17352   }
17353   test_num++;
17354   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
17355   if (test_vgs_0 () == -1) {
17356     printf ("test_vgs_0 FAILED\n");
17357     failed++;
17358   }
17359   test_num++;
17360   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17361   if (test_vgs_1 () == -1) {
17362     printf ("test_vgs_1 FAILED\n");
17363     failed++;
17364   }
17365   test_num++;
17366   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17367   if (test_pvs_0 () == -1) {
17368     printf ("test_pvs_0 FAILED\n");
17369     failed++;
17370   }
17371   test_num++;
17372   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17373   if (test_pvs_1 () == -1) {
17374     printf ("test_pvs_1 FAILED\n");
17375     failed++;
17376   }
17377   test_num++;
17378   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17379   if (test_list_partitions_0 () == -1) {
17380     printf ("test_list_partitions_0 FAILED\n");
17381     failed++;
17382   }
17383   test_num++;
17384   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17385   if (test_list_partitions_1 () == -1) {
17386     printf ("test_list_partitions_1 FAILED\n");
17387     failed++;
17388   }
17389   test_num++;
17390   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17391   if (test_list_devices_0 () == -1) {
17392     printf ("test_list_devices_0 FAILED\n");
17393     failed++;
17394   }
17395   test_num++;
17396   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17397   if (test_ls_0 () == -1) {
17398     printf ("test_ls_0 FAILED\n");
17399     failed++;
17400   }
17401   test_num++;
17402   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17403   if (test_cat_0 () == -1) {
17404     printf ("test_cat_0 FAILED\n");
17405     failed++;
17406   }
17407   test_num++;
17408   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17409   if (test_touch_0 () == -1) {
17410     printf ("test_touch_0 FAILED\n");
17411     failed++;
17412   }
17413   test_num++;
17414   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17415   if (test_sync_0 () == -1) {
17416     printf ("test_sync_0 FAILED\n");
17417     failed++;
17418   }
17419   test_num++;
17420   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17421   if (test_mount_0 () == -1) {
17422     printf ("test_mount_0 FAILED\n");
17423     failed++;
17424   }
17425
17426   guestfs_close (g);
17427   unlink ("test1.img");
17428   unlink ("test2.img");
17429   unlink ("test3.img");
17430
17431   if (failed > 0) {
17432     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
17433     exit (1);
17434   }
17435
17436   exit (0);
17437 }