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 /* This will be 's' or 'h' depending on whether the guest kernel
  35  * names IDE devices /dev/sd* or /dev/hd*.
  36  */
  37 static char devchar = 's';
  38
  39 static void print_error (guestfs_h *g, void *data, const char *msg)
  40 {
  41   if (!suppress_error)
  42     fprintf (stderr, "%s\n", msg);
  43 }
  44
  45 static void print_strings (char * const * const argv)
  46 {
  47   int argc;
  48
  49   for (argc = 0; argv[argc] != NULL; ++argc)
  50     printf ("\t%s\n", argv[argc]);
  51 }
  52
  53 /*
  54 static void print_table (char * const * const argv)
  55 {
  56   int i;
  57
  58   for (i = 0; argv[i] != NULL; i += 2)
  59     printf ("%s: %s\n", argv[i], argv[i+1]);
  60 }
  61 */
  62
  63 static void no_test_warnings (void)
  64 {
  65   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 156 }
 157
 158 static int test_sleep_0_skip (void)
 159 {
 160   const char *str;
 161
 162   str = getenv ("SKIP_TEST_SLEEP_0");
 163   if (str && strcmp (str, "1") == 0) return 1;
 164   str = getenv ("SKIP_TEST_SLEEP");
 165   if (str && strcmp (str, "1") == 0) return 1;
 166   return 0;
 167 }
 168
 169 static int test_sleep_0 (void)
 170 {
 171   if (test_sleep_0_skip ()) {
 172     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
 173     return 0;
 174   }
 175
 176   /* InitNone|InitEmpty for test_sleep_0 */
 177   {
 178     char device[] = "/dev/sda";
 179     device[5] = devchar;
 180     int r;
 181     suppress_error = 0;
 182     r = guestfs_blockdev_setrw (g, device);
 183     if (r == -1)
 184       return -1;
 185   }
 186   {
 187     int r;
 188     suppress_error = 0;
 189     r = guestfs_umount_all (g);
 190     if (r == -1)
 191       return -1;
 192   }
 193   {
 194     int r;
 195     suppress_error = 0;
 196     r = guestfs_lvm_remove_all (g);
 197     if (r == -1)
 198       return -1;
 199   }
 200   /* TestRun for sleep (0) */
 201   {
 202     int r;
 203     suppress_error = 0;
 204     r = guestfs_sleep (g, 1);
 205     if (r == -1)
 206       return -1;
 207   }
 208   return 0;
 209 }
 210
 211 static int test_find_0_skip (void)
 212 {
 213   const char *str;
 214
 215   str = getenv ("SKIP_TEST_FIND_0");
 216   if (str && strcmp (str, "1") == 0) return 1;
 217   str = getenv ("SKIP_TEST_FIND");
 218   if (str && strcmp (str, "1") == 0) return 1;
 219   return 0;
 220 }
 221
 222 static int test_find_0 (void)
 223 {
 224   if (test_find_0_skip ()) {
 225     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
 226     return 0;
 227   }
 228
 229   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 230   {
 231     char device[] = "/dev/sda";
 232     device[5] = devchar;
 233     int r;
 234     suppress_error = 0;
 235     r = guestfs_blockdev_setrw (g, device);
 236     if (r == -1)
 237       return -1;
 238   }
 239   {
 240     int r;
 241     suppress_error = 0;
 242     r = guestfs_umount_all (g);
 243     if (r == -1)
 244       return -1;
 245   }
 246   {
 247     int r;
 248     suppress_error = 0;
 249     r = guestfs_lvm_remove_all (g);
 250     if (r == -1)
 251       return -1;
 252   }
 253   {
 254     char device[] = "/dev/sda";
 255     device[5] = devchar;
 256     char lines_0[] = ",";
 257     char *lines[] = {
 258       lines_0,
 259       NULL
 260     };
 261     int r;
 262     suppress_error = 0;
 263     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 264     if (r == -1)
 265       return -1;
 266   }
 267   {
 268     char fstype[] = "ext2";
 269     char device[] = "/dev/sda1";
 270     device[5] = devchar;
 271     int r;
 272     suppress_error = 0;
 273     r = guestfs_mkfs (g, fstype, device);
 274     if (r == -1)
 275       return -1;
 276   }
 277   {
 278     char device[] = "/dev/sda1";
 279     device[5] = devchar;
 280     char mountpoint[] = "/";
 281     int r;
 282     suppress_error = 0;
 283     r = guestfs_mount (g, device, mountpoint);
 284     if (r == -1)
 285       return -1;
 286   }
 287   /* TestOutputList for find (0) */
 288   {
 289     char directory[] = "/";
 290     char **r;
 291     int i;
 292     suppress_error = 0;
 293     r = guestfs_find (g, directory);
 294     if (r == NULL)
 295       return -1;
 296     if (!r[0]) {
 297       fprintf (stderr, "test_find_0: short list returned from command\n");
 298       print_strings (r);
 299       return -1;
 300     }
 301     {
 302       char expected[] = "lost+found";
 303       if (strcmp (r[0], expected) != 0) {
 304         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 305         return -1;
 306       }
 307     }
 308     if (r[1] != NULL) {
 309       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 310       print_strings (r);
 311       return -1;
 312     }
 313     for (i = 0; r[i] != NULL; ++i)
 314       free (r[i]);
 315     free (r);
 316   }
 317   return 0;
 318 }
 319
 320 static int test_find_1_skip (void)
 321 {
 322   const char *str;
 323
 324   str = getenv ("SKIP_TEST_FIND_1");
 325   if (str && strcmp (str, "1") == 0) return 1;
 326   str = getenv ("SKIP_TEST_FIND");
 327   if (str && strcmp (str, "1") == 0) return 1;
 328   return 0;
 329 }
 330
 331 static int test_find_1 (void)
 332 {
 333   if (test_find_1_skip ()) {
 334     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
 335     return 0;
 336   }
 337
 338   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
 339   {
 340     char device[] = "/dev/sda";
 341     device[5] = devchar;
 342     int r;
 343     suppress_error = 0;
 344     r = guestfs_blockdev_setrw (g, device);
 345     if (r == -1)
 346       return -1;
 347   }
 348   {
 349     int r;
 350     suppress_error = 0;
 351     r = guestfs_umount_all (g);
 352     if (r == -1)
 353       return -1;
 354   }
 355   {
 356     int r;
 357     suppress_error = 0;
 358     r = guestfs_lvm_remove_all (g);
 359     if (r == -1)
 360       return -1;
 361   }
 362   {
 363     char device[] = "/dev/sda";
 364     device[5] = devchar;
 365     char lines_0[] = ",";
 366     char *lines[] = {
 367       lines_0,
 368       NULL
 369     };
 370     int r;
 371     suppress_error = 0;
 372     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 373     if (r == -1)
 374       return -1;
 375   }
 376   {
 377     char fstype[] = "ext2";
 378     char device[] = "/dev/sda1";
 379     device[5] = devchar;
 380     int r;
 381     suppress_error = 0;
 382     r = guestfs_mkfs (g, fstype, device);
 383     if (r == -1)
 384       return -1;
 385   }
 386   {
 387     char device[] = "/dev/sda1";
 388     device[5] = devchar;
 389     char mountpoint[] = "/";
 390     int r;
 391     suppress_error = 0;
 392     r = guestfs_mount (g, device, mountpoint);
 393     if (r == -1)
 394       return -1;
 395   }
 396   /* TestOutputList for find (1) */
 397   {
 398     char path[] = "/a";
 399     int r;
 400     suppress_error = 0;
 401     r = guestfs_touch (g, path);
 402     if (r == -1)
 403       return -1;
 404   }
 405   {
 406     char path[] = "/b";
 407     int r;
 408     suppress_error = 0;
 409     r = guestfs_mkdir (g, path);
 410     if (r == -1)
 411       return -1;
 412   }
 413   {
 414     char path[] = "/b/c";
 415     int r;
 416     suppress_error = 0;
 417     r = guestfs_touch (g, path);
 418     if (r == -1)
 419       return -1;
 420   }
 421   {
 422     char directory[] = "/";
 423     char **r;
 424     int i;
 425     suppress_error = 0;
 426     r = guestfs_find (g, directory);
 427     if (r == NULL)
 428       return -1;
 429     if (!r[0]) {
 430       fprintf (stderr, "test_find_1: short list returned from command\n");
 431       print_strings (r);
 432       return -1;
 433     }
 434     {
 435       char expected[] = "a";
 436       if (strcmp (r[0], expected) != 0) {
 437         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 438         return -1;
 439       }
 440     }
 441     if (!r[1]) {
 442       fprintf (stderr, "test_find_1: short list returned from command\n");
 443       print_strings (r);
 444       return -1;
 445     }
 446     {
 447       char expected[] = "b";
 448       if (strcmp (r[1], expected) != 0) {
 449         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 450         return -1;
 451       }
 452     }
 453     if (!r[2]) {
 454       fprintf (stderr, "test_find_1: short list returned from command\n");
 455       print_strings (r);
 456       return -1;
 457     }
 458     {
 459       char expected[] = "b/c";
 460       if (strcmp (r[2], expected) != 0) {
 461         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 462         return -1;
 463       }
 464     }
 465     if (!r[3]) {
 466       fprintf (stderr, "test_find_1: short list returned from command\n");
 467       print_strings (r);
 468       return -1;
 469     }
 470     {
 471       char expected[] = "lost+found";
 472       if (strcmp (r[3], expected) != 0) {
 473         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 474         return -1;
 475       }
 476     }
 477     if (r[4] != NULL) {
 478       fprintf (stderr, "test_find_1: extra elements returned from command\n");
 479       print_strings (r);
 480       return -1;
 481     }
 482     for (i = 0; r[i] != NULL; ++i)
 483       free (r[i]);
 484     free (r);
 485   }
 486   return 0;
 487 }
 488
 489 static int test_find_2_skip (void)
 490 {
 491   const char *str;
 492
 493   str = getenv ("SKIP_TEST_FIND_2");
 494   if (str && strcmp (str, "1") == 0) return 1;
 495   str = getenv ("SKIP_TEST_FIND");
 496   if (str && strcmp (str, "1") == 0) return 1;
 497   return 0;
 498 }
 499
 500 static int test_find_2 (void)
 501 {
 502   if (test_find_2_skip ()) {
 503     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
 504     return 0;
 505   }
 506
 507   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
 508   {
 509     char device[] = "/dev/sda";
 510     device[5] = devchar;
 511     int r;
 512     suppress_error = 0;
 513     r = guestfs_blockdev_setrw (g, device);
 514     if (r == -1)
 515       return -1;
 516   }
 517   {
 518     int r;
 519     suppress_error = 0;
 520     r = guestfs_umount_all (g);
 521     if (r == -1)
 522       return -1;
 523   }
 524   {
 525     int r;
 526     suppress_error = 0;
 527     r = guestfs_lvm_remove_all (g);
 528     if (r == -1)
 529       return -1;
 530   }
 531   {
 532     char device[] = "/dev/sda";
 533     device[5] = devchar;
 534     char lines_0[] = ",";
 535     char *lines[] = {
 536       lines_0,
 537       NULL
 538     };
 539     int r;
 540     suppress_error = 0;
 541     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 542     if (r == -1)
 543       return -1;
 544   }
 545   {
 546     char fstype[] = "ext2";
 547     char device[] = "/dev/sda1";
 548     device[5] = devchar;
 549     int r;
 550     suppress_error = 0;
 551     r = guestfs_mkfs (g, fstype, device);
 552     if (r == -1)
 553       return -1;
 554   }
 555   {
 556     char device[] = "/dev/sda1";
 557     device[5] = devchar;
 558     char mountpoint[] = "/";
 559     int r;
 560     suppress_error = 0;
 561     r = guestfs_mount (g, device, mountpoint);
 562     if (r == -1)
 563       return -1;
 564   }
 565   /* TestOutputList for find (2) */
 566   {
 567     char path[] = "/a/b/c";
 568     int r;
 569     suppress_error = 0;
 570     r = guestfs_mkdir_p (g, path);
 571     if (r == -1)
 572       return -1;
 573   }
 574   {
 575     char path[] = "/a/b/c/d";
 576     int r;
 577     suppress_error = 0;
 578     r = guestfs_touch (g, path);
 579     if (r == -1)
 580       return -1;
 581   }
 582   {
 583     char directory[] = "/a/b/";
 584     char **r;
 585     int i;
 586     suppress_error = 0;
 587     r = guestfs_find (g, directory);
 588     if (r == NULL)
 589       return -1;
 590     if (!r[0]) {
 591       fprintf (stderr, "test_find_2: short list returned from command\n");
 592       print_strings (r);
 593       return -1;
 594     }
 595     {
 596       char expected[] = "c";
 597       if (strcmp (r[0], expected) != 0) {
 598         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 599         return -1;
 600       }
 601     }
 602     if (!r[1]) {
 603       fprintf (stderr, "test_find_2: short list returned from command\n");
 604       print_strings (r);
 605       return -1;
 606     }
 607     {
 608       char expected[] = "c/d";
 609       if (strcmp (r[1], expected) != 0) {
 610         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 611         return -1;
 612       }
 613     }
 614     if (r[2] != NULL) {
 615       fprintf (stderr, "test_find_2: extra elements returned from command\n");
 616       print_strings (r);
 617       return -1;
 618     }
 619     for (i = 0; r[i] != NULL; ++i)
 620       free (r[i]);
 621     free (r);
 622   }
 623   return 0;
 624 }
 625
 626 static int test_lvresize_0_skip (void)
 627 {
 628   const char *str;
 629
 630   str = getenv ("SKIP_TEST_LVRESIZE_0");
 631   if (str && strcmp (str, "1") == 0) return 1;
 632   str = getenv ("SKIP_TEST_LVRESIZE");
 633   if (str && strcmp (str, "1") == 0) return 1;
 634   return 0;
 635 }
 636
 637 static int test_lvresize_0 (void)
 638 {
 639   if (test_lvresize_0_skip ()) {
 640     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
 641     return 0;
 642   }
 643
 644   /* InitNone|InitEmpty for test_lvresize_0 */
 645   {
 646     char device[] = "/dev/sda";
 647     device[5] = devchar;
 648     int r;
 649     suppress_error = 0;
 650     r = guestfs_blockdev_setrw (g, device);
 651     if (r == -1)
 652       return -1;
 653   }
 654   {
 655     int r;
 656     suppress_error = 0;
 657     r = guestfs_umount_all (g);
 658     if (r == -1)
 659       return -1;
 660   }
 661   {
 662     int r;
 663     suppress_error = 0;
 664     r = guestfs_lvm_remove_all (g);
 665     if (r == -1)
 666       return -1;
 667   }
 668   /* TestOutput for lvresize (0) */
 669   char expected[] = "test content";
 670   {
 671     char device[] = "/dev/sda";
 672     device[5] = devchar;
 673     char lines_0[] = ",";
 674     char *lines[] = {
 675       lines_0,
 676       NULL
 677     };
 678     int r;
 679     suppress_error = 0;
 680     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 681     if (r == -1)
 682       return -1;
 683   }
 684   {
 685     char device[] = "/dev/sda1";
 686     device[5] = devchar;
 687     int r;
 688     suppress_error = 0;
 689     r = guestfs_pvcreate (g, device);
 690     if (r == -1)
 691       return -1;
 692   }
 693   {
 694     char volgroup[] = "VG";
 695     char physvols_0[] = "/dev/sda1";
 696     physvols_0[5] = devchar;
 697     char *physvols[] = {
 698       physvols_0,
 699       NULL
 700     };
 701     int r;
 702     suppress_error = 0;
 703     r = guestfs_vgcreate (g, volgroup, physvols);
 704     if (r == -1)
 705       return -1;
 706   }
 707   {
 708     char logvol[] = "LV";
 709     char volgroup[] = "VG";
 710     int r;
 711     suppress_error = 0;
 712     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 713     if (r == -1)
 714       return -1;
 715   }
 716   {
 717     char fstype[] = "ext2";
 718     char device[] = "/dev/VG/LV";
 719     int r;
 720     suppress_error = 0;
 721     r = guestfs_mkfs (g, fstype, device);
 722     if (r == -1)
 723       return -1;
 724   }
 725   {
 726     char device[] = "/dev/VG/LV";
 727     char mountpoint[] = "/";
 728     int r;
 729     suppress_error = 0;
 730     r = guestfs_mount (g, device, mountpoint);
 731     if (r == -1)
 732       return -1;
 733   }
 734   {
 735     char path[] = "/new";
 736     char content[] = "test content";
 737     int r;
 738     suppress_error = 0;
 739     r = guestfs_write_file (g, path, content, 0);
 740     if (r == -1)
 741       return -1;
 742   }
 743   {
 744     char pathordevice[] = "/";
 745     int r;
 746     suppress_error = 0;
 747     r = guestfs_umount (g, pathordevice);
 748     if (r == -1)
 749       return -1;
 750   }
 751   {
 752     char device[] = "/dev/VG/LV";
 753     int r;
 754     suppress_error = 0;
 755     r = guestfs_lvresize (g, device, 20);
 756     if (r == -1)
 757       return -1;
 758   }
 759   {
 760     char device[] = "/dev/VG/LV";
 761     int r;
 762     suppress_error = 0;
 763     r = guestfs_e2fsck_f (g, device);
 764     if (r == -1)
 765       return -1;
 766   }
 767   {
 768     char device[] = "/dev/VG/LV";
 769     int r;
 770     suppress_error = 0;
 771     r = guestfs_resize2fs (g, device);
 772     if (r == -1)
 773       return -1;
 774   }
 775   {
 776     char device[] = "/dev/VG/LV";
 777     char mountpoint[] = "/";
 778     int r;
 779     suppress_error = 0;
 780     r = guestfs_mount (g, device, mountpoint);
 781     if (r == -1)
 782       return -1;
 783   }
 784   {
 785     char path[] = "/new";
 786     char *r;
 787     suppress_error = 0;
 788     r = guestfs_cat (g, path);
 789     if (r == NULL)
 790       return -1;
 791     if (strcmp (r, expected) != 0) {
 792       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 793       return -1;
 794     }
 795     free (r);
 796   }
 797   return 0;
 798 }
 799
 800 static int test_zerofree_0_skip (void)
 801 {
 802   const char *str;
 803
 804   str = getenv ("SKIP_TEST_ZEROFREE_0");
 805   if (str && strcmp (str, "1") == 0) return 1;
 806   str = getenv ("SKIP_TEST_ZEROFREE");
 807   if (str && strcmp (str, "1") == 0) return 1;
 808   return 0;
 809 }
 810
 811 static int test_zerofree_0 (void)
 812 {
 813   if (test_zerofree_0_skip ()) {
 814     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
 815     return 0;
 816   }
 817
 818   /* InitNone|InitEmpty for test_zerofree_0 */
 819   {
 820     char device[] = "/dev/sda";
 821     device[5] = devchar;
 822     int r;
 823     suppress_error = 0;
 824     r = guestfs_blockdev_setrw (g, device);
 825     if (r == -1)
 826       return -1;
 827   }
 828   {
 829     int r;
 830     suppress_error = 0;
 831     r = guestfs_umount_all (g);
 832     if (r == -1)
 833       return -1;
 834   }
 835   {
 836     int r;
 837     suppress_error = 0;
 838     r = guestfs_lvm_remove_all (g);
 839     if (r == -1)
 840       return -1;
 841   }
 842   /* TestOutput for zerofree (0) */
 843   char expected[] = "test file";
 844   {
 845     char device[] = "/dev/sda";
 846     device[5] = devchar;
 847     char lines_0[] = ",";
 848     char *lines[] = {
 849       lines_0,
 850       NULL
 851     };
 852     int r;
 853     suppress_error = 0;
 854     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 855     if (r == -1)
 856       return -1;
 857   }
 858   {
 859     char fstype[] = "ext3";
 860     char device[] = "/dev/sda1";
 861     device[5] = devchar;
 862     int r;
 863     suppress_error = 0;
 864     r = guestfs_mkfs (g, fstype, device);
 865     if (r == -1)
 866       return -1;
 867   }
 868   {
 869     char device[] = "/dev/sda1";
 870     device[5] = devchar;
 871     char mountpoint[] = "/";
 872     int r;
 873     suppress_error = 0;
 874     r = guestfs_mount (g, device, mountpoint);
 875     if (r == -1)
 876       return -1;
 877   }
 878   {
 879     char path[] = "/new";
 880     char content[] = "test file";
 881     int r;
 882     suppress_error = 0;
 883     r = guestfs_write_file (g, path, content, 0);
 884     if (r == -1)
 885       return -1;
 886   }
 887   {
 888     char pathordevice[] = "/dev/sda1";
 889     pathordevice[5] = devchar;
 890     int r;
 891     suppress_error = 0;
 892     r = guestfs_umount (g, pathordevice);
 893     if (r == -1)
 894       return -1;
 895   }
 896   {
 897     char device[] = "/dev/sda1";
 898     device[5] = devchar;
 899     int r;
 900     suppress_error = 0;
 901     r = guestfs_zerofree (g, device);
 902     if (r == -1)
 903       return -1;
 904   }
 905   {
 906     char device[] = "/dev/sda1";
 907     device[5] = devchar;
 908     char mountpoint[] = "/";
 909     int r;
 910     suppress_error = 0;
 911     r = guestfs_mount (g, device, mountpoint);
 912     if (r == -1)
 913       return -1;
 914   }
 915   {
 916     char path[] = "/new";
 917     char *r;
 918     suppress_error = 0;
 919     r = guestfs_cat (g, path);
 920     if (r == NULL)
 921       return -1;
 922     if (strcmp (r, expected) != 0) {
 923       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
 924       return -1;
 925     }
 926     free (r);
 927   }
 928   return 0;
 929 }
 930
 931 static int test_hexdump_0_skip (void)
 932 {
 933   const char *str;
 934
 935   str = getenv ("SKIP_TEST_HEXDUMP_0");
 936   if (str && strcmp (str, "1") == 0) return 1;
 937   str = getenv ("SKIP_TEST_HEXDUMP");
 938   if (str && strcmp (str, "1") == 0) return 1;
 939   return 0;
 940 }
 941
 942 static int test_hexdump_0 (void)
 943 {
 944   if (test_hexdump_0_skip ()) {
 945     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
 946     return 0;
 947   }
 948
 949   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
 950   {
 951     char device[] = "/dev/sda";
 952     device[5] = devchar;
 953     int r;
 954     suppress_error = 0;
 955     r = guestfs_blockdev_setrw (g, device);
 956     if (r == -1)
 957       return -1;
 958   }
 959   {
 960     int r;
 961     suppress_error = 0;
 962     r = guestfs_umount_all (g);
 963     if (r == -1)
 964       return -1;
 965   }
 966   {
 967     int r;
 968     suppress_error = 0;
 969     r = guestfs_lvm_remove_all (g);
 970     if (r == -1)
 971       return -1;
 972   }
 973   {
 974     char device[] = "/dev/sda";
 975     device[5] = devchar;
 976     char lines_0[] = ",";
 977     char *lines[] = {
 978       lines_0,
 979       NULL
 980     };
 981     int r;
 982     suppress_error = 0;
 983     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 984     if (r == -1)
 985       return -1;
 986   }
 987   {
 988     char fstype[] = "ext2";
 989     char device[] = "/dev/sda1";
 990     device[5] = devchar;
 991     int r;
 992     suppress_error = 0;
 993     r = guestfs_mkfs (g, fstype, device);
 994     if (r == -1)
 995       return -1;
 996   }
 997   {
 998     char device[] = "/dev/sda1";
 999     device[5] = devchar;
1000     char mountpoint[] = "/";
1001     int r;
1002     suppress_error = 0;
1003     r = guestfs_mount (g, device, mountpoint);
1004     if (r == -1)
1005       return -1;
1006   }
1007   /* TestOutput for hexdump (0) */
1008   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
1009   {
1010     char path[] = "/new";
1011     char content[] = "hello\nworld\n";
1012     int r;
1013     suppress_error = 0;
1014     r = guestfs_write_file (g, path, content, 12);
1015     if (r == -1)
1016       return -1;
1017   }
1018   {
1019     char path[] = "/new";
1020     char *r;
1021     suppress_error = 0;
1022     r = guestfs_hexdump (g, path);
1023     if (r == NULL)
1024       return -1;
1025     if (strcmp (r, expected) != 0) {
1026       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1027       return -1;
1028     }
1029     free (r);
1030   }
1031   return 0;
1032 }
1033
1034 static int test_strings_e_0_skip (void)
1035 {
1036   const char *str;
1037
1038   str = getenv ("SKIP_TEST_STRINGS_E_0");
1039   if (str && strcmp (str, "1") == 0) return 1;
1040   str = getenv ("SKIP_TEST_STRINGS_E");
1041   if (str && strcmp (str, "1") == 0) return 1;
1042   return 0;
1043 }
1044
1045 static int test_strings_e_0 (void)
1046 {
1047   if (test_strings_e_0_skip ()) {
1048     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1049     return 0;
1050   }
1051
1052   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1053   {
1054     char device[] = "/dev/sda";
1055     device[5] = devchar;
1056     int r;
1057     suppress_error = 0;
1058     r = guestfs_blockdev_setrw (g, device);
1059     if (r == -1)
1060       return -1;
1061   }
1062   {
1063     int r;
1064     suppress_error = 0;
1065     r = guestfs_umount_all (g);
1066     if (r == -1)
1067       return -1;
1068   }
1069   {
1070     int r;
1071     suppress_error = 0;
1072     r = guestfs_lvm_remove_all (g);
1073     if (r == -1)
1074       return -1;
1075   }
1076   {
1077     char device[] = "/dev/sda";
1078     device[5] = devchar;
1079     char lines_0[] = ",";
1080     char *lines[] = {
1081       lines_0,
1082       NULL
1083     };
1084     int r;
1085     suppress_error = 0;
1086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1087     if (r == -1)
1088       return -1;
1089   }
1090   {
1091     char fstype[] = "ext2";
1092     char device[] = "/dev/sda1";
1093     device[5] = devchar;
1094     int r;
1095     suppress_error = 0;
1096     r = guestfs_mkfs (g, fstype, device);
1097     if (r == -1)
1098       return -1;
1099   }
1100   {
1101     char device[] = "/dev/sda1";
1102     device[5] = devchar;
1103     char mountpoint[] = "/";
1104     int r;
1105     suppress_error = 0;
1106     r = guestfs_mount (g, device, mountpoint);
1107     if (r == -1)
1108       return -1;
1109   }
1110   /* TestOutputList for strings_e (0) */
1111   {
1112     char path[] = "/new";
1113     char content[] = "hello\nworld\n";
1114     int r;
1115     suppress_error = 0;
1116     r = guestfs_write_file (g, path, content, 0);
1117     if (r == -1)
1118       return -1;
1119   }
1120   {
1121     char encoding[] = "b";
1122     char path[] = "/new";
1123     char **r;
1124     int i;
1125     suppress_error = 0;
1126     r = guestfs_strings_e (g, encoding, path);
1127     if (r == NULL)
1128       return -1;
1129     if (r[0] != NULL) {
1130       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1131       print_strings (r);
1132       return -1;
1133     }
1134     for (i = 0; r[i] != NULL; ++i)
1135       free (r[i]);
1136     free (r);
1137   }
1138   return 0;
1139 }
1140
1141 static int test_strings_e_1_skip (void)
1142 {
1143   const char *str;
1144
1145   str = getenv ("SKIP_TEST_STRINGS_E_1");
1146   if (str && strcmp (str, "1") == 0) return 1;
1147   str = getenv ("SKIP_TEST_STRINGS_E");
1148   if (str && strcmp (str, "1") == 0) return 1;
1149   return 0;
1150 }
1151
1152 static int test_strings_e_1 (void)
1153 {
1154   if (test_strings_e_1_skip ()) {
1155     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1156     return 0;
1157   }
1158
1159   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1160   return 0;
1161 }
1162
1163 static int test_strings_0_skip (void)
1164 {
1165   const char *str;
1166
1167   str = getenv ("SKIP_TEST_STRINGS_0");
1168   if (str && strcmp (str, "1") == 0) return 1;
1169   str = getenv ("SKIP_TEST_STRINGS");
1170   if (str && strcmp (str, "1") == 0) return 1;
1171   return 0;
1172 }
1173
1174 static int test_strings_0 (void)
1175 {
1176   if (test_strings_0_skip ()) {
1177     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1178     return 0;
1179   }
1180
1181   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1182   {
1183     char device[] = "/dev/sda";
1184     device[5] = devchar;
1185     int r;
1186     suppress_error = 0;
1187     r = guestfs_blockdev_setrw (g, device);
1188     if (r == -1)
1189       return -1;
1190   }
1191   {
1192     int r;
1193     suppress_error = 0;
1194     r = guestfs_umount_all (g);
1195     if (r == -1)
1196       return -1;
1197   }
1198   {
1199     int r;
1200     suppress_error = 0;
1201     r = guestfs_lvm_remove_all (g);
1202     if (r == -1)
1203       return -1;
1204   }
1205   {
1206     char device[] = "/dev/sda";
1207     device[5] = devchar;
1208     char lines_0[] = ",";
1209     char *lines[] = {
1210       lines_0,
1211       NULL
1212     };
1213     int r;
1214     suppress_error = 0;
1215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1216     if (r == -1)
1217       return -1;
1218   }
1219   {
1220     char fstype[] = "ext2";
1221     char device[] = "/dev/sda1";
1222     device[5] = devchar;
1223     int r;
1224     suppress_error = 0;
1225     r = guestfs_mkfs (g, fstype, device);
1226     if (r == -1)
1227       return -1;
1228   }
1229   {
1230     char device[] = "/dev/sda1";
1231     device[5] = devchar;
1232     char mountpoint[] = "/";
1233     int r;
1234     suppress_error = 0;
1235     r = guestfs_mount (g, device, mountpoint);
1236     if (r == -1)
1237       return -1;
1238   }
1239   /* TestOutputList for strings (0) */
1240   {
1241     char path[] = "/new";
1242     char content[] = "hello\nworld\n";
1243     int r;
1244     suppress_error = 0;
1245     r = guestfs_write_file (g, path, content, 0);
1246     if (r == -1)
1247       return -1;
1248   }
1249   {
1250     char path[] = "/new";
1251     char **r;
1252     int i;
1253     suppress_error = 0;
1254     r = guestfs_strings (g, path);
1255     if (r == NULL)
1256       return -1;
1257     if (!r[0]) {
1258       fprintf (stderr, "test_strings_0: short list returned from command\n");
1259       print_strings (r);
1260       return -1;
1261     }
1262     {
1263       char expected[] = "hello";
1264       if (strcmp (r[0], expected) != 0) {
1265         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1266         return -1;
1267       }
1268     }
1269     if (!r[1]) {
1270       fprintf (stderr, "test_strings_0: short list returned from command\n");
1271       print_strings (r);
1272       return -1;
1273     }
1274     {
1275       char expected[] = "world";
1276       if (strcmp (r[1], expected) != 0) {
1277         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1278         return -1;
1279       }
1280     }
1281     if (r[2] != NULL) {
1282       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1283       print_strings (r);
1284       return -1;
1285     }
1286     for (i = 0; r[i] != NULL; ++i)
1287       free (r[i]);
1288     free (r);
1289   }
1290   return 0;
1291 }
1292
1293 static int test_strings_1_skip (void)
1294 {
1295   const char *str;
1296
1297   str = getenv ("SKIP_TEST_STRINGS_1");
1298   if (str && strcmp (str, "1") == 0) return 1;
1299   str = getenv ("SKIP_TEST_STRINGS");
1300   if (str && strcmp (str, "1") == 0) return 1;
1301   return 0;
1302 }
1303
1304 static int test_strings_1 (void)
1305 {
1306   if (test_strings_1_skip ()) {
1307     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1308     return 0;
1309   }
1310
1311   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1312   {
1313     char device[] = "/dev/sda";
1314     device[5] = devchar;
1315     int r;
1316     suppress_error = 0;
1317     r = guestfs_blockdev_setrw (g, device);
1318     if (r == -1)
1319       return -1;
1320   }
1321   {
1322     int r;
1323     suppress_error = 0;
1324     r = guestfs_umount_all (g);
1325     if (r == -1)
1326       return -1;
1327   }
1328   {
1329     int r;
1330     suppress_error = 0;
1331     r = guestfs_lvm_remove_all (g);
1332     if (r == -1)
1333       return -1;
1334   }
1335   {
1336     char device[] = "/dev/sda";
1337     device[5] = devchar;
1338     char lines_0[] = ",";
1339     char *lines[] = {
1340       lines_0,
1341       NULL
1342     };
1343     int r;
1344     suppress_error = 0;
1345     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1346     if (r == -1)
1347       return -1;
1348   }
1349   {
1350     char fstype[] = "ext2";
1351     char device[] = "/dev/sda1";
1352     device[5] = devchar;
1353     int r;
1354     suppress_error = 0;
1355     r = guestfs_mkfs (g, fstype, device);
1356     if (r == -1)
1357       return -1;
1358   }
1359   {
1360     char device[] = "/dev/sda1";
1361     device[5] = devchar;
1362     char mountpoint[] = "/";
1363     int r;
1364     suppress_error = 0;
1365     r = guestfs_mount (g, device, mountpoint);
1366     if (r == -1)
1367       return -1;
1368   }
1369   /* TestOutputList for strings (1) */
1370   {
1371     char path[] = "/new";
1372     int r;
1373     suppress_error = 0;
1374     r = guestfs_touch (g, path);
1375     if (r == -1)
1376       return -1;
1377   }
1378   {
1379     char path[] = "/new";
1380     char **r;
1381     int i;
1382     suppress_error = 0;
1383     r = guestfs_strings (g, path);
1384     if (r == NULL)
1385       return -1;
1386     if (r[0] != NULL) {
1387       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1388       print_strings (r);
1389       return -1;
1390     }
1391     for (i = 0; r[i] != NULL; ++i)
1392       free (r[i]);
1393     free (r);
1394   }
1395   return 0;
1396 }
1397
1398 static int test_equal_0_skip (void)
1399 {
1400   const char *str;
1401
1402   str = getenv ("SKIP_TEST_EQUAL_0");
1403   if (str && strcmp (str, "1") == 0) return 1;
1404   str = getenv ("SKIP_TEST_EQUAL");
1405   if (str && strcmp (str, "1") == 0) return 1;
1406   return 0;
1407 }
1408
1409 static int test_equal_0 (void)
1410 {
1411   if (test_equal_0_skip ()) {
1412     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1413     return 0;
1414   }
1415
1416   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1417   {
1418     char device[] = "/dev/sda";
1419     device[5] = devchar;
1420     int r;
1421     suppress_error = 0;
1422     r = guestfs_blockdev_setrw (g, device);
1423     if (r == -1)
1424       return -1;
1425   }
1426   {
1427     int r;
1428     suppress_error = 0;
1429     r = guestfs_umount_all (g);
1430     if (r == -1)
1431       return -1;
1432   }
1433   {
1434     int r;
1435     suppress_error = 0;
1436     r = guestfs_lvm_remove_all (g);
1437     if (r == -1)
1438       return -1;
1439   }
1440   {
1441     char device[] = "/dev/sda";
1442     device[5] = devchar;
1443     char lines_0[] = ",";
1444     char *lines[] = {
1445       lines_0,
1446       NULL
1447     };
1448     int r;
1449     suppress_error = 0;
1450     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1451     if (r == -1)
1452       return -1;
1453   }
1454   {
1455     char fstype[] = "ext2";
1456     char device[] = "/dev/sda1";
1457     device[5] = devchar;
1458     int r;
1459     suppress_error = 0;
1460     r = guestfs_mkfs (g, fstype, device);
1461     if (r == -1)
1462       return -1;
1463   }
1464   {
1465     char device[] = "/dev/sda1";
1466     device[5] = devchar;
1467     char mountpoint[] = "/";
1468     int r;
1469     suppress_error = 0;
1470     r = guestfs_mount (g, device, mountpoint);
1471     if (r == -1)
1472       return -1;
1473   }
1474   /* TestOutputTrue for equal (0) */
1475   {
1476     char path[] = "/file1";
1477     char content[] = "contents of a file";
1478     int r;
1479     suppress_error = 0;
1480     r = guestfs_write_file (g, path, content, 0);
1481     if (r == -1)
1482       return -1;
1483   }
1484   {
1485     char src[] = "/file1";
1486     char dest[] = "/file2";
1487     int r;
1488     suppress_error = 0;
1489     r = guestfs_cp (g, src, dest);
1490     if (r == -1)
1491       return -1;
1492   }
1493   {
1494     char file1[] = "/file1";
1495     char file2[] = "/file2";
1496     int r;
1497     suppress_error = 0;
1498     r = guestfs_equal (g, file1, file2);
1499     if (r == -1)
1500       return -1;
1501     if (!r) {
1502       fprintf (stderr, "test_equal_0: expected true, got false\n");
1503       return -1;
1504     }
1505   }
1506   return 0;
1507 }
1508
1509 static int test_equal_1_skip (void)
1510 {
1511   const char *str;
1512
1513   str = getenv ("SKIP_TEST_EQUAL_1");
1514   if (str && strcmp (str, "1") == 0) return 1;
1515   str = getenv ("SKIP_TEST_EQUAL");
1516   if (str && strcmp (str, "1") == 0) return 1;
1517   return 0;
1518 }
1519
1520 static int test_equal_1 (void)
1521 {
1522   if (test_equal_1_skip ()) {
1523     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1524     return 0;
1525   }
1526
1527   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1528   {
1529     char device[] = "/dev/sda";
1530     device[5] = devchar;
1531     int r;
1532     suppress_error = 0;
1533     r = guestfs_blockdev_setrw (g, device);
1534     if (r == -1)
1535       return -1;
1536   }
1537   {
1538     int r;
1539     suppress_error = 0;
1540     r = guestfs_umount_all (g);
1541     if (r == -1)
1542       return -1;
1543   }
1544   {
1545     int r;
1546     suppress_error = 0;
1547     r = guestfs_lvm_remove_all (g);
1548     if (r == -1)
1549       return -1;
1550   }
1551   {
1552     char device[] = "/dev/sda";
1553     device[5] = devchar;
1554     char lines_0[] = ",";
1555     char *lines[] = {
1556       lines_0,
1557       NULL
1558     };
1559     int r;
1560     suppress_error = 0;
1561     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1562     if (r == -1)
1563       return -1;
1564   }
1565   {
1566     char fstype[] = "ext2";
1567     char device[] = "/dev/sda1";
1568     device[5] = devchar;
1569     int r;
1570     suppress_error = 0;
1571     r = guestfs_mkfs (g, fstype, device);
1572     if (r == -1)
1573       return -1;
1574   }
1575   {
1576     char device[] = "/dev/sda1";
1577     device[5] = devchar;
1578     char mountpoint[] = "/";
1579     int r;
1580     suppress_error = 0;
1581     r = guestfs_mount (g, device, mountpoint);
1582     if (r == -1)
1583       return -1;
1584   }
1585   /* TestOutputFalse for equal (1) */
1586   {
1587     char path[] = "/file1";
1588     char content[] = "contents of a file";
1589     int r;
1590     suppress_error = 0;
1591     r = guestfs_write_file (g, path, content, 0);
1592     if (r == -1)
1593       return -1;
1594   }
1595   {
1596     char path[] = "/file2";
1597     char content[] = "contents of another file";
1598     int r;
1599     suppress_error = 0;
1600     r = guestfs_write_file (g, path, content, 0);
1601     if (r == -1)
1602       return -1;
1603   }
1604   {
1605     char file1[] = "/file1";
1606     char file2[] = "/file2";
1607     int r;
1608     suppress_error = 0;
1609     r = guestfs_equal (g, file1, file2);
1610     if (r == -1)
1611       return -1;
1612     if (r) {
1613       fprintf (stderr, "test_equal_1: expected false, got true\n");
1614       return -1;
1615     }
1616   }
1617   return 0;
1618 }
1619
1620 static int test_equal_2_skip (void)
1621 {
1622   const char *str;
1623
1624   str = getenv ("SKIP_TEST_EQUAL_2");
1625   if (str && strcmp (str, "1") == 0) return 1;
1626   str = getenv ("SKIP_TEST_EQUAL");
1627   if (str && strcmp (str, "1") == 0) return 1;
1628   return 0;
1629 }
1630
1631 static int test_equal_2 (void)
1632 {
1633   if (test_equal_2_skip ()) {
1634     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1635     return 0;
1636   }
1637
1638   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1639   {
1640     char device[] = "/dev/sda";
1641     device[5] = devchar;
1642     int r;
1643     suppress_error = 0;
1644     r = guestfs_blockdev_setrw (g, device);
1645     if (r == -1)
1646       return -1;
1647   }
1648   {
1649     int r;
1650     suppress_error = 0;
1651     r = guestfs_umount_all (g);
1652     if (r == -1)
1653       return -1;
1654   }
1655   {
1656     int r;
1657     suppress_error = 0;
1658     r = guestfs_lvm_remove_all (g);
1659     if (r == -1)
1660       return -1;
1661   }
1662   {
1663     char device[] = "/dev/sda";
1664     device[5] = devchar;
1665     char lines_0[] = ",";
1666     char *lines[] = {
1667       lines_0,
1668       NULL
1669     };
1670     int r;
1671     suppress_error = 0;
1672     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1673     if (r == -1)
1674       return -1;
1675   }
1676   {
1677     char fstype[] = "ext2";
1678     char device[] = "/dev/sda1";
1679     device[5] = devchar;
1680     int r;
1681     suppress_error = 0;
1682     r = guestfs_mkfs (g, fstype, device);
1683     if (r == -1)
1684       return -1;
1685   }
1686   {
1687     char device[] = "/dev/sda1";
1688     device[5] = devchar;
1689     char mountpoint[] = "/";
1690     int r;
1691     suppress_error = 0;
1692     r = guestfs_mount (g, device, mountpoint);
1693     if (r == -1)
1694       return -1;
1695   }
1696   /* TestLastFail for equal (2) */
1697   {
1698     char file1[] = "/file1";
1699     char file2[] = "/file2";
1700     int r;
1701     suppress_error = 1;
1702     r = guestfs_equal (g, file1, file2);
1703     if (r != -1)
1704       return -1;
1705   }
1706   return 0;
1707 }
1708
1709 static int test_ping_daemon_0_skip (void)
1710 {
1711   const char *str;
1712
1713   str = getenv ("SKIP_TEST_PING_DAEMON_0");
1714   if (str && strcmp (str, "1") == 0) return 1;
1715   str = getenv ("SKIP_TEST_PING_DAEMON");
1716   if (str && strcmp (str, "1") == 0) return 1;
1717   return 0;
1718 }
1719
1720 static int test_ping_daemon_0 (void)
1721 {
1722   if (test_ping_daemon_0_skip ()) {
1723     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1724     return 0;
1725   }
1726
1727   /* InitNone|InitEmpty for test_ping_daemon_0 */
1728   {
1729     char device[] = "/dev/sda";
1730     device[5] = devchar;
1731     int r;
1732     suppress_error = 0;
1733     r = guestfs_blockdev_setrw (g, device);
1734     if (r == -1)
1735       return -1;
1736   }
1737   {
1738     int r;
1739     suppress_error = 0;
1740     r = guestfs_umount_all (g);
1741     if (r == -1)
1742       return -1;
1743   }
1744   {
1745     int r;
1746     suppress_error = 0;
1747     r = guestfs_lvm_remove_all (g);
1748     if (r == -1)
1749       return -1;
1750   }
1751   /* TestRun for ping_daemon (0) */
1752   {
1753     int r;
1754     suppress_error = 0;
1755     r = guestfs_ping_daemon (g);
1756     if (r == -1)
1757       return -1;
1758   }
1759   return 0;
1760 }
1761
1762 static int test_dmesg_0_skip (void)
1763 {
1764   const char *str;
1765
1766   str = getenv ("SKIP_TEST_DMESG_0");
1767   if (str && strcmp (str, "1") == 0) return 1;
1768   str = getenv ("SKIP_TEST_DMESG");
1769   if (str && strcmp (str, "1") == 0) return 1;
1770   return 0;
1771 }
1772
1773 static int test_dmesg_0 (void)
1774 {
1775   if (test_dmesg_0_skip ()) {
1776     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1777     return 0;
1778   }
1779
1780   /* InitNone|InitEmpty for test_dmesg_0 */
1781   {
1782     char device[] = "/dev/sda";
1783     device[5] = devchar;
1784     int r;
1785     suppress_error = 0;
1786     r = guestfs_blockdev_setrw (g, device);
1787     if (r == -1)
1788       return -1;
1789   }
1790   {
1791     int r;
1792     suppress_error = 0;
1793     r = guestfs_umount_all (g);
1794     if (r == -1)
1795       return -1;
1796   }
1797   {
1798     int r;
1799     suppress_error = 0;
1800     r = guestfs_lvm_remove_all (g);
1801     if (r == -1)
1802       return -1;
1803   }
1804   /* TestRun for dmesg (0) */
1805   {
1806     char *r;
1807     suppress_error = 0;
1808     r = guestfs_dmesg (g);
1809     if (r == NULL)
1810       return -1;
1811     free (r);
1812   }
1813   return 0;
1814 }
1815
1816 static int test_drop_caches_0_skip (void)
1817 {
1818   const char *str;
1819
1820   str = getenv ("SKIP_TEST_DROP_CACHES_0");
1821   if (str && strcmp (str, "1") == 0) return 1;
1822   str = getenv ("SKIP_TEST_DROP_CACHES");
1823   if (str && strcmp (str, "1") == 0) return 1;
1824   return 0;
1825 }
1826
1827 static int test_drop_caches_0 (void)
1828 {
1829   if (test_drop_caches_0_skip ()) {
1830     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1831     return 0;
1832   }
1833
1834   /* InitNone|InitEmpty for test_drop_caches_0 */
1835   {
1836     char device[] = "/dev/sda";
1837     device[5] = devchar;
1838     int r;
1839     suppress_error = 0;
1840     r = guestfs_blockdev_setrw (g, device);
1841     if (r == -1)
1842       return -1;
1843   }
1844   {
1845     int r;
1846     suppress_error = 0;
1847     r = guestfs_umount_all (g);
1848     if (r == -1)
1849       return -1;
1850   }
1851   {
1852     int r;
1853     suppress_error = 0;
1854     r = guestfs_lvm_remove_all (g);
1855     if (r == -1)
1856       return -1;
1857   }
1858   /* TestRun for drop_caches (0) */
1859   {
1860     int r;
1861     suppress_error = 0;
1862     r = guestfs_drop_caches (g, 3);
1863     if (r == -1)
1864       return -1;
1865   }
1866   return 0;
1867 }
1868
1869 static int test_mv_0_skip (void)
1870 {
1871   const char *str;
1872
1873   str = getenv ("SKIP_TEST_MV_0");
1874   if (str && strcmp (str, "1") == 0) return 1;
1875   str = getenv ("SKIP_TEST_MV");
1876   if (str && strcmp (str, "1") == 0) return 1;
1877   return 0;
1878 }
1879
1880 static int test_mv_0 (void)
1881 {
1882   if (test_mv_0_skip ()) {
1883     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
1884     return 0;
1885   }
1886
1887   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1888   {
1889     char device[] = "/dev/sda";
1890     device[5] = devchar;
1891     int r;
1892     suppress_error = 0;
1893     r = guestfs_blockdev_setrw (g, device);
1894     if (r == -1)
1895       return -1;
1896   }
1897   {
1898     int r;
1899     suppress_error = 0;
1900     r = guestfs_umount_all (g);
1901     if (r == -1)
1902       return -1;
1903   }
1904   {
1905     int r;
1906     suppress_error = 0;
1907     r = guestfs_lvm_remove_all (g);
1908     if (r == -1)
1909       return -1;
1910   }
1911   {
1912     char device[] = "/dev/sda";
1913     device[5] = devchar;
1914     char lines_0[] = ",";
1915     char *lines[] = {
1916       lines_0,
1917       NULL
1918     };
1919     int r;
1920     suppress_error = 0;
1921     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1922     if (r == -1)
1923       return -1;
1924   }
1925   {
1926     char fstype[] = "ext2";
1927     char device[] = "/dev/sda1";
1928     device[5] = devchar;
1929     int r;
1930     suppress_error = 0;
1931     r = guestfs_mkfs (g, fstype, device);
1932     if (r == -1)
1933       return -1;
1934   }
1935   {
1936     char device[] = "/dev/sda1";
1937     device[5] = devchar;
1938     char mountpoint[] = "/";
1939     int r;
1940     suppress_error = 0;
1941     r = guestfs_mount (g, device, mountpoint);
1942     if (r == -1)
1943       return -1;
1944   }
1945   /* TestOutput for mv (0) */
1946   char expected[] = "file content";
1947   {
1948     char path[] = "/old";
1949     char content[] = "file content";
1950     int r;
1951     suppress_error = 0;
1952     r = guestfs_write_file (g, path, content, 0);
1953     if (r == -1)
1954       return -1;
1955   }
1956   {
1957     char src[] = "/old";
1958     char dest[] = "/new";
1959     int r;
1960     suppress_error = 0;
1961     r = guestfs_mv (g, src, dest);
1962     if (r == -1)
1963       return -1;
1964   }
1965   {
1966     char path[] = "/new";
1967     char *r;
1968     suppress_error = 0;
1969     r = guestfs_cat (g, path);
1970     if (r == NULL)
1971       return -1;
1972     if (strcmp (r, expected) != 0) {
1973       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1974       return -1;
1975     }
1976     free (r);
1977   }
1978   return 0;
1979 }
1980
1981 static int test_mv_1_skip (void)
1982 {
1983   const char *str;
1984
1985   str = getenv ("SKIP_TEST_MV_1");
1986   if (str && strcmp (str, "1") == 0) return 1;
1987   str = getenv ("SKIP_TEST_MV");
1988   if (str && strcmp (str, "1") == 0) return 1;
1989   return 0;
1990 }
1991
1992 static int test_mv_1 (void)
1993 {
1994   if (test_mv_1_skip ()) {
1995     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
1996     return 0;
1997   }
1998
1999   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2000   {
2001     char device[] = "/dev/sda";
2002     device[5] = devchar;
2003     int r;
2004     suppress_error = 0;
2005     r = guestfs_blockdev_setrw (g, device);
2006     if (r == -1)
2007       return -1;
2008   }
2009   {
2010     int r;
2011     suppress_error = 0;
2012     r = guestfs_umount_all (g);
2013     if (r == -1)
2014       return -1;
2015   }
2016   {
2017     int r;
2018     suppress_error = 0;
2019     r = guestfs_lvm_remove_all (g);
2020     if (r == -1)
2021       return -1;
2022   }
2023   {
2024     char device[] = "/dev/sda";
2025     device[5] = devchar;
2026     char lines_0[] = ",";
2027     char *lines[] = {
2028       lines_0,
2029       NULL
2030     };
2031     int r;
2032     suppress_error = 0;
2033     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2034     if (r == -1)
2035       return -1;
2036   }
2037   {
2038     char fstype[] = "ext2";
2039     char device[] = "/dev/sda1";
2040     device[5] = devchar;
2041     int r;
2042     suppress_error = 0;
2043     r = guestfs_mkfs (g, fstype, device);
2044     if (r == -1)
2045       return -1;
2046   }
2047   {
2048     char device[] = "/dev/sda1";
2049     device[5] = devchar;
2050     char mountpoint[] = "/";
2051     int r;
2052     suppress_error = 0;
2053     r = guestfs_mount (g, device, mountpoint);
2054     if (r == -1)
2055       return -1;
2056   }
2057   /* TestOutputFalse for mv (1) */
2058   {
2059     char path[] = "/old";
2060     char content[] = "file content";
2061     int r;
2062     suppress_error = 0;
2063     r = guestfs_write_file (g, path, content, 0);
2064     if (r == -1)
2065       return -1;
2066   }
2067   {
2068     char src[] = "/old";
2069     char dest[] = "/new";
2070     int r;
2071     suppress_error = 0;
2072     r = guestfs_mv (g, src, dest);
2073     if (r == -1)
2074       return -1;
2075   }
2076   {
2077     char path[] = "/old";
2078     int r;
2079     suppress_error = 0;
2080     r = guestfs_is_file (g, path);
2081     if (r == -1)
2082       return -1;
2083     if (r) {
2084       fprintf (stderr, "test_mv_1: expected false, got true\n");
2085       return -1;
2086     }
2087   }
2088   return 0;
2089 }
2090
2091 static int test_cp_a_0_skip (void)
2092 {
2093   const char *str;
2094
2095   str = getenv ("SKIP_TEST_CP_A_0");
2096   if (str && strcmp (str, "1") == 0) return 1;
2097   str = getenv ("SKIP_TEST_CP_A");
2098   if (str && strcmp (str, "1") == 0) return 1;
2099   return 0;
2100 }
2101
2102 static int test_cp_a_0 (void)
2103 {
2104   if (test_cp_a_0_skip ()) {
2105     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2106     return 0;
2107   }
2108
2109   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2110   {
2111     char device[] = "/dev/sda";
2112     device[5] = devchar;
2113     int r;
2114     suppress_error = 0;
2115     r = guestfs_blockdev_setrw (g, device);
2116     if (r == -1)
2117       return -1;
2118   }
2119   {
2120     int r;
2121     suppress_error = 0;
2122     r = guestfs_umount_all (g);
2123     if (r == -1)
2124       return -1;
2125   }
2126   {
2127     int r;
2128     suppress_error = 0;
2129     r = guestfs_lvm_remove_all (g);
2130     if (r == -1)
2131       return -1;
2132   }
2133   {
2134     char device[] = "/dev/sda";
2135     device[5] = devchar;
2136     char lines_0[] = ",";
2137     char *lines[] = {
2138       lines_0,
2139       NULL
2140     };
2141     int r;
2142     suppress_error = 0;
2143     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2144     if (r == -1)
2145       return -1;
2146   }
2147   {
2148     char fstype[] = "ext2";
2149     char device[] = "/dev/sda1";
2150     device[5] = devchar;
2151     int r;
2152     suppress_error = 0;
2153     r = guestfs_mkfs (g, fstype, device);
2154     if (r == -1)
2155       return -1;
2156   }
2157   {
2158     char device[] = "/dev/sda1";
2159     device[5] = devchar;
2160     char mountpoint[] = "/";
2161     int r;
2162     suppress_error = 0;
2163     r = guestfs_mount (g, device, mountpoint);
2164     if (r == -1)
2165       return -1;
2166   }
2167   /* TestOutput for cp_a (0) */
2168   char expected[] = "file content";
2169   {
2170     char path[] = "/olddir";
2171     int r;
2172     suppress_error = 0;
2173     r = guestfs_mkdir (g, path);
2174     if (r == -1)
2175       return -1;
2176   }
2177   {
2178     char path[] = "/newdir";
2179     int r;
2180     suppress_error = 0;
2181     r = guestfs_mkdir (g, path);
2182     if (r == -1)
2183       return -1;
2184   }
2185   {
2186     char path[] = "/olddir/file";
2187     char content[] = "file content";
2188     int r;
2189     suppress_error = 0;
2190     r = guestfs_write_file (g, path, content, 0);
2191     if (r == -1)
2192       return -1;
2193   }
2194   {
2195     char src[] = "/olddir";
2196     char dest[] = "/newdir";
2197     int r;
2198     suppress_error = 0;
2199     r = guestfs_cp_a (g, src, dest);
2200     if (r == -1)
2201       return -1;
2202   }
2203   {
2204     char path[] = "/newdir/olddir/file";
2205     char *r;
2206     suppress_error = 0;
2207     r = guestfs_cat (g, path);
2208     if (r == NULL)
2209       return -1;
2210     if (strcmp (r, expected) != 0) {
2211       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2212       return -1;
2213     }
2214     free (r);
2215   }
2216   return 0;
2217 }
2218
2219 static int test_cp_0_skip (void)
2220 {
2221   const char *str;
2222
2223   str = getenv ("SKIP_TEST_CP_0");
2224   if (str && strcmp (str, "1") == 0) return 1;
2225   str = getenv ("SKIP_TEST_CP");
2226   if (str && strcmp (str, "1") == 0) return 1;
2227   return 0;
2228 }
2229
2230 static int test_cp_0 (void)
2231 {
2232   if (test_cp_0_skip ()) {
2233     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2234     return 0;
2235   }
2236
2237   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2238   {
2239     char device[] = "/dev/sda";
2240     device[5] = devchar;
2241     int r;
2242     suppress_error = 0;
2243     r = guestfs_blockdev_setrw (g, device);
2244     if (r == -1)
2245       return -1;
2246   }
2247   {
2248     int r;
2249     suppress_error = 0;
2250     r = guestfs_umount_all (g);
2251     if (r == -1)
2252       return -1;
2253   }
2254   {
2255     int r;
2256     suppress_error = 0;
2257     r = guestfs_lvm_remove_all (g);
2258     if (r == -1)
2259       return -1;
2260   }
2261   {
2262     char device[] = "/dev/sda";
2263     device[5] = devchar;
2264     char lines_0[] = ",";
2265     char *lines[] = {
2266       lines_0,
2267       NULL
2268     };
2269     int r;
2270     suppress_error = 0;
2271     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2272     if (r == -1)
2273       return -1;
2274   }
2275   {
2276     char fstype[] = "ext2";
2277     char device[] = "/dev/sda1";
2278     device[5] = devchar;
2279     int r;
2280     suppress_error = 0;
2281     r = guestfs_mkfs (g, fstype, device);
2282     if (r == -1)
2283       return -1;
2284   }
2285   {
2286     char device[] = "/dev/sda1";
2287     device[5] = devchar;
2288     char mountpoint[] = "/";
2289     int r;
2290     suppress_error = 0;
2291     r = guestfs_mount (g, device, mountpoint);
2292     if (r == -1)
2293       return -1;
2294   }
2295   /* TestOutput for cp (0) */
2296   char expected[] = "file content";
2297   {
2298     char path[] = "/old";
2299     char content[] = "file content";
2300     int r;
2301     suppress_error = 0;
2302     r = guestfs_write_file (g, path, content, 0);
2303     if (r == -1)
2304       return -1;
2305   }
2306   {
2307     char src[] = "/old";
2308     char dest[] = "/new";
2309     int r;
2310     suppress_error = 0;
2311     r = guestfs_cp (g, src, dest);
2312     if (r == -1)
2313       return -1;
2314   }
2315   {
2316     char path[] = "/new";
2317     char *r;
2318     suppress_error = 0;
2319     r = guestfs_cat (g, path);
2320     if (r == NULL)
2321       return -1;
2322     if (strcmp (r, expected) != 0) {
2323       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2324       return -1;
2325     }
2326     free (r);
2327   }
2328   return 0;
2329 }
2330
2331 static int test_cp_1_skip (void)
2332 {
2333   const char *str;
2334
2335   str = getenv ("SKIP_TEST_CP_1");
2336   if (str && strcmp (str, "1") == 0) return 1;
2337   str = getenv ("SKIP_TEST_CP");
2338   if (str && strcmp (str, "1") == 0) return 1;
2339   return 0;
2340 }
2341
2342 static int test_cp_1 (void)
2343 {
2344   if (test_cp_1_skip ()) {
2345     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2346     return 0;
2347   }
2348
2349   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2350   {
2351     char device[] = "/dev/sda";
2352     device[5] = devchar;
2353     int r;
2354     suppress_error = 0;
2355     r = guestfs_blockdev_setrw (g, device);
2356     if (r == -1)
2357       return -1;
2358   }
2359   {
2360     int r;
2361     suppress_error = 0;
2362     r = guestfs_umount_all (g);
2363     if (r == -1)
2364       return -1;
2365   }
2366   {
2367     int r;
2368     suppress_error = 0;
2369     r = guestfs_lvm_remove_all (g);
2370     if (r == -1)
2371       return -1;
2372   }
2373   {
2374     char device[] = "/dev/sda";
2375     device[5] = devchar;
2376     char lines_0[] = ",";
2377     char *lines[] = {
2378       lines_0,
2379       NULL
2380     };
2381     int r;
2382     suppress_error = 0;
2383     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2384     if (r == -1)
2385       return -1;
2386   }
2387   {
2388     char fstype[] = "ext2";
2389     char device[] = "/dev/sda1";
2390     device[5] = devchar;
2391     int r;
2392     suppress_error = 0;
2393     r = guestfs_mkfs (g, fstype, device);
2394     if (r == -1)
2395       return -1;
2396   }
2397   {
2398     char device[] = "/dev/sda1";
2399     device[5] = devchar;
2400     char mountpoint[] = "/";
2401     int r;
2402     suppress_error = 0;
2403     r = guestfs_mount (g, device, mountpoint);
2404     if (r == -1)
2405       return -1;
2406   }
2407   /* TestOutputTrue for cp (1) */
2408   {
2409     char path[] = "/old";
2410     char content[] = "file content";
2411     int r;
2412     suppress_error = 0;
2413     r = guestfs_write_file (g, path, content, 0);
2414     if (r == -1)
2415       return -1;
2416   }
2417   {
2418     char src[] = "/old";
2419     char dest[] = "/new";
2420     int r;
2421     suppress_error = 0;
2422     r = guestfs_cp (g, src, dest);
2423     if (r == -1)
2424       return -1;
2425   }
2426   {
2427     char path[] = "/old";
2428     int r;
2429     suppress_error = 0;
2430     r = guestfs_is_file (g, path);
2431     if (r == -1)
2432       return -1;
2433     if (!r) {
2434       fprintf (stderr, "test_cp_1: expected true, got false\n");
2435       return -1;
2436     }
2437   }
2438   return 0;
2439 }
2440
2441 static int test_cp_2_skip (void)
2442 {
2443   const char *str;
2444
2445   str = getenv ("SKIP_TEST_CP_2");
2446   if (str && strcmp (str, "1") == 0) return 1;
2447   str = getenv ("SKIP_TEST_CP");
2448   if (str && strcmp (str, "1") == 0) return 1;
2449   return 0;
2450 }
2451
2452 static int test_cp_2 (void)
2453 {
2454   if (test_cp_2_skip ()) {
2455     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2456     return 0;
2457   }
2458
2459   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2460   {
2461     char device[] = "/dev/sda";
2462     device[5] = devchar;
2463     int r;
2464     suppress_error = 0;
2465     r = guestfs_blockdev_setrw (g, device);
2466     if (r == -1)
2467       return -1;
2468   }
2469   {
2470     int r;
2471     suppress_error = 0;
2472     r = guestfs_umount_all (g);
2473     if (r == -1)
2474       return -1;
2475   }
2476   {
2477     int r;
2478     suppress_error = 0;
2479     r = guestfs_lvm_remove_all (g);
2480     if (r == -1)
2481       return -1;
2482   }
2483   {
2484     char device[] = "/dev/sda";
2485     device[5] = devchar;
2486     char lines_0[] = ",";
2487     char *lines[] = {
2488       lines_0,
2489       NULL
2490     };
2491     int r;
2492     suppress_error = 0;
2493     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2494     if (r == -1)
2495       return -1;
2496   }
2497   {
2498     char fstype[] = "ext2";
2499     char device[] = "/dev/sda1";
2500     device[5] = devchar;
2501     int r;
2502     suppress_error = 0;
2503     r = guestfs_mkfs (g, fstype, device);
2504     if (r == -1)
2505       return -1;
2506   }
2507   {
2508     char device[] = "/dev/sda1";
2509     device[5] = devchar;
2510     char mountpoint[] = "/";
2511     int r;
2512     suppress_error = 0;
2513     r = guestfs_mount (g, device, mountpoint);
2514     if (r == -1)
2515       return -1;
2516   }
2517   /* TestOutput for cp (2) */
2518   char expected[] = "file content";
2519   {
2520     char path[] = "/old";
2521     char content[] = "file content";
2522     int r;
2523     suppress_error = 0;
2524     r = guestfs_write_file (g, path, content, 0);
2525     if (r == -1)
2526       return -1;
2527   }
2528   {
2529     char path[] = "/dir";
2530     int r;
2531     suppress_error = 0;
2532     r = guestfs_mkdir (g, path);
2533     if (r == -1)
2534       return -1;
2535   }
2536   {
2537     char src[] = "/old";
2538     char dest[] = "/dir/new";
2539     int r;
2540     suppress_error = 0;
2541     r = guestfs_cp (g, src, dest);
2542     if (r == -1)
2543       return -1;
2544   }
2545   {
2546     char path[] = "/dir/new";
2547     char *r;
2548     suppress_error = 0;
2549     r = guestfs_cat (g, path);
2550     if (r == NULL)
2551       return -1;
2552     if (strcmp (r, expected) != 0) {
2553       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2554       return -1;
2555     }
2556     free (r);
2557   }
2558   return 0;
2559 }
2560
2561 static int test_grub_install_0_skip (void)
2562 {
2563   const char *str;
2564
2565   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2566   if (str && strcmp (str, "1") == 0) return 1;
2567   str = getenv ("SKIP_TEST_GRUB_INSTALL");
2568   if (str && strcmp (str, "1") == 0) return 1;
2569   return 0;
2570 }
2571
2572 static int test_grub_install_0 (void)
2573 {
2574   if (test_grub_install_0_skip ()) {
2575     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2576     return 0;
2577   }
2578
2579   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2580   {
2581     char device[] = "/dev/sda";
2582     device[5] = devchar;
2583     int r;
2584     suppress_error = 0;
2585     r = guestfs_blockdev_setrw (g, device);
2586     if (r == -1)
2587       return -1;
2588   }
2589   {
2590     int r;
2591     suppress_error = 0;
2592     r = guestfs_umount_all (g);
2593     if (r == -1)
2594       return -1;
2595   }
2596   {
2597     int r;
2598     suppress_error = 0;
2599     r = guestfs_lvm_remove_all (g);
2600     if (r == -1)
2601       return -1;
2602   }
2603   {
2604     char device[] = "/dev/sda";
2605     device[5] = devchar;
2606     char lines_0[] = ",";
2607     char *lines[] = {
2608       lines_0,
2609       NULL
2610     };
2611     int r;
2612     suppress_error = 0;
2613     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2614     if (r == -1)
2615       return -1;
2616   }
2617   {
2618     char fstype[] = "ext2";
2619     char device[] = "/dev/sda1";
2620     device[5] = devchar;
2621     int r;
2622     suppress_error = 0;
2623     r = guestfs_mkfs (g, fstype, device);
2624     if (r == -1)
2625       return -1;
2626   }
2627   {
2628     char device[] = "/dev/sda1";
2629     device[5] = devchar;
2630     char mountpoint[] = "/";
2631     int r;
2632     suppress_error = 0;
2633     r = guestfs_mount (g, device, mountpoint);
2634     if (r == -1)
2635       return -1;
2636   }
2637   /* TestOutputTrue for grub_install (0) */
2638   {
2639     char root[] = "/";
2640     char device[] = "/dev/sda1";
2641     device[5] = devchar;
2642     int r;
2643     suppress_error = 0;
2644     r = guestfs_grub_install (g, root, device);
2645     if (r == -1)
2646       return -1;
2647   }
2648   {
2649     char path[] = "/boot";
2650     int r;
2651     suppress_error = 0;
2652     r = guestfs_is_dir (g, path);
2653     if (r == -1)
2654       return -1;
2655     if (!r) {
2656       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2657       return -1;
2658     }
2659   }
2660   return 0;
2661 }
2662
2663 static int test_zero_0_skip (void)
2664 {
2665   const char *str;
2666
2667   str = getenv ("SKIP_TEST_ZERO_0");
2668   if (str && strcmp (str, "1") == 0) return 1;
2669   str = getenv ("SKIP_TEST_ZERO");
2670   if (str && strcmp (str, "1") == 0) return 1;
2671   return 0;
2672 }
2673
2674 static int test_zero_0 (void)
2675 {
2676   if (test_zero_0_skip ()) {
2677     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2678     return 0;
2679   }
2680
2681   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2682   {
2683     char device[] = "/dev/sda";
2684     device[5] = devchar;
2685     int r;
2686     suppress_error = 0;
2687     r = guestfs_blockdev_setrw (g, device);
2688     if (r == -1)
2689       return -1;
2690   }
2691   {
2692     int r;
2693     suppress_error = 0;
2694     r = guestfs_umount_all (g);
2695     if (r == -1)
2696       return -1;
2697   }
2698   {
2699     int r;
2700     suppress_error = 0;
2701     r = guestfs_lvm_remove_all (g);
2702     if (r == -1)
2703       return -1;
2704   }
2705   {
2706     char device[] = "/dev/sda";
2707     device[5] = devchar;
2708     char lines_0[] = ",";
2709     char *lines[] = {
2710       lines_0,
2711       NULL
2712     };
2713     int r;
2714     suppress_error = 0;
2715     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2716     if (r == -1)
2717       return -1;
2718   }
2719   {
2720     char fstype[] = "ext2";
2721     char device[] = "/dev/sda1";
2722     device[5] = devchar;
2723     int r;
2724     suppress_error = 0;
2725     r = guestfs_mkfs (g, fstype, device);
2726     if (r == -1)
2727       return -1;
2728   }
2729   {
2730     char device[] = "/dev/sda1";
2731     device[5] = devchar;
2732     char mountpoint[] = "/";
2733     int r;
2734     suppress_error = 0;
2735     r = guestfs_mount (g, device, mountpoint);
2736     if (r == -1)
2737       return -1;
2738   }
2739   /* TestOutput for zero (0) */
2740   char expected[] = "data";
2741   {
2742     char pathordevice[] = "/dev/sda1";
2743     pathordevice[5] = devchar;
2744     int r;
2745     suppress_error = 0;
2746     r = guestfs_umount (g, pathordevice);
2747     if (r == -1)
2748       return -1;
2749   }
2750   {
2751     char device[] = "/dev/sda1";
2752     device[5] = devchar;
2753     int r;
2754     suppress_error = 0;
2755     r = guestfs_zero (g, device);
2756     if (r == -1)
2757       return -1;
2758   }
2759   {
2760     char path[] = "/dev/sda1";
2761     path[5] = devchar;
2762     char *r;
2763     suppress_error = 0;
2764     r = guestfs_file (g, path);
2765     if (r == NULL)
2766       return -1;
2767     if (strcmp (r, expected) != 0) {
2768       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2769       return -1;
2770     }
2771     free (r);
2772   }
2773   return 0;
2774 }
2775
2776 static int test_fsck_0_skip (void)
2777 {
2778   const char *str;
2779
2780   str = getenv ("SKIP_TEST_FSCK_0");
2781   if (str && strcmp (str, "1") == 0) return 1;
2782   str = getenv ("SKIP_TEST_FSCK");
2783   if (str && strcmp (str, "1") == 0) return 1;
2784   return 0;
2785 }
2786
2787 static int test_fsck_0 (void)
2788 {
2789   if (test_fsck_0_skip ()) {
2790     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2791     return 0;
2792   }
2793
2794   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2795   {
2796     char device[] = "/dev/sda";
2797     device[5] = devchar;
2798     int r;
2799     suppress_error = 0;
2800     r = guestfs_blockdev_setrw (g, device);
2801     if (r == -1)
2802       return -1;
2803   }
2804   {
2805     int r;
2806     suppress_error = 0;
2807     r = guestfs_umount_all (g);
2808     if (r == -1)
2809       return -1;
2810   }
2811   {
2812     int r;
2813     suppress_error = 0;
2814     r = guestfs_lvm_remove_all (g);
2815     if (r == -1)
2816       return -1;
2817   }
2818   {
2819     char device[] = "/dev/sda";
2820     device[5] = devchar;
2821     char lines_0[] = ",";
2822     char *lines[] = {
2823       lines_0,
2824       NULL
2825     };
2826     int r;
2827     suppress_error = 0;
2828     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2829     if (r == -1)
2830       return -1;
2831   }
2832   {
2833     char fstype[] = "ext2";
2834     char device[] = "/dev/sda1";
2835     device[5] = devchar;
2836     int r;
2837     suppress_error = 0;
2838     r = guestfs_mkfs (g, fstype, device);
2839     if (r == -1)
2840       return -1;
2841   }
2842   {
2843     char device[] = "/dev/sda1";
2844     device[5] = devchar;
2845     char mountpoint[] = "/";
2846     int r;
2847     suppress_error = 0;
2848     r = guestfs_mount (g, device, mountpoint);
2849     if (r == -1)
2850       return -1;
2851   }
2852   /* TestOutputInt for fsck (0) */
2853   {
2854     char pathordevice[] = "/dev/sda1";
2855     pathordevice[5] = devchar;
2856     int r;
2857     suppress_error = 0;
2858     r = guestfs_umount (g, pathordevice);
2859     if (r == -1)
2860       return -1;
2861   }
2862   {
2863     char fstype[] = "ext2";
2864     char device[] = "/dev/sda1";
2865     device[5] = devchar;
2866     int r;
2867     suppress_error = 0;
2868     r = guestfs_fsck (g, fstype, device);
2869     if (r == -1)
2870       return -1;
2871     if (r != 0) {
2872       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
2873       return -1;
2874     }
2875   }
2876   return 0;
2877 }
2878
2879 static int test_fsck_1_skip (void)
2880 {
2881   const char *str;
2882
2883   str = getenv ("SKIP_TEST_FSCK_1");
2884   if (str && strcmp (str, "1") == 0) return 1;
2885   str = getenv ("SKIP_TEST_FSCK");
2886   if (str && strcmp (str, "1") == 0) return 1;
2887   return 0;
2888 }
2889
2890 static int test_fsck_1 (void)
2891 {
2892   if (test_fsck_1_skip ()) {
2893     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
2894     return 0;
2895   }
2896
2897   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2898   {
2899     char device[] = "/dev/sda";
2900     device[5] = devchar;
2901     int r;
2902     suppress_error = 0;
2903     r = guestfs_blockdev_setrw (g, device);
2904     if (r == -1)
2905       return -1;
2906   }
2907   {
2908     int r;
2909     suppress_error = 0;
2910     r = guestfs_umount_all (g);
2911     if (r == -1)
2912       return -1;
2913   }
2914   {
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_lvm_remove_all (g);
2918     if (r == -1)
2919       return -1;
2920   }
2921   {
2922     char device[] = "/dev/sda";
2923     device[5] = devchar;
2924     char lines_0[] = ",";
2925     char *lines[] = {
2926       lines_0,
2927       NULL
2928     };
2929     int r;
2930     suppress_error = 0;
2931     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2932     if (r == -1)
2933       return -1;
2934   }
2935   {
2936     char fstype[] = "ext2";
2937     char device[] = "/dev/sda1";
2938     device[5] = devchar;
2939     int r;
2940     suppress_error = 0;
2941     r = guestfs_mkfs (g, fstype, device);
2942     if (r == -1)
2943       return -1;
2944   }
2945   {
2946     char device[] = "/dev/sda1";
2947     device[5] = devchar;
2948     char mountpoint[] = "/";
2949     int r;
2950     suppress_error = 0;
2951     r = guestfs_mount (g, device, mountpoint);
2952     if (r == -1)
2953       return -1;
2954   }
2955   /* TestOutputInt for fsck (1) */
2956   {
2957     char pathordevice[] = "/dev/sda1";
2958     pathordevice[5] = devchar;
2959     int r;
2960     suppress_error = 0;
2961     r = guestfs_umount (g, pathordevice);
2962     if (r == -1)
2963       return -1;
2964   }
2965   {
2966     char device[] = "/dev/sda1";
2967     device[5] = devchar;
2968     int r;
2969     suppress_error = 0;
2970     r = guestfs_zero (g, device);
2971     if (r == -1)
2972       return -1;
2973   }
2974   {
2975     char fstype[] = "ext2";
2976     char device[] = "/dev/sda1";
2977     device[5] = devchar;
2978     int r;
2979     suppress_error = 0;
2980     r = guestfs_fsck (g, fstype, device);
2981     if (r == -1)
2982       return -1;
2983     if (r != 8) {
2984       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
2985       return -1;
2986     }
2987   }
2988   return 0;
2989 }
2990
2991 static int test_set_e2uuid_0_skip (void)
2992 {
2993   const char *str;
2994
2995   str = getenv ("SKIP_TEST_SET_E2UUID_0");
2996   if (str && strcmp (str, "1") == 0) return 1;
2997   str = getenv ("SKIP_TEST_SET_E2UUID");
2998   if (str && strcmp (str, "1") == 0) return 1;
2999   return 0;
3000 }
3001
3002 static int test_set_e2uuid_0 (void)
3003 {
3004   if (test_set_e2uuid_0_skip ()) {
3005     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3006     return 0;
3007   }
3008
3009   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3010   {
3011     char device[] = "/dev/sda";
3012     device[5] = devchar;
3013     int r;
3014     suppress_error = 0;
3015     r = guestfs_blockdev_setrw (g, device);
3016     if (r == -1)
3017       return -1;
3018   }
3019   {
3020     int r;
3021     suppress_error = 0;
3022     r = guestfs_umount_all (g);
3023     if (r == -1)
3024       return -1;
3025   }
3026   {
3027     int r;
3028     suppress_error = 0;
3029     r = guestfs_lvm_remove_all (g);
3030     if (r == -1)
3031       return -1;
3032   }
3033   {
3034     char device[] = "/dev/sda";
3035     device[5] = devchar;
3036     char lines_0[] = ",";
3037     char *lines[] = {
3038       lines_0,
3039       NULL
3040     };
3041     int r;
3042     suppress_error = 0;
3043     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3044     if (r == -1)
3045       return -1;
3046   }
3047   {
3048     char fstype[] = "ext2";
3049     char device[] = "/dev/sda1";
3050     device[5] = devchar;
3051     int r;
3052     suppress_error = 0;
3053     r = guestfs_mkfs (g, fstype, device);
3054     if (r == -1)
3055       return -1;
3056   }
3057   {
3058     char device[] = "/dev/sda1";
3059     device[5] = devchar;
3060     char mountpoint[] = "/";
3061     int r;
3062     suppress_error = 0;
3063     r = guestfs_mount (g, device, mountpoint);
3064     if (r == -1)
3065       return -1;
3066   }
3067   /* TestOutput for set_e2uuid (0) */
3068   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3069   {
3070     char device[] = "/dev/sda1";
3071     device[5] = devchar;
3072     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3073     int r;
3074     suppress_error = 0;
3075     r = guestfs_set_e2uuid (g, device, uuid);
3076     if (r == -1)
3077       return -1;
3078   }
3079   {
3080     char device[] = "/dev/sda1";
3081     device[5] = devchar;
3082     char *r;
3083     suppress_error = 0;
3084     r = guestfs_get_e2uuid (g, device);
3085     if (r == NULL)
3086       return -1;
3087     if (strcmp (r, expected) != 0) {
3088       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3089       return -1;
3090     }
3091     free (r);
3092   }
3093   return 0;
3094 }
3095
3096 static int test_set_e2uuid_1_skip (void)
3097 {
3098   const char *str;
3099
3100   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3101   if (str && strcmp (str, "1") == 0) return 1;
3102   str = getenv ("SKIP_TEST_SET_E2UUID");
3103   if (str && strcmp (str, "1") == 0) return 1;
3104   return 0;
3105 }
3106
3107 static int test_set_e2uuid_1 (void)
3108 {
3109   if (test_set_e2uuid_1_skip ()) {
3110     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3111     return 0;
3112   }
3113
3114   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3115   {
3116     char device[] = "/dev/sda";
3117     device[5] = devchar;
3118     int r;
3119     suppress_error = 0;
3120     r = guestfs_blockdev_setrw (g, device);
3121     if (r == -1)
3122       return -1;
3123   }
3124   {
3125     int r;
3126     suppress_error = 0;
3127     r = guestfs_umount_all (g);
3128     if (r == -1)
3129       return -1;
3130   }
3131   {
3132     int r;
3133     suppress_error = 0;
3134     r = guestfs_lvm_remove_all (g);
3135     if (r == -1)
3136       return -1;
3137   }
3138   {
3139     char device[] = "/dev/sda";
3140     device[5] = devchar;
3141     char lines_0[] = ",";
3142     char *lines[] = {
3143       lines_0,
3144       NULL
3145     };
3146     int r;
3147     suppress_error = 0;
3148     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3149     if (r == -1)
3150       return -1;
3151   }
3152   {
3153     char fstype[] = "ext2";
3154     char device[] = "/dev/sda1";
3155     device[5] = devchar;
3156     int r;
3157     suppress_error = 0;
3158     r = guestfs_mkfs (g, fstype, device);
3159     if (r == -1)
3160       return -1;
3161   }
3162   {
3163     char device[] = "/dev/sda1";
3164     device[5] = devchar;
3165     char mountpoint[] = "/";
3166     int r;
3167     suppress_error = 0;
3168     r = guestfs_mount (g, device, mountpoint);
3169     if (r == -1)
3170       return -1;
3171   }
3172   /* TestOutput for set_e2uuid (1) */
3173   char expected[] = "";
3174   {
3175     char device[] = "/dev/sda1";
3176     device[5] = devchar;
3177     char uuid[] = "clear";
3178     int r;
3179     suppress_error = 0;
3180     r = guestfs_set_e2uuid (g, device, uuid);
3181     if (r == -1)
3182       return -1;
3183   }
3184   {
3185     char device[] = "/dev/sda1";
3186     device[5] = devchar;
3187     char *r;
3188     suppress_error = 0;
3189     r = guestfs_get_e2uuid (g, device);
3190     if (r == NULL)
3191       return -1;
3192     if (strcmp (r, expected) != 0) {
3193       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3194       return -1;
3195     }
3196     free (r);
3197   }
3198   return 0;
3199 }
3200
3201 static int test_set_e2uuid_2_skip (void)
3202 {
3203   const char *str;
3204
3205   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3206   if (str && strcmp (str, "1") == 0) return 1;
3207   str = getenv ("SKIP_TEST_SET_E2UUID");
3208   if (str && strcmp (str, "1") == 0) return 1;
3209   return 0;
3210 }
3211
3212 static int test_set_e2uuid_2 (void)
3213 {
3214   if (test_set_e2uuid_2_skip ()) {
3215     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3216     return 0;
3217   }
3218
3219   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3220   {
3221     char device[] = "/dev/sda";
3222     device[5] = devchar;
3223     int r;
3224     suppress_error = 0;
3225     r = guestfs_blockdev_setrw (g, device);
3226     if (r == -1)
3227       return -1;
3228   }
3229   {
3230     int r;
3231     suppress_error = 0;
3232     r = guestfs_umount_all (g);
3233     if (r == -1)
3234       return -1;
3235   }
3236   {
3237     int r;
3238     suppress_error = 0;
3239     r = guestfs_lvm_remove_all (g);
3240     if (r == -1)
3241       return -1;
3242   }
3243   {
3244     char device[] = "/dev/sda";
3245     device[5] = devchar;
3246     char lines_0[] = ",";
3247     char *lines[] = {
3248       lines_0,
3249       NULL
3250     };
3251     int r;
3252     suppress_error = 0;
3253     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3254     if (r == -1)
3255       return -1;
3256   }
3257   {
3258     char fstype[] = "ext2";
3259     char device[] = "/dev/sda1";
3260     device[5] = devchar;
3261     int r;
3262     suppress_error = 0;
3263     r = guestfs_mkfs (g, fstype, device);
3264     if (r == -1)
3265       return -1;
3266   }
3267   {
3268     char device[] = "/dev/sda1";
3269     device[5] = devchar;
3270     char mountpoint[] = "/";
3271     int r;
3272     suppress_error = 0;
3273     r = guestfs_mount (g, device, mountpoint);
3274     if (r == -1)
3275       return -1;
3276   }
3277   /* TestRun for set_e2uuid (2) */
3278   {
3279     char device[] = "/dev/sda1";
3280     device[5] = devchar;
3281     char uuid[] = "random";
3282     int r;
3283     suppress_error = 0;
3284     r = guestfs_set_e2uuid (g, device, uuid);
3285     if (r == -1)
3286       return -1;
3287   }
3288   return 0;
3289 }
3290
3291 static int test_set_e2uuid_3_skip (void)
3292 {
3293   const char *str;
3294
3295   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3296   if (str && strcmp (str, "1") == 0) return 1;
3297   str = getenv ("SKIP_TEST_SET_E2UUID");
3298   if (str && strcmp (str, "1") == 0) return 1;
3299   return 0;
3300 }
3301
3302 static int test_set_e2uuid_3 (void)
3303 {
3304   if (test_set_e2uuid_3_skip ()) {
3305     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3306     return 0;
3307   }
3308
3309   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3310   {
3311     char device[] = "/dev/sda";
3312     device[5] = devchar;
3313     int r;
3314     suppress_error = 0;
3315     r = guestfs_blockdev_setrw (g, device);
3316     if (r == -1)
3317       return -1;
3318   }
3319   {
3320     int r;
3321     suppress_error = 0;
3322     r = guestfs_umount_all (g);
3323     if (r == -1)
3324       return -1;
3325   }
3326   {
3327     int r;
3328     suppress_error = 0;
3329     r = guestfs_lvm_remove_all (g);
3330     if (r == -1)
3331       return -1;
3332   }
3333   {
3334     char device[] = "/dev/sda";
3335     device[5] = devchar;
3336     char lines_0[] = ",";
3337     char *lines[] = {
3338       lines_0,
3339       NULL
3340     };
3341     int r;
3342     suppress_error = 0;
3343     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3344     if (r == -1)
3345       return -1;
3346   }
3347   {
3348     char fstype[] = "ext2";
3349     char device[] = "/dev/sda1";
3350     device[5] = devchar;
3351     int r;
3352     suppress_error = 0;
3353     r = guestfs_mkfs (g, fstype, device);
3354     if (r == -1)
3355       return -1;
3356   }
3357   {
3358     char device[] = "/dev/sda1";
3359     device[5] = devchar;
3360     char mountpoint[] = "/";
3361     int r;
3362     suppress_error = 0;
3363     r = guestfs_mount (g, device, mountpoint);
3364     if (r == -1)
3365       return -1;
3366   }
3367   /* TestRun for set_e2uuid (3) */
3368   {
3369     char device[] = "/dev/sda1";
3370     device[5] = devchar;
3371     char uuid[] = "time";
3372     int r;
3373     suppress_error = 0;
3374     r = guestfs_set_e2uuid (g, device, uuid);
3375     if (r == -1)
3376       return -1;
3377   }
3378   return 0;
3379 }
3380
3381 static int test_set_e2label_0_skip (void)
3382 {
3383   const char *str;
3384
3385   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3386   if (str && strcmp (str, "1") == 0) return 1;
3387   str = getenv ("SKIP_TEST_SET_E2LABEL");
3388   if (str && strcmp (str, "1") == 0) return 1;
3389   return 0;
3390 }
3391
3392 static int test_set_e2label_0 (void)
3393 {
3394   if (test_set_e2label_0_skip ()) {
3395     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3396     return 0;
3397   }
3398
3399   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3400   {
3401     char device[] = "/dev/sda";
3402     device[5] = devchar;
3403     int r;
3404     suppress_error = 0;
3405     r = guestfs_blockdev_setrw (g, device);
3406     if (r == -1)
3407       return -1;
3408   }
3409   {
3410     int r;
3411     suppress_error = 0;
3412     r = guestfs_umount_all (g);
3413     if (r == -1)
3414       return -1;
3415   }
3416   {
3417     int r;
3418     suppress_error = 0;
3419     r = guestfs_lvm_remove_all (g);
3420     if (r == -1)
3421       return -1;
3422   }
3423   {
3424     char device[] = "/dev/sda";
3425     device[5] = devchar;
3426     char lines_0[] = ",";
3427     char *lines[] = {
3428       lines_0,
3429       NULL
3430     };
3431     int r;
3432     suppress_error = 0;
3433     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3434     if (r == -1)
3435       return -1;
3436   }
3437   {
3438     char fstype[] = "ext2";
3439     char device[] = "/dev/sda1";
3440     device[5] = devchar;
3441     int r;
3442     suppress_error = 0;
3443     r = guestfs_mkfs (g, fstype, device);
3444     if (r == -1)
3445       return -1;
3446   }
3447   {
3448     char device[] = "/dev/sda1";
3449     device[5] = devchar;
3450     char mountpoint[] = "/";
3451     int r;
3452     suppress_error = 0;
3453     r = guestfs_mount (g, device, mountpoint);
3454     if (r == -1)
3455       return -1;
3456   }
3457   /* TestOutput for set_e2label (0) */
3458   char expected[] = "testlabel";
3459   {
3460     char device[] = "/dev/sda1";
3461     device[5] = devchar;
3462     char label[] = "testlabel";
3463     int r;
3464     suppress_error = 0;
3465     r = guestfs_set_e2label (g, device, label);
3466     if (r == -1)
3467       return -1;
3468   }
3469   {
3470     char device[] = "/dev/sda1";
3471     device[5] = devchar;
3472     char *r;
3473     suppress_error = 0;
3474     r = guestfs_get_e2label (g, device);
3475     if (r == NULL)
3476       return -1;
3477     if (strcmp (r, expected) != 0) {
3478       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3479       return -1;
3480     }
3481     free (r);
3482   }
3483   return 0;
3484 }
3485
3486 static int test_pvremove_0_skip (void)
3487 {
3488   const char *str;
3489
3490   str = getenv ("SKIP_TEST_PVREMOVE_0");
3491   if (str && strcmp (str, "1") == 0) return 1;
3492   str = getenv ("SKIP_TEST_PVREMOVE");
3493   if (str && strcmp (str, "1") == 0) return 1;
3494   return 0;
3495 }
3496
3497 static int test_pvremove_0 (void)
3498 {
3499   if (test_pvremove_0_skip ()) {
3500     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3501     return 0;
3502   }
3503
3504   /* InitNone|InitEmpty for test_pvremove_0 */
3505   {
3506     char device[] = "/dev/sda";
3507     device[5] = devchar;
3508     int r;
3509     suppress_error = 0;
3510     r = guestfs_blockdev_setrw (g, device);
3511     if (r == -1)
3512       return -1;
3513   }
3514   {
3515     int r;
3516     suppress_error = 0;
3517     r = guestfs_umount_all (g);
3518     if (r == -1)
3519       return -1;
3520   }
3521   {
3522     int r;
3523     suppress_error = 0;
3524     r = guestfs_lvm_remove_all (g);
3525     if (r == -1)
3526       return -1;
3527   }
3528   /* TestOutputList for pvremove (0) */
3529   {
3530     char device[] = "/dev/sda";
3531     device[5] = devchar;
3532     char lines_0[] = ",";
3533     char *lines[] = {
3534       lines_0,
3535       NULL
3536     };
3537     int r;
3538     suppress_error = 0;
3539     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3540     if (r == -1)
3541       return -1;
3542   }
3543   {
3544     char device[] = "/dev/sda1";
3545     device[5] = devchar;
3546     int r;
3547     suppress_error = 0;
3548     r = guestfs_pvcreate (g, device);
3549     if (r == -1)
3550       return -1;
3551   }
3552   {
3553     char volgroup[] = "VG";
3554     char physvols_0[] = "/dev/sda1";
3555     physvols_0[5] = devchar;
3556     char *physvols[] = {
3557       physvols_0,
3558       NULL
3559     };
3560     int r;
3561     suppress_error = 0;
3562     r = guestfs_vgcreate (g, volgroup, physvols);
3563     if (r == -1)
3564       return -1;
3565   }
3566   {
3567     char logvol[] = "LV1";
3568     char volgroup[] = "VG";
3569     int r;
3570     suppress_error = 0;
3571     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3572     if (r == -1)
3573       return -1;
3574   }
3575   {
3576     char logvol[] = "LV2";
3577     char volgroup[] = "VG";
3578     int r;
3579     suppress_error = 0;
3580     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3581     if (r == -1)
3582       return -1;
3583   }
3584   {
3585     char vgname[] = "VG";
3586     int r;
3587     suppress_error = 0;
3588     r = guestfs_vgremove (g, vgname);
3589     if (r == -1)
3590       return -1;
3591   }
3592   {
3593     char device[] = "/dev/sda1";
3594     device[5] = devchar;
3595     int r;
3596     suppress_error = 0;
3597     r = guestfs_pvremove (g, device);
3598     if (r == -1)
3599       return -1;
3600   }
3601   {
3602     char **r;
3603     int i;
3604     suppress_error = 0;
3605     r = guestfs_lvs (g);
3606     if (r == NULL)
3607       return -1;
3608     if (r[0] != NULL) {
3609       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3610       print_strings (r);
3611       return -1;
3612     }
3613     for (i = 0; r[i] != NULL; ++i)
3614       free (r[i]);
3615     free (r);
3616   }
3617   return 0;
3618 }
3619
3620 static int test_pvremove_1_skip (void)
3621 {
3622   const char *str;
3623
3624   str = getenv ("SKIP_TEST_PVREMOVE_1");
3625   if (str && strcmp (str, "1") == 0) return 1;
3626   str = getenv ("SKIP_TEST_PVREMOVE");
3627   if (str && strcmp (str, "1") == 0) return 1;
3628   return 0;
3629 }
3630
3631 static int test_pvremove_1 (void)
3632 {
3633   if (test_pvremove_1_skip ()) {
3634     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3635     return 0;
3636   }
3637
3638   /* InitNone|InitEmpty for test_pvremove_1 */
3639   {
3640     char device[] = "/dev/sda";
3641     device[5] = devchar;
3642     int r;
3643     suppress_error = 0;
3644     r = guestfs_blockdev_setrw (g, device);
3645     if (r == -1)
3646       return -1;
3647   }
3648   {
3649     int r;
3650     suppress_error = 0;
3651     r = guestfs_umount_all (g);
3652     if (r == -1)
3653       return -1;
3654   }
3655   {
3656     int r;
3657     suppress_error = 0;
3658     r = guestfs_lvm_remove_all (g);
3659     if (r == -1)
3660       return -1;
3661   }
3662   /* TestOutputList for pvremove (1) */
3663   {
3664     char device[] = "/dev/sda";
3665     device[5] = devchar;
3666     char lines_0[] = ",";
3667     char *lines[] = {
3668       lines_0,
3669       NULL
3670     };
3671     int r;
3672     suppress_error = 0;
3673     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3674     if (r == -1)
3675       return -1;
3676   }
3677   {
3678     char device[] = "/dev/sda1";
3679     device[5] = devchar;
3680     int r;
3681     suppress_error = 0;
3682     r = guestfs_pvcreate (g, device);
3683     if (r == -1)
3684       return -1;
3685   }
3686   {
3687     char volgroup[] = "VG";
3688     char physvols_0[] = "/dev/sda1";
3689     physvols_0[5] = devchar;
3690     char *physvols[] = {
3691       physvols_0,
3692       NULL
3693     };
3694     int r;
3695     suppress_error = 0;
3696     r = guestfs_vgcreate (g, volgroup, physvols);
3697     if (r == -1)
3698       return -1;
3699   }
3700   {
3701     char logvol[] = "LV1";
3702     char volgroup[] = "VG";
3703     int r;
3704     suppress_error = 0;
3705     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3706     if (r == -1)
3707       return -1;
3708   }
3709   {
3710     char logvol[] = "LV2";
3711     char volgroup[] = "VG";
3712     int r;
3713     suppress_error = 0;
3714     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3715     if (r == -1)
3716       return -1;
3717   }
3718   {
3719     char vgname[] = "VG";
3720     int r;
3721     suppress_error = 0;
3722     r = guestfs_vgremove (g, vgname);
3723     if (r == -1)
3724       return -1;
3725   }
3726   {
3727     char device[] = "/dev/sda1";
3728     device[5] = devchar;
3729     int r;
3730     suppress_error = 0;
3731     r = guestfs_pvremove (g, device);
3732     if (r == -1)
3733       return -1;
3734   }
3735   {
3736     char **r;
3737     int i;
3738     suppress_error = 0;
3739     r = guestfs_vgs (g);
3740     if (r == NULL)
3741       return -1;
3742     if (r[0] != NULL) {
3743       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3744       print_strings (r);
3745       return -1;
3746     }
3747     for (i = 0; r[i] != NULL; ++i)
3748       free (r[i]);
3749     free (r);
3750   }
3751   return 0;
3752 }
3753
3754 static int test_pvremove_2_skip (void)
3755 {
3756   const char *str;
3757
3758   str = getenv ("SKIP_TEST_PVREMOVE_2");
3759   if (str && strcmp (str, "1") == 0) return 1;
3760   str = getenv ("SKIP_TEST_PVREMOVE");
3761   if (str && strcmp (str, "1") == 0) return 1;
3762   return 0;
3763 }
3764
3765 static int test_pvremove_2 (void)
3766 {
3767   if (test_pvremove_2_skip ()) {
3768     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3769     return 0;
3770   }
3771
3772   /* InitNone|InitEmpty for test_pvremove_2 */
3773   {
3774     char device[] = "/dev/sda";
3775     device[5] = devchar;
3776     int r;
3777     suppress_error = 0;
3778     r = guestfs_blockdev_setrw (g, device);
3779     if (r == -1)
3780       return -1;
3781   }
3782   {
3783     int r;
3784     suppress_error = 0;
3785     r = guestfs_umount_all (g);
3786     if (r == -1)
3787       return -1;
3788   }
3789   {
3790     int r;
3791     suppress_error = 0;
3792     r = guestfs_lvm_remove_all (g);
3793     if (r == -1)
3794       return -1;
3795   }
3796   /* TestOutputList for pvremove (2) */
3797   {
3798     char device[] = "/dev/sda";
3799     device[5] = devchar;
3800     char lines_0[] = ",";
3801     char *lines[] = {
3802       lines_0,
3803       NULL
3804     };
3805     int r;
3806     suppress_error = 0;
3807     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3808     if (r == -1)
3809       return -1;
3810   }
3811   {
3812     char device[] = "/dev/sda1";
3813     device[5] = devchar;
3814     int r;
3815     suppress_error = 0;
3816     r = guestfs_pvcreate (g, device);
3817     if (r == -1)
3818       return -1;
3819   }
3820   {
3821     char volgroup[] = "VG";
3822     char physvols_0[] = "/dev/sda1";
3823     physvols_0[5] = devchar;
3824     char *physvols[] = {
3825       physvols_0,
3826       NULL
3827     };
3828     int r;
3829     suppress_error = 0;
3830     r = guestfs_vgcreate (g, volgroup, physvols);
3831     if (r == -1)
3832       return -1;
3833   }
3834   {
3835     char logvol[] = "LV1";
3836     char volgroup[] = "VG";
3837     int r;
3838     suppress_error = 0;
3839     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3840     if (r == -1)
3841       return -1;
3842   }
3843   {
3844     char logvol[] = "LV2";
3845     char volgroup[] = "VG";
3846     int r;
3847     suppress_error = 0;
3848     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3849     if (r == -1)
3850       return -1;
3851   }
3852   {
3853     char vgname[] = "VG";
3854     int r;
3855     suppress_error = 0;
3856     r = guestfs_vgremove (g, vgname);
3857     if (r == -1)
3858       return -1;
3859   }
3860   {
3861     char device[] = "/dev/sda1";
3862     device[5] = devchar;
3863     int r;
3864     suppress_error = 0;
3865     r = guestfs_pvremove (g, device);
3866     if (r == -1)
3867       return -1;
3868   }
3869   {
3870     char **r;
3871     int i;
3872     suppress_error = 0;
3873     r = guestfs_pvs (g);
3874     if (r == NULL)
3875       return -1;
3876     if (r[0] != NULL) {
3877       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3878       print_strings (r);
3879       return -1;
3880     }
3881     for (i = 0; r[i] != NULL; ++i)
3882       free (r[i]);
3883     free (r);
3884   }
3885   return 0;
3886 }
3887
3888 static int test_vgremove_0_skip (void)
3889 {
3890   const char *str;
3891
3892   str = getenv ("SKIP_TEST_VGREMOVE_0");
3893   if (str && strcmp (str, "1") == 0) return 1;
3894   str = getenv ("SKIP_TEST_VGREMOVE");
3895   if (str && strcmp (str, "1") == 0) return 1;
3896   return 0;
3897 }
3898
3899 static int test_vgremove_0 (void)
3900 {
3901   if (test_vgremove_0_skip ()) {
3902     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
3903     return 0;
3904   }
3905
3906   /* InitNone|InitEmpty for test_vgremove_0 */
3907   {
3908     char device[] = "/dev/sda";
3909     device[5] = devchar;
3910     int r;
3911     suppress_error = 0;
3912     r = guestfs_blockdev_setrw (g, device);
3913     if (r == -1)
3914       return -1;
3915   }
3916   {
3917     int r;
3918     suppress_error = 0;
3919     r = guestfs_umount_all (g);
3920     if (r == -1)
3921       return -1;
3922   }
3923   {
3924     int r;
3925     suppress_error = 0;
3926     r = guestfs_lvm_remove_all (g);
3927     if (r == -1)
3928       return -1;
3929   }
3930   /* TestOutputList for vgremove (0) */
3931   {
3932     char device[] = "/dev/sda";
3933     device[5] = devchar;
3934     char lines_0[] = ",";
3935     char *lines[] = {
3936       lines_0,
3937       NULL
3938     };
3939     int r;
3940     suppress_error = 0;
3941     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3942     if (r == -1)
3943       return -1;
3944   }
3945   {
3946     char device[] = "/dev/sda1";
3947     device[5] = devchar;
3948     int r;
3949     suppress_error = 0;
3950     r = guestfs_pvcreate (g, device);
3951     if (r == -1)
3952       return -1;
3953   }
3954   {
3955     char volgroup[] = "VG";
3956     char physvols_0[] = "/dev/sda1";
3957     physvols_0[5] = devchar;
3958     char *physvols[] = {
3959       physvols_0,
3960       NULL
3961     };
3962     int r;
3963     suppress_error = 0;
3964     r = guestfs_vgcreate (g, volgroup, physvols);
3965     if (r == -1)
3966       return -1;
3967   }
3968   {
3969     char logvol[] = "LV1";
3970     char volgroup[] = "VG";
3971     int r;
3972     suppress_error = 0;
3973     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3974     if (r == -1)
3975       return -1;
3976   }
3977   {
3978     char logvol[] = "LV2";
3979     char volgroup[] = "VG";
3980     int r;
3981     suppress_error = 0;
3982     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3983     if (r == -1)
3984       return -1;
3985   }
3986   {
3987     char vgname[] = "VG";
3988     int r;
3989     suppress_error = 0;
3990     r = guestfs_vgremove (g, vgname);
3991     if (r == -1)
3992       return -1;
3993   }
3994   {
3995     char **r;
3996     int i;
3997     suppress_error = 0;
3998     r = guestfs_lvs (g);
3999     if (r == NULL)
4000       return -1;
4001     if (r[0] != NULL) {
4002       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4003       print_strings (r);
4004       return -1;
4005     }
4006     for (i = 0; r[i] != NULL; ++i)
4007       free (r[i]);
4008     free (r);
4009   }
4010   return 0;
4011 }
4012
4013 static int test_vgremove_1_skip (void)
4014 {
4015   const char *str;
4016
4017   str = getenv ("SKIP_TEST_VGREMOVE_1");
4018   if (str && strcmp (str, "1") == 0) return 1;
4019   str = getenv ("SKIP_TEST_VGREMOVE");
4020   if (str && strcmp (str, "1") == 0) return 1;
4021   return 0;
4022 }
4023
4024 static int test_vgremove_1 (void)
4025 {
4026   if (test_vgremove_1_skip ()) {
4027     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4028     return 0;
4029   }
4030
4031   /* InitNone|InitEmpty for test_vgremove_1 */
4032   {
4033     char device[] = "/dev/sda";
4034     device[5] = devchar;
4035     int r;
4036     suppress_error = 0;
4037     r = guestfs_blockdev_setrw (g, device);
4038     if (r == -1)
4039       return -1;
4040   }
4041   {
4042     int r;
4043     suppress_error = 0;
4044     r = guestfs_umount_all (g);
4045     if (r == -1)
4046       return -1;
4047   }
4048   {
4049     int r;
4050     suppress_error = 0;
4051     r = guestfs_lvm_remove_all (g);
4052     if (r == -1)
4053       return -1;
4054   }
4055   /* TestOutputList for vgremove (1) */
4056   {
4057     char device[] = "/dev/sda";
4058     device[5] = devchar;
4059     char lines_0[] = ",";
4060     char *lines[] = {
4061       lines_0,
4062       NULL
4063     };
4064     int r;
4065     suppress_error = 0;
4066     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4067     if (r == -1)
4068       return -1;
4069   }
4070   {
4071     char device[] = "/dev/sda1";
4072     device[5] = devchar;
4073     int r;
4074     suppress_error = 0;
4075     r = guestfs_pvcreate (g, device);
4076     if (r == -1)
4077       return -1;
4078   }
4079   {
4080     char volgroup[] = "VG";
4081     char physvols_0[] = "/dev/sda1";
4082     physvols_0[5] = devchar;
4083     char *physvols[] = {
4084       physvols_0,
4085       NULL
4086     };
4087     int r;
4088     suppress_error = 0;
4089     r = guestfs_vgcreate (g, volgroup, physvols);
4090     if (r == -1)
4091       return -1;
4092   }
4093   {
4094     char logvol[] = "LV1";
4095     char volgroup[] = "VG";
4096     int r;
4097     suppress_error = 0;
4098     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4099     if (r == -1)
4100       return -1;
4101   }
4102   {
4103     char logvol[] = "LV2";
4104     char volgroup[] = "VG";
4105     int r;
4106     suppress_error = 0;
4107     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4108     if (r == -1)
4109       return -1;
4110   }
4111   {
4112     char vgname[] = "VG";
4113     int r;
4114     suppress_error = 0;
4115     r = guestfs_vgremove (g, vgname);
4116     if (r == -1)
4117       return -1;
4118   }
4119   {
4120     char **r;
4121     int i;
4122     suppress_error = 0;
4123     r = guestfs_vgs (g);
4124     if (r == NULL)
4125       return -1;
4126     if (r[0] != NULL) {
4127       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4128       print_strings (r);
4129       return -1;
4130     }
4131     for (i = 0; r[i] != NULL; ++i)
4132       free (r[i]);
4133     free (r);
4134   }
4135   return 0;
4136 }
4137
4138 static int test_lvremove_0_skip (void)
4139 {
4140   const char *str;
4141
4142   str = getenv ("SKIP_TEST_LVREMOVE_0");
4143   if (str && strcmp (str, "1") == 0) return 1;
4144   str = getenv ("SKIP_TEST_LVREMOVE");
4145   if (str && strcmp (str, "1") == 0) return 1;
4146   return 0;
4147 }
4148
4149 static int test_lvremove_0 (void)
4150 {
4151   if (test_lvremove_0_skip ()) {
4152     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4153     return 0;
4154   }
4155
4156   /* InitNone|InitEmpty for test_lvremove_0 */
4157   {
4158     char device[] = "/dev/sda";
4159     device[5] = devchar;
4160     int r;
4161     suppress_error = 0;
4162     r = guestfs_blockdev_setrw (g, device);
4163     if (r == -1)
4164       return -1;
4165   }
4166   {
4167     int r;
4168     suppress_error = 0;
4169     r = guestfs_umount_all (g);
4170     if (r == -1)
4171       return -1;
4172   }
4173   {
4174     int r;
4175     suppress_error = 0;
4176     r = guestfs_lvm_remove_all (g);
4177     if (r == -1)
4178       return -1;
4179   }
4180   /* TestOutputList for lvremove (0) */
4181   {
4182     char device[] = "/dev/sda";
4183     device[5] = devchar;
4184     char lines_0[] = ",";
4185     char *lines[] = {
4186       lines_0,
4187       NULL
4188     };
4189     int r;
4190     suppress_error = 0;
4191     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4192     if (r == -1)
4193       return -1;
4194   }
4195   {
4196     char device[] = "/dev/sda1";
4197     device[5] = devchar;
4198     int r;
4199     suppress_error = 0;
4200     r = guestfs_pvcreate (g, device);
4201     if (r == -1)
4202       return -1;
4203   }
4204   {
4205     char volgroup[] = "VG";
4206     char physvols_0[] = "/dev/sda1";
4207     physvols_0[5] = devchar;
4208     char *physvols[] = {
4209       physvols_0,
4210       NULL
4211     };
4212     int r;
4213     suppress_error = 0;
4214     r = guestfs_vgcreate (g, volgroup, physvols);
4215     if (r == -1)
4216       return -1;
4217   }
4218   {
4219     char logvol[] = "LV1";
4220     char volgroup[] = "VG";
4221     int r;
4222     suppress_error = 0;
4223     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4224     if (r == -1)
4225       return -1;
4226   }
4227   {
4228     char logvol[] = "LV2";
4229     char volgroup[] = "VG";
4230     int r;
4231     suppress_error = 0;
4232     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4233     if (r == -1)
4234       return -1;
4235   }
4236   {
4237     char device[] = "/dev/VG/LV1";
4238     int r;
4239     suppress_error = 0;
4240     r = guestfs_lvremove (g, device);
4241     if (r == -1)
4242       return -1;
4243   }
4244   {
4245     char **r;
4246     int i;
4247     suppress_error = 0;
4248     r = guestfs_lvs (g);
4249     if (r == NULL)
4250       return -1;
4251     if (!r[0]) {
4252       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4253       print_strings (r);
4254       return -1;
4255     }
4256     {
4257       char expected[] = "/dev/VG/LV2";
4258       if (strcmp (r[0], expected) != 0) {
4259         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4260         return -1;
4261       }
4262     }
4263     if (r[1] != NULL) {
4264       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4265       print_strings (r);
4266       return -1;
4267     }
4268     for (i = 0; r[i] != NULL; ++i)
4269       free (r[i]);
4270     free (r);
4271   }
4272   return 0;
4273 }
4274
4275 static int test_lvremove_1_skip (void)
4276 {
4277   const char *str;
4278
4279   str = getenv ("SKIP_TEST_LVREMOVE_1");
4280   if (str && strcmp (str, "1") == 0) return 1;
4281   str = getenv ("SKIP_TEST_LVREMOVE");
4282   if (str && strcmp (str, "1") == 0) return 1;
4283   return 0;
4284 }
4285
4286 static int test_lvremove_1 (void)
4287 {
4288   if (test_lvremove_1_skip ()) {
4289     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4290     return 0;
4291   }
4292
4293   /* InitNone|InitEmpty for test_lvremove_1 */
4294   {
4295     char device[] = "/dev/sda";
4296     device[5] = devchar;
4297     int r;
4298     suppress_error = 0;
4299     r = guestfs_blockdev_setrw (g, device);
4300     if (r == -1)
4301       return -1;
4302   }
4303   {
4304     int r;
4305     suppress_error = 0;
4306     r = guestfs_umount_all (g);
4307     if (r == -1)
4308       return -1;
4309   }
4310   {
4311     int r;
4312     suppress_error = 0;
4313     r = guestfs_lvm_remove_all (g);
4314     if (r == -1)
4315       return -1;
4316   }
4317   /* TestOutputList for lvremove (1) */
4318   {
4319     char device[] = "/dev/sda";
4320     device[5] = devchar;
4321     char lines_0[] = ",";
4322     char *lines[] = {
4323       lines_0,
4324       NULL
4325     };
4326     int r;
4327     suppress_error = 0;
4328     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4329     if (r == -1)
4330       return -1;
4331   }
4332   {
4333     char device[] = "/dev/sda1";
4334     device[5] = devchar;
4335     int r;
4336     suppress_error = 0;
4337     r = guestfs_pvcreate (g, device);
4338     if (r == -1)
4339       return -1;
4340   }
4341   {
4342     char volgroup[] = "VG";
4343     char physvols_0[] = "/dev/sda1";
4344     physvols_0[5] = devchar;
4345     char *physvols[] = {
4346       physvols_0,
4347       NULL
4348     };
4349     int r;
4350     suppress_error = 0;
4351     r = guestfs_vgcreate (g, volgroup, physvols);
4352     if (r == -1)
4353       return -1;
4354   }
4355   {
4356     char logvol[] = "LV1";
4357     char volgroup[] = "VG";
4358     int r;
4359     suppress_error = 0;
4360     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4361     if (r == -1)
4362       return -1;
4363   }
4364   {
4365     char logvol[] = "LV2";
4366     char volgroup[] = "VG";
4367     int r;
4368     suppress_error = 0;
4369     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4370     if (r == -1)
4371       return -1;
4372   }
4373   {
4374     char device[] = "/dev/VG";
4375     int r;
4376     suppress_error = 0;
4377     r = guestfs_lvremove (g, device);
4378     if (r == -1)
4379       return -1;
4380   }
4381   {
4382     char **r;
4383     int i;
4384     suppress_error = 0;
4385     r = guestfs_lvs (g);
4386     if (r == NULL)
4387       return -1;
4388     if (r[0] != NULL) {
4389       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4390       print_strings (r);
4391       return -1;
4392     }
4393     for (i = 0; r[i] != NULL; ++i)
4394       free (r[i]);
4395     free (r);
4396   }
4397   return 0;
4398 }
4399
4400 static int test_lvremove_2_skip (void)
4401 {
4402   const char *str;
4403
4404   str = getenv ("SKIP_TEST_LVREMOVE_2");
4405   if (str && strcmp (str, "1") == 0) return 1;
4406   str = getenv ("SKIP_TEST_LVREMOVE");
4407   if (str && strcmp (str, "1") == 0) return 1;
4408   return 0;
4409 }
4410
4411 static int test_lvremove_2 (void)
4412 {
4413   if (test_lvremove_2_skip ()) {
4414     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4415     return 0;
4416   }
4417
4418   /* InitNone|InitEmpty for test_lvremove_2 */
4419   {
4420     char device[] = "/dev/sda";
4421     device[5] = devchar;
4422     int r;
4423     suppress_error = 0;
4424     r = guestfs_blockdev_setrw (g, device);
4425     if (r == -1)
4426       return -1;
4427   }
4428   {
4429     int r;
4430     suppress_error = 0;
4431     r = guestfs_umount_all (g);
4432     if (r == -1)
4433       return -1;
4434   }
4435   {
4436     int r;
4437     suppress_error = 0;
4438     r = guestfs_lvm_remove_all (g);
4439     if (r == -1)
4440       return -1;
4441   }
4442   /* TestOutputList for lvremove (2) */
4443   {
4444     char device[] = "/dev/sda";
4445     device[5] = devchar;
4446     char lines_0[] = ",";
4447     char *lines[] = {
4448       lines_0,
4449       NULL
4450     };
4451     int r;
4452     suppress_error = 0;
4453     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4454     if (r == -1)
4455       return -1;
4456   }
4457   {
4458     char device[] = "/dev/sda1";
4459     device[5] = devchar;
4460     int r;
4461     suppress_error = 0;
4462     r = guestfs_pvcreate (g, device);
4463     if (r == -1)
4464       return -1;
4465   }
4466   {
4467     char volgroup[] = "VG";
4468     char physvols_0[] = "/dev/sda1";
4469     physvols_0[5] = devchar;
4470     char *physvols[] = {
4471       physvols_0,
4472       NULL
4473     };
4474     int r;
4475     suppress_error = 0;
4476     r = guestfs_vgcreate (g, volgroup, physvols);
4477     if (r == -1)
4478       return -1;
4479   }
4480   {
4481     char logvol[] = "LV1";
4482     char volgroup[] = "VG";
4483     int r;
4484     suppress_error = 0;
4485     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4486     if (r == -1)
4487       return -1;
4488   }
4489   {
4490     char logvol[] = "LV2";
4491     char volgroup[] = "VG";
4492     int r;
4493     suppress_error = 0;
4494     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4495     if (r == -1)
4496       return -1;
4497   }
4498   {
4499     char device[] = "/dev/VG";
4500     int r;
4501     suppress_error = 0;
4502     r = guestfs_lvremove (g, device);
4503     if (r == -1)
4504       return -1;
4505   }
4506   {
4507     char **r;
4508     int i;
4509     suppress_error = 0;
4510     r = guestfs_vgs (g);
4511     if (r == NULL)
4512       return -1;
4513     if (!r[0]) {
4514       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4515       print_strings (r);
4516       return -1;
4517     }
4518     {
4519       char expected[] = "VG";
4520       if (strcmp (r[0], expected) != 0) {
4521         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4522         return -1;
4523       }
4524     }
4525     if (r[1] != NULL) {
4526       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4527       print_strings (r);
4528       return -1;
4529     }
4530     for (i = 0; r[i] != NULL; ++i)
4531       free (r[i]);
4532     free (r);
4533   }
4534   return 0;
4535 }
4536
4537 static int test_mount_ro_0_skip (void)
4538 {
4539   const char *str;
4540
4541   str = getenv ("SKIP_TEST_MOUNT_RO_0");
4542   if (str && strcmp (str, "1") == 0) return 1;
4543   str = getenv ("SKIP_TEST_MOUNT_RO");
4544   if (str && strcmp (str, "1") == 0) return 1;
4545   return 0;
4546 }
4547
4548 static int test_mount_ro_0 (void)
4549 {
4550   if (test_mount_ro_0_skip ()) {
4551     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4552     return 0;
4553   }
4554
4555   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4556   {
4557     char device[] = "/dev/sda";
4558     device[5] = devchar;
4559     int r;
4560     suppress_error = 0;
4561     r = guestfs_blockdev_setrw (g, device);
4562     if (r == -1)
4563       return -1;
4564   }
4565   {
4566     int r;
4567     suppress_error = 0;
4568     r = guestfs_umount_all (g);
4569     if (r == -1)
4570       return -1;
4571   }
4572   {
4573     int r;
4574     suppress_error = 0;
4575     r = guestfs_lvm_remove_all (g);
4576     if (r == -1)
4577       return -1;
4578   }
4579   {
4580     char device[] = "/dev/sda";
4581     device[5] = devchar;
4582     char lines_0[] = ",";
4583     char *lines[] = {
4584       lines_0,
4585       NULL
4586     };
4587     int r;
4588     suppress_error = 0;
4589     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4590     if (r == -1)
4591       return -1;
4592   }
4593   {
4594     char fstype[] = "ext2";
4595     char device[] = "/dev/sda1";
4596     device[5] = devchar;
4597     int r;
4598     suppress_error = 0;
4599     r = guestfs_mkfs (g, fstype, device);
4600     if (r == -1)
4601       return -1;
4602   }
4603   {
4604     char device[] = "/dev/sda1";
4605     device[5] = devchar;
4606     char mountpoint[] = "/";
4607     int r;
4608     suppress_error = 0;
4609     r = guestfs_mount (g, device, mountpoint);
4610     if (r == -1)
4611       return -1;
4612   }
4613   /* TestLastFail for mount_ro (0) */
4614   {
4615     char pathordevice[] = "/";
4616     int r;
4617     suppress_error = 0;
4618     r = guestfs_umount (g, pathordevice);
4619     if (r == -1)
4620       return -1;
4621   }
4622   {
4623     char device[] = "/dev/sda1";
4624     device[5] = devchar;
4625     char mountpoint[] = "/";
4626     int r;
4627     suppress_error = 0;
4628     r = guestfs_mount_ro (g, device, mountpoint);
4629     if (r == -1)
4630       return -1;
4631   }
4632   {
4633     char path[] = "/new";
4634     int r;
4635     suppress_error = 1;
4636     r = guestfs_touch (g, path);
4637     if (r != -1)
4638       return -1;
4639   }
4640   return 0;
4641 }
4642
4643 static int test_mount_ro_1_skip (void)
4644 {
4645   const char *str;
4646
4647   str = getenv ("SKIP_TEST_MOUNT_RO_1");
4648   if (str && strcmp (str, "1") == 0) return 1;
4649   str = getenv ("SKIP_TEST_MOUNT_RO");
4650   if (str && strcmp (str, "1") == 0) return 1;
4651   return 0;
4652 }
4653
4654 static int test_mount_ro_1 (void)
4655 {
4656   if (test_mount_ro_1_skip ()) {
4657     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4658     return 0;
4659   }
4660
4661   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4662   {
4663     char device[] = "/dev/sda";
4664     device[5] = devchar;
4665     int r;
4666     suppress_error = 0;
4667     r = guestfs_blockdev_setrw (g, device);
4668     if (r == -1)
4669       return -1;
4670   }
4671   {
4672     int r;
4673     suppress_error = 0;
4674     r = guestfs_umount_all (g);
4675     if (r == -1)
4676       return -1;
4677   }
4678   {
4679     int r;
4680     suppress_error = 0;
4681     r = guestfs_lvm_remove_all (g);
4682     if (r == -1)
4683       return -1;
4684   }
4685   {
4686     char device[] = "/dev/sda";
4687     device[5] = devchar;
4688     char lines_0[] = ",";
4689     char *lines[] = {
4690       lines_0,
4691       NULL
4692     };
4693     int r;
4694     suppress_error = 0;
4695     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4696     if (r == -1)
4697       return -1;
4698   }
4699   {
4700     char fstype[] = "ext2";
4701     char device[] = "/dev/sda1";
4702     device[5] = devchar;
4703     int r;
4704     suppress_error = 0;
4705     r = guestfs_mkfs (g, fstype, device);
4706     if (r == -1)
4707       return -1;
4708   }
4709   {
4710     char device[] = "/dev/sda1";
4711     device[5] = devchar;
4712     char mountpoint[] = "/";
4713     int r;
4714     suppress_error = 0;
4715     r = guestfs_mount (g, device, mountpoint);
4716     if (r == -1)
4717       return -1;
4718   }
4719   /* TestOutput for mount_ro (1) */
4720   char expected[] = "data";
4721   {
4722     char path[] = "/new";
4723     char content[] = "data";
4724     int r;
4725     suppress_error = 0;
4726     r = guestfs_write_file (g, path, content, 0);
4727     if (r == -1)
4728       return -1;
4729   }
4730   {
4731     char pathordevice[] = "/";
4732     int r;
4733     suppress_error = 0;
4734     r = guestfs_umount (g, pathordevice);
4735     if (r == -1)
4736       return -1;
4737   }
4738   {
4739     char device[] = "/dev/sda1";
4740     device[5] = devchar;
4741     char mountpoint[] = "/";
4742     int r;
4743     suppress_error = 0;
4744     r = guestfs_mount_ro (g, device, mountpoint);
4745     if (r == -1)
4746       return -1;
4747   }
4748   {
4749     char path[] = "/new";
4750     char *r;
4751     suppress_error = 0;
4752     r = guestfs_cat (g, path);
4753     if (r == NULL)
4754       return -1;
4755     if (strcmp (r, expected) != 0) {
4756       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4757       return -1;
4758     }
4759     free (r);
4760   }
4761   return 0;
4762 }
4763
4764 static int test_tgz_in_0_skip (void)
4765 {
4766   const char *str;
4767
4768   str = getenv ("SKIP_TEST_TGZ_IN_0");
4769   if (str && strcmp (str, "1") == 0) return 1;
4770   str = getenv ("SKIP_TEST_TGZ_IN");
4771   if (str && strcmp (str, "1") == 0) return 1;
4772   return 0;
4773 }
4774
4775 static int test_tgz_in_0 (void)
4776 {
4777   if (test_tgz_in_0_skip ()) {
4778     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4779     return 0;
4780   }
4781
4782   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4783   {
4784     char device[] = "/dev/sda";
4785     device[5] = devchar;
4786     int r;
4787     suppress_error = 0;
4788     r = guestfs_blockdev_setrw (g, device);
4789     if (r == -1)
4790       return -1;
4791   }
4792   {
4793     int r;
4794     suppress_error = 0;
4795     r = guestfs_umount_all (g);
4796     if (r == -1)
4797       return -1;
4798   }
4799   {
4800     int r;
4801     suppress_error = 0;
4802     r = guestfs_lvm_remove_all (g);
4803     if (r == -1)
4804       return -1;
4805   }
4806   {
4807     char device[] = "/dev/sda";
4808     device[5] = devchar;
4809     char lines_0[] = ",";
4810     char *lines[] = {
4811       lines_0,
4812       NULL
4813     };
4814     int r;
4815     suppress_error = 0;
4816     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4817     if (r == -1)
4818       return -1;
4819   }
4820   {
4821     char fstype[] = "ext2";
4822     char device[] = "/dev/sda1";
4823     device[5] = devchar;
4824     int r;
4825     suppress_error = 0;
4826     r = guestfs_mkfs (g, fstype, device);
4827     if (r == -1)
4828       return -1;
4829   }
4830   {
4831     char device[] = "/dev/sda1";
4832     device[5] = devchar;
4833     char mountpoint[] = "/";
4834     int r;
4835     suppress_error = 0;
4836     r = guestfs_mount (g, device, mountpoint);
4837     if (r == -1)
4838       return -1;
4839   }
4840   /* TestOutput for tgz_in (0) */
4841   char expected[] = "hello\n";
4842   {
4843     char directory[] = "/";
4844     int r;
4845     suppress_error = 0;
4846     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
4847     if (r == -1)
4848       return -1;
4849   }
4850   {
4851     char path[] = "/hello";
4852     char *r;
4853     suppress_error = 0;
4854     r = guestfs_cat (g, path);
4855     if (r == NULL)
4856       return -1;
4857     if (strcmp (r, expected) != 0) {
4858       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4859       return -1;
4860     }
4861     free (r);
4862   }
4863   return 0;
4864 }
4865
4866 static int test_tar_in_0_skip (void)
4867 {
4868   const char *str;
4869
4870   str = getenv ("SKIP_TEST_TAR_IN_0");
4871   if (str && strcmp (str, "1") == 0) return 1;
4872   str = getenv ("SKIP_TEST_TAR_IN");
4873   if (str && strcmp (str, "1") == 0) return 1;
4874   return 0;
4875 }
4876
4877 static int test_tar_in_0 (void)
4878 {
4879   if (test_tar_in_0_skip ()) {
4880     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
4881     return 0;
4882   }
4883
4884   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4885   {
4886     char device[] = "/dev/sda";
4887     device[5] = devchar;
4888     int r;
4889     suppress_error = 0;
4890     r = guestfs_blockdev_setrw (g, device);
4891     if (r == -1)
4892       return -1;
4893   }
4894   {
4895     int r;
4896     suppress_error = 0;
4897     r = guestfs_umount_all (g);
4898     if (r == -1)
4899       return -1;
4900   }
4901   {
4902     int r;
4903     suppress_error = 0;
4904     r = guestfs_lvm_remove_all (g);
4905     if (r == -1)
4906       return -1;
4907   }
4908   {
4909     char device[] = "/dev/sda";
4910     device[5] = devchar;
4911     char lines_0[] = ",";
4912     char *lines[] = {
4913       lines_0,
4914       NULL
4915     };
4916     int r;
4917     suppress_error = 0;
4918     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4919     if (r == -1)
4920       return -1;
4921   }
4922   {
4923     char fstype[] = "ext2";
4924     char device[] = "/dev/sda1";
4925     device[5] = devchar;
4926     int r;
4927     suppress_error = 0;
4928     r = guestfs_mkfs (g, fstype, device);
4929     if (r == -1)
4930       return -1;
4931   }
4932   {
4933     char device[] = "/dev/sda1";
4934     device[5] = devchar;
4935     char mountpoint[] = "/";
4936     int r;
4937     suppress_error = 0;
4938     r = guestfs_mount (g, device, mountpoint);
4939     if (r == -1)
4940       return -1;
4941   }
4942   /* TestOutput for tar_in (0) */
4943   char expected[] = "hello\n";
4944   {
4945     char directory[] = "/";
4946     int r;
4947     suppress_error = 0;
4948     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
4949     if (r == -1)
4950       return -1;
4951   }
4952   {
4953     char path[] = "/hello";
4954     char *r;
4955     suppress_error = 0;
4956     r = guestfs_cat (g, path);
4957     if (r == NULL)
4958       return -1;
4959     if (strcmp (r, expected) != 0) {
4960       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4961       return -1;
4962     }
4963     free (r);
4964   }
4965   return 0;
4966 }
4967
4968 static int test_checksum_0_skip (void)
4969 {
4970   const char *str;
4971
4972   str = getenv ("SKIP_TEST_CHECKSUM_0");
4973   if (str && strcmp (str, "1") == 0) return 1;
4974   str = getenv ("SKIP_TEST_CHECKSUM");
4975   if (str && strcmp (str, "1") == 0) return 1;
4976   return 0;
4977 }
4978
4979 static int test_checksum_0 (void)
4980 {
4981   if (test_checksum_0_skip ()) {
4982     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
4983     return 0;
4984   }
4985
4986   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4987   {
4988     char device[] = "/dev/sda";
4989     device[5] = devchar;
4990     int r;
4991     suppress_error = 0;
4992     r = guestfs_blockdev_setrw (g, device);
4993     if (r == -1)
4994       return -1;
4995   }
4996   {
4997     int r;
4998     suppress_error = 0;
4999     r = guestfs_umount_all (g);
5000     if (r == -1)
5001       return -1;
5002   }
5003   {
5004     int r;
5005     suppress_error = 0;
5006     r = guestfs_lvm_remove_all (g);
5007     if (r == -1)
5008       return -1;
5009   }
5010   {
5011     char device[] = "/dev/sda";
5012     device[5] = devchar;
5013     char lines_0[] = ",";
5014     char *lines[] = {
5015       lines_0,
5016       NULL
5017     };
5018     int r;
5019     suppress_error = 0;
5020     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5021     if (r == -1)
5022       return -1;
5023   }
5024   {
5025     char fstype[] = "ext2";
5026     char device[] = "/dev/sda1";
5027     device[5] = devchar;
5028     int r;
5029     suppress_error = 0;
5030     r = guestfs_mkfs (g, fstype, device);
5031     if (r == -1)
5032       return -1;
5033   }
5034   {
5035     char device[] = "/dev/sda1";
5036     device[5] = devchar;
5037     char mountpoint[] = "/";
5038     int r;
5039     suppress_error = 0;
5040     r = guestfs_mount (g, device, mountpoint);
5041     if (r == -1)
5042       return -1;
5043   }
5044   /* TestOutput for checksum (0) */
5045   char expected[] = "935282863";
5046   {
5047     char path[] = "/new";
5048     char content[] = "test\n";
5049     int r;
5050     suppress_error = 0;
5051     r = guestfs_write_file (g, path, content, 0);
5052     if (r == -1)
5053       return -1;
5054   }
5055   {
5056     char csumtype[] = "crc";
5057     char path[] = "/new";
5058     char *r;
5059     suppress_error = 0;
5060     r = guestfs_checksum (g, csumtype, path);
5061     if (r == NULL)
5062       return -1;
5063     if (strcmp (r, expected) != 0) {
5064       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5065       return -1;
5066     }
5067     free (r);
5068   }
5069   return 0;
5070 }
5071
5072 static int test_checksum_1_skip (void)
5073 {
5074   const char *str;
5075
5076   str = getenv ("SKIP_TEST_CHECKSUM_1");
5077   if (str && strcmp (str, "1") == 0) return 1;
5078   str = getenv ("SKIP_TEST_CHECKSUM");
5079   if (str && strcmp (str, "1") == 0) return 1;
5080   return 0;
5081 }
5082
5083 static int test_checksum_1 (void)
5084 {
5085   if (test_checksum_1_skip ()) {
5086     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5087     return 0;
5088   }
5089
5090   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5091   {
5092     char device[] = "/dev/sda";
5093     device[5] = devchar;
5094     int r;
5095     suppress_error = 0;
5096     r = guestfs_blockdev_setrw (g, device);
5097     if (r == -1)
5098       return -1;
5099   }
5100   {
5101     int r;
5102     suppress_error = 0;
5103     r = guestfs_umount_all (g);
5104     if (r == -1)
5105       return -1;
5106   }
5107   {
5108     int r;
5109     suppress_error = 0;
5110     r = guestfs_lvm_remove_all (g);
5111     if (r == -1)
5112       return -1;
5113   }
5114   {
5115     char device[] = "/dev/sda";
5116     device[5] = devchar;
5117     char lines_0[] = ",";
5118     char *lines[] = {
5119       lines_0,
5120       NULL
5121     };
5122     int r;
5123     suppress_error = 0;
5124     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5125     if (r == -1)
5126       return -1;
5127   }
5128   {
5129     char fstype[] = "ext2";
5130     char device[] = "/dev/sda1";
5131     device[5] = devchar;
5132     int r;
5133     suppress_error = 0;
5134     r = guestfs_mkfs (g, fstype, device);
5135     if (r == -1)
5136       return -1;
5137   }
5138   {
5139     char device[] = "/dev/sda1";
5140     device[5] = devchar;
5141     char mountpoint[] = "/";
5142     int r;
5143     suppress_error = 0;
5144     r = guestfs_mount (g, device, mountpoint);
5145     if (r == -1)
5146       return -1;
5147   }
5148   /* TestLastFail for checksum (1) */
5149   {
5150     char csumtype[] = "crc";
5151     char path[] = "/new";
5152     char *r;
5153     suppress_error = 1;
5154     r = guestfs_checksum (g, csumtype, path);
5155     if (r != NULL)
5156       return -1;
5157     free (r);
5158   }
5159   return 0;
5160 }
5161
5162 static int test_checksum_2_skip (void)
5163 {
5164   const char *str;
5165
5166   str = getenv ("SKIP_TEST_CHECKSUM_2");
5167   if (str && strcmp (str, "1") == 0) return 1;
5168   str = getenv ("SKIP_TEST_CHECKSUM");
5169   if (str && strcmp (str, "1") == 0) return 1;
5170   return 0;
5171 }
5172
5173 static int test_checksum_2 (void)
5174 {
5175   if (test_checksum_2_skip ()) {
5176     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5177     return 0;
5178   }
5179
5180   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5181   {
5182     char device[] = "/dev/sda";
5183     device[5] = devchar;
5184     int r;
5185     suppress_error = 0;
5186     r = guestfs_blockdev_setrw (g, device);
5187     if (r == -1)
5188       return -1;
5189   }
5190   {
5191     int r;
5192     suppress_error = 0;
5193     r = guestfs_umount_all (g);
5194     if (r == -1)
5195       return -1;
5196   }
5197   {
5198     int r;
5199     suppress_error = 0;
5200     r = guestfs_lvm_remove_all (g);
5201     if (r == -1)
5202       return -1;
5203   }
5204   {
5205     char device[] = "/dev/sda";
5206     device[5] = devchar;
5207     char lines_0[] = ",";
5208     char *lines[] = {
5209       lines_0,
5210       NULL
5211     };
5212     int r;
5213     suppress_error = 0;
5214     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5215     if (r == -1)
5216       return -1;
5217   }
5218   {
5219     char fstype[] = "ext2";
5220     char device[] = "/dev/sda1";
5221     device[5] = devchar;
5222     int r;
5223     suppress_error = 0;
5224     r = guestfs_mkfs (g, fstype, device);
5225     if (r == -1)
5226       return -1;
5227   }
5228   {
5229     char device[] = "/dev/sda1";
5230     device[5] = devchar;
5231     char mountpoint[] = "/";
5232     int r;
5233     suppress_error = 0;
5234     r = guestfs_mount (g, device, mountpoint);
5235     if (r == -1)
5236       return -1;
5237   }
5238   /* TestOutput for checksum (2) */
5239   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5240   {
5241     char path[] = "/new";
5242     char content[] = "test\n";
5243     int r;
5244     suppress_error = 0;
5245     r = guestfs_write_file (g, path, content, 0);
5246     if (r == -1)
5247       return -1;
5248   }
5249   {
5250     char csumtype[] = "md5";
5251     char path[] = "/new";
5252     char *r;
5253     suppress_error = 0;
5254     r = guestfs_checksum (g, csumtype, path);
5255     if (r == NULL)
5256       return -1;
5257     if (strcmp (r, expected) != 0) {
5258       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5259       return -1;
5260     }
5261     free (r);
5262   }
5263   return 0;
5264 }
5265
5266 static int test_checksum_3_skip (void)
5267 {
5268   const char *str;
5269
5270   str = getenv ("SKIP_TEST_CHECKSUM_3");
5271   if (str && strcmp (str, "1") == 0) return 1;
5272   str = getenv ("SKIP_TEST_CHECKSUM");
5273   if (str && strcmp (str, "1") == 0) return 1;
5274   return 0;
5275 }
5276
5277 static int test_checksum_3 (void)
5278 {
5279   if (test_checksum_3_skip ()) {
5280     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5281     return 0;
5282   }
5283
5284   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5285   {
5286     char device[] = "/dev/sda";
5287     device[5] = devchar;
5288     int r;
5289     suppress_error = 0;
5290     r = guestfs_blockdev_setrw (g, device);
5291     if (r == -1)
5292       return -1;
5293   }
5294   {
5295     int r;
5296     suppress_error = 0;
5297     r = guestfs_umount_all (g);
5298     if (r == -1)
5299       return -1;
5300   }
5301   {
5302     int r;
5303     suppress_error = 0;
5304     r = guestfs_lvm_remove_all (g);
5305     if (r == -1)
5306       return -1;
5307   }
5308   {
5309     char device[] = "/dev/sda";
5310     device[5] = devchar;
5311     char lines_0[] = ",";
5312     char *lines[] = {
5313       lines_0,
5314       NULL
5315     };
5316     int r;
5317     suppress_error = 0;
5318     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5319     if (r == -1)
5320       return -1;
5321   }
5322   {
5323     char fstype[] = "ext2";
5324     char device[] = "/dev/sda1";
5325     device[5] = devchar;
5326     int r;
5327     suppress_error = 0;
5328     r = guestfs_mkfs (g, fstype, device);
5329     if (r == -1)
5330       return -1;
5331   }
5332   {
5333     char device[] = "/dev/sda1";
5334     device[5] = devchar;
5335     char mountpoint[] = "/";
5336     int r;
5337     suppress_error = 0;
5338     r = guestfs_mount (g, device, mountpoint);
5339     if (r == -1)
5340       return -1;
5341   }
5342   /* TestOutput for checksum (3) */
5343   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5344   {
5345     char path[] = "/new";
5346     char content[] = "test\n";
5347     int r;
5348     suppress_error = 0;
5349     r = guestfs_write_file (g, path, content, 0);
5350     if (r == -1)
5351       return -1;
5352   }
5353   {
5354     char csumtype[] = "sha1";
5355     char path[] = "/new";
5356     char *r;
5357     suppress_error = 0;
5358     r = guestfs_checksum (g, csumtype, path);
5359     if (r == NULL)
5360       return -1;
5361     if (strcmp (r, expected) != 0) {
5362       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5363       return -1;
5364     }
5365     free (r);
5366   }
5367   return 0;
5368 }
5369
5370 static int test_checksum_4_skip (void)
5371 {
5372   const char *str;
5373
5374   str = getenv ("SKIP_TEST_CHECKSUM_4");
5375   if (str && strcmp (str, "1") == 0) return 1;
5376   str = getenv ("SKIP_TEST_CHECKSUM");
5377   if (str && strcmp (str, "1") == 0) return 1;
5378   return 0;
5379 }
5380
5381 static int test_checksum_4 (void)
5382 {
5383   if (test_checksum_4_skip ()) {
5384     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5385     return 0;
5386   }
5387
5388   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5389   {
5390     char device[] = "/dev/sda";
5391     device[5] = devchar;
5392     int r;
5393     suppress_error = 0;
5394     r = guestfs_blockdev_setrw (g, device);
5395     if (r == -1)
5396       return -1;
5397   }
5398   {
5399     int r;
5400     suppress_error = 0;
5401     r = guestfs_umount_all (g);
5402     if (r == -1)
5403       return -1;
5404   }
5405   {
5406     int r;
5407     suppress_error = 0;
5408     r = guestfs_lvm_remove_all (g);
5409     if (r == -1)
5410       return -1;
5411   }
5412   {
5413     char device[] = "/dev/sda";
5414     device[5] = devchar;
5415     char lines_0[] = ",";
5416     char *lines[] = {
5417       lines_0,
5418       NULL
5419     };
5420     int r;
5421     suppress_error = 0;
5422     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5423     if (r == -1)
5424       return -1;
5425   }
5426   {
5427     char fstype[] = "ext2";
5428     char device[] = "/dev/sda1";
5429     device[5] = devchar;
5430     int r;
5431     suppress_error = 0;
5432     r = guestfs_mkfs (g, fstype, device);
5433     if (r == -1)
5434       return -1;
5435   }
5436   {
5437     char device[] = "/dev/sda1";
5438     device[5] = devchar;
5439     char mountpoint[] = "/";
5440     int r;
5441     suppress_error = 0;
5442     r = guestfs_mount (g, device, mountpoint);
5443     if (r == -1)
5444       return -1;
5445   }
5446   /* TestOutput for checksum (4) */
5447   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5448   {
5449     char path[] = "/new";
5450     char content[] = "test\n";
5451     int r;
5452     suppress_error = 0;
5453     r = guestfs_write_file (g, path, content, 0);
5454     if (r == -1)
5455       return -1;
5456   }
5457   {
5458     char csumtype[] = "sha224";
5459     char path[] = "/new";
5460     char *r;
5461     suppress_error = 0;
5462     r = guestfs_checksum (g, csumtype, path);
5463     if (r == NULL)
5464       return -1;
5465     if (strcmp (r, expected) != 0) {
5466       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5467       return -1;
5468     }
5469     free (r);
5470   }
5471   return 0;
5472 }
5473
5474 static int test_checksum_5_skip (void)
5475 {
5476   const char *str;
5477
5478   str = getenv ("SKIP_TEST_CHECKSUM_5");
5479   if (str && strcmp (str, "1") == 0) return 1;
5480   str = getenv ("SKIP_TEST_CHECKSUM");
5481   if (str && strcmp (str, "1") == 0) return 1;
5482   return 0;
5483 }
5484
5485 static int test_checksum_5 (void)
5486 {
5487   if (test_checksum_5_skip ()) {
5488     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5489     return 0;
5490   }
5491
5492   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5493   {
5494     char device[] = "/dev/sda";
5495     device[5] = devchar;
5496     int r;
5497     suppress_error = 0;
5498     r = guestfs_blockdev_setrw (g, device);
5499     if (r == -1)
5500       return -1;
5501   }
5502   {
5503     int r;
5504     suppress_error = 0;
5505     r = guestfs_umount_all (g);
5506     if (r == -1)
5507       return -1;
5508   }
5509   {
5510     int r;
5511     suppress_error = 0;
5512     r = guestfs_lvm_remove_all (g);
5513     if (r == -1)
5514       return -1;
5515   }
5516   {
5517     char device[] = "/dev/sda";
5518     device[5] = devchar;
5519     char lines_0[] = ",";
5520     char *lines[] = {
5521       lines_0,
5522       NULL
5523     };
5524     int r;
5525     suppress_error = 0;
5526     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5527     if (r == -1)
5528       return -1;
5529   }
5530   {
5531     char fstype[] = "ext2";
5532     char device[] = "/dev/sda1";
5533     device[5] = devchar;
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     device[5] = devchar;
5543     char mountpoint[] = "/";
5544     int r;
5545     suppress_error = 0;
5546     r = guestfs_mount (g, device, mountpoint);
5547     if (r == -1)
5548       return -1;
5549   }
5550   /* TestOutput for checksum (5) */
5551   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5552   {
5553     char path[] = "/new";
5554     char content[] = "test\n";
5555     int r;
5556     suppress_error = 0;
5557     r = guestfs_write_file (g, path, content, 0);
5558     if (r == -1)
5559       return -1;
5560   }
5561   {
5562     char csumtype[] = "sha256";
5563     char path[] = "/new";
5564     char *r;
5565     suppress_error = 0;
5566     r = guestfs_checksum (g, csumtype, path);
5567     if (r == NULL)
5568       return -1;
5569     if (strcmp (r, expected) != 0) {
5570       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5571       return -1;
5572     }
5573     free (r);
5574   }
5575   return 0;
5576 }
5577
5578 static int test_checksum_6_skip (void)
5579 {
5580   const char *str;
5581
5582   str = getenv ("SKIP_TEST_CHECKSUM_6");
5583   if (str && strcmp (str, "1") == 0) return 1;
5584   str = getenv ("SKIP_TEST_CHECKSUM");
5585   if (str && strcmp (str, "1") == 0) return 1;
5586   return 0;
5587 }
5588
5589 static int test_checksum_6 (void)
5590 {
5591   if (test_checksum_6_skip ()) {
5592     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5593     return 0;
5594   }
5595
5596   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5597   {
5598     char device[] = "/dev/sda";
5599     device[5] = devchar;
5600     int r;
5601     suppress_error = 0;
5602     r = guestfs_blockdev_setrw (g, device);
5603     if (r == -1)
5604       return -1;
5605   }
5606   {
5607     int r;
5608     suppress_error = 0;
5609     r = guestfs_umount_all (g);
5610     if (r == -1)
5611       return -1;
5612   }
5613   {
5614     int r;
5615     suppress_error = 0;
5616     r = guestfs_lvm_remove_all (g);
5617     if (r == -1)
5618       return -1;
5619   }
5620   {
5621     char device[] = "/dev/sda";
5622     device[5] = devchar;
5623     char lines_0[] = ",";
5624     char *lines[] = {
5625       lines_0,
5626       NULL
5627     };
5628     int r;
5629     suppress_error = 0;
5630     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5631     if (r == -1)
5632       return -1;
5633   }
5634   {
5635     char fstype[] = "ext2";
5636     char device[] = "/dev/sda1";
5637     device[5] = devchar;
5638     int r;
5639     suppress_error = 0;
5640     r = guestfs_mkfs (g, fstype, device);
5641     if (r == -1)
5642       return -1;
5643   }
5644   {
5645     char device[] = "/dev/sda1";
5646     device[5] = devchar;
5647     char mountpoint[] = "/";
5648     int r;
5649     suppress_error = 0;
5650     r = guestfs_mount (g, device, mountpoint);
5651     if (r == -1)
5652       return -1;
5653   }
5654   /* TestOutput for checksum (6) */
5655   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5656   {
5657     char path[] = "/new";
5658     char content[] = "test\n";
5659     int r;
5660     suppress_error = 0;
5661     r = guestfs_write_file (g, path, content, 0);
5662     if (r == -1)
5663       return -1;
5664   }
5665   {
5666     char csumtype[] = "sha384";
5667     char path[] = "/new";
5668     char *r;
5669     suppress_error = 0;
5670     r = guestfs_checksum (g, csumtype, path);
5671     if (r == NULL)
5672       return -1;
5673     if (strcmp (r, expected) != 0) {
5674       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5675       return -1;
5676     }
5677     free (r);
5678   }
5679   return 0;
5680 }
5681
5682 static int test_checksum_7_skip (void)
5683 {
5684   const char *str;
5685
5686   str = getenv ("SKIP_TEST_CHECKSUM_7");
5687   if (str && strcmp (str, "1") == 0) return 1;
5688   str = getenv ("SKIP_TEST_CHECKSUM");
5689   if (str && strcmp (str, "1") == 0) return 1;
5690   return 0;
5691 }
5692
5693 static int test_checksum_7 (void)
5694 {
5695   if (test_checksum_7_skip ()) {
5696     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5697     return 0;
5698   }
5699
5700   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5701   {
5702     char device[] = "/dev/sda";
5703     device[5] = devchar;
5704     int r;
5705     suppress_error = 0;
5706     r = guestfs_blockdev_setrw (g, device);
5707     if (r == -1)
5708       return -1;
5709   }
5710   {
5711     int r;
5712     suppress_error = 0;
5713     r = guestfs_umount_all (g);
5714     if (r == -1)
5715       return -1;
5716   }
5717   {
5718     int r;
5719     suppress_error = 0;
5720     r = guestfs_lvm_remove_all (g);
5721     if (r == -1)
5722       return -1;
5723   }
5724   {
5725     char device[] = "/dev/sda";
5726     device[5] = devchar;
5727     char lines_0[] = ",";
5728     char *lines[] = {
5729       lines_0,
5730       NULL
5731     };
5732     int r;
5733     suppress_error = 0;
5734     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5735     if (r == -1)
5736       return -1;
5737   }
5738   {
5739     char fstype[] = "ext2";
5740     char device[] = "/dev/sda1";
5741     device[5] = devchar;
5742     int r;
5743     suppress_error = 0;
5744     r = guestfs_mkfs (g, fstype, device);
5745     if (r == -1)
5746       return -1;
5747   }
5748   {
5749     char device[] = "/dev/sda1";
5750     device[5] = devchar;
5751     char mountpoint[] = "/";
5752     int r;
5753     suppress_error = 0;
5754     r = guestfs_mount (g, device, mountpoint);
5755     if (r == -1)
5756       return -1;
5757   }
5758   /* TestOutput for checksum (7) */
5759   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5760   {
5761     char path[] = "/new";
5762     char content[] = "test\n";
5763     int r;
5764     suppress_error = 0;
5765     r = guestfs_write_file (g, path, content, 0);
5766     if (r == -1)
5767       return -1;
5768   }
5769   {
5770     char csumtype[] = "sha512";
5771     char path[] = "/new";
5772     char *r;
5773     suppress_error = 0;
5774     r = guestfs_checksum (g, csumtype, path);
5775     if (r == NULL)
5776       return -1;
5777     if (strcmp (r, expected) != 0) {
5778       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5779       return -1;
5780     }
5781     free (r);
5782   }
5783   return 0;
5784 }
5785
5786 static int test_checksum_8_skip (void)
5787 {
5788   const char *str;
5789
5790   str = getenv ("SKIP_TEST_CHECKSUM_8");
5791   if (str && strcmp (str, "1") == 0) return 1;
5792   str = getenv ("SKIP_TEST_CHECKSUM");
5793   if (str && strcmp (str, "1") == 0) return 1;
5794   return 0;
5795 }
5796
5797 static int test_checksum_8 (void)
5798 {
5799   if (test_checksum_8_skip ()) {
5800     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
5801     return 0;
5802   }
5803
5804   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
5805   {
5806     char device[] = "/dev/sda";
5807     device[5] = devchar;
5808     int r;
5809     suppress_error = 0;
5810     r = guestfs_blockdev_setrw (g, device);
5811     if (r == -1)
5812       return -1;
5813   }
5814   {
5815     int r;
5816     suppress_error = 0;
5817     r = guestfs_umount_all (g);
5818     if (r == -1)
5819       return -1;
5820   }
5821   {
5822     int r;
5823     suppress_error = 0;
5824     r = guestfs_lvm_remove_all (g);
5825     if (r == -1)
5826       return -1;
5827   }
5828   {
5829     char device[] = "/dev/sda";
5830     device[5] = devchar;
5831     char lines_0[] = ",";
5832     char *lines[] = {
5833       lines_0,
5834       NULL
5835     };
5836     int r;
5837     suppress_error = 0;
5838     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5839     if (r == -1)
5840       return -1;
5841   }
5842   {
5843     char fstype[] = "ext2";
5844     char device[] = "/dev/sda1";
5845     device[5] = devchar;
5846     int r;
5847     suppress_error = 0;
5848     r = guestfs_mkfs (g, fstype, device);
5849     if (r == -1)
5850       return -1;
5851   }
5852   {
5853     char device[] = "/dev/sda1";
5854     device[5] = devchar;
5855     char mountpoint[] = "/";
5856     int r;
5857     suppress_error = 0;
5858     r = guestfs_mount (g, device, mountpoint);
5859     if (r == -1)
5860       return -1;
5861   }
5862   /* TestOutput for checksum (8) */
5863   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
5864   {
5865     char device[] = "/dev/sdd";
5866     device[5] = devchar;
5867     char mountpoint[] = "/";
5868     int r;
5869     suppress_error = 0;
5870     r = guestfs_mount (g, device, mountpoint);
5871     if (r == -1)
5872       return -1;
5873   }
5874   {
5875     char csumtype[] = "md5";
5876     char path[] = "/known-3";
5877     char *r;
5878     suppress_error = 0;
5879     r = guestfs_checksum (g, csumtype, path);
5880     if (r == NULL)
5881       return -1;
5882     if (strcmp (r, expected) != 0) {
5883       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
5884       return -1;
5885     }
5886     free (r);
5887   }
5888   return 0;
5889 }
5890
5891 static int test_download_0_skip (void)
5892 {
5893   const char *str;
5894
5895   str = getenv ("SKIP_TEST_DOWNLOAD_0");
5896   if (str && strcmp (str, "1") == 0) return 1;
5897   str = getenv ("SKIP_TEST_DOWNLOAD");
5898   if (str && strcmp (str, "1") == 0) return 1;
5899   return 0;
5900 }
5901
5902 static int test_download_0 (void)
5903 {
5904   if (test_download_0_skip ()) {
5905     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5906     return 0;
5907   }
5908
5909   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5910   {
5911     char device[] = "/dev/sda";
5912     device[5] = devchar;
5913     int r;
5914     suppress_error = 0;
5915     r = guestfs_blockdev_setrw (g, device);
5916     if (r == -1)
5917       return -1;
5918   }
5919   {
5920     int r;
5921     suppress_error = 0;
5922     r = guestfs_umount_all (g);
5923     if (r == -1)
5924       return -1;
5925   }
5926   {
5927     int r;
5928     suppress_error = 0;
5929     r = guestfs_lvm_remove_all (g);
5930     if (r == -1)
5931       return -1;
5932   }
5933   {
5934     char device[] = "/dev/sda";
5935     device[5] = devchar;
5936     char lines_0[] = ",";
5937     char *lines[] = {
5938       lines_0,
5939       NULL
5940     };
5941     int r;
5942     suppress_error = 0;
5943     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5944     if (r == -1)
5945       return -1;
5946   }
5947   {
5948     char fstype[] = "ext2";
5949     char device[] = "/dev/sda1";
5950     device[5] = devchar;
5951     int r;
5952     suppress_error = 0;
5953     r = guestfs_mkfs (g, fstype, device);
5954     if (r == -1)
5955       return -1;
5956   }
5957   {
5958     char device[] = "/dev/sda1";
5959     device[5] = devchar;
5960     char mountpoint[] = "/";
5961     int r;
5962     suppress_error = 0;
5963     r = guestfs_mount (g, device, mountpoint);
5964     if (r == -1)
5965       return -1;
5966   }
5967   /* TestOutput for download (0) */
5968   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5969   {
5970     char remotefilename[] = "/COPYING.LIB";
5971     int r;
5972     suppress_error = 0;
5973     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5974     if (r == -1)
5975       return -1;
5976   }
5977   {
5978     char remotefilename[] = "/COPYING.LIB";
5979     int r;
5980     suppress_error = 0;
5981     r = guestfs_download (g, remotefilename, "testdownload.tmp");
5982     if (r == -1)
5983       return -1;
5984   }
5985   {
5986     char remotefilename[] = "/upload";
5987     int r;
5988     suppress_error = 0;
5989     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5990     if (r == -1)
5991       return -1;
5992   }
5993   {
5994     char csumtype[] = "md5";
5995     char path[] = "/upload";
5996     char *r;
5997     suppress_error = 0;
5998     r = guestfs_checksum (g, csumtype, path);
5999     if (r == NULL)
6000       return -1;
6001     if (strcmp (r, expected) != 0) {
6002       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6003       return -1;
6004     }
6005     free (r);
6006   }
6007   return 0;
6008 }
6009
6010 static int test_upload_0_skip (void)
6011 {
6012   const char *str;
6013
6014   str = getenv ("SKIP_TEST_UPLOAD_0");
6015   if (str && strcmp (str, "1") == 0) return 1;
6016   str = getenv ("SKIP_TEST_UPLOAD");
6017   if (str && strcmp (str, "1") == 0) return 1;
6018   return 0;
6019 }
6020
6021 static int test_upload_0 (void)
6022 {
6023   if (test_upload_0_skip ()) {
6024     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6025     return 0;
6026   }
6027
6028   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6029   {
6030     char device[] = "/dev/sda";
6031     device[5] = devchar;
6032     int r;
6033     suppress_error = 0;
6034     r = guestfs_blockdev_setrw (g, device);
6035     if (r == -1)
6036       return -1;
6037   }
6038   {
6039     int r;
6040     suppress_error = 0;
6041     r = guestfs_umount_all (g);
6042     if (r == -1)
6043       return -1;
6044   }
6045   {
6046     int r;
6047     suppress_error = 0;
6048     r = guestfs_lvm_remove_all (g);
6049     if (r == -1)
6050       return -1;
6051   }
6052   {
6053     char device[] = "/dev/sda";
6054     device[5] = devchar;
6055     char lines_0[] = ",";
6056     char *lines[] = {
6057       lines_0,
6058       NULL
6059     };
6060     int r;
6061     suppress_error = 0;
6062     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6063     if (r == -1)
6064       return -1;
6065   }
6066   {
6067     char fstype[] = "ext2";
6068     char device[] = "/dev/sda1";
6069     device[5] = devchar;
6070     int r;
6071     suppress_error = 0;
6072     r = guestfs_mkfs (g, fstype, device);
6073     if (r == -1)
6074       return -1;
6075   }
6076   {
6077     char device[] = "/dev/sda1";
6078     device[5] = devchar;
6079     char mountpoint[] = "/";
6080     int r;
6081     suppress_error = 0;
6082     r = guestfs_mount (g, device, mountpoint);
6083     if (r == -1)
6084       return -1;
6085   }
6086   /* TestOutput for upload (0) */
6087   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6088   {
6089     char remotefilename[] = "/COPYING.LIB";
6090     int r;
6091     suppress_error = 0;
6092     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6093     if (r == -1)
6094       return -1;
6095   }
6096   {
6097     char csumtype[] = "md5";
6098     char path[] = "/COPYING.LIB";
6099     char *r;
6100     suppress_error = 0;
6101     r = guestfs_checksum (g, csumtype, path);
6102     if (r == NULL)
6103       return -1;
6104     if (strcmp (r, expected) != 0) {
6105       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6106       return -1;
6107     }
6108     free (r);
6109   }
6110   return 0;
6111 }
6112
6113 static int test_blockdev_rereadpt_0_skip (void)
6114 {
6115   const char *str;
6116
6117   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6118   if (str && strcmp (str, "1") == 0) return 1;
6119   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6120   if (str && strcmp (str, "1") == 0) return 1;
6121   return 0;
6122 }
6123
6124 static int test_blockdev_rereadpt_0 (void)
6125 {
6126   if (test_blockdev_rereadpt_0_skip ()) {
6127     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6128     return 0;
6129   }
6130
6131   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6132   {
6133     char device[] = "/dev/sda";
6134     device[5] = devchar;
6135     int r;
6136     suppress_error = 0;
6137     r = guestfs_blockdev_setrw (g, device);
6138     if (r == -1)
6139       return -1;
6140   }
6141   {
6142     int r;
6143     suppress_error = 0;
6144     r = guestfs_umount_all (g);
6145     if (r == -1)
6146       return -1;
6147   }
6148   {
6149     int r;
6150     suppress_error = 0;
6151     r = guestfs_lvm_remove_all (g);
6152     if (r == -1)
6153       return -1;
6154   }
6155   /* TestRun for blockdev_rereadpt (0) */
6156   {
6157     char device[] = "/dev/sda";
6158     device[5] = devchar;
6159     int r;
6160     suppress_error = 0;
6161     r = guestfs_blockdev_rereadpt (g, device);
6162     if (r == -1)
6163       return -1;
6164   }
6165   return 0;
6166 }
6167
6168 static int test_blockdev_flushbufs_0_skip (void)
6169 {
6170   const char *str;
6171
6172   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6173   if (str && strcmp (str, "1") == 0) return 1;
6174   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6175   if (str && strcmp (str, "1") == 0) return 1;
6176   return 0;
6177 }
6178
6179 static int test_blockdev_flushbufs_0 (void)
6180 {
6181   if (test_blockdev_flushbufs_0_skip ()) {
6182     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6183     return 0;
6184   }
6185
6186   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6187   {
6188     char device[] = "/dev/sda";
6189     device[5] = devchar;
6190     int r;
6191     suppress_error = 0;
6192     r = guestfs_blockdev_setrw (g, device);
6193     if (r == -1)
6194       return -1;
6195   }
6196   {
6197     int r;
6198     suppress_error = 0;
6199     r = guestfs_umount_all (g);
6200     if (r == -1)
6201       return -1;
6202   }
6203   {
6204     int r;
6205     suppress_error = 0;
6206     r = guestfs_lvm_remove_all (g);
6207     if (r == -1)
6208       return -1;
6209   }
6210   /* TestRun for blockdev_flushbufs (0) */
6211   {
6212     char device[] = "/dev/sda";
6213     device[5] = devchar;
6214     int r;
6215     suppress_error = 0;
6216     r = guestfs_blockdev_flushbufs (g, device);
6217     if (r == -1)
6218       return -1;
6219   }
6220   return 0;
6221 }
6222
6223 static int test_blockdev_getsize64_0_skip (void)
6224 {
6225   const char *str;
6226
6227   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6228   if (str && strcmp (str, "1") == 0) return 1;
6229   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6230   if (str && strcmp (str, "1") == 0) return 1;
6231   return 0;
6232 }
6233
6234 static int test_blockdev_getsize64_0 (void)
6235 {
6236   if (test_blockdev_getsize64_0_skip ()) {
6237     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6238     return 0;
6239   }
6240
6241   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6242   {
6243     char device[] = "/dev/sda";
6244     device[5] = devchar;
6245     int r;
6246     suppress_error = 0;
6247     r = guestfs_blockdev_setrw (g, device);
6248     if (r == -1)
6249       return -1;
6250   }
6251   {
6252     int r;
6253     suppress_error = 0;
6254     r = guestfs_umount_all (g);
6255     if (r == -1)
6256       return -1;
6257   }
6258   {
6259     int r;
6260     suppress_error = 0;
6261     r = guestfs_lvm_remove_all (g);
6262     if (r == -1)
6263       return -1;
6264   }
6265   /* TestOutputInt for blockdev_getsize64 (0) */
6266   {
6267     char device[] = "/dev/sda";
6268     device[5] = devchar;
6269     int64_t r;
6270     suppress_error = 0;
6271     r = guestfs_blockdev_getsize64 (g, device);
6272     if (r == -1)
6273       return -1;
6274     if (r != 524288000) {
6275       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6276       return -1;
6277     }
6278   }
6279   return 0;
6280 }
6281
6282 static int test_blockdev_getsz_0_skip (void)
6283 {
6284   const char *str;
6285
6286   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6287   if (str && strcmp (str, "1") == 0) return 1;
6288   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6289   if (str && strcmp (str, "1") == 0) return 1;
6290   return 0;
6291 }
6292
6293 static int test_blockdev_getsz_0 (void)
6294 {
6295   if (test_blockdev_getsz_0_skip ()) {
6296     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6297     return 0;
6298   }
6299
6300   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6301   {
6302     char device[] = "/dev/sda";
6303     device[5] = devchar;
6304     int r;
6305     suppress_error = 0;
6306     r = guestfs_blockdev_setrw (g, device);
6307     if (r == -1)
6308       return -1;
6309   }
6310   {
6311     int r;
6312     suppress_error = 0;
6313     r = guestfs_umount_all (g);
6314     if (r == -1)
6315       return -1;
6316   }
6317   {
6318     int r;
6319     suppress_error = 0;
6320     r = guestfs_lvm_remove_all (g);
6321     if (r == -1)
6322       return -1;
6323   }
6324   /* TestOutputInt for blockdev_getsz (0) */
6325   {
6326     char device[] = "/dev/sda";
6327     device[5] = devchar;
6328     int64_t r;
6329     suppress_error = 0;
6330     r = guestfs_blockdev_getsz (g, device);
6331     if (r == -1)
6332       return -1;
6333     if (r != 1024000) {
6334       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6335       return -1;
6336     }
6337   }
6338   return 0;
6339 }
6340
6341 static int test_blockdev_getbsz_0_skip (void)
6342 {
6343   const char *str;
6344
6345   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6346   if (str && strcmp (str, "1") == 0) return 1;
6347   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6348   if (str && strcmp (str, "1") == 0) return 1;
6349   return 0;
6350 }
6351
6352 static int test_blockdev_getbsz_0 (void)
6353 {
6354   if (test_blockdev_getbsz_0_skip ()) {
6355     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6356     return 0;
6357   }
6358
6359   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6360   {
6361     char device[] = "/dev/sda";
6362     device[5] = devchar;
6363     int r;
6364     suppress_error = 0;
6365     r = guestfs_blockdev_setrw (g, device);
6366     if (r == -1)
6367       return -1;
6368   }
6369   {
6370     int r;
6371     suppress_error = 0;
6372     r = guestfs_umount_all (g);
6373     if (r == -1)
6374       return -1;
6375   }
6376   {
6377     int r;
6378     suppress_error = 0;
6379     r = guestfs_lvm_remove_all (g);
6380     if (r == -1)
6381       return -1;
6382   }
6383   /* TestOutputInt for blockdev_getbsz (0) */
6384   {
6385     char device[] = "/dev/sda";
6386     device[5] = devchar;
6387     int r;
6388     suppress_error = 0;
6389     r = guestfs_blockdev_getbsz (g, device);
6390     if (r == -1)
6391       return -1;
6392     if (r != 4096) {
6393       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6394       return -1;
6395     }
6396   }
6397   return 0;
6398 }
6399
6400 static int test_blockdev_getss_0_skip (void)
6401 {
6402   const char *str;
6403
6404   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6405   if (str && strcmp (str, "1") == 0) return 1;
6406   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6407   if (str && strcmp (str, "1") == 0) return 1;
6408   return 0;
6409 }
6410
6411 static int test_blockdev_getss_0 (void)
6412 {
6413   if (test_blockdev_getss_0_skip ()) {
6414     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6415     return 0;
6416   }
6417
6418   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6419   {
6420     char device[] = "/dev/sda";
6421     device[5] = devchar;
6422     int r;
6423     suppress_error = 0;
6424     r = guestfs_blockdev_setrw (g, device);
6425     if (r == -1)
6426       return -1;
6427   }
6428   {
6429     int r;
6430     suppress_error = 0;
6431     r = guestfs_umount_all (g);
6432     if (r == -1)
6433       return -1;
6434   }
6435   {
6436     int r;
6437     suppress_error = 0;
6438     r = guestfs_lvm_remove_all (g);
6439     if (r == -1)
6440       return -1;
6441   }
6442   /* TestOutputInt for blockdev_getss (0) */
6443   {
6444     char device[] = "/dev/sda";
6445     device[5] = devchar;
6446     int r;
6447     suppress_error = 0;
6448     r = guestfs_blockdev_getss (g, device);
6449     if (r == -1)
6450       return -1;
6451     if (r != 512) {
6452       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6453       return -1;
6454     }
6455   }
6456   return 0;
6457 }
6458
6459 static int test_blockdev_getro_0_skip (void)
6460 {
6461   const char *str;
6462
6463   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6464   if (str && strcmp (str, "1") == 0) return 1;
6465   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6466   if (str && strcmp (str, "1") == 0) return 1;
6467   return 0;
6468 }
6469
6470 static int test_blockdev_getro_0 (void)
6471 {
6472   if (test_blockdev_getro_0_skip ()) {
6473     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6474     return 0;
6475   }
6476
6477   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6478   {
6479     char device[] = "/dev/sda";
6480     device[5] = devchar;
6481     int r;
6482     suppress_error = 0;
6483     r = guestfs_blockdev_setrw (g, device);
6484     if (r == -1)
6485       return -1;
6486   }
6487   {
6488     int r;
6489     suppress_error = 0;
6490     r = guestfs_umount_all (g);
6491     if (r == -1)
6492       return -1;
6493   }
6494   {
6495     int r;
6496     suppress_error = 0;
6497     r = guestfs_lvm_remove_all (g);
6498     if (r == -1)
6499       return -1;
6500   }
6501   /* TestOutputTrue for blockdev_getro (0) */
6502   {
6503     char device[] = "/dev/sda";
6504     device[5] = devchar;
6505     int r;
6506     suppress_error = 0;
6507     r = guestfs_blockdev_setro (g, device);
6508     if (r == -1)
6509       return -1;
6510   }
6511   {
6512     char device[] = "/dev/sda";
6513     device[5] = devchar;
6514     int r;
6515     suppress_error = 0;
6516     r = guestfs_blockdev_getro (g, device);
6517     if (r == -1)
6518       return -1;
6519     if (!r) {
6520       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6521       return -1;
6522     }
6523   }
6524   return 0;
6525 }
6526
6527 static int test_blockdev_setrw_0_skip (void)
6528 {
6529   const char *str;
6530
6531   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6532   if (str && strcmp (str, "1") == 0) return 1;
6533   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6534   if (str && strcmp (str, "1") == 0) return 1;
6535   return 0;
6536 }
6537
6538 static int test_blockdev_setrw_0 (void)
6539 {
6540   if (test_blockdev_setrw_0_skip ()) {
6541     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6542     return 0;
6543   }
6544
6545   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6546   {
6547     char device[] = "/dev/sda";
6548     device[5] = devchar;
6549     int r;
6550     suppress_error = 0;
6551     r = guestfs_blockdev_setrw (g, device);
6552     if (r == -1)
6553       return -1;
6554   }
6555   {
6556     int r;
6557     suppress_error = 0;
6558     r = guestfs_umount_all (g);
6559     if (r == -1)
6560       return -1;
6561   }
6562   {
6563     int r;
6564     suppress_error = 0;
6565     r = guestfs_lvm_remove_all (g);
6566     if (r == -1)
6567       return -1;
6568   }
6569   /* TestOutputFalse for blockdev_setrw (0) */
6570   {
6571     char device[] = "/dev/sda";
6572     device[5] = devchar;
6573     int r;
6574     suppress_error = 0;
6575     r = guestfs_blockdev_setrw (g, device);
6576     if (r == -1)
6577       return -1;
6578   }
6579   {
6580     char device[] = "/dev/sda";
6581     device[5] = devchar;
6582     int r;
6583     suppress_error = 0;
6584     r = guestfs_blockdev_getro (g, device);
6585     if (r == -1)
6586       return -1;
6587     if (r) {
6588       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6589       return -1;
6590     }
6591   }
6592   return 0;
6593 }
6594
6595 static int test_blockdev_setro_0_skip (void)
6596 {
6597   const char *str;
6598
6599   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6600   if (str && strcmp (str, "1") == 0) return 1;
6601   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6602   if (str && strcmp (str, "1") == 0) return 1;
6603   return 0;
6604 }
6605
6606 static int test_blockdev_setro_0 (void)
6607 {
6608   if (test_blockdev_setro_0_skip ()) {
6609     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6610     return 0;
6611   }
6612
6613   /* InitNone|InitEmpty for test_blockdev_setro_0 */
6614   {
6615     char device[] = "/dev/sda";
6616     device[5] = devchar;
6617     int r;
6618     suppress_error = 0;
6619     r = guestfs_blockdev_setrw (g, device);
6620     if (r == -1)
6621       return -1;
6622   }
6623   {
6624     int r;
6625     suppress_error = 0;
6626     r = guestfs_umount_all (g);
6627     if (r == -1)
6628       return -1;
6629   }
6630   {
6631     int r;
6632     suppress_error = 0;
6633     r = guestfs_lvm_remove_all (g);
6634     if (r == -1)
6635       return -1;
6636   }
6637   /* TestOutputTrue for blockdev_setro (0) */
6638   {
6639     char device[] = "/dev/sda";
6640     device[5] = devchar;
6641     int r;
6642     suppress_error = 0;
6643     r = guestfs_blockdev_setro (g, device);
6644     if (r == -1)
6645       return -1;
6646   }
6647   {
6648     char device[] = "/dev/sda";
6649     device[5] = devchar;
6650     int r;
6651     suppress_error = 0;
6652     r = guestfs_blockdev_getro (g, device);
6653     if (r == -1)
6654       return -1;
6655     if (!r) {
6656       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6657       return -1;
6658     }
6659   }
6660   return 0;
6661 }
6662
6663 static int test_statvfs_0_skip (void)
6664 {
6665   const char *str;
6666
6667   str = getenv ("SKIP_TEST_STATVFS_0");
6668   if (str && strcmp (str, "1") == 0) return 1;
6669   str = getenv ("SKIP_TEST_STATVFS");
6670   if (str && strcmp (str, "1") == 0) return 1;
6671   return 0;
6672 }
6673
6674 static int test_statvfs_0 (void)
6675 {
6676   if (test_statvfs_0_skip ()) {
6677     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6678     return 0;
6679   }
6680
6681   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6682   {
6683     char device[] = "/dev/sda";
6684     device[5] = devchar;
6685     int r;
6686     suppress_error = 0;
6687     r = guestfs_blockdev_setrw (g, device);
6688     if (r == -1)
6689       return -1;
6690   }
6691   {
6692     int r;
6693     suppress_error = 0;
6694     r = guestfs_umount_all (g);
6695     if (r == -1)
6696       return -1;
6697   }
6698   {
6699     int r;
6700     suppress_error = 0;
6701     r = guestfs_lvm_remove_all (g);
6702     if (r == -1)
6703       return -1;
6704   }
6705   {
6706     char device[] = "/dev/sda";
6707     device[5] = devchar;
6708     char lines_0[] = ",";
6709     char *lines[] = {
6710       lines_0,
6711       NULL
6712     };
6713     int r;
6714     suppress_error = 0;
6715     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6716     if (r == -1)
6717       return -1;
6718   }
6719   {
6720     char fstype[] = "ext2";
6721     char device[] = "/dev/sda1";
6722     device[5] = devchar;
6723     int r;
6724     suppress_error = 0;
6725     r = guestfs_mkfs (g, fstype, device);
6726     if (r == -1)
6727       return -1;
6728   }
6729   {
6730     char device[] = "/dev/sda1";
6731     device[5] = devchar;
6732     char mountpoint[] = "/";
6733     int r;
6734     suppress_error = 0;
6735     r = guestfs_mount (g, device, mountpoint);
6736     if (r == -1)
6737       return -1;
6738   }
6739   /* TestOutputStruct for statvfs (0) */
6740   {
6741     char path[] = "/";
6742     struct guestfs_statvfs *r;
6743     suppress_error = 0;
6744     r = guestfs_statvfs (g, path);
6745     if (r == NULL)
6746       return -1;
6747     if (r->bfree != 487702) {
6748       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6749                (int) r->bfree);
6750       return -1;
6751     }
6752     if (r->blocks != 490020) {
6753       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6754                (int) r->blocks);
6755       return -1;
6756     }
6757     if (r->bsize != 1024) {
6758       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6759                (int) r->bsize);
6760       return -1;
6761     }
6762     free (r);
6763   }
6764   return 0;
6765 }
6766
6767 static int test_lstat_0_skip (void)
6768 {
6769   const char *str;
6770
6771   str = getenv ("SKIP_TEST_LSTAT_0");
6772   if (str && strcmp (str, "1") == 0) return 1;
6773   str = getenv ("SKIP_TEST_LSTAT");
6774   if (str && strcmp (str, "1") == 0) return 1;
6775   return 0;
6776 }
6777
6778 static int test_lstat_0 (void)
6779 {
6780   if (test_lstat_0_skip ()) {
6781     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6782     return 0;
6783   }
6784
6785   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6786   {
6787     char device[] = "/dev/sda";
6788     device[5] = devchar;
6789     int r;
6790     suppress_error = 0;
6791     r = guestfs_blockdev_setrw (g, device);
6792     if (r == -1)
6793       return -1;
6794   }
6795   {
6796     int r;
6797     suppress_error = 0;
6798     r = guestfs_umount_all (g);
6799     if (r == -1)
6800       return -1;
6801   }
6802   {
6803     int r;
6804     suppress_error = 0;
6805     r = guestfs_lvm_remove_all (g);
6806     if (r == -1)
6807       return -1;
6808   }
6809   {
6810     char device[] = "/dev/sda";
6811     device[5] = devchar;
6812     char lines_0[] = ",";
6813     char *lines[] = {
6814       lines_0,
6815       NULL
6816     };
6817     int r;
6818     suppress_error = 0;
6819     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6820     if (r == -1)
6821       return -1;
6822   }
6823   {
6824     char fstype[] = "ext2";
6825     char device[] = "/dev/sda1";
6826     device[5] = devchar;
6827     int r;
6828     suppress_error = 0;
6829     r = guestfs_mkfs (g, fstype, device);
6830     if (r == -1)
6831       return -1;
6832   }
6833   {
6834     char device[] = "/dev/sda1";
6835     device[5] = devchar;
6836     char mountpoint[] = "/";
6837     int r;
6838     suppress_error = 0;
6839     r = guestfs_mount (g, device, mountpoint);
6840     if (r == -1)
6841       return -1;
6842   }
6843   /* TestOutputStruct for lstat (0) */
6844   {
6845     char path[] = "/new";
6846     int r;
6847     suppress_error = 0;
6848     r = guestfs_touch (g, path);
6849     if (r == -1)
6850       return -1;
6851   }
6852   {
6853     char path[] = "/new";
6854     struct guestfs_stat *r;
6855     suppress_error = 0;
6856     r = guestfs_lstat (g, path);
6857     if (r == NULL)
6858       return -1;
6859     if (r->size != 0) {
6860       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6861                (int) r->size);
6862       return -1;
6863     }
6864     free (r);
6865   }
6866   return 0;
6867 }
6868
6869 static int test_stat_0_skip (void)
6870 {
6871   const char *str;
6872
6873   str = getenv ("SKIP_TEST_STAT_0");
6874   if (str && strcmp (str, "1") == 0) return 1;
6875   str = getenv ("SKIP_TEST_STAT");
6876   if (str && strcmp (str, "1") == 0) return 1;
6877   return 0;
6878 }
6879
6880 static int test_stat_0 (void)
6881 {
6882   if (test_stat_0_skip ()) {
6883     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6884     return 0;
6885   }
6886
6887   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6888   {
6889     char device[] = "/dev/sda";
6890     device[5] = devchar;
6891     int r;
6892     suppress_error = 0;
6893     r = guestfs_blockdev_setrw (g, device);
6894     if (r == -1)
6895       return -1;
6896   }
6897   {
6898     int r;
6899     suppress_error = 0;
6900     r = guestfs_umount_all (g);
6901     if (r == -1)
6902       return -1;
6903   }
6904   {
6905     int r;
6906     suppress_error = 0;
6907     r = guestfs_lvm_remove_all (g);
6908     if (r == -1)
6909       return -1;
6910   }
6911   {
6912     char device[] = "/dev/sda";
6913     device[5] = devchar;
6914     char lines_0[] = ",";
6915     char *lines[] = {
6916       lines_0,
6917       NULL
6918     };
6919     int r;
6920     suppress_error = 0;
6921     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6922     if (r == -1)
6923       return -1;
6924   }
6925   {
6926     char fstype[] = "ext2";
6927     char device[] = "/dev/sda1";
6928     device[5] = devchar;
6929     int r;
6930     suppress_error = 0;
6931     r = guestfs_mkfs (g, fstype, device);
6932     if (r == -1)
6933       return -1;
6934   }
6935   {
6936     char device[] = "/dev/sda1";
6937     device[5] = devchar;
6938     char mountpoint[] = "/";
6939     int r;
6940     suppress_error = 0;
6941     r = guestfs_mount (g, device, mountpoint);
6942     if (r == -1)
6943       return -1;
6944   }
6945   /* TestOutputStruct for stat (0) */
6946   {
6947     char path[] = "/new";
6948     int r;
6949     suppress_error = 0;
6950     r = guestfs_touch (g, path);
6951     if (r == -1)
6952       return -1;
6953   }
6954   {
6955     char path[] = "/new";
6956     struct guestfs_stat *r;
6957     suppress_error = 0;
6958     r = guestfs_stat (g, path);
6959     if (r == NULL)
6960       return -1;
6961     if (r->size != 0) {
6962       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6963                (int) r->size);
6964       return -1;
6965     }
6966     free (r);
6967   }
6968   return 0;
6969 }
6970
6971 static int test_command_lines_0_skip (void)
6972 {
6973   const char *str;
6974
6975   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6976   if (str && strcmp (str, "1") == 0) return 1;
6977   str = getenv ("SKIP_TEST_COMMAND_LINES");
6978   if (str && strcmp (str, "1") == 0) return 1;
6979   return 0;
6980 }
6981
6982 static int test_command_lines_0 (void)
6983 {
6984   if (test_command_lines_0_skip ()) {
6985     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6986     return 0;
6987   }
6988
6989   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6990   {
6991     char device[] = "/dev/sda";
6992     device[5] = devchar;
6993     int r;
6994     suppress_error = 0;
6995     r = guestfs_blockdev_setrw (g, device);
6996     if (r == -1)
6997       return -1;
6998   }
6999   {
7000     int r;
7001     suppress_error = 0;
7002     r = guestfs_umount_all (g);
7003     if (r == -1)
7004       return -1;
7005   }
7006   {
7007     int r;
7008     suppress_error = 0;
7009     r = guestfs_lvm_remove_all (g);
7010     if (r == -1)
7011       return -1;
7012   }
7013   {
7014     char device[] = "/dev/sda";
7015     device[5] = devchar;
7016     char lines_0[] = ",";
7017     char *lines[] = {
7018       lines_0,
7019       NULL
7020     };
7021     int r;
7022     suppress_error = 0;
7023     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7024     if (r == -1)
7025       return -1;
7026   }
7027   {
7028     char fstype[] = "ext2";
7029     char device[] = "/dev/sda1";
7030     device[5] = devchar;
7031     int r;
7032     suppress_error = 0;
7033     r = guestfs_mkfs (g, fstype, device);
7034     if (r == -1)
7035       return -1;
7036   }
7037   {
7038     char device[] = "/dev/sda1";
7039     device[5] = devchar;
7040     char mountpoint[] = "/";
7041     int r;
7042     suppress_error = 0;
7043     r = guestfs_mount (g, device, mountpoint);
7044     if (r == -1)
7045       return -1;
7046   }
7047   /* TestOutputList for command_lines (0) */
7048   {
7049     char remotefilename[] = "/test-command";
7050     int r;
7051     suppress_error = 0;
7052     r = guestfs_upload (g, "test-command", remotefilename);
7053     if (r == -1)
7054       return -1;
7055   }
7056   {
7057     char path[] = "/test-command";
7058     int r;
7059     suppress_error = 0;
7060     r = guestfs_chmod (g, 493, path);
7061     if (r == -1)
7062       return -1;
7063   }
7064   {
7065     char arguments_0[] = "/test-command";
7066     char arguments_1[] = "1";
7067     char *arguments[] = {
7068       arguments_0,
7069       arguments_1,
7070       NULL
7071     };
7072     char **r;
7073     int i;
7074     suppress_error = 0;
7075     r = guestfs_command_lines (g, arguments);
7076     if (r == NULL)
7077       return -1;
7078     if (!r[0]) {
7079       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7080       print_strings (r);
7081       return -1;
7082     }
7083     {
7084       char expected[] = "Result1";
7085       if (strcmp (r[0], expected) != 0) {
7086         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7087         return -1;
7088       }
7089     }
7090     if (r[1] != NULL) {
7091       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7092       print_strings (r);
7093       return -1;
7094     }
7095     for (i = 0; r[i] != NULL; ++i)
7096       free (r[i]);
7097     free (r);
7098   }
7099   return 0;
7100 }
7101
7102 static int test_command_lines_1_skip (void)
7103 {
7104   const char *str;
7105
7106   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7107   if (str && strcmp (str, "1") == 0) return 1;
7108   str = getenv ("SKIP_TEST_COMMAND_LINES");
7109   if (str && strcmp (str, "1") == 0) return 1;
7110   return 0;
7111 }
7112
7113 static int test_command_lines_1 (void)
7114 {
7115   if (test_command_lines_1_skip ()) {
7116     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7117     return 0;
7118   }
7119
7120   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7121   {
7122     char device[] = "/dev/sda";
7123     device[5] = devchar;
7124     int r;
7125     suppress_error = 0;
7126     r = guestfs_blockdev_setrw (g, device);
7127     if (r == -1)
7128       return -1;
7129   }
7130   {
7131     int r;
7132     suppress_error = 0;
7133     r = guestfs_umount_all (g);
7134     if (r == -1)
7135       return -1;
7136   }
7137   {
7138     int r;
7139     suppress_error = 0;
7140     r = guestfs_lvm_remove_all (g);
7141     if (r == -1)
7142       return -1;
7143   }
7144   {
7145     char device[] = "/dev/sda";
7146     device[5] = devchar;
7147     char lines_0[] = ",";
7148     char *lines[] = {
7149       lines_0,
7150       NULL
7151     };
7152     int r;
7153     suppress_error = 0;
7154     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7155     if (r == -1)
7156       return -1;
7157   }
7158   {
7159     char fstype[] = "ext2";
7160     char device[] = "/dev/sda1";
7161     device[5] = devchar;
7162     int r;
7163     suppress_error = 0;
7164     r = guestfs_mkfs (g, fstype, device);
7165     if (r == -1)
7166       return -1;
7167   }
7168   {
7169     char device[] = "/dev/sda1";
7170     device[5] = devchar;
7171     char mountpoint[] = "/";
7172     int r;
7173     suppress_error = 0;
7174     r = guestfs_mount (g, device, mountpoint);
7175     if (r == -1)
7176       return -1;
7177   }
7178   /* TestOutputList for command_lines (1) */
7179   {
7180     char remotefilename[] = "/test-command";
7181     int r;
7182     suppress_error = 0;
7183     r = guestfs_upload (g, "test-command", remotefilename);
7184     if (r == -1)
7185       return -1;
7186   }
7187   {
7188     char path[] = "/test-command";
7189     int r;
7190     suppress_error = 0;
7191     r = guestfs_chmod (g, 493, path);
7192     if (r == -1)
7193       return -1;
7194   }
7195   {
7196     char arguments_0[] = "/test-command";
7197     char arguments_1[] = "2";
7198     char *arguments[] = {
7199       arguments_0,
7200       arguments_1,
7201       NULL
7202     };
7203     char **r;
7204     int i;
7205     suppress_error = 0;
7206     r = guestfs_command_lines (g, arguments);
7207     if (r == NULL)
7208       return -1;
7209     if (!r[0]) {
7210       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7211       print_strings (r);
7212       return -1;
7213     }
7214     {
7215       char expected[] = "Result2";
7216       if (strcmp (r[0], expected) != 0) {
7217         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7218         return -1;
7219       }
7220     }
7221     if (r[1] != NULL) {
7222       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7223       print_strings (r);
7224       return -1;
7225     }
7226     for (i = 0; r[i] != NULL; ++i)
7227       free (r[i]);
7228     free (r);
7229   }
7230   return 0;
7231 }
7232
7233 static int test_command_lines_2_skip (void)
7234 {
7235   const char *str;
7236
7237   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7238   if (str && strcmp (str, "1") == 0) return 1;
7239   str = getenv ("SKIP_TEST_COMMAND_LINES");
7240   if (str && strcmp (str, "1") == 0) return 1;
7241   return 0;
7242 }
7243
7244 static int test_command_lines_2 (void)
7245 {
7246   if (test_command_lines_2_skip ()) {
7247     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7248     return 0;
7249   }
7250
7251   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7252   {
7253     char device[] = "/dev/sda";
7254     device[5] = devchar;
7255     int r;
7256     suppress_error = 0;
7257     r = guestfs_blockdev_setrw (g, device);
7258     if (r == -1)
7259       return -1;
7260   }
7261   {
7262     int r;
7263     suppress_error = 0;
7264     r = guestfs_umount_all (g);
7265     if (r == -1)
7266       return -1;
7267   }
7268   {
7269     int r;
7270     suppress_error = 0;
7271     r = guestfs_lvm_remove_all (g);
7272     if (r == -1)
7273       return -1;
7274   }
7275   {
7276     char device[] = "/dev/sda";
7277     device[5] = devchar;
7278     char lines_0[] = ",";
7279     char *lines[] = {
7280       lines_0,
7281       NULL
7282     };
7283     int r;
7284     suppress_error = 0;
7285     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7286     if (r == -1)
7287       return -1;
7288   }
7289   {
7290     char fstype[] = "ext2";
7291     char device[] = "/dev/sda1";
7292     device[5] = devchar;
7293     int r;
7294     suppress_error = 0;
7295     r = guestfs_mkfs (g, fstype, device);
7296     if (r == -1)
7297       return -1;
7298   }
7299   {
7300     char device[] = "/dev/sda1";
7301     device[5] = devchar;
7302     char mountpoint[] = "/";
7303     int r;
7304     suppress_error = 0;
7305     r = guestfs_mount (g, device, mountpoint);
7306     if (r == -1)
7307       return -1;
7308   }
7309   /* TestOutputList for command_lines (2) */
7310   {
7311     char remotefilename[] = "/test-command";
7312     int r;
7313     suppress_error = 0;
7314     r = guestfs_upload (g, "test-command", remotefilename);
7315     if (r == -1)
7316       return -1;
7317   }
7318   {
7319     char path[] = "/test-command";
7320     int r;
7321     suppress_error = 0;
7322     r = guestfs_chmod (g, 493, path);
7323     if (r == -1)
7324       return -1;
7325   }
7326   {
7327     char arguments_0[] = "/test-command";
7328     char arguments_1[] = "3";
7329     char *arguments[] = {
7330       arguments_0,
7331       arguments_1,
7332       NULL
7333     };
7334     char **r;
7335     int i;
7336     suppress_error = 0;
7337     r = guestfs_command_lines (g, arguments);
7338     if (r == NULL)
7339       return -1;
7340     if (!r[0]) {
7341       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7342       print_strings (r);
7343       return -1;
7344     }
7345     {
7346       char expected[] = "";
7347       if (strcmp (r[0], expected) != 0) {
7348         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7349         return -1;
7350       }
7351     }
7352     if (!r[1]) {
7353       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7354       print_strings (r);
7355       return -1;
7356     }
7357     {
7358       char expected[] = "Result3";
7359       if (strcmp (r[1], expected) != 0) {
7360         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7361         return -1;
7362       }
7363     }
7364     if (r[2] != NULL) {
7365       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7366       print_strings (r);
7367       return -1;
7368     }
7369     for (i = 0; r[i] != NULL; ++i)
7370       free (r[i]);
7371     free (r);
7372   }
7373   return 0;
7374 }
7375
7376 static int test_command_lines_3_skip (void)
7377 {
7378   const char *str;
7379
7380   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7381   if (str && strcmp (str, "1") == 0) return 1;
7382   str = getenv ("SKIP_TEST_COMMAND_LINES");
7383   if (str && strcmp (str, "1") == 0) return 1;
7384   return 0;
7385 }
7386
7387 static int test_command_lines_3 (void)
7388 {
7389   if (test_command_lines_3_skip ()) {
7390     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7391     return 0;
7392   }
7393
7394   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7395   {
7396     char device[] = "/dev/sda";
7397     device[5] = devchar;
7398     int r;
7399     suppress_error = 0;
7400     r = guestfs_blockdev_setrw (g, device);
7401     if (r == -1)
7402       return -1;
7403   }
7404   {
7405     int r;
7406     suppress_error = 0;
7407     r = guestfs_umount_all (g);
7408     if (r == -1)
7409       return -1;
7410   }
7411   {
7412     int r;
7413     suppress_error = 0;
7414     r = guestfs_lvm_remove_all (g);
7415     if (r == -1)
7416       return -1;
7417   }
7418   {
7419     char device[] = "/dev/sda";
7420     device[5] = devchar;
7421     char lines_0[] = ",";
7422     char *lines[] = {
7423       lines_0,
7424       NULL
7425     };
7426     int r;
7427     suppress_error = 0;
7428     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7429     if (r == -1)
7430       return -1;
7431   }
7432   {
7433     char fstype[] = "ext2";
7434     char device[] = "/dev/sda1";
7435     device[5] = devchar;
7436     int r;
7437     suppress_error = 0;
7438     r = guestfs_mkfs (g, fstype, device);
7439     if (r == -1)
7440       return -1;
7441   }
7442   {
7443     char device[] = "/dev/sda1";
7444     device[5] = devchar;
7445     char mountpoint[] = "/";
7446     int r;
7447     suppress_error = 0;
7448     r = guestfs_mount (g, device, mountpoint);
7449     if (r == -1)
7450       return -1;
7451   }
7452   /* TestOutputList for command_lines (3) */
7453   {
7454     char remotefilename[] = "/test-command";
7455     int r;
7456     suppress_error = 0;
7457     r = guestfs_upload (g, "test-command", remotefilename);
7458     if (r == -1)
7459       return -1;
7460   }
7461   {
7462     char path[] = "/test-command";
7463     int r;
7464     suppress_error = 0;
7465     r = guestfs_chmod (g, 493, path);
7466     if (r == -1)
7467       return -1;
7468   }
7469   {
7470     char arguments_0[] = "/test-command";
7471     char arguments_1[] = "4";
7472     char *arguments[] = {
7473       arguments_0,
7474       arguments_1,
7475       NULL
7476     };
7477     char **r;
7478     int i;
7479     suppress_error = 0;
7480     r = guestfs_command_lines (g, arguments);
7481     if (r == NULL)
7482       return -1;
7483     if (!r[0]) {
7484       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7485       print_strings (r);
7486       return -1;
7487     }
7488     {
7489       char expected[] = "";
7490       if (strcmp (r[0], expected) != 0) {
7491         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7492         return -1;
7493       }
7494     }
7495     if (!r[1]) {
7496       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7497       print_strings (r);
7498       return -1;
7499     }
7500     {
7501       char expected[] = "Result4";
7502       if (strcmp (r[1], expected) != 0) {
7503         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7504         return -1;
7505       }
7506     }
7507     if (r[2] != NULL) {
7508       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7509       print_strings (r);
7510       return -1;
7511     }
7512     for (i = 0; r[i] != NULL; ++i)
7513       free (r[i]);
7514     free (r);
7515   }
7516   return 0;
7517 }
7518
7519 static int test_command_lines_4_skip (void)
7520 {
7521   const char *str;
7522
7523   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7524   if (str && strcmp (str, "1") == 0) return 1;
7525   str = getenv ("SKIP_TEST_COMMAND_LINES");
7526   if (str && strcmp (str, "1") == 0) return 1;
7527   return 0;
7528 }
7529
7530 static int test_command_lines_4 (void)
7531 {
7532   if (test_command_lines_4_skip ()) {
7533     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7534     return 0;
7535   }
7536
7537   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7538   {
7539     char device[] = "/dev/sda";
7540     device[5] = devchar;
7541     int r;
7542     suppress_error = 0;
7543     r = guestfs_blockdev_setrw (g, device);
7544     if (r == -1)
7545       return -1;
7546   }
7547   {
7548     int r;
7549     suppress_error = 0;
7550     r = guestfs_umount_all (g);
7551     if (r == -1)
7552       return -1;
7553   }
7554   {
7555     int r;
7556     suppress_error = 0;
7557     r = guestfs_lvm_remove_all (g);
7558     if (r == -1)
7559       return -1;
7560   }
7561   {
7562     char device[] = "/dev/sda";
7563     device[5] = devchar;
7564     char lines_0[] = ",";
7565     char *lines[] = {
7566       lines_0,
7567       NULL
7568     };
7569     int r;
7570     suppress_error = 0;
7571     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7572     if (r == -1)
7573       return -1;
7574   }
7575   {
7576     char fstype[] = "ext2";
7577     char device[] = "/dev/sda1";
7578     device[5] = devchar;
7579     int r;
7580     suppress_error = 0;
7581     r = guestfs_mkfs (g, fstype, device);
7582     if (r == -1)
7583       return -1;
7584   }
7585   {
7586     char device[] = "/dev/sda1";
7587     device[5] = devchar;
7588     char mountpoint[] = "/";
7589     int r;
7590     suppress_error = 0;
7591     r = guestfs_mount (g, device, mountpoint);
7592     if (r == -1)
7593       return -1;
7594   }
7595   /* TestOutputList for command_lines (4) */
7596   {
7597     char remotefilename[] = "/test-command";
7598     int r;
7599     suppress_error = 0;
7600     r = guestfs_upload (g, "test-command", remotefilename);
7601     if (r == -1)
7602       return -1;
7603   }
7604   {
7605     char path[] = "/test-command";
7606     int r;
7607     suppress_error = 0;
7608     r = guestfs_chmod (g, 493, path);
7609     if (r == -1)
7610       return -1;
7611   }
7612   {
7613     char arguments_0[] = "/test-command";
7614     char arguments_1[] = "5";
7615     char *arguments[] = {
7616       arguments_0,
7617       arguments_1,
7618       NULL
7619     };
7620     char **r;
7621     int i;
7622     suppress_error = 0;
7623     r = guestfs_command_lines (g, arguments);
7624     if (r == NULL)
7625       return -1;
7626     if (!r[0]) {
7627       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7628       print_strings (r);
7629       return -1;
7630     }
7631     {
7632       char expected[] = "";
7633       if (strcmp (r[0], expected) != 0) {
7634         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7635         return -1;
7636       }
7637     }
7638     if (!r[1]) {
7639       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7640       print_strings (r);
7641       return -1;
7642     }
7643     {
7644       char expected[] = "Result5";
7645       if (strcmp (r[1], expected) != 0) {
7646         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7647         return -1;
7648       }
7649     }
7650     if (!r[2]) {
7651       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7652       print_strings (r);
7653       return -1;
7654     }
7655     {
7656       char expected[] = "";
7657       if (strcmp (r[2], expected) != 0) {
7658         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7659         return -1;
7660       }
7661     }
7662     if (r[3] != NULL) {
7663       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7664       print_strings (r);
7665       return -1;
7666     }
7667     for (i = 0; r[i] != NULL; ++i)
7668       free (r[i]);
7669     free (r);
7670   }
7671   return 0;
7672 }
7673
7674 static int test_command_lines_5_skip (void)
7675 {
7676   const char *str;
7677
7678   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7679   if (str && strcmp (str, "1") == 0) return 1;
7680   str = getenv ("SKIP_TEST_COMMAND_LINES");
7681   if (str && strcmp (str, "1") == 0) return 1;
7682   return 0;
7683 }
7684
7685 static int test_command_lines_5 (void)
7686 {
7687   if (test_command_lines_5_skip ()) {
7688     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7689     return 0;
7690   }
7691
7692   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7693   {
7694     char device[] = "/dev/sda";
7695     device[5] = devchar;
7696     int r;
7697     suppress_error = 0;
7698     r = guestfs_blockdev_setrw (g, device);
7699     if (r == -1)
7700       return -1;
7701   }
7702   {
7703     int r;
7704     suppress_error = 0;
7705     r = guestfs_umount_all (g);
7706     if (r == -1)
7707       return -1;
7708   }
7709   {
7710     int r;
7711     suppress_error = 0;
7712     r = guestfs_lvm_remove_all (g);
7713     if (r == -1)
7714       return -1;
7715   }
7716   {
7717     char device[] = "/dev/sda";
7718     device[5] = devchar;
7719     char lines_0[] = ",";
7720     char *lines[] = {
7721       lines_0,
7722       NULL
7723     };
7724     int r;
7725     suppress_error = 0;
7726     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7727     if (r == -1)
7728       return -1;
7729   }
7730   {
7731     char fstype[] = "ext2";
7732     char device[] = "/dev/sda1";
7733     device[5] = devchar;
7734     int r;
7735     suppress_error = 0;
7736     r = guestfs_mkfs (g, fstype, device);
7737     if (r == -1)
7738       return -1;
7739   }
7740   {
7741     char device[] = "/dev/sda1";
7742     device[5] = devchar;
7743     char mountpoint[] = "/";
7744     int r;
7745     suppress_error = 0;
7746     r = guestfs_mount (g, device, mountpoint);
7747     if (r == -1)
7748       return -1;
7749   }
7750   /* TestOutputList for command_lines (5) */
7751   {
7752     char remotefilename[] = "/test-command";
7753     int r;
7754     suppress_error = 0;
7755     r = guestfs_upload (g, "test-command", remotefilename);
7756     if (r == -1)
7757       return -1;
7758   }
7759   {
7760     char path[] = "/test-command";
7761     int r;
7762     suppress_error = 0;
7763     r = guestfs_chmod (g, 493, path);
7764     if (r == -1)
7765       return -1;
7766   }
7767   {
7768     char arguments_0[] = "/test-command";
7769     char arguments_1[] = "6";
7770     char *arguments[] = {
7771       arguments_0,
7772       arguments_1,
7773       NULL
7774     };
7775     char **r;
7776     int i;
7777     suppress_error = 0;
7778     r = guestfs_command_lines (g, arguments);
7779     if (r == NULL)
7780       return -1;
7781     if (!r[0]) {
7782       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7783       print_strings (r);
7784       return -1;
7785     }
7786     {
7787       char expected[] = "";
7788       if (strcmp (r[0], expected) != 0) {
7789         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7790         return -1;
7791       }
7792     }
7793     if (!r[1]) {
7794       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7795       print_strings (r);
7796       return -1;
7797     }
7798     {
7799       char expected[] = "";
7800       if (strcmp (r[1], expected) != 0) {
7801         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7802         return -1;
7803       }
7804     }
7805     if (!r[2]) {
7806       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7807       print_strings (r);
7808       return -1;
7809     }
7810     {
7811       char expected[] = "Result6";
7812       if (strcmp (r[2], expected) != 0) {
7813         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7814         return -1;
7815       }
7816     }
7817     if (!r[3]) {
7818       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7819       print_strings (r);
7820       return -1;
7821     }
7822     {
7823       char expected[] = "";
7824       if (strcmp (r[3], expected) != 0) {
7825         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7826         return -1;
7827       }
7828     }
7829     if (r[4] != NULL) {
7830       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7831       print_strings (r);
7832       return -1;
7833     }
7834     for (i = 0; r[i] != NULL; ++i)
7835       free (r[i]);
7836     free (r);
7837   }
7838   return 0;
7839 }
7840
7841 static int test_command_lines_6_skip (void)
7842 {
7843   const char *str;
7844
7845   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7846   if (str && strcmp (str, "1") == 0) return 1;
7847   str = getenv ("SKIP_TEST_COMMAND_LINES");
7848   if (str && strcmp (str, "1") == 0) return 1;
7849   return 0;
7850 }
7851
7852 static int test_command_lines_6 (void)
7853 {
7854   if (test_command_lines_6_skip ()) {
7855     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7856     return 0;
7857   }
7858
7859   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7860   {
7861     char device[] = "/dev/sda";
7862     device[5] = devchar;
7863     int r;
7864     suppress_error = 0;
7865     r = guestfs_blockdev_setrw (g, device);
7866     if (r == -1)
7867       return -1;
7868   }
7869   {
7870     int r;
7871     suppress_error = 0;
7872     r = guestfs_umount_all (g);
7873     if (r == -1)
7874       return -1;
7875   }
7876   {
7877     int r;
7878     suppress_error = 0;
7879     r = guestfs_lvm_remove_all (g);
7880     if (r == -1)
7881       return -1;
7882   }
7883   {
7884     char device[] = "/dev/sda";
7885     device[5] = devchar;
7886     char lines_0[] = ",";
7887     char *lines[] = {
7888       lines_0,
7889       NULL
7890     };
7891     int r;
7892     suppress_error = 0;
7893     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7894     if (r == -1)
7895       return -1;
7896   }
7897   {
7898     char fstype[] = "ext2";
7899     char device[] = "/dev/sda1";
7900     device[5] = devchar;
7901     int r;
7902     suppress_error = 0;
7903     r = guestfs_mkfs (g, fstype, device);
7904     if (r == -1)
7905       return -1;
7906   }
7907   {
7908     char device[] = "/dev/sda1";
7909     device[5] = devchar;
7910     char mountpoint[] = "/";
7911     int r;
7912     suppress_error = 0;
7913     r = guestfs_mount (g, device, mountpoint);
7914     if (r == -1)
7915       return -1;
7916   }
7917   /* TestOutputList for command_lines (6) */
7918   {
7919     char remotefilename[] = "/test-command";
7920     int r;
7921     suppress_error = 0;
7922     r = guestfs_upload (g, "test-command", remotefilename);
7923     if (r == -1)
7924       return -1;
7925   }
7926   {
7927     char path[] = "/test-command";
7928     int r;
7929     suppress_error = 0;
7930     r = guestfs_chmod (g, 493, path);
7931     if (r == -1)
7932       return -1;
7933   }
7934   {
7935     char arguments_0[] = "/test-command";
7936     char arguments_1[] = "7";
7937     char *arguments[] = {
7938       arguments_0,
7939       arguments_1,
7940       NULL
7941     };
7942     char **r;
7943     int i;
7944     suppress_error = 0;
7945     r = guestfs_command_lines (g, arguments);
7946     if (r == NULL)
7947       return -1;
7948     if (r[0] != NULL) {
7949       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7950       print_strings (r);
7951       return -1;
7952     }
7953     for (i = 0; r[i] != NULL; ++i)
7954       free (r[i]);
7955     free (r);
7956   }
7957   return 0;
7958 }
7959
7960 static int test_command_lines_7_skip (void)
7961 {
7962   const char *str;
7963
7964   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7965   if (str && strcmp (str, "1") == 0) return 1;
7966   str = getenv ("SKIP_TEST_COMMAND_LINES");
7967   if (str && strcmp (str, "1") == 0) return 1;
7968   return 0;
7969 }
7970
7971 static int test_command_lines_7 (void)
7972 {
7973   if (test_command_lines_7_skip ()) {
7974     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7975     return 0;
7976   }
7977
7978   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7979   {
7980     char device[] = "/dev/sda";
7981     device[5] = devchar;
7982     int r;
7983     suppress_error = 0;
7984     r = guestfs_blockdev_setrw (g, device);
7985     if (r == -1)
7986       return -1;
7987   }
7988   {
7989     int r;
7990     suppress_error = 0;
7991     r = guestfs_umount_all (g);
7992     if (r == -1)
7993       return -1;
7994   }
7995   {
7996     int r;
7997     suppress_error = 0;
7998     r = guestfs_lvm_remove_all (g);
7999     if (r == -1)
8000       return -1;
8001   }
8002   {
8003     char device[] = "/dev/sda";
8004     device[5] = devchar;
8005     char lines_0[] = ",";
8006     char *lines[] = {
8007       lines_0,
8008       NULL
8009     };
8010     int r;
8011     suppress_error = 0;
8012     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8013     if (r == -1)
8014       return -1;
8015   }
8016   {
8017     char fstype[] = "ext2";
8018     char device[] = "/dev/sda1";
8019     device[5] = devchar;
8020     int r;
8021     suppress_error = 0;
8022     r = guestfs_mkfs (g, fstype, device);
8023     if (r == -1)
8024       return -1;
8025   }
8026   {
8027     char device[] = "/dev/sda1";
8028     device[5] = devchar;
8029     char mountpoint[] = "/";
8030     int r;
8031     suppress_error = 0;
8032     r = guestfs_mount (g, device, mountpoint);
8033     if (r == -1)
8034       return -1;
8035   }
8036   /* TestOutputList for command_lines (7) */
8037   {
8038     char remotefilename[] = "/test-command";
8039     int r;
8040     suppress_error = 0;
8041     r = guestfs_upload (g, "test-command", remotefilename);
8042     if (r == -1)
8043       return -1;
8044   }
8045   {
8046     char path[] = "/test-command";
8047     int r;
8048     suppress_error = 0;
8049     r = guestfs_chmod (g, 493, path);
8050     if (r == -1)
8051       return -1;
8052   }
8053   {
8054     char arguments_0[] = "/test-command";
8055     char arguments_1[] = "8";
8056     char *arguments[] = {
8057       arguments_0,
8058       arguments_1,
8059       NULL
8060     };
8061     char **r;
8062     int i;
8063     suppress_error = 0;
8064     r = guestfs_command_lines (g, arguments);
8065     if (r == NULL)
8066       return -1;
8067     if (!r[0]) {
8068       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8069       print_strings (r);
8070       return -1;
8071     }
8072     {
8073       char expected[] = "";
8074       if (strcmp (r[0], expected) != 0) {
8075         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8076         return -1;
8077       }
8078     }
8079     if (r[1] != NULL) {
8080       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8081       print_strings (r);
8082       return -1;
8083     }
8084     for (i = 0; r[i] != NULL; ++i)
8085       free (r[i]);
8086     free (r);
8087   }
8088   return 0;
8089 }
8090
8091 static int test_command_lines_8_skip (void)
8092 {
8093   const char *str;
8094
8095   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8096   if (str && strcmp (str, "1") == 0) return 1;
8097   str = getenv ("SKIP_TEST_COMMAND_LINES");
8098   if (str && strcmp (str, "1") == 0) return 1;
8099   return 0;
8100 }
8101
8102 static int test_command_lines_8 (void)
8103 {
8104   if (test_command_lines_8_skip ()) {
8105     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8106     return 0;
8107   }
8108
8109   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8110   {
8111     char device[] = "/dev/sda";
8112     device[5] = devchar;
8113     int r;
8114     suppress_error = 0;
8115     r = guestfs_blockdev_setrw (g, device);
8116     if (r == -1)
8117       return -1;
8118   }
8119   {
8120     int r;
8121     suppress_error = 0;
8122     r = guestfs_umount_all (g);
8123     if (r == -1)
8124       return -1;
8125   }
8126   {
8127     int r;
8128     suppress_error = 0;
8129     r = guestfs_lvm_remove_all (g);
8130     if (r == -1)
8131       return -1;
8132   }
8133   {
8134     char device[] = "/dev/sda";
8135     device[5] = devchar;
8136     char lines_0[] = ",";
8137     char *lines[] = {
8138       lines_0,
8139       NULL
8140     };
8141     int r;
8142     suppress_error = 0;
8143     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8144     if (r == -1)
8145       return -1;
8146   }
8147   {
8148     char fstype[] = "ext2";
8149     char device[] = "/dev/sda1";
8150     device[5] = devchar;
8151     int r;
8152     suppress_error = 0;
8153     r = guestfs_mkfs (g, fstype, device);
8154     if (r == -1)
8155       return -1;
8156   }
8157   {
8158     char device[] = "/dev/sda1";
8159     device[5] = devchar;
8160     char mountpoint[] = "/";
8161     int r;
8162     suppress_error = 0;
8163     r = guestfs_mount (g, device, mountpoint);
8164     if (r == -1)
8165       return -1;
8166   }
8167   /* TestOutputList for command_lines (8) */
8168   {
8169     char remotefilename[] = "/test-command";
8170     int r;
8171     suppress_error = 0;
8172     r = guestfs_upload (g, "test-command", remotefilename);
8173     if (r == -1)
8174       return -1;
8175   }
8176   {
8177     char path[] = "/test-command";
8178     int r;
8179     suppress_error = 0;
8180     r = guestfs_chmod (g, 493, path);
8181     if (r == -1)
8182       return -1;
8183   }
8184   {
8185     char arguments_0[] = "/test-command";
8186     char arguments_1[] = "9";
8187     char *arguments[] = {
8188       arguments_0,
8189       arguments_1,
8190       NULL
8191     };
8192     char **r;
8193     int i;
8194     suppress_error = 0;
8195     r = guestfs_command_lines (g, arguments);
8196     if (r == NULL)
8197       return -1;
8198     if (!r[0]) {
8199       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8200       print_strings (r);
8201       return -1;
8202     }
8203     {
8204       char expected[] = "";
8205       if (strcmp (r[0], expected) != 0) {
8206         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8207         return -1;
8208       }
8209     }
8210     if (!r[1]) {
8211       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8212       print_strings (r);
8213       return -1;
8214     }
8215     {
8216       char expected[] = "";
8217       if (strcmp (r[1], expected) != 0) {
8218         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8219         return -1;
8220       }
8221     }
8222     if (r[2] != NULL) {
8223       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8224       print_strings (r);
8225       return -1;
8226     }
8227     for (i = 0; r[i] != NULL; ++i)
8228       free (r[i]);
8229     free (r);
8230   }
8231   return 0;
8232 }
8233
8234 static int test_command_lines_9_skip (void)
8235 {
8236   const char *str;
8237
8238   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8239   if (str && strcmp (str, "1") == 0) return 1;
8240   str = getenv ("SKIP_TEST_COMMAND_LINES");
8241   if (str && strcmp (str, "1") == 0) return 1;
8242   return 0;
8243 }
8244
8245 static int test_command_lines_9 (void)
8246 {
8247   if (test_command_lines_9_skip ()) {
8248     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8249     return 0;
8250   }
8251
8252   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8253   {
8254     char device[] = "/dev/sda";
8255     device[5] = devchar;
8256     int r;
8257     suppress_error = 0;
8258     r = guestfs_blockdev_setrw (g, device);
8259     if (r == -1)
8260       return -1;
8261   }
8262   {
8263     int r;
8264     suppress_error = 0;
8265     r = guestfs_umount_all (g);
8266     if (r == -1)
8267       return -1;
8268   }
8269   {
8270     int r;
8271     suppress_error = 0;
8272     r = guestfs_lvm_remove_all (g);
8273     if (r == -1)
8274       return -1;
8275   }
8276   {
8277     char device[] = "/dev/sda";
8278     device[5] = devchar;
8279     char lines_0[] = ",";
8280     char *lines[] = {
8281       lines_0,
8282       NULL
8283     };
8284     int r;
8285     suppress_error = 0;
8286     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8287     if (r == -1)
8288       return -1;
8289   }
8290   {
8291     char fstype[] = "ext2";
8292     char device[] = "/dev/sda1";
8293     device[5] = devchar;
8294     int r;
8295     suppress_error = 0;
8296     r = guestfs_mkfs (g, fstype, device);
8297     if (r == -1)
8298       return -1;
8299   }
8300   {
8301     char device[] = "/dev/sda1";
8302     device[5] = devchar;
8303     char mountpoint[] = "/";
8304     int r;
8305     suppress_error = 0;
8306     r = guestfs_mount (g, device, mountpoint);
8307     if (r == -1)
8308       return -1;
8309   }
8310   /* TestOutputList for command_lines (9) */
8311   {
8312     char remotefilename[] = "/test-command";
8313     int r;
8314     suppress_error = 0;
8315     r = guestfs_upload (g, "test-command", remotefilename);
8316     if (r == -1)
8317       return -1;
8318   }
8319   {
8320     char path[] = "/test-command";
8321     int r;
8322     suppress_error = 0;
8323     r = guestfs_chmod (g, 493, path);
8324     if (r == -1)
8325       return -1;
8326   }
8327   {
8328     char arguments_0[] = "/test-command";
8329     char arguments_1[] = "10";
8330     char *arguments[] = {
8331       arguments_0,
8332       arguments_1,
8333       NULL
8334     };
8335     char **r;
8336     int i;
8337     suppress_error = 0;
8338     r = guestfs_command_lines (g, arguments);
8339     if (r == NULL)
8340       return -1;
8341     if (!r[0]) {
8342       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8343       print_strings (r);
8344       return -1;
8345     }
8346     {
8347       char expected[] = "Result10-1";
8348       if (strcmp (r[0], expected) != 0) {
8349         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8350         return -1;
8351       }
8352     }
8353     if (!r[1]) {
8354       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8355       print_strings (r);
8356       return -1;
8357     }
8358     {
8359       char expected[] = "Result10-2";
8360       if (strcmp (r[1], expected) != 0) {
8361         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8362         return -1;
8363       }
8364     }
8365     if (r[2] != NULL) {
8366       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8367       print_strings (r);
8368       return -1;
8369     }
8370     for (i = 0; r[i] != NULL; ++i)
8371       free (r[i]);
8372     free (r);
8373   }
8374   return 0;
8375 }
8376
8377 static int test_command_lines_10_skip (void)
8378 {
8379   const char *str;
8380
8381   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8382   if (str && strcmp (str, "1") == 0) return 1;
8383   str = getenv ("SKIP_TEST_COMMAND_LINES");
8384   if (str && strcmp (str, "1") == 0) return 1;
8385   return 0;
8386 }
8387
8388 static int test_command_lines_10 (void)
8389 {
8390   if (test_command_lines_10_skip ()) {
8391     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8392     return 0;
8393   }
8394
8395   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8396   {
8397     char device[] = "/dev/sda";
8398     device[5] = devchar;
8399     int r;
8400     suppress_error = 0;
8401     r = guestfs_blockdev_setrw (g, device);
8402     if (r == -1)
8403       return -1;
8404   }
8405   {
8406     int r;
8407     suppress_error = 0;
8408     r = guestfs_umount_all (g);
8409     if (r == -1)
8410       return -1;
8411   }
8412   {
8413     int r;
8414     suppress_error = 0;
8415     r = guestfs_lvm_remove_all (g);
8416     if (r == -1)
8417       return -1;
8418   }
8419   {
8420     char device[] = "/dev/sda";
8421     device[5] = devchar;
8422     char lines_0[] = ",";
8423     char *lines[] = {
8424       lines_0,
8425       NULL
8426     };
8427     int r;
8428     suppress_error = 0;
8429     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8430     if (r == -1)
8431       return -1;
8432   }
8433   {
8434     char fstype[] = "ext2";
8435     char device[] = "/dev/sda1";
8436     device[5] = devchar;
8437     int r;
8438     suppress_error = 0;
8439     r = guestfs_mkfs (g, fstype, device);
8440     if (r == -1)
8441       return -1;
8442   }
8443   {
8444     char device[] = "/dev/sda1";
8445     device[5] = devchar;
8446     char mountpoint[] = "/";
8447     int r;
8448     suppress_error = 0;
8449     r = guestfs_mount (g, device, mountpoint);
8450     if (r == -1)
8451       return -1;
8452   }
8453   /* TestOutputList for command_lines (10) */
8454   {
8455     char remotefilename[] = "/test-command";
8456     int r;
8457     suppress_error = 0;
8458     r = guestfs_upload (g, "test-command", remotefilename);
8459     if (r == -1)
8460       return -1;
8461   }
8462   {
8463     char path[] = "/test-command";
8464     int r;
8465     suppress_error = 0;
8466     r = guestfs_chmod (g, 493, path);
8467     if (r == -1)
8468       return -1;
8469   }
8470   {
8471     char arguments_0[] = "/test-command";
8472     char arguments_1[] = "11";
8473     char *arguments[] = {
8474       arguments_0,
8475       arguments_1,
8476       NULL
8477     };
8478     char **r;
8479     int i;
8480     suppress_error = 0;
8481     r = guestfs_command_lines (g, arguments);
8482     if (r == NULL)
8483       return -1;
8484     if (!r[0]) {
8485       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8486       print_strings (r);
8487       return -1;
8488     }
8489     {
8490       char expected[] = "Result11-1";
8491       if (strcmp (r[0], expected) != 0) {
8492         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8493         return -1;
8494       }
8495     }
8496     if (!r[1]) {
8497       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8498       print_strings (r);
8499       return -1;
8500     }
8501     {
8502       char expected[] = "Result11-2";
8503       if (strcmp (r[1], expected) != 0) {
8504         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8505         return -1;
8506       }
8507     }
8508     if (r[2] != NULL) {
8509       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8510       print_strings (r);
8511       return -1;
8512     }
8513     for (i = 0; r[i] != NULL; ++i)
8514       free (r[i]);
8515     free (r);
8516   }
8517   return 0;
8518 }
8519
8520 static int test_command_0_skip (void)
8521 {
8522   const char *str;
8523
8524   str = getenv ("SKIP_TEST_COMMAND_0");
8525   if (str && strcmp (str, "1") == 0) return 1;
8526   str = getenv ("SKIP_TEST_COMMAND");
8527   if (str && strcmp (str, "1") == 0) return 1;
8528   return 0;
8529 }
8530
8531 static int test_command_0 (void)
8532 {
8533   if (test_command_0_skip ()) {
8534     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8535     return 0;
8536   }
8537
8538   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8539   {
8540     char device[] = "/dev/sda";
8541     device[5] = devchar;
8542     int r;
8543     suppress_error = 0;
8544     r = guestfs_blockdev_setrw (g, device);
8545     if (r == -1)
8546       return -1;
8547   }
8548   {
8549     int r;
8550     suppress_error = 0;
8551     r = guestfs_umount_all (g);
8552     if (r == -1)
8553       return -1;
8554   }
8555   {
8556     int r;
8557     suppress_error = 0;
8558     r = guestfs_lvm_remove_all (g);
8559     if (r == -1)
8560       return -1;
8561   }
8562   {
8563     char device[] = "/dev/sda";
8564     device[5] = devchar;
8565     char lines_0[] = ",";
8566     char *lines[] = {
8567       lines_0,
8568       NULL
8569     };
8570     int r;
8571     suppress_error = 0;
8572     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8573     if (r == -1)
8574       return -1;
8575   }
8576   {
8577     char fstype[] = "ext2";
8578     char device[] = "/dev/sda1";
8579     device[5] = devchar;
8580     int r;
8581     suppress_error = 0;
8582     r = guestfs_mkfs (g, fstype, device);
8583     if (r == -1)
8584       return -1;
8585   }
8586   {
8587     char device[] = "/dev/sda1";
8588     device[5] = devchar;
8589     char mountpoint[] = "/";
8590     int r;
8591     suppress_error = 0;
8592     r = guestfs_mount (g, device, mountpoint);
8593     if (r == -1)
8594       return -1;
8595   }
8596   /* TestOutput for command (0) */
8597   char expected[] = "Result1";
8598   {
8599     char remotefilename[] = "/test-command";
8600     int r;
8601     suppress_error = 0;
8602     r = guestfs_upload (g, "test-command", remotefilename);
8603     if (r == -1)
8604       return -1;
8605   }
8606   {
8607     char path[] = "/test-command";
8608     int r;
8609     suppress_error = 0;
8610     r = guestfs_chmod (g, 493, path);
8611     if (r == -1)
8612       return -1;
8613   }
8614   {
8615     char arguments_0[] = "/test-command";
8616     char arguments_1[] = "1";
8617     char *arguments[] = {
8618       arguments_0,
8619       arguments_1,
8620       NULL
8621     };
8622     char *r;
8623     suppress_error = 0;
8624     r = guestfs_command (g, arguments);
8625     if (r == NULL)
8626       return -1;
8627     if (strcmp (r, expected) != 0) {
8628       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8629       return -1;
8630     }
8631     free (r);
8632   }
8633   return 0;
8634 }
8635
8636 static int test_command_1_skip (void)
8637 {
8638   const char *str;
8639
8640   str = getenv ("SKIP_TEST_COMMAND_1");
8641   if (str && strcmp (str, "1") == 0) return 1;
8642   str = getenv ("SKIP_TEST_COMMAND");
8643   if (str && strcmp (str, "1") == 0) return 1;
8644   return 0;
8645 }
8646
8647 static int test_command_1 (void)
8648 {
8649   if (test_command_1_skip ()) {
8650     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8651     return 0;
8652   }
8653
8654   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8655   {
8656     char device[] = "/dev/sda";
8657     device[5] = devchar;
8658     int r;
8659     suppress_error = 0;
8660     r = guestfs_blockdev_setrw (g, device);
8661     if (r == -1)
8662       return -1;
8663   }
8664   {
8665     int r;
8666     suppress_error = 0;
8667     r = guestfs_umount_all (g);
8668     if (r == -1)
8669       return -1;
8670   }
8671   {
8672     int r;
8673     suppress_error = 0;
8674     r = guestfs_lvm_remove_all (g);
8675     if (r == -1)
8676       return -1;
8677   }
8678   {
8679     char device[] = "/dev/sda";
8680     device[5] = devchar;
8681     char lines_0[] = ",";
8682     char *lines[] = {
8683       lines_0,
8684       NULL
8685     };
8686     int r;
8687     suppress_error = 0;
8688     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8689     if (r == -1)
8690       return -1;
8691   }
8692   {
8693     char fstype[] = "ext2";
8694     char device[] = "/dev/sda1";
8695     device[5] = devchar;
8696     int r;
8697     suppress_error = 0;
8698     r = guestfs_mkfs (g, fstype, device);
8699     if (r == -1)
8700       return -1;
8701   }
8702   {
8703     char device[] = "/dev/sda1";
8704     device[5] = devchar;
8705     char mountpoint[] = "/";
8706     int r;
8707     suppress_error = 0;
8708     r = guestfs_mount (g, device, mountpoint);
8709     if (r == -1)
8710       return -1;
8711   }
8712   /* TestOutput for command (1) */
8713   char expected[] = "Result2\n";
8714   {
8715     char remotefilename[] = "/test-command";
8716     int r;
8717     suppress_error = 0;
8718     r = guestfs_upload (g, "test-command", remotefilename);
8719     if (r == -1)
8720       return -1;
8721   }
8722   {
8723     char path[] = "/test-command";
8724     int r;
8725     suppress_error = 0;
8726     r = guestfs_chmod (g, 493, path);
8727     if (r == -1)
8728       return -1;
8729   }
8730   {
8731     char arguments_0[] = "/test-command";
8732     char arguments_1[] = "2";
8733     char *arguments[] = {
8734       arguments_0,
8735       arguments_1,
8736       NULL
8737     };
8738     char *r;
8739     suppress_error = 0;
8740     r = guestfs_command (g, arguments);
8741     if (r == NULL)
8742       return -1;
8743     if (strcmp (r, expected) != 0) {
8744       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8745       return -1;
8746     }
8747     free (r);
8748   }
8749   return 0;
8750 }
8751
8752 static int test_command_2_skip (void)
8753 {
8754   const char *str;
8755
8756   str = getenv ("SKIP_TEST_COMMAND_2");
8757   if (str && strcmp (str, "1") == 0) return 1;
8758   str = getenv ("SKIP_TEST_COMMAND");
8759   if (str && strcmp (str, "1") == 0) return 1;
8760   return 0;
8761 }
8762
8763 static int test_command_2 (void)
8764 {
8765   if (test_command_2_skip ()) {
8766     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8767     return 0;
8768   }
8769
8770   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8771   {
8772     char device[] = "/dev/sda";
8773     device[5] = devchar;
8774     int r;
8775     suppress_error = 0;
8776     r = guestfs_blockdev_setrw (g, device);
8777     if (r == -1)
8778       return -1;
8779   }
8780   {
8781     int r;
8782     suppress_error = 0;
8783     r = guestfs_umount_all (g);
8784     if (r == -1)
8785       return -1;
8786   }
8787   {
8788     int r;
8789     suppress_error = 0;
8790     r = guestfs_lvm_remove_all (g);
8791     if (r == -1)
8792       return -1;
8793   }
8794   {
8795     char device[] = "/dev/sda";
8796     device[5] = devchar;
8797     char lines_0[] = ",";
8798     char *lines[] = {
8799       lines_0,
8800       NULL
8801     };
8802     int r;
8803     suppress_error = 0;
8804     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8805     if (r == -1)
8806       return -1;
8807   }
8808   {
8809     char fstype[] = "ext2";
8810     char device[] = "/dev/sda1";
8811     device[5] = devchar;
8812     int r;
8813     suppress_error = 0;
8814     r = guestfs_mkfs (g, fstype, device);
8815     if (r == -1)
8816       return -1;
8817   }
8818   {
8819     char device[] = "/dev/sda1";
8820     device[5] = devchar;
8821     char mountpoint[] = "/";
8822     int r;
8823     suppress_error = 0;
8824     r = guestfs_mount (g, device, mountpoint);
8825     if (r == -1)
8826       return -1;
8827   }
8828   /* TestOutput for command (2) */
8829   char expected[] = "\nResult3";
8830   {
8831     char remotefilename[] = "/test-command";
8832     int r;
8833     suppress_error = 0;
8834     r = guestfs_upload (g, "test-command", remotefilename);
8835     if (r == -1)
8836       return -1;
8837   }
8838   {
8839     char path[] = "/test-command";
8840     int r;
8841     suppress_error = 0;
8842     r = guestfs_chmod (g, 493, path);
8843     if (r == -1)
8844       return -1;
8845   }
8846   {
8847     char arguments_0[] = "/test-command";
8848     char arguments_1[] = "3";
8849     char *arguments[] = {
8850       arguments_0,
8851       arguments_1,
8852       NULL
8853     };
8854     char *r;
8855     suppress_error = 0;
8856     r = guestfs_command (g, arguments);
8857     if (r == NULL)
8858       return -1;
8859     if (strcmp (r, expected) != 0) {
8860       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8861       return -1;
8862     }
8863     free (r);
8864   }
8865   return 0;
8866 }
8867
8868 static int test_command_3_skip (void)
8869 {
8870   const char *str;
8871
8872   str = getenv ("SKIP_TEST_COMMAND_3");
8873   if (str && strcmp (str, "1") == 0) return 1;
8874   str = getenv ("SKIP_TEST_COMMAND");
8875   if (str && strcmp (str, "1") == 0) return 1;
8876   return 0;
8877 }
8878
8879 static int test_command_3 (void)
8880 {
8881   if (test_command_3_skip ()) {
8882     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8883     return 0;
8884   }
8885
8886   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8887   {
8888     char device[] = "/dev/sda";
8889     device[5] = devchar;
8890     int r;
8891     suppress_error = 0;
8892     r = guestfs_blockdev_setrw (g, device);
8893     if (r == -1)
8894       return -1;
8895   }
8896   {
8897     int r;
8898     suppress_error = 0;
8899     r = guestfs_umount_all (g);
8900     if (r == -1)
8901       return -1;
8902   }
8903   {
8904     int r;
8905     suppress_error = 0;
8906     r = guestfs_lvm_remove_all (g);
8907     if (r == -1)
8908       return -1;
8909   }
8910   {
8911     char device[] = "/dev/sda";
8912     device[5] = devchar;
8913     char lines_0[] = ",";
8914     char *lines[] = {
8915       lines_0,
8916       NULL
8917     };
8918     int r;
8919     suppress_error = 0;
8920     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8921     if (r == -1)
8922       return -1;
8923   }
8924   {
8925     char fstype[] = "ext2";
8926     char device[] = "/dev/sda1";
8927     device[5] = devchar;
8928     int r;
8929     suppress_error = 0;
8930     r = guestfs_mkfs (g, fstype, device);
8931     if (r == -1)
8932       return -1;
8933   }
8934   {
8935     char device[] = "/dev/sda1";
8936     device[5] = devchar;
8937     char mountpoint[] = "/";
8938     int r;
8939     suppress_error = 0;
8940     r = guestfs_mount (g, device, mountpoint);
8941     if (r == -1)
8942       return -1;
8943   }
8944   /* TestOutput for command (3) */
8945   char expected[] = "\nResult4\n";
8946   {
8947     char remotefilename[] = "/test-command";
8948     int r;
8949     suppress_error = 0;
8950     r = guestfs_upload (g, "test-command", remotefilename);
8951     if (r == -1)
8952       return -1;
8953   }
8954   {
8955     char path[] = "/test-command";
8956     int r;
8957     suppress_error = 0;
8958     r = guestfs_chmod (g, 493, path);
8959     if (r == -1)
8960       return -1;
8961   }
8962   {
8963     char arguments_0[] = "/test-command";
8964     char arguments_1[] = "4";
8965     char *arguments[] = {
8966       arguments_0,
8967       arguments_1,
8968       NULL
8969     };
8970     char *r;
8971     suppress_error = 0;
8972     r = guestfs_command (g, arguments);
8973     if (r == NULL)
8974       return -1;
8975     if (strcmp (r, expected) != 0) {
8976       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8977       return -1;
8978     }
8979     free (r);
8980   }
8981   return 0;
8982 }
8983
8984 static int test_command_4_skip (void)
8985 {
8986   const char *str;
8987
8988   str = getenv ("SKIP_TEST_COMMAND_4");
8989   if (str && strcmp (str, "1") == 0) return 1;
8990   str = getenv ("SKIP_TEST_COMMAND");
8991   if (str && strcmp (str, "1") == 0) return 1;
8992   return 0;
8993 }
8994
8995 static int test_command_4 (void)
8996 {
8997   if (test_command_4_skip ()) {
8998     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8999     return 0;
9000   }
9001
9002   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9003   {
9004     char device[] = "/dev/sda";
9005     device[5] = devchar;
9006     int r;
9007     suppress_error = 0;
9008     r = guestfs_blockdev_setrw (g, device);
9009     if (r == -1)
9010       return -1;
9011   }
9012   {
9013     int r;
9014     suppress_error = 0;
9015     r = guestfs_umount_all (g);
9016     if (r == -1)
9017       return -1;
9018   }
9019   {
9020     int r;
9021     suppress_error = 0;
9022     r = guestfs_lvm_remove_all (g);
9023     if (r == -1)
9024       return -1;
9025   }
9026   {
9027     char device[] = "/dev/sda";
9028     device[5] = devchar;
9029     char lines_0[] = ",";
9030     char *lines[] = {
9031       lines_0,
9032       NULL
9033     };
9034     int r;
9035     suppress_error = 0;
9036     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9037     if (r == -1)
9038       return -1;
9039   }
9040   {
9041     char fstype[] = "ext2";
9042     char device[] = "/dev/sda1";
9043     device[5] = devchar;
9044     int r;
9045     suppress_error = 0;
9046     r = guestfs_mkfs (g, fstype, device);
9047     if (r == -1)
9048       return -1;
9049   }
9050   {
9051     char device[] = "/dev/sda1";
9052     device[5] = devchar;
9053     char mountpoint[] = "/";
9054     int r;
9055     suppress_error = 0;
9056     r = guestfs_mount (g, device, mountpoint);
9057     if (r == -1)
9058       return -1;
9059   }
9060   /* TestOutput for command (4) */
9061   char expected[] = "\nResult5\n\n";
9062   {
9063     char remotefilename[] = "/test-command";
9064     int r;
9065     suppress_error = 0;
9066     r = guestfs_upload (g, "test-command", remotefilename);
9067     if (r == -1)
9068       return -1;
9069   }
9070   {
9071     char path[] = "/test-command";
9072     int r;
9073     suppress_error = 0;
9074     r = guestfs_chmod (g, 493, path);
9075     if (r == -1)
9076       return -1;
9077   }
9078   {
9079     char arguments_0[] = "/test-command";
9080     char arguments_1[] = "5";
9081     char *arguments[] = {
9082       arguments_0,
9083       arguments_1,
9084       NULL
9085     };
9086     char *r;
9087     suppress_error = 0;
9088     r = guestfs_command (g, arguments);
9089     if (r == NULL)
9090       return -1;
9091     if (strcmp (r, expected) != 0) {
9092       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9093       return -1;
9094     }
9095     free (r);
9096   }
9097   return 0;
9098 }
9099
9100 static int test_command_5_skip (void)
9101 {
9102   const char *str;
9103
9104   str = getenv ("SKIP_TEST_COMMAND_5");
9105   if (str && strcmp (str, "1") == 0) return 1;
9106   str = getenv ("SKIP_TEST_COMMAND");
9107   if (str && strcmp (str, "1") == 0) return 1;
9108   return 0;
9109 }
9110
9111 static int test_command_5 (void)
9112 {
9113   if (test_command_5_skip ()) {
9114     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9115     return 0;
9116   }
9117
9118   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9119   {
9120     char device[] = "/dev/sda";
9121     device[5] = devchar;
9122     int r;
9123     suppress_error = 0;
9124     r = guestfs_blockdev_setrw (g, device);
9125     if (r == -1)
9126       return -1;
9127   }
9128   {
9129     int r;
9130     suppress_error = 0;
9131     r = guestfs_umount_all (g);
9132     if (r == -1)
9133       return -1;
9134   }
9135   {
9136     int r;
9137     suppress_error = 0;
9138     r = guestfs_lvm_remove_all (g);
9139     if (r == -1)
9140       return -1;
9141   }
9142   {
9143     char device[] = "/dev/sda";
9144     device[5] = devchar;
9145     char lines_0[] = ",";
9146     char *lines[] = {
9147       lines_0,
9148       NULL
9149     };
9150     int r;
9151     suppress_error = 0;
9152     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9153     if (r == -1)
9154       return -1;
9155   }
9156   {
9157     char fstype[] = "ext2";
9158     char device[] = "/dev/sda1";
9159     device[5] = devchar;
9160     int r;
9161     suppress_error = 0;
9162     r = guestfs_mkfs (g, fstype, device);
9163     if (r == -1)
9164       return -1;
9165   }
9166   {
9167     char device[] = "/dev/sda1";
9168     device[5] = devchar;
9169     char mountpoint[] = "/";
9170     int r;
9171     suppress_error = 0;
9172     r = guestfs_mount (g, device, mountpoint);
9173     if (r == -1)
9174       return -1;
9175   }
9176   /* TestOutput for command (5) */
9177   char expected[] = "\n\nResult6\n\n";
9178   {
9179     char remotefilename[] = "/test-command";
9180     int r;
9181     suppress_error = 0;
9182     r = guestfs_upload (g, "test-command", remotefilename);
9183     if (r == -1)
9184       return -1;
9185   }
9186   {
9187     char path[] = "/test-command";
9188     int r;
9189     suppress_error = 0;
9190     r = guestfs_chmod (g, 493, path);
9191     if (r == -1)
9192       return -1;
9193   }
9194   {
9195     char arguments_0[] = "/test-command";
9196     char arguments_1[] = "6";
9197     char *arguments[] = {
9198       arguments_0,
9199       arguments_1,
9200       NULL
9201     };
9202     char *r;
9203     suppress_error = 0;
9204     r = guestfs_command (g, arguments);
9205     if (r == NULL)
9206       return -1;
9207     if (strcmp (r, expected) != 0) {
9208       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9209       return -1;
9210     }
9211     free (r);
9212   }
9213   return 0;
9214 }
9215
9216 static int test_command_6_skip (void)
9217 {
9218   const char *str;
9219
9220   str = getenv ("SKIP_TEST_COMMAND_6");
9221   if (str && strcmp (str, "1") == 0) return 1;
9222   str = getenv ("SKIP_TEST_COMMAND");
9223   if (str && strcmp (str, "1") == 0) return 1;
9224   return 0;
9225 }
9226
9227 static int test_command_6 (void)
9228 {
9229   if (test_command_6_skip ()) {
9230     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9231     return 0;
9232   }
9233
9234   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9235   {
9236     char device[] = "/dev/sda";
9237     device[5] = devchar;
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     device[5] = devchar;
9261     char lines_0[] = ",";
9262     char *lines[] = {
9263       lines_0,
9264       NULL
9265     };
9266     int r;
9267     suppress_error = 0;
9268     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9269     if (r == -1)
9270       return -1;
9271   }
9272   {
9273     char fstype[] = "ext2";
9274     char device[] = "/dev/sda1";
9275     device[5] = devchar;
9276     int r;
9277     suppress_error = 0;
9278     r = guestfs_mkfs (g, fstype, device);
9279     if (r == -1)
9280       return -1;
9281   }
9282   {
9283     char device[] = "/dev/sda1";
9284     device[5] = devchar;
9285     char mountpoint[] = "/";
9286     int r;
9287     suppress_error = 0;
9288     r = guestfs_mount (g, device, mountpoint);
9289     if (r == -1)
9290       return -1;
9291   }
9292   /* TestOutput for command (6) */
9293   char expected[] = "";
9294   {
9295     char remotefilename[] = "/test-command";
9296     int r;
9297     suppress_error = 0;
9298     r = guestfs_upload (g, "test-command", remotefilename);
9299     if (r == -1)
9300       return -1;
9301   }
9302   {
9303     char path[] = "/test-command";
9304     int r;
9305     suppress_error = 0;
9306     r = guestfs_chmod (g, 493, path);
9307     if (r == -1)
9308       return -1;
9309   }
9310   {
9311     char arguments_0[] = "/test-command";
9312     char arguments_1[] = "7";
9313     char *arguments[] = {
9314       arguments_0,
9315       arguments_1,
9316       NULL
9317     };
9318     char *r;
9319     suppress_error = 0;
9320     r = guestfs_command (g, arguments);
9321     if (r == NULL)
9322       return -1;
9323     if (strcmp (r, expected) != 0) {
9324       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9325       return -1;
9326     }
9327     free (r);
9328   }
9329   return 0;
9330 }
9331
9332 static int test_command_7_skip (void)
9333 {
9334   const char *str;
9335
9336   str = getenv ("SKIP_TEST_COMMAND_7");
9337   if (str && strcmp (str, "1") == 0) return 1;
9338   str = getenv ("SKIP_TEST_COMMAND");
9339   if (str && strcmp (str, "1") == 0) return 1;
9340   return 0;
9341 }
9342
9343 static int test_command_7 (void)
9344 {
9345   if (test_command_7_skip ()) {
9346     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9347     return 0;
9348   }
9349
9350   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9351   {
9352     char device[] = "/dev/sda";
9353     device[5] = devchar;
9354     int r;
9355     suppress_error = 0;
9356     r = guestfs_blockdev_setrw (g, device);
9357     if (r == -1)
9358       return -1;
9359   }
9360   {
9361     int r;
9362     suppress_error = 0;
9363     r = guestfs_umount_all (g);
9364     if (r == -1)
9365       return -1;
9366   }
9367   {
9368     int r;
9369     suppress_error = 0;
9370     r = guestfs_lvm_remove_all (g);
9371     if (r == -1)
9372       return -1;
9373   }
9374   {
9375     char device[] = "/dev/sda";
9376     device[5] = devchar;
9377     char lines_0[] = ",";
9378     char *lines[] = {
9379       lines_0,
9380       NULL
9381     };
9382     int r;
9383     suppress_error = 0;
9384     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9385     if (r == -1)
9386       return -1;
9387   }
9388   {
9389     char fstype[] = "ext2";
9390     char device[] = "/dev/sda1";
9391     device[5] = devchar;
9392     int r;
9393     suppress_error = 0;
9394     r = guestfs_mkfs (g, fstype, device);
9395     if (r == -1)
9396       return -1;
9397   }
9398   {
9399     char device[] = "/dev/sda1";
9400     device[5] = devchar;
9401     char mountpoint[] = "/";
9402     int r;
9403     suppress_error = 0;
9404     r = guestfs_mount (g, device, mountpoint);
9405     if (r == -1)
9406       return -1;
9407   }
9408   /* TestOutput for command (7) */
9409   char expected[] = "\n";
9410   {
9411     char remotefilename[] = "/test-command";
9412     int r;
9413     suppress_error = 0;
9414     r = guestfs_upload (g, "test-command", remotefilename);
9415     if (r == -1)
9416       return -1;
9417   }
9418   {
9419     char path[] = "/test-command";
9420     int r;
9421     suppress_error = 0;
9422     r = guestfs_chmod (g, 493, path);
9423     if (r == -1)
9424       return -1;
9425   }
9426   {
9427     char arguments_0[] = "/test-command";
9428     char arguments_1[] = "8";
9429     char *arguments[] = {
9430       arguments_0,
9431       arguments_1,
9432       NULL
9433     };
9434     char *r;
9435     suppress_error = 0;
9436     r = guestfs_command (g, arguments);
9437     if (r == NULL)
9438       return -1;
9439     if (strcmp (r, expected) != 0) {
9440       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9441       return -1;
9442     }
9443     free (r);
9444   }
9445   return 0;
9446 }
9447
9448 static int test_command_8_skip (void)
9449 {
9450   const char *str;
9451
9452   str = getenv ("SKIP_TEST_COMMAND_8");
9453   if (str && strcmp (str, "1") == 0) return 1;
9454   str = getenv ("SKIP_TEST_COMMAND");
9455   if (str && strcmp (str, "1") == 0) return 1;
9456   return 0;
9457 }
9458
9459 static int test_command_8 (void)
9460 {
9461   if (test_command_8_skip ()) {
9462     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9463     return 0;
9464   }
9465
9466   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9467   {
9468     char device[] = "/dev/sda";
9469     device[5] = devchar;
9470     int r;
9471     suppress_error = 0;
9472     r = guestfs_blockdev_setrw (g, device);
9473     if (r == -1)
9474       return -1;
9475   }
9476   {
9477     int r;
9478     suppress_error = 0;
9479     r = guestfs_umount_all (g);
9480     if (r == -1)
9481       return -1;
9482   }
9483   {
9484     int r;
9485     suppress_error = 0;
9486     r = guestfs_lvm_remove_all (g);
9487     if (r == -1)
9488       return -1;
9489   }
9490   {
9491     char device[] = "/dev/sda";
9492     device[5] = devchar;
9493     char lines_0[] = ",";
9494     char *lines[] = {
9495       lines_0,
9496       NULL
9497     };
9498     int r;
9499     suppress_error = 0;
9500     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9501     if (r == -1)
9502       return -1;
9503   }
9504   {
9505     char fstype[] = "ext2";
9506     char device[] = "/dev/sda1";
9507     device[5] = devchar;
9508     int r;
9509     suppress_error = 0;
9510     r = guestfs_mkfs (g, fstype, device);
9511     if (r == -1)
9512       return -1;
9513   }
9514   {
9515     char device[] = "/dev/sda1";
9516     device[5] = devchar;
9517     char mountpoint[] = "/";
9518     int r;
9519     suppress_error = 0;
9520     r = guestfs_mount (g, device, mountpoint);
9521     if (r == -1)
9522       return -1;
9523   }
9524   /* TestOutput for command (8) */
9525   char expected[] = "\n\n";
9526   {
9527     char remotefilename[] = "/test-command";
9528     int r;
9529     suppress_error = 0;
9530     r = guestfs_upload (g, "test-command", remotefilename);
9531     if (r == -1)
9532       return -1;
9533   }
9534   {
9535     char path[] = "/test-command";
9536     int r;
9537     suppress_error = 0;
9538     r = guestfs_chmod (g, 493, path);
9539     if (r == -1)
9540       return -1;
9541   }
9542   {
9543     char arguments_0[] = "/test-command";
9544     char arguments_1[] = "9";
9545     char *arguments[] = {
9546       arguments_0,
9547       arguments_1,
9548       NULL
9549     };
9550     char *r;
9551     suppress_error = 0;
9552     r = guestfs_command (g, arguments);
9553     if (r == NULL)
9554       return -1;
9555     if (strcmp (r, expected) != 0) {
9556       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9557       return -1;
9558     }
9559     free (r);
9560   }
9561   return 0;
9562 }
9563
9564 static int test_command_9_skip (void)
9565 {
9566   const char *str;
9567
9568   str = getenv ("SKIP_TEST_COMMAND_9");
9569   if (str && strcmp (str, "1") == 0) return 1;
9570   str = getenv ("SKIP_TEST_COMMAND");
9571   if (str && strcmp (str, "1") == 0) return 1;
9572   return 0;
9573 }
9574
9575 static int test_command_9 (void)
9576 {
9577   if (test_command_9_skip ()) {
9578     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9579     return 0;
9580   }
9581
9582   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9583   {
9584     char device[] = "/dev/sda";
9585     device[5] = devchar;
9586     int r;
9587     suppress_error = 0;
9588     r = guestfs_blockdev_setrw (g, device);
9589     if (r == -1)
9590       return -1;
9591   }
9592   {
9593     int r;
9594     suppress_error = 0;
9595     r = guestfs_umount_all (g);
9596     if (r == -1)
9597       return -1;
9598   }
9599   {
9600     int r;
9601     suppress_error = 0;
9602     r = guestfs_lvm_remove_all (g);
9603     if (r == -1)
9604       return -1;
9605   }
9606   {
9607     char device[] = "/dev/sda";
9608     device[5] = devchar;
9609     char lines_0[] = ",";
9610     char *lines[] = {
9611       lines_0,
9612       NULL
9613     };
9614     int r;
9615     suppress_error = 0;
9616     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9617     if (r == -1)
9618       return -1;
9619   }
9620   {
9621     char fstype[] = "ext2";
9622     char device[] = "/dev/sda1";
9623     device[5] = devchar;
9624     int r;
9625     suppress_error = 0;
9626     r = guestfs_mkfs (g, fstype, device);
9627     if (r == -1)
9628       return -1;
9629   }
9630   {
9631     char device[] = "/dev/sda1";
9632     device[5] = devchar;
9633     char mountpoint[] = "/";
9634     int r;
9635     suppress_error = 0;
9636     r = guestfs_mount (g, device, mountpoint);
9637     if (r == -1)
9638       return -1;
9639   }
9640   /* TestOutput for command (9) */
9641   char expected[] = "Result10-1\nResult10-2\n";
9642   {
9643     char remotefilename[] = "/test-command";
9644     int r;
9645     suppress_error = 0;
9646     r = guestfs_upload (g, "test-command", remotefilename);
9647     if (r == -1)
9648       return -1;
9649   }
9650   {
9651     char path[] = "/test-command";
9652     int r;
9653     suppress_error = 0;
9654     r = guestfs_chmod (g, 493, path);
9655     if (r == -1)
9656       return -1;
9657   }
9658   {
9659     char arguments_0[] = "/test-command";
9660     char arguments_1[] = "10";
9661     char *arguments[] = {
9662       arguments_0,
9663       arguments_1,
9664       NULL
9665     };
9666     char *r;
9667     suppress_error = 0;
9668     r = guestfs_command (g, arguments);
9669     if (r == NULL)
9670       return -1;
9671     if (strcmp (r, expected) != 0) {
9672       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9673       return -1;
9674     }
9675     free (r);
9676   }
9677   return 0;
9678 }
9679
9680 static int test_command_10_skip (void)
9681 {
9682   const char *str;
9683
9684   str = getenv ("SKIP_TEST_COMMAND_10");
9685   if (str && strcmp (str, "1") == 0) return 1;
9686   str = getenv ("SKIP_TEST_COMMAND");
9687   if (str && strcmp (str, "1") == 0) return 1;
9688   return 0;
9689 }
9690
9691 static int test_command_10 (void)
9692 {
9693   if (test_command_10_skip ()) {
9694     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9695     return 0;
9696   }
9697
9698   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9699   {
9700     char device[] = "/dev/sda";
9701     device[5] = devchar;
9702     int r;
9703     suppress_error = 0;
9704     r = guestfs_blockdev_setrw (g, device);
9705     if (r == -1)
9706       return -1;
9707   }
9708   {
9709     int r;
9710     suppress_error = 0;
9711     r = guestfs_umount_all (g);
9712     if (r == -1)
9713       return -1;
9714   }
9715   {
9716     int r;
9717     suppress_error = 0;
9718     r = guestfs_lvm_remove_all (g);
9719     if (r == -1)
9720       return -1;
9721   }
9722   {
9723     char device[] = "/dev/sda";
9724     device[5] = devchar;
9725     char lines_0[] = ",";
9726     char *lines[] = {
9727       lines_0,
9728       NULL
9729     };
9730     int r;
9731     suppress_error = 0;
9732     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9733     if (r == -1)
9734       return -1;
9735   }
9736   {
9737     char fstype[] = "ext2";
9738     char device[] = "/dev/sda1";
9739     device[5] = devchar;
9740     int r;
9741     suppress_error = 0;
9742     r = guestfs_mkfs (g, fstype, device);
9743     if (r == -1)
9744       return -1;
9745   }
9746   {
9747     char device[] = "/dev/sda1";
9748     device[5] = devchar;
9749     char mountpoint[] = "/";
9750     int r;
9751     suppress_error = 0;
9752     r = guestfs_mount (g, device, mountpoint);
9753     if (r == -1)
9754       return -1;
9755   }
9756   /* TestOutput for command (10) */
9757   char expected[] = "Result11-1\nResult11-2";
9758   {
9759     char remotefilename[] = "/test-command";
9760     int r;
9761     suppress_error = 0;
9762     r = guestfs_upload (g, "test-command", remotefilename);
9763     if (r == -1)
9764       return -1;
9765   }
9766   {
9767     char path[] = "/test-command";
9768     int r;
9769     suppress_error = 0;
9770     r = guestfs_chmod (g, 493, path);
9771     if (r == -1)
9772       return -1;
9773   }
9774   {
9775     char arguments_0[] = "/test-command";
9776     char arguments_1[] = "11";
9777     char *arguments[] = {
9778       arguments_0,
9779       arguments_1,
9780       NULL
9781     };
9782     char *r;
9783     suppress_error = 0;
9784     r = guestfs_command (g, arguments);
9785     if (r == NULL)
9786       return -1;
9787     if (strcmp (r, expected) != 0) {
9788       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9789       return -1;
9790     }
9791     free (r);
9792   }
9793   return 0;
9794 }
9795
9796 static int test_command_11_skip (void)
9797 {
9798   const char *str;
9799
9800   str = getenv ("SKIP_TEST_COMMAND_11");
9801   if (str && strcmp (str, "1") == 0) return 1;
9802   str = getenv ("SKIP_TEST_COMMAND");
9803   if (str && strcmp (str, "1") == 0) return 1;
9804   return 0;
9805 }
9806
9807 static int test_command_11 (void)
9808 {
9809   if (test_command_11_skip ()) {
9810     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9811     return 0;
9812   }
9813
9814   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9815   {
9816     char device[] = "/dev/sda";
9817     device[5] = devchar;
9818     int r;
9819     suppress_error = 0;
9820     r = guestfs_blockdev_setrw (g, device);
9821     if (r == -1)
9822       return -1;
9823   }
9824   {
9825     int r;
9826     suppress_error = 0;
9827     r = guestfs_umount_all (g);
9828     if (r == -1)
9829       return -1;
9830   }
9831   {
9832     int r;
9833     suppress_error = 0;
9834     r = guestfs_lvm_remove_all (g);
9835     if (r == -1)
9836       return -1;
9837   }
9838   {
9839     char device[] = "/dev/sda";
9840     device[5] = devchar;
9841     char lines_0[] = ",";
9842     char *lines[] = {
9843       lines_0,
9844       NULL
9845     };
9846     int r;
9847     suppress_error = 0;
9848     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9849     if (r == -1)
9850       return -1;
9851   }
9852   {
9853     char fstype[] = "ext2";
9854     char device[] = "/dev/sda1";
9855     device[5] = devchar;
9856     int r;
9857     suppress_error = 0;
9858     r = guestfs_mkfs (g, fstype, device);
9859     if (r == -1)
9860       return -1;
9861   }
9862   {
9863     char device[] = "/dev/sda1";
9864     device[5] = devchar;
9865     char mountpoint[] = "/";
9866     int r;
9867     suppress_error = 0;
9868     r = guestfs_mount (g, device, mountpoint);
9869     if (r == -1)
9870       return -1;
9871   }
9872   /* TestLastFail for command (11) */
9873   {
9874     char remotefilename[] = "/test-command";
9875     int r;
9876     suppress_error = 0;
9877     r = guestfs_upload (g, "test-command", remotefilename);
9878     if (r == -1)
9879       return -1;
9880   }
9881   {
9882     char path[] = "/test-command";
9883     int r;
9884     suppress_error = 0;
9885     r = guestfs_chmod (g, 493, path);
9886     if (r == -1)
9887       return -1;
9888   }
9889   {
9890     char arguments_0[] = "/test-command";
9891     char *arguments[] = {
9892       arguments_0,
9893       NULL
9894     };
9895     char *r;
9896     suppress_error = 1;
9897     r = guestfs_command (g, arguments);
9898     if (r != NULL)
9899       return -1;
9900     free (r);
9901   }
9902   return 0;
9903 }
9904
9905 static int test_file_0_skip (void)
9906 {
9907   const char *str;
9908
9909   str = getenv ("SKIP_TEST_FILE_0");
9910   if (str && strcmp (str, "1") == 0) return 1;
9911   str = getenv ("SKIP_TEST_FILE");
9912   if (str && strcmp (str, "1") == 0) return 1;
9913   return 0;
9914 }
9915
9916 static int test_file_0 (void)
9917 {
9918   if (test_file_0_skip ()) {
9919     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9920     return 0;
9921   }
9922
9923   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9924   {
9925     char device[] = "/dev/sda";
9926     device[5] = devchar;
9927     int r;
9928     suppress_error = 0;
9929     r = guestfs_blockdev_setrw (g, device);
9930     if (r == -1)
9931       return -1;
9932   }
9933   {
9934     int r;
9935     suppress_error = 0;
9936     r = guestfs_umount_all (g);
9937     if (r == -1)
9938       return -1;
9939   }
9940   {
9941     int r;
9942     suppress_error = 0;
9943     r = guestfs_lvm_remove_all (g);
9944     if (r == -1)
9945       return -1;
9946   }
9947   {
9948     char device[] = "/dev/sda";
9949     device[5] = devchar;
9950     char lines_0[] = ",";
9951     char *lines[] = {
9952       lines_0,
9953       NULL
9954     };
9955     int r;
9956     suppress_error = 0;
9957     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9958     if (r == -1)
9959       return -1;
9960   }
9961   {
9962     char fstype[] = "ext2";
9963     char device[] = "/dev/sda1";
9964     device[5] = devchar;
9965     int r;
9966     suppress_error = 0;
9967     r = guestfs_mkfs (g, fstype, device);
9968     if (r == -1)
9969       return -1;
9970   }
9971   {
9972     char device[] = "/dev/sda1";
9973     device[5] = devchar;
9974     char mountpoint[] = "/";
9975     int r;
9976     suppress_error = 0;
9977     r = guestfs_mount (g, device, mountpoint);
9978     if (r == -1)
9979       return -1;
9980   }
9981   /* TestOutput for file (0) */
9982   char expected[] = "empty";
9983   {
9984     char path[] = "/new";
9985     int r;
9986     suppress_error = 0;
9987     r = guestfs_touch (g, path);
9988     if (r == -1)
9989       return -1;
9990   }
9991   {
9992     char path[] = "/new";
9993     char *r;
9994     suppress_error = 0;
9995     r = guestfs_file (g, path);
9996     if (r == NULL)
9997       return -1;
9998     if (strcmp (r, expected) != 0) {
9999       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10000       return -1;
10001     }
10002     free (r);
10003   }
10004   return 0;
10005 }
10006
10007 static int test_file_1_skip (void)
10008 {
10009   const char *str;
10010
10011   str = getenv ("SKIP_TEST_FILE_1");
10012   if (str && strcmp (str, "1") == 0) return 1;
10013   str = getenv ("SKIP_TEST_FILE");
10014   if (str && strcmp (str, "1") == 0) return 1;
10015   return 0;
10016 }
10017
10018 static int test_file_1 (void)
10019 {
10020   if (test_file_1_skip ()) {
10021     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10022     return 0;
10023   }
10024
10025   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10026   {
10027     char device[] = "/dev/sda";
10028     device[5] = devchar;
10029     int r;
10030     suppress_error = 0;
10031     r = guestfs_blockdev_setrw (g, device);
10032     if (r == -1)
10033       return -1;
10034   }
10035   {
10036     int r;
10037     suppress_error = 0;
10038     r = guestfs_umount_all (g);
10039     if (r == -1)
10040       return -1;
10041   }
10042   {
10043     int r;
10044     suppress_error = 0;
10045     r = guestfs_lvm_remove_all (g);
10046     if (r == -1)
10047       return -1;
10048   }
10049   {
10050     char device[] = "/dev/sda";
10051     device[5] = devchar;
10052     char lines_0[] = ",";
10053     char *lines[] = {
10054       lines_0,
10055       NULL
10056     };
10057     int r;
10058     suppress_error = 0;
10059     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10060     if (r == -1)
10061       return -1;
10062   }
10063   {
10064     char fstype[] = "ext2";
10065     char device[] = "/dev/sda1";
10066     device[5] = devchar;
10067     int r;
10068     suppress_error = 0;
10069     r = guestfs_mkfs (g, fstype, device);
10070     if (r == -1)
10071       return -1;
10072   }
10073   {
10074     char device[] = "/dev/sda1";
10075     device[5] = devchar;
10076     char mountpoint[] = "/";
10077     int r;
10078     suppress_error = 0;
10079     r = guestfs_mount (g, device, mountpoint);
10080     if (r == -1)
10081       return -1;
10082   }
10083   /* TestOutput for file (1) */
10084   char expected[] = "ASCII text";
10085   {
10086     char path[] = "/new";
10087     char content[] = "some content\n";
10088     int r;
10089     suppress_error = 0;
10090     r = guestfs_write_file (g, path, content, 0);
10091     if (r == -1)
10092       return -1;
10093   }
10094   {
10095     char path[] = "/new";
10096     char *r;
10097     suppress_error = 0;
10098     r = guestfs_file (g, path);
10099     if (r == NULL)
10100       return -1;
10101     if (strcmp (r, expected) != 0) {
10102       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10103       return -1;
10104     }
10105     free (r);
10106   }
10107   return 0;
10108 }
10109
10110 static int test_file_2_skip (void)
10111 {
10112   const char *str;
10113
10114   str = getenv ("SKIP_TEST_FILE_2");
10115   if (str && strcmp (str, "1") == 0) return 1;
10116   str = getenv ("SKIP_TEST_FILE");
10117   if (str && strcmp (str, "1") == 0) return 1;
10118   return 0;
10119 }
10120
10121 static int test_file_2 (void)
10122 {
10123   if (test_file_2_skip ()) {
10124     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10125     return 0;
10126   }
10127
10128   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10129   {
10130     char device[] = "/dev/sda";
10131     device[5] = devchar;
10132     int r;
10133     suppress_error = 0;
10134     r = guestfs_blockdev_setrw (g, device);
10135     if (r == -1)
10136       return -1;
10137   }
10138   {
10139     int r;
10140     suppress_error = 0;
10141     r = guestfs_umount_all (g);
10142     if (r == -1)
10143       return -1;
10144   }
10145   {
10146     int r;
10147     suppress_error = 0;
10148     r = guestfs_lvm_remove_all (g);
10149     if (r == -1)
10150       return -1;
10151   }
10152   {
10153     char device[] = "/dev/sda";
10154     device[5] = devchar;
10155     char lines_0[] = ",";
10156     char *lines[] = {
10157       lines_0,
10158       NULL
10159     };
10160     int r;
10161     suppress_error = 0;
10162     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10163     if (r == -1)
10164       return -1;
10165   }
10166   {
10167     char fstype[] = "ext2";
10168     char device[] = "/dev/sda1";
10169     device[5] = devchar;
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     device[5] = devchar;
10179     char mountpoint[] = "/";
10180     int r;
10181     suppress_error = 0;
10182     r = guestfs_mount (g, device, mountpoint);
10183     if (r == -1)
10184       return -1;
10185   }
10186   /* TestLastFail for file (2) */
10187   {
10188     char path[] = "/nofile";
10189     char *r;
10190     suppress_error = 1;
10191     r = guestfs_file (g, path);
10192     if (r != NULL)
10193       return -1;
10194     free (r);
10195   }
10196   return 0;
10197 }
10198
10199 static int test_umount_all_0_skip (void)
10200 {
10201   const char *str;
10202
10203   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10204   if (str && strcmp (str, "1") == 0) return 1;
10205   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10206   if (str && strcmp (str, "1") == 0) return 1;
10207   return 0;
10208 }
10209
10210 static int test_umount_all_0 (void)
10211 {
10212   if (test_umount_all_0_skip ()) {
10213     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10214     return 0;
10215   }
10216
10217   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10218   {
10219     char device[] = "/dev/sda";
10220     device[5] = devchar;
10221     int r;
10222     suppress_error = 0;
10223     r = guestfs_blockdev_setrw (g, device);
10224     if (r == -1)
10225       return -1;
10226   }
10227   {
10228     int r;
10229     suppress_error = 0;
10230     r = guestfs_umount_all (g);
10231     if (r == -1)
10232       return -1;
10233   }
10234   {
10235     int r;
10236     suppress_error = 0;
10237     r = guestfs_lvm_remove_all (g);
10238     if (r == -1)
10239       return -1;
10240   }
10241   {
10242     char device[] = "/dev/sda";
10243     device[5] = devchar;
10244     char lines_0[] = ",";
10245     char *lines[] = {
10246       lines_0,
10247       NULL
10248     };
10249     int r;
10250     suppress_error = 0;
10251     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10252     if (r == -1)
10253       return -1;
10254   }
10255   {
10256     char fstype[] = "ext2";
10257     char device[] = "/dev/sda1";
10258     device[5] = devchar;
10259     int r;
10260     suppress_error = 0;
10261     r = guestfs_mkfs (g, fstype, device);
10262     if (r == -1)
10263       return -1;
10264   }
10265   {
10266     char device[] = "/dev/sda1";
10267     device[5] = devchar;
10268     char mountpoint[] = "/";
10269     int r;
10270     suppress_error = 0;
10271     r = guestfs_mount (g, device, mountpoint);
10272     if (r == -1)
10273       return -1;
10274   }
10275   /* TestOutputList for umount_all (0) */
10276   {
10277     int r;
10278     suppress_error = 0;
10279     r = guestfs_umount_all (g);
10280     if (r == -1)
10281       return -1;
10282   }
10283   {
10284     char **r;
10285     int i;
10286     suppress_error = 0;
10287     r = guestfs_mounts (g);
10288     if (r == NULL)
10289       return -1;
10290     if (r[0] != NULL) {
10291       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10292       print_strings (r);
10293       return -1;
10294     }
10295     for (i = 0; r[i] != NULL; ++i)
10296       free (r[i]);
10297     free (r);
10298   }
10299   return 0;
10300 }
10301
10302 static int test_umount_all_1_skip (void)
10303 {
10304   const char *str;
10305
10306   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10307   if (str && strcmp (str, "1") == 0) return 1;
10308   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10309   if (str && strcmp (str, "1") == 0) return 1;
10310   return 0;
10311 }
10312
10313 static int test_umount_all_1 (void)
10314 {
10315   if (test_umount_all_1_skip ()) {
10316     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10317     return 0;
10318   }
10319
10320   /* InitNone|InitEmpty for test_umount_all_1 */
10321   {
10322     char device[] = "/dev/sda";
10323     device[5] = devchar;
10324     int r;
10325     suppress_error = 0;
10326     r = guestfs_blockdev_setrw (g, device);
10327     if (r == -1)
10328       return -1;
10329   }
10330   {
10331     int r;
10332     suppress_error = 0;
10333     r = guestfs_umount_all (g);
10334     if (r == -1)
10335       return -1;
10336   }
10337   {
10338     int r;
10339     suppress_error = 0;
10340     r = guestfs_lvm_remove_all (g);
10341     if (r == -1)
10342       return -1;
10343   }
10344   /* TestOutputList for umount_all (1) */
10345   {
10346     char device[] = "/dev/sda";
10347     device[5] = devchar;
10348     char lines_0[] = ",10";
10349     char lines_1[] = ",20";
10350     char lines_2[] = ",";
10351     char *lines[] = {
10352       lines_0,
10353       lines_1,
10354       lines_2,
10355       NULL
10356     };
10357     int r;
10358     suppress_error = 0;
10359     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10360     if (r == -1)
10361       return -1;
10362   }
10363   {
10364     char fstype[] = "ext2";
10365     char device[] = "/dev/sda1";
10366     device[5] = devchar;
10367     int r;
10368     suppress_error = 0;
10369     r = guestfs_mkfs (g, fstype, device);
10370     if (r == -1)
10371       return -1;
10372   }
10373   {
10374     char fstype[] = "ext2";
10375     char device[] = "/dev/sda2";
10376     device[5] = devchar;
10377     int r;
10378     suppress_error = 0;
10379     r = guestfs_mkfs (g, fstype, device);
10380     if (r == -1)
10381       return -1;
10382   }
10383   {
10384     char fstype[] = "ext2";
10385     char device[] = "/dev/sda3";
10386     device[5] = devchar;
10387     int r;
10388     suppress_error = 0;
10389     r = guestfs_mkfs (g, fstype, device);
10390     if (r == -1)
10391       return -1;
10392   }
10393   {
10394     char device[] = "/dev/sda1";
10395     device[5] = devchar;
10396     char mountpoint[] = "/";
10397     int r;
10398     suppress_error = 0;
10399     r = guestfs_mount (g, device, mountpoint);
10400     if (r == -1)
10401       return -1;
10402   }
10403   {
10404     char path[] = "/mp1";
10405     int r;
10406     suppress_error = 0;
10407     r = guestfs_mkdir (g, path);
10408     if (r == -1)
10409       return -1;
10410   }
10411   {
10412     char device[] = "/dev/sda2";
10413     device[5] = devchar;
10414     char mountpoint[] = "/mp1";
10415     int r;
10416     suppress_error = 0;
10417     r = guestfs_mount (g, device, mountpoint);
10418     if (r == -1)
10419       return -1;
10420   }
10421   {
10422     char path[] = "/mp1/mp2";
10423     int r;
10424     suppress_error = 0;
10425     r = guestfs_mkdir (g, path);
10426     if (r == -1)
10427       return -1;
10428   }
10429   {
10430     char device[] = "/dev/sda3";
10431     device[5] = devchar;
10432     char mountpoint[] = "/mp1/mp2";
10433     int r;
10434     suppress_error = 0;
10435     r = guestfs_mount (g, device, mountpoint);
10436     if (r == -1)
10437       return -1;
10438   }
10439   {
10440     char path[] = "/mp1/mp2/mp3";
10441     int r;
10442     suppress_error = 0;
10443     r = guestfs_mkdir (g, path);
10444     if (r == -1)
10445       return -1;
10446   }
10447   {
10448     int r;
10449     suppress_error = 0;
10450     r = guestfs_umount_all (g);
10451     if (r == -1)
10452       return -1;
10453   }
10454   {
10455     char **r;
10456     int i;
10457     suppress_error = 0;
10458     r = guestfs_mounts (g);
10459     if (r == NULL)
10460       return -1;
10461     if (r[0] != NULL) {
10462       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10463       print_strings (r);
10464       return -1;
10465     }
10466     for (i = 0; r[i] != NULL; ++i)
10467       free (r[i]);
10468     free (r);
10469   }
10470   return 0;
10471 }
10472
10473 static int test_mounts_0_skip (void)
10474 {
10475   const char *str;
10476
10477   str = getenv ("SKIP_TEST_MOUNTS_0");
10478   if (str && strcmp (str, "1") == 0) return 1;
10479   str = getenv ("SKIP_TEST_MOUNTS");
10480   if (str && strcmp (str, "1") == 0) return 1;
10481   return 0;
10482 }
10483
10484 static int test_mounts_0 (void)
10485 {
10486   if (test_mounts_0_skip ()) {
10487     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10488     return 0;
10489   }
10490
10491   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10492   {
10493     char device[] = "/dev/sda";
10494     device[5] = devchar;
10495     int r;
10496     suppress_error = 0;
10497     r = guestfs_blockdev_setrw (g, device);
10498     if (r == -1)
10499       return -1;
10500   }
10501   {
10502     int r;
10503     suppress_error = 0;
10504     r = guestfs_umount_all (g);
10505     if (r == -1)
10506       return -1;
10507   }
10508   {
10509     int r;
10510     suppress_error = 0;
10511     r = guestfs_lvm_remove_all (g);
10512     if (r == -1)
10513       return -1;
10514   }
10515   {
10516     char device[] = "/dev/sda";
10517     device[5] = devchar;
10518     char lines_0[] = ",";
10519     char *lines[] = {
10520       lines_0,
10521       NULL
10522     };
10523     int r;
10524     suppress_error = 0;
10525     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10526     if (r == -1)
10527       return -1;
10528   }
10529   {
10530     char fstype[] = "ext2";
10531     char device[] = "/dev/sda1";
10532     device[5] = devchar;
10533     int r;
10534     suppress_error = 0;
10535     r = guestfs_mkfs (g, fstype, device);
10536     if (r == -1)
10537       return -1;
10538   }
10539   {
10540     char device[] = "/dev/sda1";
10541     device[5] = devchar;
10542     char mountpoint[] = "/";
10543     int r;
10544     suppress_error = 0;
10545     r = guestfs_mount (g, device, mountpoint);
10546     if (r == -1)
10547       return -1;
10548   }
10549   /* TestOutputList for mounts (0) */
10550   {
10551     char **r;
10552     int i;
10553     suppress_error = 0;
10554     r = guestfs_mounts (g);
10555     if (r == NULL)
10556       return -1;
10557     if (!r[0]) {
10558       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10559       print_strings (r);
10560       return -1;
10561     }
10562     {
10563       char expected[] = "/dev/sda1";
10564       expected[5] = devchar;
10565       if (strcmp (r[0], expected) != 0) {
10566         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10567         return -1;
10568       }
10569     }
10570     if (r[1] != NULL) {
10571       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10572       print_strings (r);
10573       return -1;
10574     }
10575     for (i = 0; r[i] != NULL; ++i)
10576       free (r[i]);
10577     free (r);
10578   }
10579   return 0;
10580 }
10581
10582 static int test_umount_0_skip (void)
10583 {
10584   const char *str;
10585
10586   str = getenv ("SKIP_TEST_UMOUNT_0");
10587   if (str && strcmp (str, "1") == 0) return 1;
10588   str = getenv ("SKIP_TEST_UMOUNT");
10589   if (str && strcmp (str, "1") == 0) return 1;
10590   return 0;
10591 }
10592
10593 static int test_umount_0 (void)
10594 {
10595   if (test_umount_0_skip ()) {
10596     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10597     return 0;
10598   }
10599
10600   /* InitNone|InitEmpty for test_umount_0 */
10601   {
10602     char device[] = "/dev/sda";
10603     device[5] = devchar;
10604     int r;
10605     suppress_error = 0;
10606     r = guestfs_blockdev_setrw (g, device);
10607     if (r == -1)
10608       return -1;
10609   }
10610   {
10611     int r;
10612     suppress_error = 0;
10613     r = guestfs_umount_all (g);
10614     if (r == -1)
10615       return -1;
10616   }
10617   {
10618     int r;
10619     suppress_error = 0;
10620     r = guestfs_lvm_remove_all (g);
10621     if (r == -1)
10622       return -1;
10623   }
10624   /* TestOutputList for umount (0) */
10625   {
10626     char device[] = "/dev/sda";
10627     device[5] = devchar;
10628     char lines_0[] = ",";
10629     char *lines[] = {
10630       lines_0,
10631       NULL
10632     };
10633     int r;
10634     suppress_error = 0;
10635     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10636     if (r == -1)
10637       return -1;
10638   }
10639   {
10640     char fstype[] = "ext2";
10641     char device[] = "/dev/sda1";
10642     device[5] = devchar;
10643     int r;
10644     suppress_error = 0;
10645     r = guestfs_mkfs (g, fstype, device);
10646     if (r == -1)
10647       return -1;
10648   }
10649   {
10650     char device[] = "/dev/sda1";
10651     device[5] = devchar;
10652     char mountpoint[] = "/";
10653     int r;
10654     suppress_error = 0;
10655     r = guestfs_mount (g, device, mountpoint);
10656     if (r == -1)
10657       return -1;
10658   }
10659   {
10660     char **r;
10661     int i;
10662     suppress_error = 0;
10663     r = guestfs_mounts (g);
10664     if (r == NULL)
10665       return -1;
10666     if (!r[0]) {
10667       fprintf (stderr, "test_umount_0: short list returned from command\n");
10668       print_strings (r);
10669       return -1;
10670     }
10671     {
10672       char expected[] = "/dev/sda1";
10673       expected[5] = devchar;
10674       if (strcmp (r[0], expected) != 0) {
10675         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10676         return -1;
10677       }
10678     }
10679     if (r[1] != NULL) {
10680       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10681       print_strings (r);
10682       return -1;
10683     }
10684     for (i = 0; r[i] != NULL; ++i)
10685       free (r[i]);
10686     free (r);
10687   }
10688   return 0;
10689 }
10690
10691 static int test_umount_1_skip (void)
10692 {
10693   const char *str;
10694
10695   str = getenv ("SKIP_TEST_UMOUNT_1");
10696   if (str && strcmp (str, "1") == 0) return 1;
10697   str = getenv ("SKIP_TEST_UMOUNT");
10698   if (str && strcmp (str, "1") == 0) return 1;
10699   return 0;
10700 }
10701
10702 static int test_umount_1 (void)
10703 {
10704   if (test_umount_1_skip ()) {
10705     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10706     return 0;
10707   }
10708
10709   /* InitNone|InitEmpty for test_umount_1 */
10710   {
10711     char device[] = "/dev/sda";
10712     device[5] = devchar;
10713     int r;
10714     suppress_error = 0;
10715     r = guestfs_blockdev_setrw (g, device);
10716     if (r == -1)
10717       return -1;
10718   }
10719   {
10720     int r;
10721     suppress_error = 0;
10722     r = guestfs_umount_all (g);
10723     if (r == -1)
10724       return -1;
10725   }
10726   {
10727     int r;
10728     suppress_error = 0;
10729     r = guestfs_lvm_remove_all (g);
10730     if (r == -1)
10731       return -1;
10732   }
10733   /* TestOutputList for umount (1) */
10734   {
10735     char device[] = "/dev/sda";
10736     device[5] = devchar;
10737     char lines_0[] = ",";
10738     char *lines[] = {
10739       lines_0,
10740       NULL
10741     };
10742     int r;
10743     suppress_error = 0;
10744     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10745     if (r == -1)
10746       return -1;
10747   }
10748   {
10749     char fstype[] = "ext2";
10750     char device[] = "/dev/sda1";
10751     device[5] = devchar;
10752     int r;
10753     suppress_error = 0;
10754     r = guestfs_mkfs (g, fstype, device);
10755     if (r == -1)
10756       return -1;
10757   }
10758   {
10759     char device[] = "/dev/sda1";
10760     device[5] = devchar;
10761     char mountpoint[] = "/";
10762     int r;
10763     suppress_error = 0;
10764     r = guestfs_mount (g, device, mountpoint);
10765     if (r == -1)
10766       return -1;
10767   }
10768   {
10769     char pathordevice[] = "/";
10770     int r;
10771     suppress_error = 0;
10772     r = guestfs_umount (g, pathordevice);
10773     if (r == -1)
10774       return -1;
10775   }
10776   {
10777     char **r;
10778     int i;
10779     suppress_error = 0;
10780     r = guestfs_mounts (g);
10781     if (r == NULL)
10782       return -1;
10783     if (r[0] != NULL) {
10784       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10785       print_strings (r);
10786       return -1;
10787     }
10788     for (i = 0; r[i] != NULL; ++i)
10789       free (r[i]);
10790     free (r);
10791   }
10792   return 0;
10793 }
10794
10795 static int test_write_file_0_skip (void)
10796 {
10797   const char *str;
10798
10799   str = getenv ("SKIP_TEST_WRITE_FILE_0");
10800   if (str && strcmp (str, "1") == 0) return 1;
10801   str = getenv ("SKIP_TEST_WRITE_FILE");
10802   if (str && strcmp (str, "1") == 0) return 1;
10803   return 0;
10804 }
10805
10806 static int test_write_file_0 (void)
10807 {
10808   if (test_write_file_0_skip ()) {
10809     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10810     return 0;
10811   }
10812
10813   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10814   {
10815     char device[] = "/dev/sda";
10816     device[5] = devchar;
10817     int r;
10818     suppress_error = 0;
10819     r = guestfs_blockdev_setrw (g, device);
10820     if (r == -1)
10821       return -1;
10822   }
10823   {
10824     int r;
10825     suppress_error = 0;
10826     r = guestfs_umount_all (g);
10827     if (r == -1)
10828       return -1;
10829   }
10830   {
10831     int r;
10832     suppress_error = 0;
10833     r = guestfs_lvm_remove_all (g);
10834     if (r == -1)
10835       return -1;
10836   }
10837   {
10838     char device[] = "/dev/sda";
10839     device[5] = devchar;
10840     char lines_0[] = ",";
10841     char *lines[] = {
10842       lines_0,
10843       NULL
10844     };
10845     int r;
10846     suppress_error = 0;
10847     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10848     if (r == -1)
10849       return -1;
10850   }
10851   {
10852     char fstype[] = "ext2";
10853     char device[] = "/dev/sda1";
10854     device[5] = devchar;
10855     int r;
10856     suppress_error = 0;
10857     r = guestfs_mkfs (g, fstype, device);
10858     if (r == -1)
10859       return -1;
10860   }
10861   {
10862     char device[] = "/dev/sda1";
10863     device[5] = devchar;
10864     char mountpoint[] = "/";
10865     int r;
10866     suppress_error = 0;
10867     r = guestfs_mount (g, device, mountpoint);
10868     if (r == -1)
10869       return -1;
10870   }
10871   /* TestOutput for write_file (0) */
10872   char expected[] = "new file contents";
10873   {
10874     char path[] = "/new";
10875     char content[] = "new file contents";
10876     int r;
10877     suppress_error = 0;
10878     r = guestfs_write_file (g, path, content, 0);
10879     if (r == -1)
10880       return -1;
10881   }
10882   {
10883     char path[] = "/new";
10884     char *r;
10885     suppress_error = 0;
10886     r = guestfs_cat (g, path);
10887     if (r == NULL)
10888       return -1;
10889     if (strcmp (r, expected) != 0) {
10890       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10891       return -1;
10892     }
10893     free (r);
10894   }
10895   return 0;
10896 }
10897
10898 static int test_write_file_1_skip (void)
10899 {
10900   const char *str;
10901
10902   str = getenv ("SKIP_TEST_WRITE_FILE_1");
10903   if (str && strcmp (str, "1") == 0) return 1;
10904   str = getenv ("SKIP_TEST_WRITE_FILE");
10905   if (str && strcmp (str, "1") == 0) return 1;
10906   return 0;
10907 }
10908
10909 static int test_write_file_1 (void)
10910 {
10911   if (test_write_file_1_skip ()) {
10912     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10913     return 0;
10914   }
10915
10916   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10917   {
10918     char device[] = "/dev/sda";
10919     device[5] = devchar;
10920     int r;
10921     suppress_error = 0;
10922     r = guestfs_blockdev_setrw (g, device);
10923     if (r == -1)
10924       return -1;
10925   }
10926   {
10927     int r;
10928     suppress_error = 0;
10929     r = guestfs_umount_all (g);
10930     if (r == -1)
10931       return -1;
10932   }
10933   {
10934     int r;
10935     suppress_error = 0;
10936     r = guestfs_lvm_remove_all (g);
10937     if (r == -1)
10938       return -1;
10939   }
10940   {
10941     char device[] = "/dev/sda";
10942     device[5] = devchar;
10943     char lines_0[] = ",";
10944     char *lines[] = {
10945       lines_0,
10946       NULL
10947     };
10948     int r;
10949     suppress_error = 0;
10950     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10951     if (r == -1)
10952       return -1;
10953   }
10954   {
10955     char fstype[] = "ext2";
10956     char device[] = "/dev/sda1";
10957     device[5] = devchar;
10958     int r;
10959     suppress_error = 0;
10960     r = guestfs_mkfs (g, fstype, device);
10961     if (r == -1)
10962       return -1;
10963   }
10964   {
10965     char device[] = "/dev/sda1";
10966     device[5] = devchar;
10967     char mountpoint[] = "/";
10968     int r;
10969     suppress_error = 0;
10970     r = guestfs_mount (g, device, mountpoint);
10971     if (r == -1)
10972       return -1;
10973   }
10974   /* TestOutput for write_file (1) */
10975   char expected[] = "\nnew file contents\n";
10976   {
10977     char path[] = "/new";
10978     char content[] = "\nnew file contents\n";
10979     int r;
10980     suppress_error = 0;
10981     r = guestfs_write_file (g, path, content, 0);
10982     if (r == -1)
10983       return -1;
10984   }
10985   {
10986     char path[] = "/new";
10987     char *r;
10988     suppress_error = 0;
10989     r = guestfs_cat (g, path);
10990     if (r == NULL)
10991       return -1;
10992     if (strcmp (r, expected) != 0) {
10993       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10994       return -1;
10995     }
10996     free (r);
10997   }
10998   return 0;
10999 }
11000
11001 static int test_write_file_2_skip (void)
11002 {
11003   const char *str;
11004
11005   str = getenv ("SKIP_TEST_WRITE_FILE_2");
11006   if (str && strcmp (str, "1") == 0) return 1;
11007   str = getenv ("SKIP_TEST_WRITE_FILE");
11008   if (str && strcmp (str, "1") == 0) return 1;
11009   return 0;
11010 }
11011
11012 static int test_write_file_2 (void)
11013 {
11014   if (test_write_file_2_skip ()) {
11015     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11016     return 0;
11017   }
11018
11019   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11020   {
11021     char device[] = "/dev/sda";
11022     device[5] = devchar;
11023     int r;
11024     suppress_error = 0;
11025     r = guestfs_blockdev_setrw (g, device);
11026     if (r == -1)
11027       return -1;
11028   }
11029   {
11030     int r;
11031     suppress_error = 0;
11032     r = guestfs_umount_all (g);
11033     if (r == -1)
11034       return -1;
11035   }
11036   {
11037     int r;
11038     suppress_error = 0;
11039     r = guestfs_lvm_remove_all (g);
11040     if (r == -1)
11041       return -1;
11042   }
11043   {
11044     char device[] = "/dev/sda";
11045     device[5] = devchar;
11046     char lines_0[] = ",";
11047     char *lines[] = {
11048       lines_0,
11049       NULL
11050     };
11051     int r;
11052     suppress_error = 0;
11053     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11054     if (r == -1)
11055       return -1;
11056   }
11057   {
11058     char fstype[] = "ext2";
11059     char device[] = "/dev/sda1";
11060     device[5] = devchar;
11061     int r;
11062     suppress_error = 0;
11063     r = guestfs_mkfs (g, fstype, device);
11064     if (r == -1)
11065       return -1;
11066   }
11067   {
11068     char device[] = "/dev/sda1";
11069     device[5] = devchar;
11070     char mountpoint[] = "/";
11071     int r;
11072     suppress_error = 0;
11073     r = guestfs_mount (g, device, mountpoint);
11074     if (r == -1)
11075       return -1;
11076   }
11077   /* TestOutput for write_file (2) */
11078   char expected[] = "\n\n";
11079   {
11080     char path[] = "/new";
11081     char content[] = "\n\n";
11082     int r;
11083     suppress_error = 0;
11084     r = guestfs_write_file (g, path, content, 0);
11085     if (r == -1)
11086       return -1;
11087   }
11088   {
11089     char path[] = "/new";
11090     char *r;
11091     suppress_error = 0;
11092     r = guestfs_cat (g, path);
11093     if (r == NULL)
11094       return -1;
11095     if (strcmp (r, expected) != 0) {
11096       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11097       return -1;
11098     }
11099     free (r);
11100   }
11101   return 0;
11102 }
11103
11104 static int test_write_file_3_skip (void)
11105 {
11106   const char *str;
11107
11108   str = getenv ("SKIP_TEST_WRITE_FILE_3");
11109   if (str && strcmp (str, "1") == 0) return 1;
11110   str = getenv ("SKIP_TEST_WRITE_FILE");
11111   if (str && strcmp (str, "1") == 0) return 1;
11112   return 0;
11113 }
11114
11115 static int test_write_file_3 (void)
11116 {
11117   if (test_write_file_3_skip ()) {
11118     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11119     return 0;
11120   }
11121
11122   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11123   {
11124     char device[] = "/dev/sda";
11125     device[5] = devchar;
11126     int r;
11127     suppress_error = 0;
11128     r = guestfs_blockdev_setrw (g, device);
11129     if (r == -1)
11130       return -1;
11131   }
11132   {
11133     int r;
11134     suppress_error = 0;
11135     r = guestfs_umount_all (g);
11136     if (r == -1)
11137       return -1;
11138   }
11139   {
11140     int r;
11141     suppress_error = 0;
11142     r = guestfs_lvm_remove_all (g);
11143     if (r == -1)
11144       return -1;
11145   }
11146   {
11147     char device[] = "/dev/sda";
11148     device[5] = devchar;
11149     char lines_0[] = ",";
11150     char *lines[] = {
11151       lines_0,
11152       NULL
11153     };
11154     int r;
11155     suppress_error = 0;
11156     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11157     if (r == -1)
11158       return -1;
11159   }
11160   {
11161     char fstype[] = "ext2";
11162     char device[] = "/dev/sda1";
11163     device[5] = devchar;
11164     int r;
11165     suppress_error = 0;
11166     r = guestfs_mkfs (g, fstype, device);
11167     if (r == -1)
11168       return -1;
11169   }
11170   {
11171     char device[] = "/dev/sda1";
11172     device[5] = devchar;
11173     char mountpoint[] = "/";
11174     int r;
11175     suppress_error = 0;
11176     r = guestfs_mount (g, device, mountpoint);
11177     if (r == -1)
11178       return -1;
11179   }
11180   /* TestOutput for write_file (3) */
11181   char expected[] = "";
11182   {
11183     char path[] = "/new";
11184     char content[] = "";
11185     int r;
11186     suppress_error = 0;
11187     r = guestfs_write_file (g, path, content, 0);
11188     if (r == -1)
11189       return -1;
11190   }
11191   {
11192     char path[] = "/new";
11193     char *r;
11194     suppress_error = 0;
11195     r = guestfs_cat (g, path);
11196     if (r == NULL)
11197       return -1;
11198     if (strcmp (r, expected) != 0) {
11199       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11200       return -1;
11201     }
11202     free (r);
11203   }
11204   return 0;
11205 }
11206
11207 static int test_write_file_4_skip (void)
11208 {
11209   const char *str;
11210
11211   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11212   if (str && strcmp (str, "1") == 0) return 1;
11213   str = getenv ("SKIP_TEST_WRITE_FILE");
11214   if (str && strcmp (str, "1") == 0) return 1;
11215   return 0;
11216 }
11217
11218 static int test_write_file_4 (void)
11219 {
11220   if (test_write_file_4_skip ()) {
11221     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11222     return 0;
11223   }
11224
11225   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11226   {
11227     char device[] = "/dev/sda";
11228     device[5] = devchar;
11229     int r;
11230     suppress_error = 0;
11231     r = guestfs_blockdev_setrw (g, device);
11232     if (r == -1)
11233       return -1;
11234   }
11235   {
11236     int r;
11237     suppress_error = 0;
11238     r = guestfs_umount_all (g);
11239     if (r == -1)
11240       return -1;
11241   }
11242   {
11243     int r;
11244     suppress_error = 0;
11245     r = guestfs_lvm_remove_all (g);
11246     if (r == -1)
11247       return -1;
11248   }
11249   {
11250     char device[] = "/dev/sda";
11251     device[5] = devchar;
11252     char lines_0[] = ",";
11253     char *lines[] = {
11254       lines_0,
11255       NULL
11256     };
11257     int r;
11258     suppress_error = 0;
11259     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11260     if (r == -1)
11261       return -1;
11262   }
11263   {
11264     char fstype[] = "ext2";
11265     char device[] = "/dev/sda1";
11266     device[5] = devchar;
11267     int r;
11268     suppress_error = 0;
11269     r = guestfs_mkfs (g, fstype, device);
11270     if (r == -1)
11271       return -1;
11272   }
11273   {
11274     char device[] = "/dev/sda1";
11275     device[5] = devchar;
11276     char mountpoint[] = "/";
11277     int r;
11278     suppress_error = 0;
11279     r = guestfs_mount (g, device, mountpoint);
11280     if (r == -1)
11281       return -1;
11282   }
11283   /* TestOutput for write_file (4) */
11284   char expected[] = "\n\n\n";
11285   {
11286     char path[] = "/new";
11287     char content[] = "\n\n\n";
11288     int r;
11289     suppress_error = 0;
11290     r = guestfs_write_file (g, path, content, 0);
11291     if (r == -1)
11292       return -1;
11293   }
11294   {
11295     char path[] = "/new";
11296     char *r;
11297     suppress_error = 0;
11298     r = guestfs_cat (g, path);
11299     if (r == NULL)
11300       return -1;
11301     if (strcmp (r, expected) != 0) {
11302       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11303       return -1;
11304     }
11305     free (r);
11306   }
11307   return 0;
11308 }
11309
11310 static int test_write_file_5_skip (void)
11311 {
11312   const char *str;
11313
11314   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11315   if (str && strcmp (str, "1") == 0) return 1;
11316   str = getenv ("SKIP_TEST_WRITE_FILE");
11317   if (str && strcmp (str, "1") == 0) return 1;
11318   return 0;
11319 }
11320
11321 static int test_write_file_5 (void)
11322 {
11323   if (test_write_file_5_skip ()) {
11324     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11325     return 0;
11326   }
11327
11328   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11329   {
11330     char device[] = "/dev/sda";
11331     device[5] = devchar;
11332     int r;
11333     suppress_error = 0;
11334     r = guestfs_blockdev_setrw (g, device);
11335     if (r == -1)
11336       return -1;
11337   }
11338   {
11339     int r;
11340     suppress_error = 0;
11341     r = guestfs_umount_all (g);
11342     if (r == -1)
11343       return -1;
11344   }
11345   {
11346     int r;
11347     suppress_error = 0;
11348     r = guestfs_lvm_remove_all (g);
11349     if (r == -1)
11350       return -1;
11351   }
11352   {
11353     char device[] = "/dev/sda";
11354     device[5] = devchar;
11355     char lines_0[] = ",";
11356     char *lines[] = {
11357       lines_0,
11358       NULL
11359     };
11360     int r;
11361     suppress_error = 0;
11362     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11363     if (r == -1)
11364       return -1;
11365   }
11366   {
11367     char fstype[] = "ext2";
11368     char device[] = "/dev/sda1";
11369     device[5] = devchar;
11370     int r;
11371     suppress_error = 0;
11372     r = guestfs_mkfs (g, fstype, device);
11373     if (r == -1)
11374       return -1;
11375   }
11376   {
11377     char device[] = "/dev/sda1";
11378     device[5] = devchar;
11379     char mountpoint[] = "/";
11380     int r;
11381     suppress_error = 0;
11382     r = guestfs_mount (g, device, mountpoint);
11383     if (r == -1)
11384       return -1;
11385   }
11386   /* TestOutput for write_file (5) */
11387   char expected[] = "\n";
11388   {
11389     char path[] = "/new";
11390     char content[] = "\n";
11391     int r;
11392     suppress_error = 0;
11393     r = guestfs_write_file (g, path, content, 0);
11394     if (r == -1)
11395       return -1;
11396   }
11397   {
11398     char path[] = "/new";
11399     char *r;
11400     suppress_error = 0;
11401     r = guestfs_cat (g, path);
11402     if (r == NULL)
11403       return -1;
11404     if (strcmp (r, expected) != 0) {
11405       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11406       return -1;
11407     }
11408     free (r);
11409   }
11410   return 0;
11411 }
11412
11413 static int test_mkfs_0_skip (void)
11414 {
11415   const char *str;
11416
11417   str = getenv ("SKIP_TEST_MKFS_0");
11418   if (str && strcmp (str, "1") == 0) return 1;
11419   str = getenv ("SKIP_TEST_MKFS");
11420   if (str && strcmp (str, "1") == 0) return 1;
11421   return 0;
11422 }
11423
11424 static int test_mkfs_0 (void)
11425 {
11426   if (test_mkfs_0_skip ()) {
11427     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11428     return 0;
11429   }
11430
11431   /* InitNone|InitEmpty for test_mkfs_0 */
11432   {
11433     char device[] = "/dev/sda";
11434     device[5] = devchar;
11435     int r;
11436     suppress_error = 0;
11437     r = guestfs_blockdev_setrw (g, device);
11438     if (r == -1)
11439       return -1;
11440   }
11441   {
11442     int r;
11443     suppress_error = 0;
11444     r = guestfs_umount_all (g);
11445     if (r == -1)
11446       return -1;
11447   }
11448   {
11449     int r;
11450     suppress_error = 0;
11451     r = guestfs_lvm_remove_all (g);
11452     if (r == -1)
11453       return -1;
11454   }
11455   /* TestOutput for mkfs (0) */
11456   char expected[] = "new file contents";
11457   {
11458     char device[] = "/dev/sda";
11459     device[5] = devchar;
11460     char lines_0[] = ",";
11461     char *lines[] = {
11462       lines_0,
11463       NULL
11464     };
11465     int r;
11466     suppress_error = 0;
11467     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11468     if (r == -1)
11469       return -1;
11470   }
11471   {
11472     char fstype[] = "ext2";
11473     char device[] = "/dev/sda1";
11474     device[5] = devchar;
11475     int r;
11476     suppress_error = 0;
11477     r = guestfs_mkfs (g, fstype, device);
11478     if (r == -1)
11479       return -1;
11480   }
11481   {
11482     char device[] = "/dev/sda1";
11483     device[5] = devchar;
11484     char mountpoint[] = "/";
11485     int r;
11486     suppress_error = 0;
11487     r = guestfs_mount (g, device, mountpoint);
11488     if (r == -1)
11489       return -1;
11490   }
11491   {
11492     char path[] = "/new";
11493     char content[] = "new file contents";
11494     int r;
11495     suppress_error = 0;
11496     r = guestfs_write_file (g, path, content, 0);
11497     if (r == -1)
11498       return -1;
11499   }
11500   {
11501     char path[] = "/new";
11502     char *r;
11503     suppress_error = 0;
11504     r = guestfs_cat (g, path);
11505     if (r == NULL)
11506       return -1;
11507     if (strcmp (r, expected) != 0) {
11508       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11509       return -1;
11510     }
11511     free (r);
11512   }
11513   return 0;
11514 }
11515
11516 static int test_lvcreate_0_skip (void)
11517 {
11518   const char *str;
11519
11520   str = getenv ("SKIP_TEST_LVCREATE_0");
11521   if (str && strcmp (str, "1") == 0) return 1;
11522   str = getenv ("SKIP_TEST_LVCREATE");
11523   if (str && strcmp (str, "1") == 0) return 1;
11524   return 0;
11525 }
11526
11527 static int test_lvcreate_0 (void)
11528 {
11529   if (test_lvcreate_0_skip ()) {
11530     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11531     return 0;
11532   }
11533
11534   /* InitNone|InitEmpty for test_lvcreate_0 */
11535   {
11536     char device[] = "/dev/sda";
11537     device[5] = devchar;
11538     int r;
11539     suppress_error = 0;
11540     r = guestfs_blockdev_setrw (g, device);
11541     if (r == -1)
11542       return -1;
11543   }
11544   {
11545     int r;
11546     suppress_error = 0;
11547     r = guestfs_umount_all (g);
11548     if (r == -1)
11549       return -1;
11550   }
11551   {
11552     int r;
11553     suppress_error = 0;
11554     r = guestfs_lvm_remove_all (g);
11555     if (r == -1)
11556       return -1;
11557   }
11558   /* TestOutputList for lvcreate (0) */
11559   {
11560     char device[] = "/dev/sda";
11561     device[5] = devchar;
11562     char lines_0[] = ",10";
11563     char lines_1[] = ",20";
11564     char lines_2[] = ",";
11565     char *lines[] = {
11566       lines_0,
11567       lines_1,
11568       lines_2,
11569       NULL
11570     };
11571     int r;
11572     suppress_error = 0;
11573     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11574     if (r == -1)
11575       return -1;
11576   }
11577   {
11578     char device[] = "/dev/sda1";
11579     device[5] = devchar;
11580     int r;
11581     suppress_error = 0;
11582     r = guestfs_pvcreate (g, device);
11583     if (r == -1)
11584       return -1;
11585   }
11586   {
11587     char device[] = "/dev/sda2";
11588     device[5] = devchar;
11589     int r;
11590     suppress_error = 0;
11591     r = guestfs_pvcreate (g, device);
11592     if (r == -1)
11593       return -1;
11594   }
11595   {
11596     char device[] = "/dev/sda3";
11597     device[5] = devchar;
11598     int r;
11599     suppress_error = 0;
11600     r = guestfs_pvcreate (g, device);
11601     if (r == -1)
11602       return -1;
11603   }
11604   {
11605     char volgroup[] = "VG1";
11606     char physvols_0[] = "/dev/sda1";
11607     physvols_0[5] = devchar;
11608     char physvols_1[] = "/dev/sda2";
11609     physvols_1[5] = devchar;
11610     char *physvols[] = {
11611       physvols_0,
11612       physvols_1,
11613       NULL
11614     };
11615     int r;
11616     suppress_error = 0;
11617     r = guestfs_vgcreate (g, volgroup, physvols);
11618     if (r == -1)
11619       return -1;
11620   }
11621   {
11622     char volgroup[] = "VG2";
11623     char physvols_0[] = "/dev/sda3";
11624     physvols_0[5] = devchar;
11625     char *physvols[] = {
11626       physvols_0,
11627       NULL
11628     };
11629     int r;
11630     suppress_error = 0;
11631     r = guestfs_vgcreate (g, volgroup, physvols);
11632     if (r == -1)
11633       return -1;
11634   }
11635   {
11636     char logvol[] = "LV1";
11637     char volgroup[] = "VG1";
11638     int r;
11639     suppress_error = 0;
11640     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11641     if (r == -1)
11642       return -1;
11643   }
11644   {
11645     char logvol[] = "LV2";
11646     char volgroup[] = "VG1";
11647     int r;
11648     suppress_error = 0;
11649     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11650     if (r == -1)
11651       return -1;
11652   }
11653   {
11654     char logvol[] = "LV3";
11655     char volgroup[] = "VG2";
11656     int r;
11657     suppress_error = 0;
11658     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11659     if (r == -1)
11660       return -1;
11661   }
11662   {
11663     char logvol[] = "LV4";
11664     char volgroup[] = "VG2";
11665     int r;
11666     suppress_error = 0;
11667     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11668     if (r == -1)
11669       return -1;
11670   }
11671   {
11672     char logvol[] = "LV5";
11673     char volgroup[] = "VG2";
11674     int r;
11675     suppress_error = 0;
11676     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11677     if (r == -1)
11678       return -1;
11679   }
11680   {
11681     char **r;
11682     int i;
11683     suppress_error = 0;
11684     r = guestfs_lvs (g);
11685     if (r == NULL)
11686       return -1;
11687     if (!r[0]) {
11688       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11689       print_strings (r);
11690       return -1;
11691     }
11692     {
11693       char expected[] = "/dev/VG1/LV1";
11694       if (strcmp (r[0], expected) != 0) {
11695         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11696         return -1;
11697       }
11698     }
11699     if (!r[1]) {
11700       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11701       print_strings (r);
11702       return -1;
11703     }
11704     {
11705       char expected[] = "/dev/VG1/LV2";
11706       if (strcmp (r[1], expected) != 0) {
11707         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11708         return -1;
11709       }
11710     }
11711     if (!r[2]) {
11712       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11713       print_strings (r);
11714       return -1;
11715     }
11716     {
11717       char expected[] = "/dev/VG2/LV3";
11718       if (strcmp (r[2], expected) != 0) {
11719         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11720         return -1;
11721       }
11722     }
11723     if (!r[3]) {
11724       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11725       print_strings (r);
11726       return -1;
11727     }
11728     {
11729       char expected[] = "/dev/VG2/LV4";
11730       if (strcmp (r[3], expected) != 0) {
11731         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11732         return -1;
11733       }
11734     }
11735     if (!r[4]) {
11736       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11737       print_strings (r);
11738       return -1;
11739     }
11740     {
11741       char expected[] = "/dev/VG2/LV5";
11742       if (strcmp (r[4], expected) != 0) {
11743         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11744         return -1;
11745       }
11746     }
11747     if (r[5] != NULL) {
11748       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11749       print_strings (r);
11750       return -1;
11751     }
11752     for (i = 0; r[i] != NULL; ++i)
11753       free (r[i]);
11754     free (r);
11755   }
11756   return 0;
11757 }
11758
11759 static int test_vgcreate_0_skip (void)
11760 {
11761   const char *str;
11762
11763   str = getenv ("SKIP_TEST_VGCREATE_0");
11764   if (str && strcmp (str, "1") == 0) return 1;
11765   str = getenv ("SKIP_TEST_VGCREATE");
11766   if (str && strcmp (str, "1") == 0) return 1;
11767   return 0;
11768 }
11769
11770 static int test_vgcreate_0 (void)
11771 {
11772   if (test_vgcreate_0_skip ()) {
11773     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11774     return 0;
11775   }
11776
11777   /* InitNone|InitEmpty for test_vgcreate_0 */
11778   {
11779     char device[] = "/dev/sda";
11780     device[5] = devchar;
11781     int r;
11782     suppress_error = 0;
11783     r = guestfs_blockdev_setrw (g, device);
11784     if (r == -1)
11785       return -1;
11786   }
11787   {
11788     int r;
11789     suppress_error = 0;
11790     r = guestfs_umount_all (g);
11791     if (r == -1)
11792       return -1;
11793   }
11794   {
11795     int r;
11796     suppress_error = 0;
11797     r = guestfs_lvm_remove_all (g);
11798     if (r == -1)
11799       return -1;
11800   }
11801   /* TestOutputList for vgcreate (0) */
11802   {
11803     char device[] = "/dev/sda";
11804     device[5] = devchar;
11805     char lines_0[] = ",10";
11806     char lines_1[] = ",20";
11807     char lines_2[] = ",";
11808     char *lines[] = {
11809       lines_0,
11810       lines_1,
11811       lines_2,
11812       NULL
11813     };
11814     int r;
11815     suppress_error = 0;
11816     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11817     if (r == -1)
11818       return -1;
11819   }
11820   {
11821     char device[] = "/dev/sda1";
11822     device[5] = devchar;
11823     int r;
11824     suppress_error = 0;
11825     r = guestfs_pvcreate (g, device);
11826     if (r == -1)
11827       return -1;
11828   }
11829   {
11830     char device[] = "/dev/sda2";
11831     device[5] = devchar;
11832     int r;
11833     suppress_error = 0;
11834     r = guestfs_pvcreate (g, device);
11835     if (r == -1)
11836       return -1;
11837   }
11838   {
11839     char device[] = "/dev/sda3";
11840     device[5] = devchar;
11841     int r;
11842     suppress_error = 0;
11843     r = guestfs_pvcreate (g, device);
11844     if (r == -1)
11845       return -1;
11846   }
11847   {
11848     char volgroup[] = "VG1";
11849     char physvols_0[] = "/dev/sda1";
11850     physvols_0[5] = devchar;
11851     char physvols_1[] = "/dev/sda2";
11852     physvols_1[5] = devchar;
11853     char *physvols[] = {
11854       physvols_0,
11855       physvols_1,
11856       NULL
11857     };
11858     int r;
11859     suppress_error = 0;
11860     r = guestfs_vgcreate (g, volgroup, physvols);
11861     if (r == -1)
11862       return -1;
11863   }
11864   {
11865     char volgroup[] = "VG2";
11866     char physvols_0[] = "/dev/sda3";
11867     physvols_0[5] = devchar;
11868     char *physvols[] = {
11869       physvols_0,
11870       NULL
11871     };
11872     int r;
11873     suppress_error = 0;
11874     r = guestfs_vgcreate (g, volgroup, physvols);
11875     if (r == -1)
11876       return -1;
11877   }
11878   {
11879     char **r;
11880     int i;
11881     suppress_error = 0;
11882     r = guestfs_vgs (g);
11883     if (r == NULL)
11884       return -1;
11885     if (!r[0]) {
11886       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11887       print_strings (r);
11888       return -1;
11889     }
11890     {
11891       char expected[] = "VG1";
11892       if (strcmp (r[0], expected) != 0) {
11893         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11894         return -1;
11895       }
11896     }
11897     if (!r[1]) {
11898       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11899       print_strings (r);
11900       return -1;
11901     }
11902     {
11903       char expected[] = "VG2";
11904       if (strcmp (r[1], expected) != 0) {
11905         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11906         return -1;
11907       }
11908     }
11909     if (r[2] != NULL) {
11910       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11911       print_strings (r);
11912       return -1;
11913     }
11914     for (i = 0; r[i] != NULL; ++i)
11915       free (r[i]);
11916     free (r);
11917   }
11918   return 0;
11919 }
11920
11921 static int test_pvcreate_0_skip (void)
11922 {
11923   const char *str;
11924
11925   str = getenv ("SKIP_TEST_PVCREATE_0");
11926   if (str && strcmp (str, "1") == 0) return 1;
11927   str = getenv ("SKIP_TEST_PVCREATE");
11928   if (str && strcmp (str, "1") == 0) return 1;
11929   return 0;
11930 }
11931
11932 static int test_pvcreate_0 (void)
11933 {
11934   if (test_pvcreate_0_skip ()) {
11935     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11936     return 0;
11937   }
11938
11939   /* InitNone|InitEmpty for test_pvcreate_0 */
11940   {
11941     char device[] = "/dev/sda";
11942     device[5] = devchar;
11943     int r;
11944     suppress_error = 0;
11945     r = guestfs_blockdev_setrw (g, device);
11946     if (r == -1)
11947       return -1;
11948   }
11949   {
11950     int r;
11951     suppress_error = 0;
11952     r = guestfs_umount_all (g);
11953     if (r == -1)
11954       return -1;
11955   }
11956   {
11957     int r;
11958     suppress_error = 0;
11959     r = guestfs_lvm_remove_all (g);
11960     if (r == -1)
11961       return -1;
11962   }
11963   /* TestOutputList for pvcreate (0) */
11964   {
11965     char device[] = "/dev/sda";
11966     device[5] = devchar;
11967     char lines_0[] = ",10";
11968     char lines_1[] = ",20";
11969     char lines_2[] = ",";
11970     char *lines[] = {
11971       lines_0,
11972       lines_1,
11973       lines_2,
11974       NULL
11975     };
11976     int r;
11977     suppress_error = 0;
11978     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11979     if (r == -1)
11980       return -1;
11981   }
11982   {
11983     char device[] = "/dev/sda1";
11984     device[5] = devchar;
11985     int r;
11986     suppress_error = 0;
11987     r = guestfs_pvcreate (g, device);
11988     if (r == -1)
11989       return -1;
11990   }
11991   {
11992     char device[] = "/dev/sda2";
11993     device[5] = devchar;
11994     int r;
11995     suppress_error = 0;
11996     r = guestfs_pvcreate (g, device);
11997     if (r == -1)
11998       return -1;
11999   }
12000   {
12001     char device[] = "/dev/sda3";
12002     device[5] = devchar;
12003     int r;
12004     suppress_error = 0;
12005     r = guestfs_pvcreate (g, device);
12006     if (r == -1)
12007       return -1;
12008   }
12009   {
12010     char **r;
12011     int i;
12012     suppress_error = 0;
12013     r = guestfs_pvs (g);
12014     if (r == NULL)
12015       return -1;
12016     if (!r[0]) {
12017       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12018       print_strings (r);
12019       return -1;
12020     }
12021     {
12022       char expected[] = "/dev/sda1";
12023       expected[5] = devchar;
12024       if (strcmp (r[0], expected) != 0) {
12025         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12026         return -1;
12027       }
12028     }
12029     if (!r[1]) {
12030       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12031       print_strings (r);
12032       return -1;
12033     }
12034     {
12035       char expected[] = "/dev/sda2";
12036       expected[5] = devchar;
12037       if (strcmp (r[1], expected) != 0) {
12038         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12039         return -1;
12040       }
12041     }
12042     if (!r[2]) {
12043       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12044       print_strings (r);
12045       return -1;
12046     }
12047     {
12048       char expected[] = "/dev/sda3";
12049       expected[5] = devchar;
12050       if (strcmp (r[2], expected) != 0) {
12051         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12052         return -1;
12053       }
12054     }
12055     if (r[3] != NULL) {
12056       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12057       print_strings (r);
12058       return -1;
12059     }
12060     for (i = 0; r[i] != NULL; ++i)
12061       free (r[i]);
12062     free (r);
12063   }
12064   return 0;
12065 }
12066
12067 static int test_is_dir_0_skip (void)
12068 {
12069   const char *str;
12070
12071   str = getenv ("SKIP_TEST_IS_DIR_0");
12072   if (str && strcmp (str, "1") == 0) return 1;
12073   str = getenv ("SKIP_TEST_IS_DIR");
12074   if (str && strcmp (str, "1") == 0) return 1;
12075   return 0;
12076 }
12077
12078 static int test_is_dir_0 (void)
12079 {
12080   if (test_is_dir_0_skip ()) {
12081     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12082     return 0;
12083   }
12084
12085   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12086   {
12087     char device[] = "/dev/sda";
12088     device[5] = devchar;
12089     int r;
12090     suppress_error = 0;
12091     r = guestfs_blockdev_setrw (g, device);
12092     if (r == -1)
12093       return -1;
12094   }
12095   {
12096     int r;
12097     suppress_error = 0;
12098     r = guestfs_umount_all (g);
12099     if (r == -1)
12100       return -1;
12101   }
12102   {
12103     int r;
12104     suppress_error = 0;
12105     r = guestfs_lvm_remove_all (g);
12106     if (r == -1)
12107       return -1;
12108   }
12109   {
12110     char device[] = "/dev/sda";
12111     device[5] = devchar;
12112     char lines_0[] = ",";
12113     char *lines[] = {
12114       lines_0,
12115       NULL
12116     };
12117     int r;
12118     suppress_error = 0;
12119     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12120     if (r == -1)
12121       return -1;
12122   }
12123   {
12124     char fstype[] = "ext2";
12125     char device[] = "/dev/sda1";
12126     device[5] = devchar;
12127     int r;
12128     suppress_error = 0;
12129     r = guestfs_mkfs (g, fstype, device);
12130     if (r == -1)
12131       return -1;
12132   }
12133   {
12134     char device[] = "/dev/sda1";
12135     device[5] = devchar;
12136     char mountpoint[] = "/";
12137     int r;
12138     suppress_error = 0;
12139     r = guestfs_mount (g, device, mountpoint);
12140     if (r == -1)
12141       return -1;
12142   }
12143   /* TestOutputFalse for is_dir (0) */
12144   {
12145     char path[] = "/new";
12146     int r;
12147     suppress_error = 0;
12148     r = guestfs_touch (g, path);
12149     if (r == -1)
12150       return -1;
12151   }
12152   {
12153     char path[] = "/new";
12154     int r;
12155     suppress_error = 0;
12156     r = guestfs_is_dir (g, path);
12157     if (r == -1)
12158       return -1;
12159     if (r) {
12160       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12161       return -1;
12162     }
12163   }
12164   return 0;
12165 }
12166
12167 static int test_is_dir_1_skip (void)
12168 {
12169   const char *str;
12170
12171   str = getenv ("SKIP_TEST_IS_DIR_1");
12172   if (str && strcmp (str, "1") == 0) return 1;
12173   str = getenv ("SKIP_TEST_IS_DIR");
12174   if (str && strcmp (str, "1") == 0) return 1;
12175   return 0;
12176 }
12177
12178 static int test_is_dir_1 (void)
12179 {
12180   if (test_is_dir_1_skip ()) {
12181     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12182     return 0;
12183   }
12184
12185   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12186   {
12187     char device[] = "/dev/sda";
12188     device[5] = devchar;
12189     int r;
12190     suppress_error = 0;
12191     r = guestfs_blockdev_setrw (g, device);
12192     if (r == -1)
12193       return -1;
12194   }
12195   {
12196     int r;
12197     suppress_error = 0;
12198     r = guestfs_umount_all (g);
12199     if (r == -1)
12200       return -1;
12201   }
12202   {
12203     int r;
12204     suppress_error = 0;
12205     r = guestfs_lvm_remove_all (g);
12206     if (r == -1)
12207       return -1;
12208   }
12209   {
12210     char device[] = "/dev/sda";
12211     device[5] = devchar;
12212     char lines_0[] = ",";
12213     char *lines[] = {
12214       lines_0,
12215       NULL
12216     };
12217     int r;
12218     suppress_error = 0;
12219     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12220     if (r == -1)
12221       return -1;
12222   }
12223   {
12224     char fstype[] = "ext2";
12225     char device[] = "/dev/sda1";
12226     device[5] = devchar;
12227     int r;
12228     suppress_error = 0;
12229     r = guestfs_mkfs (g, fstype, device);
12230     if (r == -1)
12231       return -1;
12232   }
12233   {
12234     char device[] = "/dev/sda1";
12235     device[5] = devchar;
12236     char mountpoint[] = "/";
12237     int r;
12238     suppress_error = 0;
12239     r = guestfs_mount (g, device, mountpoint);
12240     if (r == -1)
12241       return -1;
12242   }
12243   /* TestOutputTrue for is_dir (1) */
12244   {
12245     char path[] = "/new";
12246     int r;
12247     suppress_error = 0;
12248     r = guestfs_mkdir (g, path);
12249     if (r == -1)
12250       return -1;
12251   }
12252   {
12253     char path[] = "/new";
12254     int r;
12255     suppress_error = 0;
12256     r = guestfs_is_dir (g, path);
12257     if (r == -1)
12258       return -1;
12259     if (!r) {
12260       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12261       return -1;
12262     }
12263   }
12264   return 0;
12265 }
12266
12267 static int test_is_file_0_skip (void)
12268 {
12269   const char *str;
12270
12271   str = getenv ("SKIP_TEST_IS_FILE_0");
12272   if (str && strcmp (str, "1") == 0) return 1;
12273   str = getenv ("SKIP_TEST_IS_FILE");
12274   if (str && strcmp (str, "1") == 0) return 1;
12275   return 0;
12276 }
12277
12278 static int test_is_file_0 (void)
12279 {
12280   if (test_is_file_0_skip ()) {
12281     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12282     return 0;
12283   }
12284
12285   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12286   {
12287     char device[] = "/dev/sda";
12288     device[5] = devchar;
12289     int r;
12290     suppress_error = 0;
12291     r = guestfs_blockdev_setrw (g, device);
12292     if (r == -1)
12293       return -1;
12294   }
12295   {
12296     int r;
12297     suppress_error = 0;
12298     r = guestfs_umount_all (g);
12299     if (r == -1)
12300       return -1;
12301   }
12302   {
12303     int r;
12304     suppress_error = 0;
12305     r = guestfs_lvm_remove_all (g);
12306     if (r == -1)
12307       return -1;
12308   }
12309   {
12310     char device[] = "/dev/sda";
12311     device[5] = devchar;
12312     char lines_0[] = ",";
12313     char *lines[] = {
12314       lines_0,
12315       NULL
12316     };
12317     int r;
12318     suppress_error = 0;
12319     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12320     if (r == -1)
12321       return -1;
12322   }
12323   {
12324     char fstype[] = "ext2";
12325     char device[] = "/dev/sda1";
12326     device[5] = devchar;
12327     int r;
12328     suppress_error = 0;
12329     r = guestfs_mkfs (g, fstype, device);
12330     if (r == -1)
12331       return -1;
12332   }
12333   {
12334     char device[] = "/dev/sda1";
12335     device[5] = devchar;
12336     char mountpoint[] = "/";
12337     int r;
12338     suppress_error = 0;
12339     r = guestfs_mount (g, device, mountpoint);
12340     if (r == -1)
12341       return -1;
12342   }
12343   /* TestOutputTrue for is_file (0) */
12344   {
12345     char path[] = "/new";
12346     int r;
12347     suppress_error = 0;
12348     r = guestfs_touch (g, path);
12349     if (r == -1)
12350       return -1;
12351   }
12352   {
12353     char path[] = "/new";
12354     int r;
12355     suppress_error = 0;
12356     r = guestfs_is_file (g, path);
12357     if (r == -1)
12358       return -1;
12359     if (!r) {
12360       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12361       return -1;
12362     }
12363   }
12364   return 0;
12365 }
12366
12367 static int test_is_file_1_skip (void)
12368 {
12369   const char *str;
12370
12371   str = getenv ("SKIP_TEST_IS_FILE_1");
12372   if (str && strcmp (str, "1") == 0) return 1;
12373   str = getenv ("SKIP_TEST_IS_FILE");
12374   if (str && strcmp (str, "1") == 0) return 1;
12375   return 0;
12376 }
12377
12378 static int test_is_file_1 (void)
12379 {
12380   if (test_is_file_1_skip ()) {
12381     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12382     return 0;
12383   }
12384
12385   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12386   {
12387     char device[] = "/dev/sda";
12388     device[5] = devchar;
12389     int r;
12390     suppress_error = 0;
12391     r = guestfs_blockdev_setrw (g, device);
12392     if (r == -1)
12393       return -1;
12394   }
12395   {
12396     int r;
12397     suppress_error = 0;
12398     r = guestfs_umount_all (g);
12399     if (r == -1)
12400       return -1;
12401   }
12402   {
12403     int r;
12404     suppress_error = 0;
12405     r = guestfs_lvm_remove_all (g);
12406     if (r == -1)
12407       return -1;
12408   }
12409   {
12410     char device[] = "/dev/sda";
12411     device[5] = devchar;
12412     char lines_0[] = ",";
12413     char *lines[] = {
12414       lines_0,
12415       NULL
12416     };
12417     int r;
12418     suppress_error = 0;
12419     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12420     if (r == -1)
12421       return -1;
12422   }
12423   {
12424     char fstype[] = "ext2";
12425     char device[] = "/dev/sda1";
12426     device[5] = devchar;
12427     int r;
12428     suppress_error = 0;
12429     r = guestfs_mkfs (g, fstype, device);
12430     if (r == -1)
12431       return -1;
12432   }
12433   {
12434     char device[] = "/dev/sda1";
12435     device[5] = devchar;
12436     char mountpoint[] = "/";
12437     int r;
12438     suppress_error = 0;
12439     r = guestfs_mount (g, device, mountpoint);
12440     if (r == -1)
12441       return -1;
12442   }
12443   /* TestOutputFalse for is_file (1) */
12444   {
12445     char path[] = "/new";
12446     int r;
12447     suppress_error = 0;
12448     r = guestfs_mkdir (g, path);
12449     if (r == -1)
12450       return -1;
12451   }
12452   {
12453     char path[] = "/new";
12454     int r;
12455     suppress_error = 0;
12456     r = guestfs_is_file (g, path);
12457     if (r == -1)
12458       return -1;
12459     if (r) {
12460       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12461       return -1;
12462     }
12463   }
12464   return 0;
12465 }
12466
12467 static int test_exists_0_skip (void)
12468 {
12469   const char *str;
12470
12471   str = getenv ("SKIP_TEST_EXISTS_0");
12472   if (str && strcmp (str, "1") == 0) return 1;
12473   str = getenv ("SKIP_TEST_EXISTS");
12474   if (str && strcmp (str, "1") == 0) return 1;
12475   return 0;
12476 }
12477
12478 static int test_exists_0 (void)
12479 {
12480   if (test_exists_0_skip ()) {
12481     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12482     return 0;
12483   }
12484
12485   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12486   {
12487     char device[] = "/dev/sda";
12488     device[5] = devchar;
12489     int r;
12490     suppress_error = 0;
12491     r = guestfs_blockdev_setrw (g, device);
12492     if (r == -1)
12493       return -1;
12494   }
12495   {
12496     int r;
12497     suppress_error = 0;
12498     r = guestfs_umount_all (g);
12499     if (r == -1)
12500       return -1;
12501   }
12502   {
12503     int r;
12504     suppress_error = 0;
12505     r = guestfs_lvm_remove_all (g);
12506     if (r == -1)
12507       return -1;
12508   }
12509   {
12510     char device[] = "/dev/sda";
12511     device[5] = devchar;
12512     char lines_0[] = ",";
12513     char *lines[] = {
12514       lines_0,
12515       NULL
12516     };
12517     int r;
12518     suppress_error = 0;
12519     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12520     if (r == -1)
12521       return -1;
12522   }
12523   {
12524     char fstype[] = "ext2";
12525     char device[] = "/dev/sda1";
12526     device[5] = devchar;
12527     int r;
12528     suppress_error = 0;
12529     r = guestfs_mkfs (g, fstype, device);
12530     if (r == -1)
12531       return -1;
12532   }
12533   {
12534     char device[] = "/dev/sda1";
12535     device[5] = devchar;
12536     char mountpoint[] = "/";
12537     int r;
12538     suppress_error = 0;
12539     r = guestfs_mount (g, device, mountpoint);
12540     if (r == -1)
12541       return -1;
12542   }
12543   /* TestOutputTrue for exists (0) */
12544   {
12545     char path[] = "/new";
12546     int r;
12547     suppress_error = 0;
12548     r = guestfs_touch (g, path);
12549     if (r == -1)
12550       return -1;
12551   }
12552   {
12553     char path[] = "/new";
12554     int r;
12555     suppress_error = 0;
12556     r = guestfs_exists (g, path);
12557     if (r == -1)
12558       return -1;
12559     if (!r) {
12560       fprintf (stderr, "test_exists_0: expected true, got false\n");
12561       return -1;
12562     }
12563   }
12564   return 0;
12565 }
12566
12567 static int test_exists_1_skip (void)
12568 {
12569   const char *str;
12570
12571   str = getenv ("SKIP_TEST_EXISTS_1");
12572   if (str && strcmp (str, "1") == 0) return 1;
12573   str = getenv ("SKIP_TEST_EXISTS");
12574   if (str && strcmp (str, "1") == 0) return 1;
12575   return 0;
12576 }
12577
12578 static int test_exists_1 (void)
12579 {
12580   if (test_exists_1_skip ()) {
12581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12582     return 0;
12583   }
12584
12585   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12586   {
12587     char device[] = "/dev/sda";
12588     device[5] = devchar;
12589     int r;
12590     suppress_error = 0;
12591     r = guestfs_blockdev_setrw (g, device);
12592     if (r == -1)
12593       return -1;
12594   }
12595   {
12596     int r;
12597     suppress_error = 0;
12598     r = guestfs_umount_all (g);
12599     if (r == -1)
12600       return -1;
12601   }
12602   {
12603     int r;
12604     suppress_error = 0;
12605     r = guestfs_lvm_remove_all (g);
12606     if (r == -1)
12607       return -1;
12608   }
12609   {
12610     char device[] = "/dev/sda";
12611     device[5] = devchar;
12612     char lines_0[] = ",";
12613     char *lines[] = {
12614       lines_0,
12615       NULL
12616     };
12617     int r;
12618     suppress_error = 0;
12619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12620     if (r == -1)
12621       return -1;
12622   }
12623   {
12624     char fstype[] = "ext2";
12625     char device[] = "/dev/sda1";
12626     device[5] = devchar;
12627     int r;
12628     suppress_error = 0;
12629     r = guestfs_mkfs (g, fstype, device);
12630     if (r == -1)
12631       return -1;
12632   }
12633   {
12634     char device[] = "/dev/sda1";
12635     device[5] = devchar;
12636     char mountpoint[] = "/";
12637     int r;
12638     suppress_error = 0;
12639     r = guestfs_mount (g, device, mountpoint);
12640     if (r == -1)
12641       return -1;
12642   }
12643   /* TestOutputTrue for exists (1) */
12644   {
12645     char path[] = "/new";
12646     int r;
12647     suppress_error = 0;
12648     r = guestfs_mkdir (g, path);
12649     if (r == -1)
12650       return -1;
12651   }
12652   {
12653     char path[] = "/new";
12654     int r;
12655     suppress_error = 0;
12656     r = guestfs_exists (g, path);
12657     if (r == -1)
12658       return -1;
12659     if (!r) {
12660       fprintf (stderr, "test_exists_1: expected true, got false\n");
12661       return -1;
12662     }
12663   }
12664   return 0;
12665 }
12666
12667 static int test_mkdir_p_0_skip (void)
12668 {
12669   const char *str;
12670
12671   str = getenv ("SKIP_TEST_MKDIR_P_0");
12672   if (str && strcmp (str, "1") == 0) return 1;
12673   str = getenv ("SKIP_TEST_MKDIR_P");
12674   if (str && strcmp (str, "1") == 0) return 1;
12675   return 0;
12676 }
12677
12678 static int test_mkdir_p_0 (void)
12679 {
12680   if (test_mkdir_p_0_skip ()) {
12681     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12682     return 0;
12683   }
12684
12685   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12686   {
12687     char device[] = "/dev/sda";
12688     device[5] = devchar;
12689     int r;
12690     suppress_error = 0;
12691     r = guestfs_blockdev_setrw (g, device);
12692     if (r == -1)
12693       return -1;
12694   }
12695   {
12696     int r;
12697     suppress_error = 0;
12698     r = guestfs_umount_all (g);
12699     if (r == -1)
12700       return -1;
12701   }
12702   {
12703     int r;
12704     suppress_error = 0;
12705     r = guestfs_lvm_remove_all (g);
12706     if (r == -1)
12707       return -1;
12708   }
12709   {
12710     char device[] = "/dev/sda";
12711     device[5] = devchar;
12712     char lines_0[] = ",";
12713     char *lines[] = {
12714       lines_0,
12715       NULL
12716     };
12717     int r;
12718     suppress_error = 0;
12719     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12720     if (r == -1)
12721       return -1;
12722   }
12723   {
12724     char fstype[] = "ext2";
12725     char device[] = "/dev/sda1";
12726     device[5] = devchar;
12727     int r;
12728     suppress_error = 0;
12729     r = guestfs_mkfs (g, fstype, device);
12730     if (r == -1)
12731       return -1;
12732   }
12733   {
12734     char device[] = "/dev/sda1";
12735     device[5] = devchar;
12736     char mountpoint[] = "/";
12737     int r;
12738     suppress_error = 0;
12739     r = guestfs_mount (g, device, mountpoint);
12740     if (r == -1)
12741       return -1;
12742   }
12743   /* TestOutputTrue for mkdir_p (0) */
12744   {
12745     char path[] = "/new/foo/bar";
12746     int r;
12747     suppress_error = 0;
12748     r = guestfs_mkdir_p (g, path);
12749     if (r == -1)
12750       return -1;
12751   }
12752   {
12753     char path[] = "/new/foo/bar";
12754     int r;
12755     suppress_error = 0;
12756     r = guestfs_is_dir (g, path);
12757     if (r == -1)
12758       return -1;
12759     if (!r) {
12760       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12761       return -1;
12762     }
12763   }
12764   return 0;
12765 }
12766
12767 static int test_mkdir_p_1_skip (void)
12768 {
12769   const char *str;
12770
12771   str = getenv ("SKIP_TEST_MKDIR_P_1");
12772   if (str && strcmp (str, "1") == 0) return 1;
12773   str = getenv ("SKIP_TEST_MKDIR_P");
12774   if (str && strcmp (str, "1") == 0) return 1;
12775   return 0;
12776 }
12777
12778 static int test_mkdir_p_1 (void)
12779 {
12780   if (test_mkdir_p_1_skip ()) {
12781     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12782     return 0;
12783   }
12784
12785   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12786   {
12787     char device[] = "/dev/sda";
12788     device[5] = devchar;
12789     int r;
12790     suppress_error = 0;
12791     r = guestfs_blockdev_setrw (g, device);
12792     if (r == -1)
12793       return -1;
12794   }
12795   {
12796     int r;
12797     suppress_error = 0;
12798     r = guestfs_umount_all (g);
12799     if (r == -1)
12800       return -1;
12801   }
12802   {
12803     int r;
12804     suppress_error = 0;
12805     r = guestfs_lvm_remove_all (g);
12806     if (r == -1)
12807       return -1;
12808   }
12809   {
12810     char device[] = "/dev/sda";
12811     device[5] = devchar;
12812     char lines_0[] = ",";
12813     char *lines[] = {
12814       lines_0,
12815       NULL
12816     };
12817     int r;
12818     suppress_error = 0;
12819     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12820     if (r == -1)
12821       return -1;
12822   }
12823   {
12824     char fstype[] = "ext2";
12825     char device[] = "/dev/sda1";
12826     device[5] = devchar;
12827     int r;
12828     suppress_error = 0;
12829     r = guestfs_mkfs (g, fstype, device);
12830     if (r == -1)
12831       return -1;
12832   }
12833   {
12834     char device[] = "/dev/sda1";
12835     device[5] = devchar;
12836     char mountpoint[] = "/";
12837     int r;
12838     suppress_error = 0;
12839     r = guestfs_mount (g, device, mountpoint);
12840     if (r == -1)
12841       return -1;
12842   }
12843   /* TestOutputTrue for mkdir_p (1) */
12844   {
12845     char path[] = "/new/foo/bar";
12846     int r;
12847     suppress_error = 0;
12848     r = guestfs_mkdir_p (g, path);
12849     if (r == -1)
12850       return -1;
12851   }
12852   {
12853     char path[] = "/new/foo";
12854     int r;
12855     suppress_error = 0;
12856     r = guestfs_is_dir (g, path);
12857     if (r == -1)
12858       return -1;
12859     if (!r) {
12860       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12861       return -1;
12862     }
12863   }
12864   return 0;
12865 }
12866
12867 static int test_mkdir_p_2_skip (void)
12868 {
12869   const char *str;
12870
12871   str = getenv ("SKIP_TEST_MKDIR_P_2");
12872   if (str && strcmp (str, "1") == 0) return 1;
12873   str = getenv ("SKIP_TEST_MKDIR_P");
12874   if (str && strcmp (str, "1") == 0) return 1;
12875   return 0;
12876 }
12877
12878 static int test_mkdir_p_2 (void)
12879 {
12880   if (test_mkdir_p_2_skip ()) {
12881     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12882     return 0;
12883   }
12884
12885   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12886   {
12887     char device[] = "/dev/sda";
12888     device[5] = devchar;
12889     int r;
12890     suppress_error = 0;
12891     r = guestfs_blockdev_setrw (g, device);
12892     if (r == -1)
12893       return -1;
12894   }
12895   {
12896     int r;
12897     suppress_error = 0;
12898     r = guestfs_umount_all (g);
12899     if (r == -1)
12900       return -1;
12901   }
12902   {
12903     int r;
12904     suppress_error = 0;
12905     r = guestfs_lvm_remove_all (g);
12906     if (r == -1)
12907       return -1;
12908   }
12909   {
12910     char device[] = "/dev/sda";
12911     device[5] = devchar;
12912     char lines_0[] = ",";
12913     char *lines[] = {
12914       lines_0,
12915       NULL
12916     };
12917     int r;
12918     suppress_error = 0;
12919     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12920     if (r == -1)
12921       return -1;
12922   }
12923   {
12924     char fstype[] = "ext2";
12925     char device[] = "/dev/sda1";
12926     device[5] = devchar;
12927     int r;
12928     suppress_error = 0;
12929     r = guestfs_mkfs (g, fstype, device);
12930     if (r == -1)
12931       return -1;
12932   }
12933   {
12934     char device[] = "/dev/sda1";
12935     device[5] = devchar;
12936     char mountpoint[] = "/";
12937     int r;
12938     suppress_error = 0;
12939     r = guestfs_mount (g, device, mountpoint);
12940     if (r == -1)
12941       return -1;
12942   }
12943   /* TestOutputTrue for mkdir_p (2) */
12944   {
12945     char path[] = "/new/foo/bar";
12946     int r;
12947     suppress_error = 0;
12948     r = guestfs_mkdir_p (g, path);
12949     if (r == -1)
12950       return -1;
12951   }
12952   {
12953     char path[] = "/new";
12954     int r;
12955     suppress_error = 0;
12956     r = guestfs_is_dir (g, path);
12957     if (r == -1)
12958       return -1;
12959     if (!r) {
12960       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12961       return -1;
12962     }
12963   }
12964   return 0;
12965 }
12966
12967 static int test_mkdir_p_3_skip (void)
12968 {
12969   const char *str;
12970
12971   str = getenv ("SKIP_TEST_MKDIR_P_3");
12972   if (str && strcmp (str, "1") == 0) return 1;
12973   str = getenv ("SKIP_TEST_MKDIR_P");
12974   if (str && strcmp (str, "1") == 0) return 1;
12975   return 0;
12976 }
12977
12978 static int test_mkdir_p_3 (void)
12979 {
12980   if (test_mkdir_p_3_skip ()) {
12981     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12982     return 0;
12983   }
12984
12985   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12986   {
12987     char device[] = "/dev/sda";
12988     device[5] = devchar;
12989     int r;
12990     suppress_error = 0;
12991     r = guestfs_blockdev_setrw (g, device);
12992     if (r == -1)
12993       return -1;
12994   }
12995   {
12996     int r;
12997     suppress_error = 0;
12998     r = guestfs_umount_all (g);
12999     if (r == -1)
13000       return -1;
13001   }
13002   {
13003     int r;
13004     suppress_error = 0;
13005     r = guestfs_lvm_remove_all (g);
13006     if (r == -1)
13007       return -1;
13008   }
13009   {
13010     char device[] = "/dev/sda";
13011     device[5] = devchar;
13012     char lines_0[] = ",";
13013     char *lines[] = {
13014       lines_0,
13015       NULL
13016     };
13017     int r;
13018     suppress_error = 0;
13019     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13020     if (r == -1)
13021       return -1;
13022   }
13023   {
13024     char fstype[] = "ext2";
13025     char device[] = "/dev/sda1";
13026     device[5] = devchar;
13027     int r;
13028     suppress_error = 0;
13029     r = guestfs_mkfs (g, fstype, device);
13030     if (r == -1)
13031       return -1;
13032   }
13033   {
13034     char device[] = "/dev/sda1";
13035     device[5] = devchar;
13036     char mountpoint[] = "/";
13037     int r;
13038     suppress_error = 0;
13039     r = guestfs_mount (g, device, mountpoint);
13040     if (r == -1)
13041       return -1;
13042   }
13043   /* TestRun for mkdir_p (3) */
13044   {
13045     char path[] = "/new";
13046     int r;
13047     suppress_error = 0;
13048     r = guestfs_mkdir (g, path);
13049     if (r == -1)
13050       return -1;
13051   }
13052   {
13053     char path[] = "/new";
13054     int r;
13055     suppress_error = 0;
13056     r = guestfs_mkdir_p (g, path);
13057     if (r == -1)
13058       return -1;
13059   }
13060   return 0;
13061 }
13062
13063 static int test_mkdir_p_4_skip (void)
13064 {
13065   const char *str;
13066
13067   str = getenv ("SKIP_TEST_MKDIR_P_4");
13068   if (str && strcmp (str, "1") == 0) return 1;
13069   str = getenv ("SKIP_TEST_MKDIR_P");
13070   if (str && strcmp (str, "1") == 0) return 1;
13071   return 0;
13072 }
13073
13074 static int test_mkdir_p_4 (void)
13075 {
13076   if (test_mkdir_p_4_skip ()) {
13077     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13078     return 0;
13079   }
13080
13081   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13082   {
13083     char device[] = "/dev/sda";
13084     device[5] = devchar;
13085     int r;
13086     suppress_error = 0;
13087     r = guestfs_blockdev_setrw (g, device);
13088     if (r == -1)
13089       return -1;
13090   }
13091   {
13092     int r;
13093     suppress_error = 0;
13094     r = guestfs_umount_all (g);
13095     if (r == -1)
13096       return -1;
13097   }
13098   {
13099     int r;
13100     suppress_error = 0;
13101     r = guestfs_lvm_remove_all (g);
13102     if (r == -1)
13103       return -1;
13104   }
13105   {
13106     char device[] = "/dev/sda";
13107     device[5] = devchar;
13108     char lines_0[] = ",";
13109     char *lines[] = {
13110       lines_0,
13111       NULL
13112     };
13113     int r;
13114     suppress_error = 0;
13115     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13116     if (r == -1)
13117       return -1;
13118   }
13119   {
13120     char fstype[] = "ext2";
13121     char device[] = "/dev/sda1";
13122     device[5] = devchar;
13123     int r;
13124     suppress_error = 0;
13125     r = guestfs_mkfs (g, fstype, device);
13126     if (r == -1)
13127       return -1;
13128   }
13129   {
13130     char device[] = "/dev/sda1";
13131     device[5] = devchar;
13132     char mountpoint[] = "/";
13133     int r;
13134     suppress_error = 0;
13135     r = guestfs_mount (g, device, mountpoint);
13136     if (r == -1)
13137       return -1;
13138   }
13139   /* TestLastFail for mkdir_p (4) */
13140   {
13141     char path[] = "/new";
13142     int r;
13143     suppress_error = 0;
13144     r = guestfs_touch (g, path);
13145     if (r == -1)
13146       return -1;
13147   }
13148   {
13149     char path[] = "/new";
13150     int r;
13151     suppress_error = 1;
13152     r = guestfs_mkdir_p (g, path);
13153     if (r != -1)
13154       return -1;
13155   }
13156   return 0;
13157 }
13158
13159 static int test_mkdir_0_skip (void)
13160 {
13161   const char *str;
13162
13163   str = getenv ("SKIP_TEST_MKDIR_0");
13164   if (str && strcmp (str, "1") == 0) return 1;
13165   str = getenv ("SKIP_TEST_MKDIR");
13166   if (str && strcmp (str, "1") == 0) return 1;
13167   return 0;
13168 }
13169
13170 static int test_mkdir_0 (void)
13171 {
13172   if (test_mkdir_0_skip ()) {
13173     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13174     return 0;
13175   }
13176
13177   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13178   {
13179     char device[] = "/dev/sda";
13180     device[5] = devchar;
13181     int r;
13182     suppress_error = 0;
13183     r = guestfs_blockdev_setrw (g, device);
13184     if (r == -1)
13185       return -1;
13186   }
13187   {
13188     int r;
13189     suppress_error = 0;
13190     r = guestfs_umount_all (g);
13191     if (r == -1)
13192       return -1;
13193   }
13194   {
13195     int r;
13196     suppress_error = 0;
13197     r = guestfs_lvm_remove_all (g);
13198     if (r == -1)
13199       return -1;
13200   }
13201   {
13202     char device[] = "/dev/sda";
13203     device[5] = devchar;
13204     char lines_0[] = ",";
13205     char *lines[] = {
13206       lines_0,
13207       NULL
13208     };
13209     int r;
13210     suppress_error = 0;
13211     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13212     if (r == -1)
13213       return -1;
13214   }
13215   {
13216     char fstype[] = "ext2";
13217     char device[] = "/dev/sda1";
13218     device[5] = devchar;
13219     int r;
13220     suppress_error = 0;
13221     r = guestfs_mkfs (g, fstype, device);
13222     if (r == -1)
13223       return -1;
13224   }
13225   {
13226     char device[] = "/dev/sda1";
13227     device[5] = devchar;
13228     char mountpoint[] = "/";
13229     int r;
13230     suppress_error = 0;
13231     r = guestfs_mount (g, device, mountpoint);
13232     if (r == -1)
13233       return -1;
13234   }
13235   /* TestOutputTrue for mkdir (0) */
13236   {
13237     char path[] = "/new";
13238     int r;
13239     suppress_error = 0;
13240     r = guestfs_mkdir (g, path);
13241     if (r == -1)
13242       return -1;
13243   }
13244   {
13245     char path[] = "/new";
13246     int r;
13247     suppress_error = 0;
13248     r = guestfs_is_dir (g, path);
13249     if (r == -1)
13250       return -1;
13251     if (!r) {
13252       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13253       return -1;
13254     }
13255   }
13256   return 0;
13257 }
13258
13259 static int test_mkdir_1_skip (void)
13260 {
13261   const char *str;
13262
13263   str = getenv ("SKIP_TEST_MKDIR_1");
13264   if (str && strcmp (str, "1") == 0) return 1;
13265   str = getenv ("SKIP_TEST_MKDIR");
13266   if (str && strcmp (str, "1") == 0) return 1;
13267   return 0;
13268 }
13269
13270 static int test_mkdir_1 (void)
13271 {
13272   if (test_mkdir_1_skip ()) {
13273     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13274     return 0;
13275   }
13276
13277   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13278   {
13279     char device[] = "/dev/sda";
13280     device[5] = devchar;
13281     int r;
13282     suppress_error = 0;
13283     r = guestfs_blockdev_setrw (g, device);
13284     if (r == -1)
13285       return -1;
13286   }
13287   {
13288     int r;
13289     suppress_error = 0;
13290     r = guestfs_umount_all (g);
13291     if (r == -1)
13292       return -1;
13293   }
13294   {
13295     int r;
13296     suppress_error = 0;
13297     r = guestfs_lvm_remove_all (g);
13298     if (r == -1)
13299       return -1;
13300   }
13301   {
13302     char device[] = "/dev/sda";
13303     device[5] = devchar;
13304     char lines_0[] = ",";
13305     char *lines[] = {
13306       lines_0,
13307       NULL
13308     };
13309     int r;
13310     suppress_error = 0;
13311     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13312     if (r == -1)
13313       return -1;
13314   }
13315   {
13316     char fstype[] = "ext2";
13317     char device[] = "/dev/sda1";
13318     device[5] = devchar;
13319     int r;
13320     suppress_error = 0;
13321     r = guestfs_mkfs (g, fstype, device);
13322     if (r == -1)
13323       return -1;
13324   }
13325   {
13326     char device[] = "/dev/sda1";
13327     device[5] = devchar;
13328     char mountpoint[] = "/";
13329     int r;
13330     suppress_error = 0;
13331     r = guestfs_mount (g, device, mountpoint);
13332     if (r == -1)
13333       return -1;
13334   }
13335   /* TestLastFail for mkdir (1) */
13336   {
13337     char path[] = "/new/foo/bar";
13338     int r;
13339     suppress_error = 1;
13340     r = guestfs_mkdir (g, path);
13341     if (r != -1)
13342       return -1;
13343   }
13344   return 0;
13345 }
13346
13347 static int test_rm_rf_0_skip (void)
13348 {
13349   const char *str;
13350
13351   str = getenv ("SKIP_TEST_RM_RF_0");
13352   if (str && strcmp (str, "1") == 0) return 1;
13353   str = getenv ("SKIP_TEST_RM_RF");
13354   if (str && strcmp (str, "1") == 0) return 1;
13355   return 0;
13356 }
13357
13358 static int test_rm_rf_0 (void)
13359 {
13360   if (test_rm_rf_0_skip ()) {
13361     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13362     return 0;
13363   }
13364
13365   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13366   {
13367     char device[] = "/dev/sda";
13368     device[5] = devchar;
13369     int r;
13370     suppress_error = 0;
13371     r = guestfs_blockdev_setrw (g, device);
13372     if (r == -1)
13373       return -1;
13374   }
13375   {
13376     int r;
13377     suppress_error = 0;
13378     r = guestfs_umount_all (g);
13379     if (r == -1)
13380       return -1;
13381   }
13382   {
13383     int r;
13384     suppress_error = 0;
13385     r = guestfs_lvm_remove_all (g);
13386     if (r == -1)
13387       return -1;
13388   }
13389   {
13390     char device[] = "/dev/sda";
13391     device[5] = devchar;
13392     char lines_0[] = ",";
13393     char *lines[] = {
13394       lines_0,
13395       NULL
13396     };
13397     int r;
13398     suppress_error = 0;
13399     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13400     if (r == -1)
13401       return -1;
13402   }
13403   {
13404     char fstype[] = "ext2";
13405     char device[] = "/dev/sda1";
13406     device[5] = devchar;
13407     int r;
13408     suppress_error = 0;
13409     r = guestfs_mkfs (g, fstype, device);
13410     if (r == -1)
13411       return -1;
13412   }
13413   {
13414     char device[] = "/dev/sda1";
13415     device[5] = devchar;
13416     char mountpoint[] = "/";
13417     int r;
13418     suppress_error = 0;
13419     r = guestfs_mount (g, device, mountpoint);
13420     if (r == -1)
13421       return -1;
13422   }
13423   /* TestOutputFalse for rm_rf (0) */
13424   {
13425     char path[] = "/new";
13426     int r;
13427     suppress_error = 0;
13428     r = guestfs_mkdir (g, path);
13429     if (r == -1)
13430       return -1;
13431   }
13432   {
13433     char path[] = "/new/foo";
13434     int r;
13435     suppress_error = 0;
13436     r = guestfs_mkdir (g, path);
13437     if (r == -1)
13438       return -1;
13439   }
13440   {
13441     char path[] = "/new/foo/bar";
13442     int r;
13443     suppress_error = 0;
13444     r = guestfs_touch (g, path);
13445     if (r == -1)
13446       return -1;
13447   }
13448   {
13449     char path[] = "/new";
13450     int r;
13451     suppress_error = 0;
13452     r = guestfs_rm_rf (g, path);
13453     if (r == -1)
13454       return -1;
13455   }
13456   {
13457     char path[] = "/new";
13458     int r;
13459     suppress_error = 0;
13460     r = guestfs_exists (g, path);
13461     if (r == -1)
13462       return -1;
13463     if (r) {
13464       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13465       return -1;
13466     }
13467   }
13468   return 0;
13469 }
13470
13471 static int test_rmdir_0_skip (void)
13472 {
13473   const char *str;
13474
13475   str = getenv ("SKIP_TEST_RMDIR_0");
13476   if (str && strcmp (str, "1") == 0) return 1;
13477   str = getenv ("SKIP_TEST_RMDIR");
13478   if (str && strcmp (str, "1") == 0) return 1;
13479   return 0;
13480 }
13481
13482 static int test_rmdir_0 (void)
13483 {
13484   if (test_rmdir_0_skip ()) {
13485     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13486     return 0;
13487   }
13488
13489   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13490   {
13491     char device[] = "/dev/sda";
13492     device[5] = devchar;
13493     int r;
13494     suppress_error = 0;
13495     r = guestfs_blockdev_setrw (g, device);
13496     if (r == -1)
13497       return -1;
13498   }
13499   {
13500     int r;
13501     suppress_error = 0;
13502     r = guestfs_umount_all (g);
13503     if (r == -1)
13504       return -1;
13505   }
13506   {
13507     int r;
13508     suppress_error = 0;
13509     r = guestfs_lvm_remove_all (g);
13510     if (r == -1)
13511       return -1;
13512   }
13513   {
13514     char device[] = "/dev/sda";
13515     device[5] = devchar;
13516     char lines_0[] = ",";
13517     char *lines[] = {
13518       lines_0,
13519       NULL
13520     };
13521     int r;
13522     suppress_error = 0;
13523     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13524     if (r == -1)
13525       return -1;
13526   }
13527   {
13528     char fstype[] = "ext2";
13529     char device[] = "/dev/sda1";
13530     device[5] = devchar;
13531     int r;
13532     suppress_error = 0;
13533     r = guestfs_mkfs (g, fstype, device);
13534     if (r == -1)
13535       return -1;
13536   }
13537   {
13538     char device[] = "/dev/sda1";
13539     device[5] = devchar;
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   /* TestRun for rmdir (0) */
13548   {
13549     char path[] = "/new";
13550     int r;
13551     suppress_error = 0;
13552     r = guestfs_mkdir (g, path);
13553     if (r == -1)
13554       return -1;
13555   }
13556   {
13557     char path[] = "/new";
13558     int r;
13559     suppress_error = 0;
13560     r = guestfs_rmdir (g, path);
13561     if (r == -1)
13562       return -1;
13563   }
13564   return 0;
13565 }
13566
13567 static int test_rmdir_1_skip (void)
13568 {
13569   const char *str;
13570
13571   str = getenv ("SKIP_TEST_RMDIR_1");
13572   if (str && strcmp (str, "1") == 0) return 1;
13573   str = getenv ("SKIP_TEST_RMDIR");
13574   if (str && strcmp (str, "1") == 0) return 1;
13575   return 0;
13576 }
13577
13578 static int test_rmdir_1 (void)
13579 {
13580   if (test_rmdir_1_skip ()) {
13581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13582     return 0;
13583   }
13584
13585   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13586   {
13587     char device[] = "/dev/sda";
13588     device[5] = devchar;
13589     int r;
13590     suppress_error = 0;
13591     r = guestfs_blockdev_setrw (g, device);
13592     if (r == -1)
13593       return -1;
13594   }
13595   {
13596     int r;
13597     suppress_error = 0;
13598     r = guestfs_umount_all (g);
13599     if (r == -1)
13600       return -1;
13601   }
13602   {
13603     int r;
13604     suppress_error = 0;
13605     r = guestfs_lvm_remove_all (g);
13606     if (r == -1)
13607       return -1;
13608   }
13609   {
13610     char device[] = "/dev/sda";
13611     device[5] = devchar;
13612     char lines_0[] = ",";
13613     char *lines[] = {
13614       lines_0,
13615       NULL
13616     };
13617     int r;
13618     suppress_error = 0;
13619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13620     if (r == -1)
13621       return -1;
13622   }
13623   {
13624     char fstype[] = "ext2";
13625     char device[] = "/dev/sda1";
13626     device[5] = devchar;
13627     int r;
13628     suppress_error = 0;
13629     r = guestfs_mkfs (g, fstype, device);
13630     if (r == -1)
13631       return -1;
13632   }
13633   {
13634     char device[] = "/dev/sda1";
13635     device[5] = devchar;
13636     char mountpoint[] = "/";
13637     int r;
13638     suppress_error = 0;
13639     r = guestfs_mount (g, device, mountpoint);
13640     if (r == -1)
13641       return -1;
13642   }
13643   /* TestLastFail for rmdir (1) */
13644   {
13645     char path[] = "/new";
13646     int r;
13647     suppress_error = 1;
13648     r = guestfs_rmdir (g, path);
13649     if (r != -1)
13650       return -1;
13651   }
13652   return 0;
13653 }
13654
13655 static int test_rmdir_2_skip (void)
13656 {
13657   const char *str;
13658
13659   str = getenv ("SKIP_TEST_RMDIR_2");
13660   if (str && strcmp (str, "1") == 0) return 1;
13661   str = getenv ("SKIP_TEST_RMDIR");
13662   if (str && strcmp (str, "1") == 0) return 1;
13663   return 0;
13664 }
13665
13666 static int test_rmdir_2 (void)
13667 {
13668   if (test_rmdir_2_skip ()) {
13669     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13670     return 0;
13671   }
13672
13673   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13674   {
13675     char device[] = "/dev/sda";
13676     device[5] = devchar;
13677     int r;
13678     suppress_error = 0;
13679     r = guestfs_blockdev_setrw (g, device);
13680     if (r == -1)
13681       return -1;
13682   }
13683   {
13684     int r;
13685     suppress_error = 0;
13686     r = guestfs_umount_all (g);
13687     if (r == -1)
13688       return -1;
13689   }
13690   {
13691     int r;
13692     suppress_error = 0;
13693     r = guestfs_lvm_remove_all (g);
13694     if (r == -1)
13695       return -1;
13696   }
13697   {
13698     char device[] = "/dev/sda";
13699     device[5] = devchar;
13700     char lines_0[] = ",";
13701     char *lines[] = {
13702       lines_0,
13703       NULL
13704     };
13705     int r;
13706     suppress_error = 0;
13707     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13708     if (r == -1)
13709       return -1;
13710   }
13711   {
13712     char fstype[] = "ext2";
13713     char device[] = "/dev/sda1";
13714     device[5] = devchar;
13715     int r;
13716     suppress_error = 0;
13717     r = guestfs_mkfs (g, fstype, device);
13718     if (r == -1)
13719       return -1;
13720   }
13721   {
13722     char device[] = "/dev/sda1";
13723     device[5] = devchar;
13724     char mountpoint[] = "/";
13725     int r;
13726     suppress_error = 0;
13727     r = guestfs_mount (g, device, mountpoint);
13728     if (r == -1)
13729       return -1;
13730   }
13731   /* TestLastFail for rmdir (2) */
13732   {
13733     char path[] = "/new";
13734     int r;
13735     suppress_error = 0;
13736     r = guestfs_touch (g, path);
13737     if (r == -1)
13738       return -1;
13739   }
13740   {
13741     char path[] = "/new";
13742     int r;
13743     suppress_error = 1;
13744     r = guestfs_rmdir (g, path);
13745     if (r != -1)
13746       return -1;
13747   }
13748   return 0;
13749 }
13750
13751 static int test_rm_0_skip (void)
13752 {
13753   const char *str;
13754
13755   str = getenv ("SKIP_TEST_RM_0");
13756   if (str && strcmp (str, "1") == 0) return 1;
13757   str = getenv ("SKIP_TEST_RM");
13758   if (str && strcmp (str, "1") == 0) return 1;
13759   return 0;
13760 }
13761
13762 static int test_rm_0 (void)
13763 {
13764   if (test_rm_0_skip ()) {
13765     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13766     return 0;
13767   }
13768
13769   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13770   {
13771     char device[] = "/dev/sda";
13772     device[5] = devchar;
13773     int r;
13774     suppress_error = 0;
13775     r = guestfs_blockdev_setrw (g, device);
13776     if (r == -1)
13777       return -1;
13778   }
13779   {
13780     int r;
13781     suppress_error = 0;
13782     r = guestfs_umount_all (g);
13783     if (r == -1)
13784       return -1;
13785   }
13786   {
13787     int r;
13788     suppress_error = 0;
13789     r = guestfs_lvm_remove_all (g);
13790     if (r == -1)
13791       return -1;
13792   }
13793   {
13794     char device[] = "/dev/sda";
13795     device[5] = devchar;
13796     char lines_0[] = ",";
13797     char *lines[] = {
13798       lines_0,
13799       NULL
13800     };
13801     int r;
13802     suppress_error = 0;
13803     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13804     if (r == -1)
13805       return -1;
13806   }
13807   {
13808     char fstype[] = "ext2";
13809     char device[] = "/dev/sda1";
13810     device[5] = devchar;
13811     int r;
13812     suppress_error = 0;
13813     r = guestfs_mkfs (g, fstype, device);
13814     if (r == -1)
13815       return -1;
13816   }
13817   {
13818     char device[] = "/dev/sda1";
13819     device[5] = devchar;
13820     char mountpoint[] = "/";
13821     int r;
13822     suppress_error = 0;
13823     r = guestfs_mount (g, device, mountpoint);
13824     if (r == -1)
13825       return -1;
13826   }
13827   /* TestRun for rm (0) */
13828   {
13829     char path[] = "/new";
13830     int r;
13831     suppress_error = 0;
13832     r = guestfs_touch (g, path);
13833     if (r == -1)
13834       return -1;
13835   }
13836   {
13837     char path[] = "/new";
13838     int r;
13839     suppress_error = 0;
13840     r = guestfs_rm (g, path);
13841     if (r == -1)
13842       return -1;
13843   }
13844   return 0;
13845 }
13846
13847 static int test_rm_1_skip (void)
13848 {
13849   const char *str;
13850
13851   str = getenv ("SKIP_TEST_RM_1");
13852   if (str && strcmp (str, "1") == 0) return 1;
13853   str = getenv ("SKIP_TEST_RM");
13854   if (str && strcmp (str, "1") == 0) return 1;
13855   return 0;
13856 }
13857
13858 static int test_rm_1 (void)
13859 {
13860   if (test_rm_1_skip ()) {
13861     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13862     return 0;
13863   }
13864
13865   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13866   {
13867     char device[] = "/dev/sda";
13868     device[5] = devchar;
13869     int r;
13870     suppress_error = 0;
13871     r = guestfs_blockdev_setrw (g, device);
13872     if (r == -1)
13873       return -1;
13874   }
13875   {
13876     int r;
13877     suppress_error = 0;
13878     r = guestfs_umount_all (g);
13879     if (r == -1)
13880       return -1;
13881   }
13882   {
13883     int r;
13884     suppress_error = 0;
13885     r = guestfs_lvm_remove_all (g);
13886     if (r == -1)
13887       return -1;
13888   }
13889   {
13890     char device[] = "/dev/sda";
13891     device[5] = devchar;
13892     char lines_0[] = ",";
13893     char *lines[] = {
13894       lines_0,
13895       NULL
13896     };
13897     int r;
13898     suppress_error = 0;
13899     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13900     if (r == -1)
13901       return -1;
13902   }
13903   {
13904     char fstype[] = "ext2";
13905     char device[] = "/dev/sda1";
13906     device[5] = devchar;
13907     int r;
13908     suppress_error = 0;
13909     r = guestfs_mkfs (g, fstype, device);
13910     if (r == -1)
13911       return -1;
13912   }
13913   {
13914     char device[] = "/dev/sda1";
13915     device[5] = devchar;
13916     char mountpoint[] = "/";
13917     int r;
13918     suppress_error = 0;
13919     r = guestfs_mount (g, device, mountpoint);
13920     if (r == -1)
13921       return -1;
13922   }
13923   /* TestLastFail for rm (1) */
13924   {
13925     char path[] = "/new";
13926     int r;
13927     suppress_error = 1;
13928     r = guestfs_rm (g, path);
13929     if (r != -1)
13930       return -1;
13931   }
13932   return 0;
13933 }
13934
13935 static int test_rm_2_skip (void)
13936 {
13937   const char *str;
13938
13939   str = getenv ("SKIP_TEST_RM_2");
13940   if (str && strcmp (str, "1") == 0) return 1;
13941   str = getenv ("SKIP_TEST_RM");
13942   if (str && strcmp (str, "1") == 0) return 1;
13943   return 0;
13944 }
13945
13946 static int test_rm_2 (void)
13947 {
13948   if (test_rm_2_skip ()) {
13949     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13950     return 0;
13951   }
13952
13953   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13954   {
13955     char device[] = "/dev/sda";
13956     device[5] = devchar;
13957     int r;
13958     suppress_error = 0;
13959     r = guestfs_blockdev_setrw (g, device);
13960     if (r == -1)
13961       return -1;
13962   }
13963   {
13964     int r;
13965     suppress_error = 0;
13966     r = guestfs_umount_all (g);
13967     if (r == -1)
13968       return -1;
13969   }
13970   {
13971     int r;
13972     suppress_error = 0;
13973     r = guestfs_lvm_remove_all (g);
13974     if (r == -1)
13975       return -1;
13976   }
13977   {
13978     char device[] = "/dev/sda";
13979     device[5] = devchar;
13980     char lines_0[] = ",";
13981     char *lines[] = {
13982       lines_0,
13983       NULL
13984     };
13985     int r;
13986     suppress_error = 0;
13987     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13988     if (r == -1)
13989       return -1;
13990   }
13991   {
13992     char fstype[] = "ext2";
13993     char device[] = "/dev/sda1";
13994     device[5] = devchar;
13995     int r;
13996     suppress_error = 0;
13997     r = guestfs_mkfs (g, fstype, device);
13998     if (r == -1)
13999       return -1;
14000   }
14001   {
14002     char device[] = "/dev/sda1";
14003     device[5] = devchar;
14004     char mountpoint[] = "/";
14005     int r;
14006     suppress_error = 0;
14007     r = guestfs_mount (g, device, mountpoint);
14008     if (r == -1)
14009       return -1;
14010   }
14011   /* TestLastFail for rm (2) */
14012   {
14013     char path[] = "/new";
14014     int r;
14015     suppress_error = 0;
14016     r = guestfs_mkdir (g, path);
14017     if (r == -1)
14018       return -1;
14019   }
14020   {
14021     char path[] = "/new";
14022     int r;
14023     suppress_error = 1;
14024     r = guestfs_rm (g, path);
14025     if (r != -1)
14026       return -1;
14027   }
14028   return 0;
14029 }
14030
14031 static int test_read_lines_0_skip (void)
14032 {
14033   const char *str;
14034
14035   str = getenv ("SKIP_TEST_READ_LINES_0");
14036   if (str && strcmp (str, "1") == 0) return 1;
14037   str = getenv ("SKIP_TEST_READ_LINES");
14038   if (str && strcmp (str, "1") == 0) return 1;
14039   return 0;
14040 }
14041
14042 static int test_read_lines_0 (void)
14043 {
14044   if (test_read_lines_0_skip ()) {
14045     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14046     return 0;
14047   }
14048
14049   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14050   {
14051     char device[] = "/dev/sda";
14052     device[5] = devchar;
14053     int r;
14054     suppress_error = 0;
14055     r = guestfs_blockdev_setrw (g, device);
14056     if (r == -1)
14057       return -1;
14058   }
14059   {
14060     int r;
14061     suppress_error = 0;
14062     r = guestfs_umount_all (g);
14063     if (r == -1)
14064       return -1;
14065   }
14066   {
14067     int r;
14068     suppress_error = 0;
14069     r = guestfs_lvm_remove_all (g);
14070     if (r == -1)
14071       return -1;
14072   }
14073   {
14074     char device[] = "/dev/sda";
14075     device[5] = devchar;
14076     char lines_0[] = ",";
14077     char *lines[] = {
14078       lines_0,
14079       NULL
14080     };
14081     int r;
14082     suppress_error = 0;
14083     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14084     if (r == -1)
14085       return -1;
14086   }
14087   {
14088     char fstype[] = "ext2";
14089     char device[] = "/dev/sda1";
14090     device[5] = devchar;
14091     int r;
14092     suppress_error = 0;
14093     r = guestfs_mkfs (g, fstype, device);
14094     if (r == -1)
14095       return -1;
14096   }
14097   {
14098     char device[] = "/dev/sda1";
14099     device[5] = devchar;
14100     char mountpoint[] = "/";
14101     int r;
14102     suppress_error = 0;
14103     r = guestfs_mount (g, device, mountpoint);
14104     if (r == -1)
14105       return -1;
14106   }
14107   /* TestOutputList for read_lines (0) */
14108   {
14109     char path[] = "/new";
14110     char content[] = "line1\r\nline2\nline3";
14111     int r;
14112     suppress_error = 0;
14113     r = guestfs_write_file (g, path, content, 0);
14114     if (r == -1)
14115       return -1;
14116   }
14117   {
14118     char path[] = "/new";
14119     char **r;
14120     int i;
14121     suppress_error = 0;
14122     r = guestfs_read_lines (g, path);
14123     if (r == NULL)
14124       return -1;
14125     if (!r[0]) {
14126       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14127       print_strings (r);
14128       return -1;
14129     }
14130     {
14131       char expected[] = "line1";
14132       if (strcmp (r[0], expected) != 0) {
14133         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14134         return -1;
14135       }
14136     }
14137     if (!r[1]) {
14138       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14139       print_strings (r);
14140       return -1;
14141     }
14142     {
14143       char expected[] = "line2";
14144       if (strcmp (r[1], expected) != 0) {
14145         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14146         return -1;
14147       }
14148     }
14149     if (!r[2]) {
14150       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14151       print_strings (r);
14152       return -1;
14153     }
14154     {
14155       char expected[] = "line3";
14156       if (strcmp (r[2], expected) != 0) {
14157         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14158         return -1;
14159       }
14160     }
14161     if (r[3] != NULL) {
14162       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14163       print_strings (r);
14164       return -1;
14165     }
14166     for (i = 0; r[i] != NULL; ++i)
14167       free (r[i]);
14168     free (r);
14169   }
14170   return 0;
14171 }
14172
14173 static int test_read_lines_1_skip (void)
14174 {
14175   const char *str;
14176
14177   str = getenv ("SKIP_TEST_READ_LINES_1");
14178   if (str && strcmp (str, "1") == 0) return 1;
14179   str = getenv ("SKIP_TEST_READ_LINES");
14180   if (str && strcmp (str, "1") == 0) return 1;
14181   return 0;
14182 }
14183
14184 static int test_read_lines_1 (void)
14185 {
14186   if (test_read_lines_1_skip ()) {
14187     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14188     return 0;
14189   }
14190
14191   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14192   {
14193     char device[] = "/dev/sda";
14194     device[5] = devchar;
14195     int r;
14196     suppress_error = 0;
14197     r = guestfs_blockdev_setrw (g, device);
14198     if (r == -1)
14199       return -1;
14200   }
14201   {
14202     int r;
14203     suppress_error = 0;
14204     r = guestfs_umount_all (g);
14205     if (r == -1)
14206       return -1;
14207   }
14208   {
14209     int r;
14210     suppress_error = 0;
14211     r = guestfs_lvm_remove_all (g);
14212     if (r == -1)
14213       return -1;
14214   }
14215   {
14216     char device[] = "/dev/sda";
14217     device[5] = devchar;
14218     char lines_0[] = ",";
14219     char *lines[] = {
14220       lines_0,
14221       NULL
14222     };
14223     int r;
14224     suppress_error = 0;
14225     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14226     if (r == -1)
14227       return -1;
14228   }
14229   {
14230     char fstype[] = "ext2";
14231     char device[] = "/dev/sda1";
14232     device[5] = devchar;
14233     int r;
14234     suppress_error = 0;
14235     r = guestfs_mkfs (g, fstype, device);
14236     if (r == -1)
14237       return -1;
14238   }
14239   {
14240     char device[] = "/dev/sda1";
14241     device[5] = devchar;
14242     char mountpoint[] = "/";
14243     int r;
14244     suppress_error = 0;
14245     r = guestfs_mount (g, device, mountpoint);
14246     if (r == -1)
14247       return -1;
14248   }
14249   /* TestOutputList for read_lines (1) */
14250   {
14251     char path[] = "/new";
14252     char content[] = "";
14253     int r;
14254     suppress_error = 0;
14255     r = guestfs_write_file (g, path, content, 0);
14256     if (r == -1)
14257       return -1;
14258   }
14259   {
14260     char path[] = "/new";
14261     char **r;
14262     int i;
14263     suppress_error = 0;
14264     r = guestfs_read_lines (g, path);
14265     if (r == NULL)
14266       return -1;
14267     if (r[0] != NULL) {
14268       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14269       print_strings (r);
14270       return -1;
14271     }
14272     for (i = 0; r[i] != NULL; ++i)
14273       free (r[i]);
14274     free (r);
14275   }
14276   return 0;
14277 }
14278
14279 static int test_lvs_0_skip (void)
14280 {
14281   const char *str;
14282
14283   str = getenv ("SKIP_TEST_LVS_0");
14284   if (str && strcmp (str, "1") == 0) return 1;
14285   str = getenv ("SKIP_TEST_LVS");
14286   if (str && strcmp (str, "1") == 0) return 1;
14287   return 0;
14288 }
14289
14290 static int test_lvs_0 (void)
14291 {
14292   if (test_lvs_0_skip ()) {
14293     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14294     return 0;
14295   }
14296
14297   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14298   {
14299     char device[] = "/dev/sda";
14300     device[5] = devchar;
14301     int r;
14302     suppress_error = 0;
14303     r = guestfs_blockdev_setrw (g, device);
14304     if (r == -1)
14305       return -1;
14306   }
14307   {
14308     int r;
14309     suppress_error = 0;
14310     r = guestfs_umount_all (g);
14311     if (r == -1)
14312       return -1;
14313   }
14314   {
14315     int r;
14316     suppress_error = 0;
14317     r = guestfs_lvm_remove_all (g);
14318     if (r == -1)
14319       return -1;
14320   }
14321   {
14322     char device[] = "/dev/sda";
14323     device[5] = devchar;
14324     char lines_0[] = ",";
14325     char *lines[] = {
14326       lines_0,
14327       NULL
14328     };
14329     int r;
14330     suppress_error = 0;
14331     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14332     if (r == -1)
14333       return -1;
14334   }
14335   {
14336     char device[] = "/dev/sda1";
14337     device[5] = devchar;
14338     int r;
14339     suppress_error = 0;
14340     r = guestfs_pvcreate (g, device);
14341     if (r == -1)
14342       return -1;
14343   }
14344   {
14345     char volgroup[] = "VG";
14346     char physvols_0[] = "/dev/sda1";
14347     physvols_0[5] = devchar;
14348     char *physvols[] = {
14349       physvols_0,
14350       NULL
14351     };
14352     int r;
14353     suppress_error = 0;
14354     r = guestfs_vgcreate (g, volgroup, physvols);
14355     if (r == -1)
14356       return -1;
14357   }
14358   {
14359     char logvol[] = "LV";
14360     char volgroup[] = "VG";
14361     int r;
14362     suppress_error = 0;
14363     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14364     if (r == -1)
14365       return -1;
14366   }
14367   {
14368     char fstype[] = "ext2";
14369     char device[] = "/dev/VG/LV";
14370     int r;
14371     suppress_error = 0;
14372     r = guestfs_mkfs (g, fstype, device);
14373     if (r == -1)
14374       return -1;
14375   }
14376   {
14377     char device[] = "/dev/VG/LV";
14378     char mountpoint[] = "/";
14379     int r;
14380     suppress_error = 0;
14381     r = guestfs_mount (g, device, mountpoint);
14382     if (r == -1)
14383       return -1;
14384   }
14385   /* TestOutputList for lvs (0) */
14386   {
14387     char **r;
14388     int i;
14389     suppress_error = 0;
14390     r = guestfs_lvs (g);
14391     if (r == NULL)
14392       return -1;
14393     if (!r[0]) {
14394       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14395       print_strings (r);
14396       return -1;
14397     }
14398     {
14399       char expected[] = "/dev/VG/LV";
14400       if (strcmp (r[0], expected) != 0) {
14401         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14402         return -1;
14403       }
14404     }
14405     if (r[1] != NULL) {
14406       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14407       print_strings (r);
14408       return -1;
14409     }
14410     for (i = 0; r[i] != NULL; ++i)
14411       free (r[i]);
14412     free (r);
14413   }
14414   return 0;
14415 }
14416
14417 static int test_lvs_1_skip (void)
14418 {
14419   const char *str;
14420
14421   str = getenv ("SKIP_TEST_LVS_1");
14422   if (str && strcmp (str, "1") == 0) return 1;
14423   str = getenv ("SKIP_TEST_LVS");
14424   if (str && strcmp (str, "1") == 0) return 1;
14425   return 0;
14426 }
14427
14428 static int test_lvs_1 (void)
14429 {
14430   if (test_lvs_1_skip ()) {
14431     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14432     return 0;
14433   }
14434
14435   /* InitNone|InitEmpty for test_lvs_1 */
14436   {
14437     char device[] = "/dev/sda";
14438     device[5] = devchar;
14439     int r;
14440     suppress_error = 0;
14441     r = guestfs_blockdev_setrw (g, device);
14442     if (r == -1)
14443       return -1;
14444   }
14445   {
14446     int r;
14447     suppress_error = 0;
14448     r = guestfs_umount_all (g);
14449     if (r == -1)
14450       return -1;
14451   }
14452   {
14453     int r;
14454     suppress_error = 0;
14455     r = guestfs_lvm_remove_all (g);
14456     if (r == -1)
14457       return -1;
14458   }
14459   /* TestOutputList for lvs (1) */
14460   {
14461     char device[] = "/dev/sda";
14462     device[5] = devchar;
14463     char lines_0[] = ",10";
14464     char lines_1[] = ",20";
14465     char lines_2[] = ",";
14466     char *lines[] = {
14467       lines_0,
14468       lines_1,
14469       lines_2,
14470       NULL
14471     };
14472     int r;
14473     suppress_error = 0;
14474     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14475     if (r == -1)
14476       return -1;
14477   }
14478   {
14479     char device[] = "/dev/sda1";
14480     device[5] = devchar;
14481     int r;
14482     suppress_error = 0;
14483     r = guestfs_pvcreate (g, device);
14484     if (r == -1)
14485       return -1;
14486   }
14487   {
14488     char device[] = "/dev/sda2";
14489     device[5] = devchar;
14490     int r;
14491     suppress_error = 0;
14492     r = guestfs_pvcreate (g, device);
14493     if (r == -1)
14494       return -1;
14495   }
14496   {
14497     char device[] = "/dev/sda3";
14498     device[5] = devchar;
14499     int r;
14500     suppress_error = 0;
14501     r = guestfs_pvcreate (g, device);
14502     if (r == -1)
14503       return -1;
14504   }
14505   {
14506     char volgroup[] = "VG1";
14507     char physvols_0[] = "/dev/sda1";
14508     physvols_0[5] = devchar;
14509     char physvols_1[] = "/dev/sda2";
14510     physvols_1[5] = devchar;
14511     char *physvols[] = {
14512       physvols_0,
14513       physvols_1,
14514       NULL
14515     };
14516     int r;
14517     suppress_error = 0;
14518     r = guestfs_vgcreate (g, volgroup, physvols);
14519     if (r == -1)
14520       return -1;
14521   }
14522   {
14523     char volgroup[] = "VG2";
14524     char physvols_0[] = "/dev/sda3";
14525     physvols_0[5] = devchar;
14526     char *physvols[] = {
14527       physvols_0,
14528       NULL
14529     };
14530     int r;
14531     suppress_error = 0;
14532     r = guestfs_vgcreate (g, volgroup, physvols);
14533     if (r == -1)
14534       return -1;
14535   }
14536   {
14537     char logvol[] = "LV1";
14538     char volgroup[] = "VG1";
14539     int r;
14540     suppress_error = 0;
14541     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14542     if (r == -1)
14543       return -1;
14544   }
14545   {
14546     char logvol[] = "LV2";
14547     char volgroup[] = "VG1";
14548     int r;
14549     suppress_error = 0;
14550     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14551     if (r == -1)
14552       return -1;
14553   }
14554   {
14555     char logvol[] = "LV3";
14556     char volgroup[] = "VG2";
14557     int r;
14558     suppress_error = 0;
14559     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14560     if (r == -1)
14561       return -1;
14562   }
14563   {
14564     char **r;
14565     int i;
14566     suppress_error = 0;
14567     r = guestfs_lvs (g);
14568     if (r == NULL)
14569       return -1;
14570     if (!r[0]) {
14571       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14572       print_strings (r);
14573       return -1;
14574     }
14575     {
14576       char expected[] = "/dev/VG1/LV1";
14577       if (strcmp (r[0], expected) != 0) {
14578         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14579         return -1;
14580       }
14581     }
14582     if (!r[1]) {
14583       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14584       print_strings (r);
14585       return -1;
14586     }
14587     {
14588       char expected[] = "/dev/VG1/LV2";
14589       if (strcmp (r[1], expected) != 0) {
14590         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14591         return -1;
14592       }
14593     }
14594     if (!r[2]) {
14595       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14596       print_strings (r);
14597       return -1;
14598     }
14599     {
14600       char expected[] = "/dev/VG2/LV3";
14601       if (strcmp (r[2], expected) != 0) {
14602         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14603         return -1;
14604       }
14605     }
14606     if (r[3] != NULL) {
14607       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14608       print_strings (r);
14609       return -1;
14610     }
14611     for (i = 0; r[i] != NULL; ++i)
14612       free (r[i]);
14613     free (r);
14614   }
14615   return 0;
14616 }
14617
14618 static int test_vgs_0_skip (void)
14619 {
14620   const char *str;
14621
14622   str = getenv ("SKIP_TEST_VGS_0");
14623   if (str && strcmp (str, "1") == 0) return 1;
14624   str = getenv ("SKIP_TEST_VGS");
14625   if (str && strcmp (str, "1") == 0) return 1;
14626   return 0;
14627 }
14628
14629 static int test_vgs_0 (void)
14630 {
14631   if (test_vgs_0_skip ()) {
14632     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14633     return 0;
14634   }
14635
14636   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14637   {
14638     char device[] = "/dev/sda";
14639     device[5] = devchar;
14640     int r;
14641     suppress_error = 0;
14642     r = guestfs_blockdev_setrw (g, device);
14643     if (r == -1)
14644       return -1;
14645   }
14646   {
14647     int r;
14648     suppress_error = 0;
14649     r = guestfs_umount_all (g);
14650     if (r == -1)
14651       return -1;
14652   }
14653   {
14654     int r;
14655     suppress_error = 0;
14656     r = guestfs_lvm_remove_all (g);
14657     if (r == -1)
14658       return -1;
14659   }
14660   {
14661     char device[] = "/dev/sda";
14662     device[5] = devchar;
14663     char lines_0[] = ",";
14664     char *lines[] = {
14665       lines_0,
14666       NULL
14667     };
14668     int r;
14669     suppress_error = 0;
14670     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14671     if (r == -1)
14672       return -1;
14673   }
14674   {
14675     char device[] = "/dev/sda1";
14676     device[5] = devchar;
14677     int r;
14678     suppress_error = 0;
14679     r = guestfs_pvcreate (g, device);
14680     if (r == -1)
14681       return -1;
14682   }
14683   {
14684     char volgroup[] = "VG";
14685     char physvols_0[] = "/dev/sda1";
14686     physvols_0[5] = devchar;
14687     char *physvols[] = {
14688       physvols_0,
14689       NULL
14690     };
14691     int r;
14692     suppress_error = 0;
14693     r = guestfs_vgcreate (g, volgroup, physvols);
14694     if (r == -1)
14695       return -1;
14696   }
14697   {
14698     char logvol[] = "LV";
14699     char volgroup[] = "VG";
14700     int r;
14701     suppress_error = 0;
14702     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14703     if (r == -1)
14704       return -1;
14705   }
14706   {
14707     char fstype[] = "ext2";
14708     char device[] = "/dev/VG/LV";
14709     int r;
14710     suppress_error = 0;
14711     r = guestfs_mkfs (g, fstype, device);
14712     if (r == -1)
14713       return -1;
14714   }
14715   {
14716     char device[] = "/dev/VG/LV";
14717     char mountpoint[] = "/";
14718     int r;
14719     suppress_error = 0;
14720     r = guestfs_mount (g, device, mountpoint);
14721     if (r == -1)
14722       return -1;
14723   }
14724   /* TestOutputList for vgs (0) */
14725   {
14726     char **r;
14727     int i;
14728     suppress_error = 0;
14729     r = guestfs_vgs (g);
14730     if (r == NULL)
14731       return -1;
14732     if (!r[0]) {
14733       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14734       print_strings (r);
14735       return -1;
14736     }
14737     {
14738       char expected[] = "VG";
14739       if (strcmp (r[0], expected) != 0) {
14740         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14741         return -1;
14742       }
14743     }
14744     if (r[1] != NULL) {
14745       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14746       print_strings (r);
14747       return -1;
14748     }
14749     for (i = 0; r[i] != NULL; ++i)
14750       free (r[i]);
14751     free (r);
14752   }
14753   return 0;
14754 }
14755
14756 static int test_vgs_1_skip (void)
14757 {
14758   const char *str;
14759
14760   str = getenv ("SKIP_TEST_VGS_1");
14761   if (str && strcmp (str, "1") == 0) return 1;
14762   str = getenv ("SKIP_TEST_VGS");
14763   if (str && strcmp (str, "1") == 0) return 1;
14764   return 0;
14765 }
14766
14767 static int test_vgs_1 (void)
14768 {
14769   if (test_vgs_1_skip ()) {
14770     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14771     return 0;
14772   }
14773
14774   /* InitNone|InitEmpty for test_vgs_1 */
14775   {
14776     char device[] = "/dev/sda";
14777     device[5] = devchar;
14778     int r;
14779     suppress_error = 0;
14780     r = guestfs_blockdev_setrw (g, device);
14781     if (r == -1)
14782       return -1;
14783   }
14784   {
14785     int r;
14786     suppress_error = 0;
14787     r = guestfs_umount_all (g);
14788     if (r == -1)
14789       return -1;
14790   }
14791   {
14792     int r;
14793     suppress_error = 0;
14794     r = guestfs_lvm_remove_all (g);
14795     if (r == -1)
14796       return -1;
14797   }
14798   /* TestOutputList for vgs (1) */
14799   {
14800     char device[] = "/dev/sda";
14801     device[5] = devchar;
14802     char lines_0[] = ",10";
14803     char lines_1[] = ",20";
14804     char lines_2[] = ",";
14805     char *lines[] = {
14806       lines_0,
14807       lines_1,
14808       lines_2,
14809       NULL
14810     };
14811     int r;
14812     suppress_error = 0;
14813     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14814     if (r == -1)
14815       return -1;
14816   }
14817   {
14818     char device[] = "/dev/sda1";
14819     device[5] = devchar;
14820     int r;
14821     suppress_error = 0;
14822     r = guestfs_pvcreate (g, device);
14823     if (r == -1)
14824       return -1;
14825   }
14826   {
14827     char device[] = "/dev/sda2";
14828     device[5] = devchar;
14829     int r;
14830     suppress_error = 0;
14831     r = guestfs_pvcreate (g, device);
14832     if (r == -1)
14833       return -1;
14834   }
14835   {
14836     char device[] = "/dev/sda3";
14837     device[5] = devchar;
14838     int r;
14839     suppress_error = 0;
14840     r = guestfs_pvcreate (g, device);
14841     if (r == -1)
14842       return -1;
14843   }
14844   {
14845     char volgroup[] = "VG1";
14846     char physvols_0[] = "/dev/sda1";
14847     physvols_0[5] = devchar;
14848     char physvols_1[] = "/dev/sda2";
14849     physvols_1[5] = devchar;
14850     char *physvols[] = {
14851       physvols_0,
14852       physvols_1,
14853       NULL
14854     };
14855     int r;
14856     suppress_error = 0;
14857     r = guestfs_vgcreate (g, volgroup, physvols);
14858     if (r == -1)
14859       return -1;
14860   }
14861   {
14862     char volgroup[] = "VG2";
14863     char physvols_0[] = "/dev/sda3";
14864     physvols_0[5] = devchar;
14865     char *physvols[] = {
14866       physvols_0,
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 **r;
14877     int i;
14878     suppress_error = 0;
14879     r = guestfs_vgs (g);
14880     if (r == NULL)
14881       return -1;
14882     if (!r[0]) {
14883       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14884       print_strings (r);
14885       return -1;
14886     }
14887     {
14888       char expected[] = "VG1";
14889       if (strcmp (r[0], expected) != 0) {
14890         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14891         return -1;
14892       }
14893     }
14894     if (!r[1]) {
14895       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14896       print_strings (r);
14897       return -1;
14898     }
14899     {
14900       char expected[] = "VG2";
14901       if (strcmp (r[1], expected) != 0) {
14902         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14903         return -1;
14904       }
14905     }
14906     if (r[2] != NULL) {
14907       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14908       print_strings (r);
14909       return -1;
14910     }
14911     for (i = 0; r[i] != NULL; ++i)
14912       free (r[i]);
14913     free (r);
14914   }
14915   return 0;
14916 }
14917
14918 static int test_pvs_0_skip (void)
14919 {
14920   const char *str;
14921
14922   str = getenv ("SKIP_TEST_PVS_0");
14923   if (str && strcmp (str, "1") == 0) return 1;
14924   str = getenv ("SKIP_TEST_PVS");
14925   if (str && strcmp (str, "1") == 0) return 1;
14926   return 0;
14927 }
14928
14929 static int test_pvs_0 (void)
14930 {
14931   if (test_pvs_0_skip ()) {
14932     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14933     return 0;
14934   }
14935
14936   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14937   {
14938     char device[] = "/dev/sda";
14939     device[5] = devchar;
14940     int r;
14941     suppress_error = 0;
14942     r = guestfs_blockdev_setrw (g, device);
14943     if (r == -1)
14944       return -1;
14945   }
14946   {
14947     int r;
14948     suppress_error = 0;
14949     r = guestfs_umount_all (g);
14950     if (r == -1)
14951       return -1;
14952   }
14953   {
14954     int r;
14955     suppress_error = 0;
14956     r = guestfs_lvm_remove_all (g);
14957     if (r == -1)
14958       return -1;
14959   }
14960   {
14961     char device[] = "/dev/sda";
14962     device[5] = devchar;
14963     char lines_0[] = ",";
14964     char *lines[] = {
14965       lines_0,
14966       NULL
14967     };
14968     int r;
14969     suppress_error = 0;
14970     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14971     if (r == -1)
14972       return -1;
14973   }
14974   {
14975     char device[] = "/dev/sda1";
14976     device[5] = devchar;
14977     int r;
14978     suppress_error = 0;
14979     r = guestfs_pvcreate (g, device);
14980     if (r == -1)
14981       return -1;
14982   }
14983   {
14984     char volgroup[] = "VG";
14985     char physvols_0[] = "/dev/sda1";
14986     physvols_0[5] = devchar;
14987     char *physvols[] = {
14988       physvols_0,
14989       NULL
14990     };
14991     int r;
14992     suppress_error = 0;
14993     r = guestfs_vgcreate (g, volgroup, physvols);
14994     if (r == -1)
14995       return -1;
14996   }
14997   {
14998     char logvol[] = "LV";
14999     char volgroup[] = "VG";
15000     int r;
15001     suppress_error = 0;
15002     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15003     if (r == -1)
15004       return -1;
15005   }
15006   {
15007     char fstype[] = "ext2";
15008     char device[] = "/dev/VG/LV";
15009     int r;
15010     suppress_error = 0;
15011     r = guestfs_mkfs (g, fstype, device);
15012     if (r == -1)
15013       return -1;
15014   }
15015   {
15016     char device[] = "/dev/VG/LV";
15017     char mountpoint[] = "/";
15018     int r;
15019     suppress_error = 0;
15020     r = guestfs_mount (g, device, mountpoint);
15021     if (r == -1)
15022       return -1;
15023   }
15024   /* TestOutputList for pvs (0) */
15025   {
15026     char **r;
15027     int i;
15028     suppress_error = 0;
15029     r = guestfs_pvs (g);
15030     if (r == NULL)
15031       return -1;
15032     if (!r[0]) {
15033       fprintf (stderr, "test_pvs_0: short list returned from command\n");
15034       print_strings (r);
15035       return -1;
15036     }
15037     {
15038       char expected[] = "/dev/sda1";
15039       expected[5] = devchar;
15040       if (strcmp (r[0], expected) != 0) {
15041         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15042         return -1;
15043       }
15044     }
15045     if (r[1] != NULL) {
15046       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15047       print_strings (r);
15048       return -1;
15049     }
15050     for (i = 0; r[i] != NULL; ++i)
15051       free (r[i]);
15052     free (r);
15053   }
15054   return 0;
15055 }
15056
15057 static int test_pvs_1_skip (void)
15058 {
15059   const char *str;
15060
15061   str = getenv ("SKIP_TEST_PVS_1");
15062   if (str && strcmp (str, "1") == 0) return 1;
15063   str = getenv ("SKIP_TEST_PVS");
15064   if (str && strcmp (str, "1") == 0) return 1;
15065   return 0;
15066 }
15067
15068 static int test_pvs_1 (void)
15069 {
15070   if (test_pvs_1_skip ()) {
15071     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15072     return 0;
15073   }
15074
15075   /* InitNone|InitEmpty for test_pvs_1 */
15076   {
15077     char device[] = "/dev/sda";
15078     device[5] = devchar;
15079     int r;
15080     suppress_error = 0;
15081     r = guestfs_blockdev_setrw (g, device);
15082     if (r == -1)
15083       return -1;
15084   }
15085   {
15086     int r;
15087     suppress_error = 0;
15088     r = guestfs_umount_all (g);
15089     if (r == -1)
15090       return -1;
15091   }
15092   {
15093     int r;
15094     suppress_error = 0;
15095     r = guestfs_lvm_remove_all (g);
15096     if (r == -1)
15097       return -1;
15098   }
15099   /* TestOutputList for pvs (1) */
15100   {
15101     char device[] = "/dev/sda";
15102     device[5] = devchar;
15103     char lines_0[] = ",10";
15104     char lines_1[] = ",20";
15105     char lines_2[] = ",";
15106     char *lines[] = {
15107       lines_0,
15108       lines_1,
15109       lines_2,
15110       NULL
15111     };
15112     int r;
15113     suppress_error = 0;
15114     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15115     if (r == -1)
15116       return -1;
15117   }
15118   {
15119     char device[] = "/dev/sda1";
15120     device[5] = devchar;
15121     int r;
15122     suppress_error = 0;
15123     r = guestfs_pvcreate (g, device);
15124     if (r == -1)
15125       return -1;
15126   }
15127   {
15128     char device[] = "/dev/sda2";
15129     device[5] = devchar;
15130     int r;
15131     suppress_error = 0;
15132     r = guestfs_pvcreate (g, device);
15133     if (r == -1)
15134       return -1;
15135   }
15136   {
15137     char device[] = "/dev/sda3";
15138     device[5] = devchar;
15139     int r;
15140     suppress_error = 0;
15141     r = guestfs_pvcreate (g, device);
15142     if (r == -1)
15143       return -1;
15144   }
15145   {
15146     char **r;
15147     int i;
15148     suppress_error = 0;
15149     r = guestfs_pvs (g);
15150     if (r == NULL)
15151       return -1;
15152     if (!r[0]) {
15153       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15154       print_strings (r);
15155       return -1;
15156     }
15157     {
15158       char expected[] = "/dev/sda1";
15159       expected[5] = devchar;
15160       if (strcmp (r[0], expected) != 0) {
15161         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15162         return -1;
15163       }
15164     }
15165     if (!r[1]) {
15166       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15167       print_strings (r);
15168       return -1;
15169     }
15170     {
15171       char expected[] = "/dev/sda2";
15172       expected[5] = devchar;
15173       if (strcmp (r[1], expected) != 0) {
15174         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15175         return -1;
15176       }
15177     }
15178     if (!r[2]) {
15179       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15180       print_strings (r);
15181       return -1;
15182     }
15183     {
15184       char expected[] = "/dev/sda3";
15185       expected[5] = devchar;
15186       if (strcmp (r[2], expected) != 0) {
15187         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15188         return -1;
15189       }
15190     }
15191     if (r[3] != NULL) {
15192       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15193       print_strings (r);
15194       return -1;
15195     }
15196     for (i = 0; r[i] != NULL; ++i)
15197       free (r[i]);
15198     free (r);
15199   }
15200   return 0;
15201 }
15202
15203 static int test_list_partitions_0_skip (void)
15204 {
15205   const char *str;
15206
15207   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15208   if (str && strcmp (str, "1") == 0) return 1;
15209   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15210   if (str && strcmp (str, "1") == 0) return 1;
15211   return 0;
15212 }
15213
15214 static int test_list_partitions_0 (void)
15215 {
15216   if (test_list_partitions_0_skip ()) {
15217     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15218     return 0;
15219   }
15220
15221   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15222   {
15223     char device[] = "/dev/sda";
15224     device[5] = devchar;
15225     int r;
15226     suppress_error = 0;
15227     r = guestfs_blockdev_setrw (g, device);
15228     if (r == -1)
15229       return -1;
15230   }
15231   {
15232     int r;
15233     suppress_error = 0;
15234     r = guestfs_umount_all (g);
15235     if (r == -1)
15236       return -1;
15237   }
15238   {
15239     int r;
15240     suppress_error = 0;
15241     r = guestfs_lvm_remove_all (g);
15242     if (r == -1)
15243       return -1;
15244   }
15245   {
15246     char device[] = "/dev/sda";
15247     device[5] = devchar;
15248     char lines_0[] = ",";
15249     char *lines[] = {
15250       lines_0,
15251       NULL
15252     };
15253     int r;
15254     suppress_error = 0;
15255     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15256     if (r == -1)
15257       return -1;
15258   }
15259   {
15260     char fstype[] = "ext2";
15261     char device[] = "/dev/sda1";
15262     device[5] = devchar;
15263     int r;
15264     suppress_error = 0;
15265     r = guestfs_mkfs (g, fstype, device);
15266     if (r == -1)
15267       return -1;
15268   }
15269   {
15270     char device[] = "/dev/sda1";
15271     device[5] = devchar;
15272     char mountpoint[] = "/";
15273     int r;
15274     suppress_error = 0;
15275     r = guestfs_mount (g, device, mountpoint);
15276     if (r == -1)
15277       return -1;
15278   }
15279   /* TestOutputList for list_partitions (0) */
15280   {
15281     char **r;
15282     int i;
15283     suppress_error = 0;
15284     r = guestfs_list_partitions (g);
15285     if (r == NULL)
15286       return -1;
15287     if (!r[0]) {
15288       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15289       print_strings (r);
15290       return -1;
15291     }
15292     {
15293       char expected[] = "/dev/sda1";
15294       expected[5] = devchar;
15295       if (strcmp (r[0], expected) != 0) {
15296         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15297         return -1;
15298       }
15299     }
15300     if (r[1] != NULL) {
15301       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15302       print_strings (r);
15303       return -1;
15304     }
15305     for (i = 0; r[i] != NULL; ++i)
15306       free (r[i]);
15307     free (r);
15308   }
15309   return 0;
15310 }
15311
15312 static int test_list_partitions_1_skip (void)
15313 {
15314   const char *str;
15315
15316   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15317   if (str && strcmp (str, "1") == 0) return 1;
15318   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15319   if (str && strcmp (str, "1") == 0) return 1;
15320   return 0;
15321 }
15322
15323 static int test_list_partitions_1 (void)
15324 {
15325   if (test_list_partitions_1_skip ()) {
15326     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15327     return 0;
15328   }
15329
15330   /* InitNone|InitEmpty for test_list_partitions_1 */
15331   {
15332     char device[] = "/dev/sda";
15333     device[5] = devchar;
15334     int r;
15335     suppress_error = 0;
15336     r = guestfs_blockdev_setrw (g, device);
15337     if (r == -1)
15338       return -1;
15339   }
15340   {
15341     int r;
15342     suppress_error = 0;
15343     r = guestfs_umount_all (g);
15344     if (r == -1)
15345       return -1;
15346   }
15347   {
15348     int r;
15349     suppress_error = 0;
15350     r = guestfs_lvm_remove_all (g);
15351     if (r == -1)
15352       return -1;
15353   }
15354   /* TestOutputList for list_partitions (1) */
15355   {
15356     char device[] = "/dev/sda";
15357     device[5] = devchar;
15358     char lines_0[] = ",10";
15359     char lines_1[] = ",20";
15360     char lines_2[] = ",";
15361     char *lines[] = {
15362       lines_0,
15363       lines_1,
15364       lines_2,
15365       NULL
15366     };
15367     int r;
15368     suppress_error = 0;
15369     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15370     if (r == -1)
15371       return -1;
15372   }
15373   {
15374     char **r;
15375     int i;
15376     suppress_error = 0;
15377     r = guestfs_list_partitions (g);
15378     if (r == NULL)
15379       return -1;
15380     if (!r[0]) {
15381       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15382       print_strings (r);
15383       return -1;
15384     }
15385     {
15386       char expected[] = "/dev/sda1";
15387       expected[5] = devchar;
15388       if (strcmp (r[0], expected) != 0) {
15389         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15390         return -1;
15391       }
15392     }
15393     if (!r[1]) {
15394       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15395       print_strings (r);
15396       return -1;
15397     }
15398     {
15399       char expected[] = "/dev/sda2";
15400       expected[5] = devchar;
15401       if (strcmp (r[1], expected) != 0) {
15402         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15403         return -1;
15404       }
15405     }
15406     if (!r[2]) {
15407       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15408       print_strings (r);
15409       return -1;
15410     }
15411     {
15412       char expected[] = "/dev/sda3";
15413       expected[5] = devchar;
15414       if (strcmp (r[2], expected) != 0) {
15415         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15416         return -1;
15417       }
15418     }
15419     if (r[3] != NULL) {
15420       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15421       print_strings (r);
15422       return -1;
15423     }
15424     for (i = 0; r[i] != NULL; ++i)
15425       free (r[i]);
15426     free (r);
15427   }
15428   return 0;
15429 }
15430
15431 static int test_list_devices_0_skip (void)
15432 {
15433   const char *str;
15434
15435   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15436   if (str && strcmp (str, "1") == 0) return 1;
15437   str = getenv ("SKIP_TEST_LIST_DEVICES");
15438   if (str && strcmp (str, "1") == 0) return 1;
15439   return 0;
15440 }
15441
15442 static int test_list_devices_0 (void)
15443 {
15444   if (test_list_devices_0_skip ()) {
15445     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15446     return 0;
15447   }
15448
15449   /* InitNone|InitEmpty for test_list_devices_0 */
15450   {
15451     char device[] = "/dev/sda";
15452     device[5] = devchar;
15453     int r;
15454     suppress_error = 0;
15455     r = guestfs_blockdev_setrw (g, device);
15456     if (r == -1)
15457       return -1;
15458   }
15459   {
15460     int r;
15461     suppress_error = 0;
15462     r = guestfs_umount_all (g);
15463     if (r == -1)
15464       return -1;
15465   }
15466   {
15467     int r;
15468     suppress_error = 0;
15469     r = guestfs_lvm_remove_all (g);
15470     if (r == -1)
15471       return -1;
15472   }
15473   /* TestOutputList for list_devices (0) */
15474   {
15475     char **r;
15476     int i;
15477     suppress_error = 0;
15478     r = guestfs_list_devices (g);
15479     if (r == NULL)
15480       return -1;
15481     if (!r[0]) {
15482       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15483       print_strings (r);
15484       return -1;
15485     }
15486     {
15487       char expected[] = "/dev/sda";
15488       expected[5] = devchar;
15489       if (strcmp (r[0], expected) != 0) {
15490         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15491         return -1;
15492       }
15493     }
15494     if (!r[1]) {
15495       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15496       print_strings (r);
15497       return -1;
15498     }
15499     {
15500       char expected[] = "/dev/sdb";
15501       expected[5] = devchar;
15502       if (strcmp (r[1], expected) != 0) {
15503         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15504         return -1;
15505       }
15506     }
15507     if (!r[2]) {
15508       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15509       print_strings (r);
15510       return -1;
15511     }
15512     {
15513       char expected[] = "/dev/sdc";
15514       expected[5] = devchar;
15515       if (strcmp (r[2], expected) != 0) {
15516         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15517         return -1;
15518       }
15519     }
15520     if (!r[3]) {
15521       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15522       print_strings (r);
15523       return -1;
15524     }
15525     {
15526       char expected[] = "/dev/sdd";
15527       expected[5] = devchar;
15528       if (strcmp (r[3], expected) != 0) {
15529         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15530         return -1;
15531       }
15532     }
15533     if (r[4] != NULL) {
15534       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15535       print_strings (r);
15536       return -1;
15537     }
15538     for (i = 0; r[i] != NULL; ++i)
15539       free (r[i]);
15540     free (r);
15541   }
15542   return 0;
15543 }
15544
15545 static int test_ls_0_skip (void)
15546 {
15547   const char *str;
15548
15549   str = getenv ("SKIP_TEST_LS_0");
15550   if (str && strcmp (str, "1") == 0) return 1;
15551   str = getenv ("SKIP_TEST_LS");
15552   if (str && strcmp (str, "1") == 0) return 1;
15553   return 0;
15554 }
15555
15556 static int test_ls_0 (void)
15557 {
15558   if (test_ls_0_skip ()) {
15559     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15560     return 0;
15561   }
15562
15563   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15564   {
15565     char device[] = "/dev/sda";
15566     device[5] = devchar;
15567     int r;
15568     suppress_error = 0;
15569     r = guestfs_blockdev_setrw (g, device);
15570     if (r == -1)
15571       return -1;
15572   }
15573   {
15574     int r;
15575     suppress_error = 0;
15576     r = guestfs_umount_all (g);
15577     if (r == -1)
15578       return -1;
15579   }
15580   {
15581     int r;
15582     suppress_error = 0;
15583     r = guestfs_lvm_remove_all (g);
15584     if (r == -1)
15585       return -1;
15586   }
15587   {
15588     char device[] = "/dev/sda";
15589     device[5] = devchar;
15590     char lines_0[] = ",";
15591     char *lines[] = {
15592       lines_0,
15593       NULL
15594     };
15595     int r;
15596     suppress_error = 0;
15597     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15598     if (r == -1)
15599       return -1;
15600   }
15601   {
15602     char fstype[] = "ext2";
15603     char device[] = "/dev/sda1";
15604     device[5] = devchar;
15605     int r;
15606     suppress_error = 0;
15607     r = guestfs_mkfs (g, fstype, device);
15608     if (r == -1)
15609       return -1;
15610   }
15611   {
15612     char device[] = "/dev/sda1";
15613     device[5] = devchar;
15614     char mountpoint[] = "/";
15615     int r;
15616     suppress_error = 0;
15617     r = guestfs_mount (g, device, mountpoint);
15618     if (r == -1)
15619       return -1;
15620   }
15621   /* TestOutputList for ls (0) */
15622   {
15623     char path[] = "/new";
15624     int r;
15625     suppress_error = 0;
15626     r = guestfs_touch (g, path);
15627     if (r == -1)
15628       return -1;
15629   }
15630   {
15631     char path[] = "/newer";
15632     int r;
15633     suppress_error = 0;
15634     r = guestfs_touch (g, path);
15635     if (r == -1)
15636       return -1;
15637   }
15638   {
15639     char path[] = "/newest";
15640     int r;
15641     suppress_error = 0;
15642     r = guestfs_touch (g, path);
15643     if (r == -1)
15644       return -1;
15645   }
15646   {
15647     char directory[] = "/";
15648     char **r;
15649     int i;
15650     suppress_error = 0;
15651     r = guestfs_ls (g, directory);
15652     if (r == NULL)
15653       return -1;
15654     if (!r[0]) {
15655       fprintf (stderr, "test_ls_0: short list returned from command\n");
15656       print_strings (r);
15657       return -1;
15658     }
15659     {
15660       char expected[] = "lost+found";
15661       if (strcmp (r[0], expected) != 0) {
15662         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15663         return -1;
15664       }
15665     }
15666     if (!r[1]) {
15667       fprintf (stderr, "test_ls_0: short list returned from command\n");
15668       print_strings (r);
15669       return -1;
15670     }
15671     {
15672       char expected[] = "new";
15673       if (strcmp (r[1], expected) != 0) {
15674         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15675         return -1;
15676       }
15677     }
15678     if (!r[2]) {
15679       fprintf (stderr, "test_ls_0: short list returned from command\n");
15680       print_strings (r);
15681       return -1;
15682     }
15683     {
15684       char expected[] = "newer";
15685       if (strcmp (r[2], expected) != 0) {
15686         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15687         return -1;
15688       }
15689     }
15690     if (!r[3]) {
15691       fprintf (stderr, "test_ls_0: short list returned from command\n");
15692       print_strings (r);
15693       return -1;
15694     }
15695     {
15696       char expected[] = "newest";
15697       if (strcmp (r[3], expected) != 0) {
15698         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15699         return -1;
15700       }
15701     }
15702     if (r[4] != NULL) {
15703       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15704       print_strings (r);
15705       return -1;
15706     }
15707     for (i = 0; r[i] != NULL; ++i)
15708       free (r[i]);
15709     free (r);
15710   }
15711   return 0;
15712 }
15713
15714 static int test_cat_0_skip (void)
15715 {
15716   const char *str;
15717
15718   str = getenv ("SKIP_TEST_CAT_0");
15719   if (str && strcmp (str, "1") == 0) return 1;
15720   str = getenv ("SKIP_TEST_CAT");
15721   if (str && strcmp (str, "1") == 0) return 1;
15722   return 0;
15723 }
15724
15725 static int test_cat_0 (void)
15726 {
15727   if (test_cat_0_skip ()) {
15728     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15729     return 0;
15730   }
15731
15732   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15733   {
15734     char device[] = "/dev/sda";
15735     device[5] = devchar;
15736     int r;
15737     suppress_error = 0;
15738     r = guestfs_blockdev_setrw (g, device);
15739     if (r == -1)
15740       return -1;
15741   }
15742   {
15743     int r;
15744     suppress_error = 0;
15745     r = guestfs_umount_all (g);
15746     if (r == -1)
15747       return -1;
15748   }
15749   {
15750     int r;
15751     suppress_error = 0;
15752     r = guestfs_lvm_remove_all (g);
15753     if (r == -1)
15754       return -1;
15755   }
15756   {
15757     char device[] = "/dev/sda";
15758     device[5] = devchar;
15759     char lines_0[] = ",";
15760     char *lines[] = {
15761       lines_0,
15762       NULL
15763     };
15764     int r;
15765     suppress_error = 0;
15766     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15767     if (r == -1)
15768       return -1;
15769   }
15770   {
15771     char fstype[] = "ext2";
15772     char device[] = "/dev/sda1";
15773     device[5] = devchar;
15774     int r;
15775     suppress_error = 0;
15776     r = guestfs_mkfs (g, fstype, device);
15777     if (r == -1)
15778       return -1;
15779   }
15780   {
15781     char device[] = "/dev/sda1";
15782     device[5] = devchar;
15783     char mountpoint[] = "/";
15784     int r;
15785     suppress_error = 0;
15786     r = guestfs_mount (g, device, mountpoint);
15787     if (r == -1)
15788       return -1;
15789   }
15790   /* TestOutput for cat (0) */
15791   char expected[] = "new file contents";
15792   {
15793     char path[] = "/new";
15794     char content[] = "new file contents";
15795     int r;
15796     suppress_error = 0;
15797     r = guestfs_write_file (g, path, content, 0);
15798     if (r == -1)
15799       return -1;
15800   }
15801   {
15802     char path[] = "/new";
15803     char *r;
15804     suppress_error = 0;
15805     r = guestfs_cat (g, path);
15806     if (r == NULL)
15807       return -1;
15808     if (strcmp (r, expected) != 0) {
15809       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15810       return -1;
15811     }
15812     free (r);
15813   }
15814   return 0;
15815 }
15816
15817 static int test_touch_0_skip (void)
15818 {
15819   const char *str;
15820
15821   str = getenv ("SKIP_TEST_TOUCH_0");
15822   if (str && strcmp (str, "1") == 0) return 1;
15823   str = getenv ("SKIP_TEST_TOUCH");
15824   if (str && strcmp (str, "1") == 0) return 1;
15825   return 0;
15826 }
15827
15828 static int test_touch_0 (void)
15829 {
15830   if (test_touch_0_skip ()) {
15831     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15832     return 0;
15833   }
15834
15835   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15836   {
15837     char device[] = "/dev/sda";
15838     device[5] = devchar;
15839     int r;
15840     suppress_error = 0;
15841     r = guestfs_blockdev_setrw (g, device);
15842     if (r == -1)
15843       return -1;
15844   }
15845   {
15846     int r;
15847     suppress_error = 0;
15848     r = guestfs_umount_all (g);
15849     if (r == -1)
15850       return -1;
15851   }
15852   {
15853     int r;
15854     suppress_error = 0;
15855     r = guestfs_lvm_remove_all (g);
15856     if (r == -1)
15857       return -1;
15858   }
15859   {
15860     char device[] = "/dev/sda";
15861     device[5] = devchar;
15862     char lines_0[] = ",";
15863     char *lines[] = {
15864       lines_0,
15865       NULL
15866     };
15867     int r;
15868     suppress_error = 0;
15869     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15870     if (r == -1)
15871       return -1;
15872   }
15873   {
15874     char fstype[] = "ext2";
15875     char device[] = "/dev/sda1";
15876     device[5] = devchar;
15877     int r;
15878     suppress_error = 0;
15879     r = guestfs_mkfs (g, fstype, device);
15880     if (r == -1)
15881       return -1;
15882   }
15883   {
15884     char device[] = "/dev/sda1";
15885     device[5] = devchar;
15886     char mountpoint[] = "/";
15887     int r;
15888     suppress_error = 0;
15889     r = guestfs_mount (g, device, mountpoint);
15890     if (r == -1)
15891       return -1;
15892   }
15893   /* TestOutputTrue for touch (0) */
15894   {
15895     char path[] = "/new";
15896     int r;
15897     suppress_error = 0;
15898     r = guestfs_touch (g, path);
15899     if (r == -1)
15900       return -1;
15901   }
15902   {
15903     char path[] = "/new";
15904     int r;
15905     suppress_error = 0;
15906     r = guestfs_exists (g, path);
15907     if (r == -1)
15908       return -1;
15909     if (!r) {
15910       fprintf (stderr, "test_touch_0: expected true, got false\n");
15911       return -1;
15912     }
15913   }
15914   return 0;
15915 }
15916
15917 static int test_sync_0_skip (void)
15918 {
15919   const char *str;
15920
15921   str = getenv ("SKIP_TEST_SYNC_0");
15922   if (str && strcmp (str, "1") == 0) return 1;
15923   str = getenv ("SKIP_TEST_SYNC");
15924   if (str && strcmp (str, "1") == 0) return 1;
15925   return 0;
15926 }
15927
15928 static int test_sync_0 (void)
15929 {
15930   if (test_sync_0_skip ()) {
15931     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15932     return 0;
15933   }
15934
15935   /* InitNone|InitEmpty for test_sync_0 */
15936   {
15937     char device[] = "/dev/sda";
15938     device[5] = devchar;
15939     int r;
15940     suppress_error = 0;
15941     r = guestfs_blockdev_setrw (g, device);
15942     if (r == -1)
15943       return -1;
15944   }
15945   {
15946     int r;
15947     suppress_error = 0;
15948     r = guestfs_umount_all (g);
15949     if (r == -1)
15950       return -1;
15951   }
15952   {
15953     int r;
15954     suppress_error = 0;
15955     r = guestfs_lvm_remove_all (g);
15956     if (r == -1)
15957       return -1;
15958   }
15959   /* TestRun for sync (0) */
15960   {
15961     int r;
15962     suppress_error = 0;
15963     r = guestfs_sync (g);
15964     if (r == -1)
15965       return -1;
15966   }
15967   return 0;
15968 }
15969
15970 static int test_mount_0_skip (void)
15971 {
15972   const char *str;
15973
15974   str = getenv ("SKIP_TEST_MOUNT_0");
15975   if (str && strcmp (str, "1") == 0) return 1;
15976   str = getenv ("SKIP_TEST_MOUNT");
15977   if (str && strcmp (str, "1") == 0) return 1;
15978   return 0;
15979 }
15980
15981 static int test_mount_0 (void)
15982 {
15983   if (test_mount_0_skip ()) {
15984     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15985     return 0;
15986   }
15987
15988   /* InitNone|InitEmpty for test_mount_0 */
15989   {
15990     char device[] = "/dev/sda";
15991     device[5] = devchar;
15992     int r;
15993     suppress_error = 0;
15994     r = guestfs_blockdev_setrw (g, device);
15995     if (r == -1)
15996       return -1;
15997   }
15998   {
15999     int r;
16000     suppress_error = 0;
16001     r = guestfs_umount_all (g);
16002     if (r == -1)
16003       return -1;
16004   }
16005   {
16006     int r;
16007     suppress_error = 0;
16008     r = guestfs_lvm_remove_all (g);
16009     if (r == -1)
16010       return -1;
16011   }
16012   /* TestOutput for mount (0) */
16013   char expected[] = "new file contents";
16014   {
16015     char device[] = "/dev/sda";
16016     device[5] = devchar;
16017     char lines_0[] = ",";
16018     char *lines[] = {
16019       lines_0,
16020       NULL
16021     };
16022     int r;
16023     suppress_error = 0;
16024     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16025     if (r == -1)
16026       return -1;
16027   }
16028   {
16029     char fstype[] = "ext2";
16030     char device[] = "/dev/sda1";
16031     device[5] = devchar;
16032     int r;
16033     suppress_error = 0;
16034     r = guestfs_mkfs (g, fstype, device);
16035     if (r == -1)
16036       return -1;
16037   }
16038   {
16039     char device[] = "/dev/sda1";
16040     device[5] = devchar;
16041     char mountpoint[] = "/";
16042     int r;
16043     suppress_error = 0;
16044     r = guestfs_mount (g, device, mountpoint);
16045     if (r == -1)
16046       return -1;
16047   }
16048   {
16049     char path[] = "/new";
16050     char content[] = "new file contents";
16051     int r;
16052     suppress_error = 0;
16053     r = guestfs_write_file (g, path, content, 0);
16054     if (r == -1)
16055       return -1;
16056   }
16057   {
16058     char path[] = "/new";
16059     char *r;
16060     suppress_error = 0;
16061     r = guestfs_cat (g, path);
16062     if (r == NULL)
16063       return -1;
16064     if (strcmp (r, expected) != 0) {
16065       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16066       return -1;
16067     }
16068     free (r);
16069   }
16070   return 0;
16071 }
16072
16073 int main (int argc, char *argv[])
16074 {
16075   char c = 0;
16076   int failed = 0;
16077   const char *filename;
16078   int fd, i;
16079   int nr_tests, test_num = 0;
16080   char **devs;
16081
16082   no_test_warnings ();
16083
16084   g = guestfs_create ();
16085   if (g == NULL) {
16086     printf ("guestfs_create FAILED\n");
16087     exit (1);
16088   }
16089
16090   guestfs_set_error_handler (g, print_error, NULL);
16091
16092   guestfs_set_path (g, "../appliance");
16093
16094   filename = "test1.img";
16095   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16096   if (fd == -1) {
16097     perror (filename);
16098     exit (1);
16099   }
16100   if (lseek (fd, 524288000, SEEK_SET) == -1) {
16101     perror ("lseek");
16102     close (fd);
16103     unlink (filename);
16104     exit (1);
16105   }
16106   if (write (fd, &c, 1) == -1) {
16107     perror ("write");
16108     close (fd);
16109     unlink (filename);
16110     exit (1);
16111   }
16112   if (close (fd) == -1) {
16113     perror (filename);
16114     unlink (filename);
16115     exit (1);
16116   }
16117   if (guestfs_add_drive (g, filename) == -1) {
16118     printf ("guestfs_add_drive %s FAILED\n", filename);
16119     exit (1);
16120   }
16121
16122   filename = "test2.img";
16123   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16124   if (fd == -1) {
16125     perror (filename);
16126     exit (1);
16127   }
16128   if (lseek (fd, 52428800, SEEK_SET) == -1) {
16129     perror ("lseek");
16130     close (fd);
16131     unlink (filename);
16132     exit (1);
16133   }
16134   if (write (fd, &c, 1) == -1) {
16135     perror ("write");
16136     close (fd);
16137     unlink (filename);
16138     exit (1);
16139   }
16140   if (close (fd) == -1) {
16141     perror (filename);
16142     unlink (filename);
16143     exit (1);
16144   }
16145   if (guestfs_add_drive (g, filename) == -1) {
16146     printf ("guestfs_add_drive %s FAILED\n", filename);
16147     exit (1);
16148   }
16149
16150   filename = "test3.img";
16151   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16152   if (fd == -1) {
16153     perror (filename);
16154     exit (1);
16155   }
16156   if (lseek (fd, 10485760, SEEK_SET) == -1) {
16157     perror ("lseek");
16158     close (fd);
16159     unlink (filename);
16160     exit (1);
16161   }
16162   if (write (fd, &c, 1) == -1) {
16163     perror ("write");
16164     close (fd);
16165     unlink (filename);
16166     exit (1);
16167   }
16168   if (close (fd) == -1) {
16169     perror (filename);
16170     unlink (filename);
16171     exit (1);
16172   }
16173   if (guestfs_add_drive (g, filename) == -1) {
16174     printf ("guestfs_add_drive %s FAILED\n", filename);
16175     exit (1);
16176   }
16177
16178   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16179     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16180     exit (1);
16181   }
16182
16183   if (guestfs_launch (g) == -1) {
16184     printf ("guestfs_launch FAILED\n");
16185     exit (1);
16186   }
16187   if (guestfs_wait_ready (g) == -1) {
16188     printf ("guestfs_wait_ready FAILED\n");
16189     exit (1);
16190   }
16191
16192   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
16193    * names.  This changed between RHEL 5 and RHEL 6 so we have to
16194    * support both.
16195    */
16196   devs = guestfs_list_devices (g);
16197   if (devs == NULL || devs[0] == NULL) {
16198     printf ("guestfs_list_devices FAILED\n");
16199     exit (1);
16200   }
16201   if (strncmp (devs[0], "/dev/sd", 7) == 0)
16202     devchar = 's';
16203   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
16204     devchar = 'h';
16205   else {
16206     printf ("guestfs_list_devices returned unexpected string '%s'\n",
16207             devs[0]);
16208     exit (1);
16209   }
16210   for (i = 0; devs[i] != NULL; ++i)
16211     free (devs[i]);
16212   free (devs);
16213
16214   nr_tests = 144;
16215
16216   test_num++;
16217   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16218   if (test_sleep_0 () == -1) {
16219     printf ("test_sleep_0 FAILED\n");
16220     failed++;
16221   }
16222   test_num++;
16223   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16224   if (test_find_0 () == -1) {
16225     printf ("test_find_0 FAILED\n");
16226     failed++;
16227   }
16228   test_num++;
16229   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16230   if (test_find_1 () == -1) {
16231     printf ("test_find_1 FAILED\n");
16232     failed++;
16233   }
16234   test_num++;
16235   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16236   if (test_find_2 () == -1) {
16237     printf ("test_find_2 FAILED\n");
16238     failed++;
16239   }
16240   test_num++;
16241   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16242   if (test_lvresize_0 () == -1) {
16243     printf ("test_lvresize_0 FAILED\n");
16244     failed++;
16245   }
16246   test_num++;
16247   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16248   if (test_zerofree_0 () == -1) {
16249     printf ("test_zerofree_0 FAILED\n");
16250     failed++;
16251   }
16252   test_num++;
16253   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16254   if (test_hexdump_0 () == -1) {
16255     printf ("test_hexdump_0 FAILED\n");
16256     failed++;
16257   }
16258   test_num++;
16259   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16260   if (test_strings_e_0 () == -1) {
16261     printf ("test_strings_e_0 FAILED\n");
16262     failed++;
16263   }
16264   test_num++;
16265   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16266   if (test_strings_e_1 () == -1) {
16267     printf ("test_strings_e_1 FAILED\n");
16268     failed++;
16269   }
16270   test_num++;
16271   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16272   if (test_strings_0 () == -1) {
16273     printf ("test_strings_0 FAILED\n");
16274     failed++;
16275   }
16276   test_num++;
16277   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16278   if (test_strings_1 () == -1) {
16279     printf ("test_strings_1 FAILED\n");
16280     failed++;
16281   }
16282   test_num++;
16283   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16284   if (test_equal_0 () == -1) {
16285     printf ("test_equal_0 FAILED\n");
16286     failed++;
16287   }
16288   test_num++;
16289   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16290   if (test_equal_1 () == -1) {
16291     printf ("test_equal_1 FAILED\n");
16292     failed++;
16293   }
16294   test_num++;
16295   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16296   if (test_equal_2 () == -1) {
16297     printf ("test_equal_2 FAILED\n");
16298     failed++;
16299   }
16300   test_num++;
16301   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16302   if (test_ping_daemon_0 () == -1) {
16303     printf ("test_ping_daemon_0 FAILED\n");
16304     failed++;
16305   }
16306   test_num++;
16307   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16308   if (test_dmesg_0 () == -1) {
16309     printf ("test_dmesg_0 FAILED\n");
16310     failed++;
16311   }
16312   test_num++;
16313   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16314   if (test_drop_caches_0 () == -1) {
16315     printf ("test_drop_caches_0 FAILED\n");
16316     failed++;
16317   }
16318   test_num++;
16319   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16320   if (test_mv_0 () == -1) {
16321     printf ("test_mv_0 FAILED\n");
16322     failed++;
16323   }
16324   test_num++;
16325   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16326   if (test_mv_1 () == -1) {
16327     printf ("test_mv_1 FAILED\n");
16328     failed++;
16329   }
16330   test_num++;
16331   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16332   if (test_cp_a_0 () == -1) {
16333     printf ("test_cp_a_0 FAILED\n");
16334     failed++;
16335   }
16336   test_num++;
16337   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16338   if (test_cp_0 () == -1) {
16339     printf ("test_cp_0 FAILED\n");
16340     failed++;
16341   }
16342   test_num++;
16343   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16344   if (test_cp_1 () == -1) {
16345     printf ("test_cp_1 FAILED\n");
16346     failed++;
16347   }
16348   test_num++;
16349   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16350   if (test_cp_2 () == -1) {
16351     printf ("test_cp_2 FAILED\n");
16352     failed++;
16353   }
16354   test_num++;
16355   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16356   if (test_grub_install_0 () == -1) {
16357     printf ("test_grub_install_0 FAILED\n");
16358     failed++;
16359   }
16360   test_num++;
16361   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16362   if (test_zero_0 () == -1) {
16363     printf ("test_zero_0 FAILED\n");
16364     failed++;
16365   }
16366   test_num++;
16367   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16368   if (test_fsck_0 () == -1) {
16369     printf ("test_fsck_0 FAILED\n");
16370     failed++;
16371   }
16372   test_num++;
16373   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16374   if (test_fsck_1 () == -1) {
16375     printf ("test_fsck_1 FAILED\n");
16376     failed++;
16377   }
16378   test_num++;
16379   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16380   if (test_set_e2uuid_0 () == -1) {
16381     printf ("test_set_e2uuid_0 FAILED\n");
16382     failed++;
16383   }
16384   test_num++;
16385   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16386   if (test_set_e2uuid_1 () == -1) {
16387     printf ("test_set_e2uuid_1 FAILED\n");
16388     failed++;
16389   }
16390   test_num++;
16391   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16392   if (test_set_e2uuid_2 () == -1) {
16393     printf ("test_set_e2uuid_2 FAILED\n");
16394     failed++;
16395   }
16396   test_num++;
16397   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16398   if (test_set_e2uuid_3 () == -1) {
16399     printf ("test_set_e2uuid_3 FAILED\n");
16400     failed++;
16401   }
16402   test_num++;
16403   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16404   if (test_set_e2label_0 () == -1) {
16405     printf ("test_set_e2label_0 FAILED\n");
16406     failed++;
16407   }
16408   test_num++;
16409   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16410   if (test_pvremove_0 () == -1) {
16411     printf ("test_pvremove_0 FAILED\n");
16412     failed++;
16413   }
16414   test_num++;
16415   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16416   if (test_pvremove_1 () == -1) {
16417     printf ("test_pvremove_1 FAILED\n");
16418     failed++;
16419   }
16420   test_num++;
16421   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16422   if (test_pvremove_2 () == -1) {
16423     printf ("test_pvremove_2 FAILED\n");
16424     failed++;
16425   }
16426   test_num++;
16427   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16428   if (test_vgremove_0 () == -1) {
16429     printf ("test_vgremove_0 FAILED\n");
16430     failed++;
16431   }
16432   test_num++;
16433   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16434   if (test_vgremove_1 () == -1) {
16435     printf ("test_vgremove_1 FAILED\n");
16436     failed++;
16437   }
16438   test_num++;
16439   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16440   if (test_lvremove_0 () == -1) {
16441     printf ("test_lvremove_0 FAILED\n");
16442     failed++;
16443   }
16444   test_num++;
16445   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16446   if (test_lvremove_1 () == -1) {
16447     printf ("test_lvremove_1 FAILED\n");
16448     failed++;
16449   }
16450   test_num++;
16451   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16452   if (test_lvremove_2 () == -1) {
16453     printf ("test_lvremove_2 FAILED\n");
16454     failed++;
16455   }
16456   test_num++;
16457   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16458   if (test_mount_ro_0 () == -1) {
16459     printf ("test_mount_ro_0 FAILED\n");
16460     failed++;
16461   }
16462   test_num++;
16463   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16464   if (test_mount_ro_1 () == -1) {
16465     printf ("test_mount_ro_1 FAILED\n");
16466     failed++;
16467   }
16468   test_num++;
16469   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16470   if (test_tgz_in_0 () == -1) {
16471     printf ("test_tgz_in_0 FAILED\n");
16472     failed++;
16473   }
16474   test_num++;
16475   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16476   if (test_tar_in_0 () == -1) {
16477     printf ("test_tar_in_0 FAILED\n");
16478     failed++;
16479   }
16480   test_num++;
16481   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16482   if (test_checksum_0 () == -1) {
16483     printf ("test_checksum_0 FAILED\n");
16484     failed++;
16485   }
16486   test_num++;
16487   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16488   if (test_checksum_1 () == -1) {
16489     printf ("test_checksum_1 FAILED\n");
16490     failed++;
16491   }
16492   test_num++;
16493   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16494   if (test_checksum_2 () == -1) {
16495     printf ("test_checksum_2 FAILED\n");
16496     failed++;
16497   }
16498   test_num++;
16499   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16500   if (test_checksum_3 () == -1) {
16501     printf ("test_checksum_3 FAILED\n");
16502     failed++;
16503   }
16504   test_num++;
16505   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16506   if (test_checksum_4 () == -1) {
16507     printf ("test_checksum_4 FAILED\n");
16508     failed++;
16509   }
16510   test_num++;
16511   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16512   if (test_checksum_5 () == -1) {
16513     printf ("test_checksum_5 FAILED\n");
16514     failed++;
16515   }
16516   test_num++;
16517   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16518   if (test_checksum_6 () == -1) {
16519     printf ("test_checksum_6 FAILED\n");
16520     failed++;
16521   }
16522   test_num++;
16523   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16524   if (test_checksum_7 () == -1) {
16525     printf ("test_checksum_7 FAILED\n");
16526     failed++;
16527   }
16528   test_num++;
16529   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16530   if (test_checksum_8 () == -1) {
16531     printf ("test_checksum_8 FAILED\n");
16532     failed++;
16533   }
16534   test_num++;
16535   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16536   if (test_download_0 () == -1) {
16537     printf ("test_download_0 FAILED\n");
16538     failed++;
16539   }
16540   test_num++;
16541   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16542   if (test_upload_0 () == -1) {
16543     printf ("test_upload_0 FAILED\n");
16544     failed++;
16545   }
16546   test_num++;
16547   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16548   if (test_blockdev_rereadpt_0 () == -1) {
16549     printf ("test_blockdev_rereadpt_0 FAILED\n");
16550     failed++;
16551   }
16552   test_num++;
16553   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16554   if (test_blockdev_flushbufs_0 () == -1) {
16555     printf ("test_blockdev_flushbufs_0 FAILED\n");
16556     failed++;
16557   }
16558   test_num++;
16559   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16560   if (test_blockdev_getsize64_0 () == -1) {
16561     printf ("test_blockdev_getsize64_0 FAILED\n");
16562     failed++;
16563   }
16564   test_num++;
16565   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16566   if (test_blockdev_getsz_0 () == -1) {
16567     printf ("test_blockdev_getsz_0 FAILED\n");
16568     failed++;
16569   }
16570   test_num++;
16571   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16572   if (test_blockdev_getbsz_0 () == -1) {
16573     printf ("test_blockdev_getbsz_0 FAILED\n");
16574     failed++;
16575   }
16576   test_num++;
16577   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16578   if (test_blockdev_getss_0 () == -1) {
16579     printf ("test_blockdev_getss_0 FAILED\n");
16580     failed++;
16581   }
16582   test_num++;
16583   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16584   if (test_blockdev_getro_0 () == -1) {
16585     printf ("test_blockdev_getro_0 FAILED\n");
16586     failed++;
16587   }
16588   test_num++;
16589   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16590   if (test_blockdev_setrw_0 () == -1) {
16591     printf ("test_blockdev_setrw_0 FAILED\n");
16592     failed++;
16593   }
16594   test_num++;
16595   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16596   if (test_blockdev_setro_0 () == -1) {
16597     printf ("test_blockdev_setro_0 FAILED\n");
16598     failed++;
16599   }
16600   test_num++;
16601   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16602   if (test_statvfs_0 () == -1) {
16603     printf ("test_statvfs_0 FAILED\n");
16604     failed++;
16605   }
16606   test_num++;
16607   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16608   if (test_lstat_0 () == -1) {
16609     printf ("test_lstat_0 FAILED\n");
16610     failed++;
16611   }
16612   test_num++;
16613   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16614   if (test_stat_0 () == -1) {
16615     printf ("test_stat_0 FAILED\n");
16616     failed++;
16617   }
16618   test_num++;
16619   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16620   if (test_command_lines_0 () == -1) {
16621     printf ("test_command_lines_0 FAILED\n");
16622     failed++;
16623   }
16624   test_num++;
16625   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16626   if (test_command_lines_1 () == -1) {
16627     printf ("test_command_lines_1 FAILED\n");
16628     failed++;
16629   }
16630   test_num++;
16631   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16632   if (test_command_lines_2 () == -1) {
16633     printf ("test_command_lines_2 FAILED\n");
16634     failed++;
16635   }
16636   test_num++;
16637   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16638   if (test_command_lines_3 () == -1) {
16639     printf ("test_command_lines_3 FAILED\n");
16640     failed++;
16641   }
16642   test_num++;
16643   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16644   if (test_command_lines_4 () == -1) {
16645     printf ("test_command_lines_4 FAILED\n");
16646     failed++;
16647   }
16648   test_num++;
16649   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16650   if (test_command_lines_5 () == -1) {
16651     printf ("test_command_lines_5 FAILED\n");
16652     failed++;
16653   }
16654   test_num++;
16655   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16656   if (test_command_lines_6 () == -1) {
16657     printf ("test_command_lines_6 FAILED\n");
16658     failed++;
16659   }
16660   test_num++;
16661   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16662   if (test_command_lines_7 () == -1) {
16663     printf ("test_command_lines_7 FAILED\n");
16664     failed++;
16665   }
16666   test_num++;
16667   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16668   if (test_command_lines_8 () == -1) {
16669     printf ("test_command_lines_8 FAILED\n");
16670     failed++;
16671   }
16672   test_num++;
16673   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16674   if (test_command_lines_9 () == -1) {
16675     printf ("test_command_lines_9 FAILED\n");
16676     failed++;
16677   }
16678   test_num++;
16679   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16680   if (test_command_lines_10 () == -1) {
16681     printf ("test_command_lines_10 FAILED\n");
16682     failed++;
16683   }
16684   test_num++;
16685   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16686   if (test_command_0 () == -1) {
16687     printf ("test_command_0 FAILED\n");
16688     failed++;
16689   }
16690   test_num++;
16691   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16692   if (test_command_1 () == -1) {
16693     printf ("test_command_1 FAILED\n");
16694     failed++;
16695   }
16696   test_num++;
16697   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16698   if (test_command_2 () == -1) {
16699     printf ("test_command_2 FAILED\n");
16700     failed++;
16701   }
16702   test_num++;
16703   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16704   if (test_command_3 () == -1) {
16705     printf ("test_command_3 FAILED\n");
16706     failed++;
16707   }
16708   test_num++;
16709   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16710   if (test_command_4 () == -1) {
16711     printf ("test_command_4 FAILED\n");
16712     failed++;
16713   }
16714   test_num++;
16715   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16716   if (test_command_5 () == -1) {
16717     printf ("test_command_5 FAILED\n");
16718     failed++;
16719   }
16720   test_num++;
16721   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16722   if (test_command_6 () == -1) {
16723     printf ("test_command_6 FAILED\n");
16724     failed++;
16725   }
16726   test_num++;
16727   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16728   if (test_command_7 () == -1) {
16729     printf ("test_command_7 FAILED\n");
16730     failed++;
16731   }
16732   test_num++;
16733   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16734   if (test_command_8 () == -1) {
16735     printf ("test_command_8 FAILED\n");
16736     failed++;
16737   }
16738   test_num++;
16739   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16740   if (test_command_9 () == -1) {
16741     printf ("test_command_9 FAILED\n");
16742     failed++;
16743   }
16744   test_num++;
16745   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16746   if (test_command_10 () == -1) {
16747     printf ("test_command_10 FAILED\n");
16748     failed++;
16749   }
16750   test_num++;
16751   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16752   if (test_command_11 () == -1) {
16753     printf ("test_command_11 FAILED\n");
16754     failed++;
16755   }
16756   test_num++;
16757   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16758   if (test_file_0 () == -1) {
16759     printf ("test_file_0 FAILED\n");
16760     failed++;
16761   }
16762   test_num++;
16763   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16764   if (test_file_1 () == -1) {
16765     printf ("test_file_1 FAILED\n");
16766     failed++;
16767   }
16768   test_num++;
16769   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16770   if (test_file_2 () == -1) {
16771     printf ("test_file_2 FAILED\n");
16772     failed++;
16773   }
16774   test_num++;
16775   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16776   if (test_umount_all_0 () == -1) {
16777     printf ("test_umount_all_0 FAILED\n");
16778     failed++;
16779   }
16780   test_num++;
16781   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16782   if (test_umount_all_1 () == -1) {
16783     printf ("test_umount_all_1 FAILED\n");
16784     failed++;
16785   }
16786   test_num++;
16787   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16788   if (test_mounts_0 () == -1) {
16789     printf ("test_mounts_0 FAILED\n");
16790     failed++;
16791   }
16792   test_num++;
16793   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16794   if (test_umount_0 () == -1) {
16795     printf ("test_umount_0 FAILED\n");
16796     failed++;
16797   }
16798   test_num++;
16799   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16800   if (test_umount_1 () == -1) {
16801     printf ("test_umount_1 FAILED\n");
16802     failed++;
16803   }
16804   test_num++;
16805   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16806   if (test_write_file_0 () == -1) {
16807     printf ("test_write_file_0 FAILED\n");
16808     failed++;
16809   }
16810   test_num++;
16811   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16812   if (test_write_file_1 () == -1) {
16813     printf ("test_write_file_1 FAILED\n");
16814     failed++;
16815   }
16816   test_num++;
16817   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16818   if (test_write_file_2 () == -1) {
16819     printf ("test_write_file_2 FAILED\n");
16820     failed++;
16821   }
16822   test_num++;
16823   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16824   if (test_write_file_3 () == -1) {
16825     printf ("test_write_file_3 FAILED\n");
16826     failed++;
16827   }
16828   test_num++;
16829   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16830   if (test_write_file_4 () == -1) {
16831     printf ("test_write_file_4 FAILED\n");
16832     failed++;
16833   }
16834   test_num++;
16835   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16836   if (test_write_file_5 () == -1) {
16837     printf ("test_write_file_5 FAILED\n");
16838     failed++;
16839   }
16840   test_num++;
16841   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16842   if (test_mkfs_0 () == -1) {
16843     printf ("test_mkfs_0 FAILED\n");
16844     failed++;
16845   }
16846   test_num++;
16847   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16848   if (test_lvcreate_0 () == -1) {
16849     printf ("test_lvcreate_0 FAILED\n");
16850     failed++;
16851   }
16852   test_num++;
16853   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16854   if (test_vgcreate_0 () == -1) {
16855     printf ("test_vgcreate_0 FAILED\n");
16856     failed++;
16857   }
16858   test_num++;
16859   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16860   if (test_pvcreate_0 () == -1) {
16861     printf ("test_pvcreate_0 FAILED\n");
16862     failed++;
16863   }
16864   test_num++;
16865   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16866   if (test_is_dir_0 () == -1) {
16867     printf ("test_is_dir_0 FAILED\n");
16868     failed++;
16869   }
16870   test_num++;
16871   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16872   if (test_is_dir_1 () == -1) {
16873     printf ("test_is_dir_1 FAILED\n");
16874     failed++;
16875   }
16876   test_num++;
16877   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16878   if (test_is_file_0 () == -1) {
16879     printf ("test_is_file_0 FAILED\n");
16880     failed++;
16881   }
16882   test_num++;
16883   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16884   if (test_is_file_1 () == -1) {
16885     printf ("test_is_file_1 FAILED\n");
16886     failed++;
16887   }
16888   test_num++;
16889   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16890   if (test_exists_0 () == -1) {
16891     printf ("test_exists_0 FAILED\n");
16892     failed++;
16893   }
16894   test_num++;
16895   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16896   if (test_exists_1 () == -1) {
16897     printf ("test_exists_1 FAILED\n");
16898     failed++;
16899   }
16900   test_num++;
16901   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16902   if (test_mkdir_p_0 () == -1) {
16903     printf ("test_mkdir_p_0 FAILED\n");
16904     failed++;
16905   }
16906   test_num++;
16907   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16908   if (test_mkdir_p_1 () == -1) {
16909     printf ("test_mkdir_p_1 FAILED\n");
16910     failed++;
16911   }
16912   test_num++;
16913   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16914   if (test_mkdir_p_2 () == -1) {
16915     printf ("test_mkdir_p_2 FAILED\n");
16916     failed++;
16917   }
16918   test_num++;
16919   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16920   if (test_mkdir_p_3 () == -1) {
16921     printf ("test_mkdir_p_3 FAILED\n");
16922     failed++;
16923   }
16924   test_num++;
16925   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16926   if (test_mkdir_p_4 () == -1) {
16927     printf ("test_mkdir_p_4 FAILED\n");
16928     failed++;
16929   }
16930   test_num++;
16931   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16932   if (test_mkdir_0 () == -1) {
16933     printf ("test_mkdir_0 FAILED\n");
16934     failed++;
16935   }
16936   test_num++;
16937   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16938   if (test_mkdir_1 () == -1) {
16939     printf ("test_mkdir_1 FAILED\n");
16940     failed++;
16941   }
16942   test_num++;
16943   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16944   if (test_rm_rf_0 () == -1) {
16945     printf ("test_rm_rf_0 FAILED\n");
16946     failed++;
16947   }
16948   test_num++;
16949   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16950   if (test_rmdir_0 () == -1) {
16951     printf ("test_rmdir_0 FAILED\n");
16952     failed++;
16953   }
16954   test_num++;
16955   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16956   if (test_rmdir_1 () == -1) {
16957     printf ("test_rmdir_1 FAILED\n");
16958     failed++;
16959   }
16960   test_num++;
16961   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16962   if (test_rmdir_2 () == -1) {
16963     printf ("test_rmdir_2 FAILED\n");
16964     failed++;
16965   }
16966   test_num++;
16967   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16968   if (test_rm_0 () == -1) {
16969     printf ("test_rm_0 FAILED\n");
16970     failed++;
16971   }
16972   test_num++;
16973   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16974   if (test_rm_1 () == -1) {
16975     printf ("test_rm_1 FAILED\n");
16976     failed++;
16977   }
16978   test_num++;
16979   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16980   if (test_rm_2 () == -1) {
16981     printf ("test_rm_2 FAILED\n");
16982     failed++;
16983   }
16984   test_num++;
16985   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16986   if (test_read_lines_0 () == -1) {
16987     printf ("test_read_lines_0 FAILED\n");
16988     failed++;
16989   }
16990   test_num++;
16991   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16992   if (test_read_lines_1 () == -1) {
16993     printf ("test_read_lines_1 FAILED\n");
16994     failed++;
16995   }
16996   test_num++;
16997   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16998   if (test_lvs_0 () == -1) {
16999     printf ("test_lvs_0 FAILED\n");
17000     failed++;
17001   }
17002   test_num++;
17003   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
17004   if (test_lvs_1 () == -1) {
17005     printf ("test_lvs_1 FAILED\n");
17006     failed++;
17007   }
17008   test_num++;
17009   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
17010   if (test_vgs_0 () == -1) {
17011     printf ("test_vgs_0 FAILED\n");
17012     failed++;
17013   }
17014   test_num++;
17015   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17016   if (test_vgs_1 () == -1) {
17017     printf ("test_vgs_1 FAILED\n");
17018     failed++;
17019   }
17020   test_num++;
17021   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17022   if (test_pvs_0 () == -1) {
17023     printf ("test_pvs_0 FAILED\n");
17024     failed++;
17025   }
17026   test_num++;
17027   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17028   if (test_pvs_1 () == -1) {
17029     printf ("test_pvs_1 FAILED\n");
17030     failed++;
17031   }
17032   test_num++;
17033   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17034   if (test_list_partitions_0 () == -1) {
17035     printf ("test_list_partitions_0 FAILED\n");
17036     failed++;
17037   }
17038   test_num++;
17039   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17040   if (test_list_partitions_1 () == -1) {
17041     printf ("test_list_partitions_1 FAILED\n");
17042     failed++;
17043   }
17044   test_num++;
17045   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17046   if (test_list_devices_0 () == -1) {
17047     printf ("test_list_devices_0 FAILED\n");
17048     failed++;
17049   }
17050   test_num++;
17051   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17052   if (test_ls_0 () == -1) {
17053     printf ("test_ls_0 FAILED\n");
17054     failed++;
17055   }
17056   test_num++;
17057   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17058   if (test_cat_0 () == -1) {
17059     printf ("test_cat_0 FAILED\n");
17060     failed++;
17061   }
17062   test_num++;
17063   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17064   if (test_touch_0 () == -1) {
17065     printf ("test_touch_0 FAILED\n");
17066     failed++;
17067   }
17068   test_num++;
17069   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17070   if (test_sync_0 () == -1) {
17071     printf ("test_sync_0 FAILED\n");
17072     failed++;
17073   }
17074   test_num++;
17075   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17076   if (test_mount_0 () == -1) {
17077     printf ("test_mount_0 FAILED\n");
17078     failed++;
17079   }
17080
17081   guestfs_close (g);
17082   unlink ("test1.img");
17083   unlink ("test2.img");
17084   unlink ("test3.img");
17085
17086   if (failed > 0) {
17087     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
17088     exit (1);
17089   }
17090
17091   exit (0);
17092 }