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_find_0_skip (void)
 159 {
 160   const char *str;
 161
 162   str = getenv ("SKIP_TEST_FIND_0");
 163   if (str && strcmp (str, "1") == 0) return 1;
 164   str = getenv ("SKIP_TEST_FIND");
 165   if (str && strcmp (str, "1") == 0) return 1;
 166   return 0;
 167 }
 168
 169 static int test_find_0 (void)
 170 {
 171   if (test_find_0_skip ()) {
 172     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
 173     return 0;
 174   }
 175
 176   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 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   {
 201     char device[] = "/dev/sda";
 202     device[5] = devchar;
 203     char lines_0[] = ",";
 204     char *lines[] = {
 205       lines_0,
 206       NULL
 207     };
 208     int r;
 209     suppress_error = 0;
 210     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 211     if (r == -1)
 212       return -1;
 213   }
 214   {
 215     char fstype[] = "ext2";
 216     char device[] = "/dev/sda1";
 217     device[5] = devchar;
 218     int r;
 219     suppress_error = 0;
 220     r = guestfs_mkfs (g, fstype, device);
 221     if (r == -1)
 222       return -1;
 223   }
 224   {
 225     char device[] = "/dev/sda1";
 226     device[5] = devchar;
 227     char mountpoint[] = "/";
 228     int r;
 229     suppress_error = 0;
 230     r = guestfs_mount (g, device, mountpoint);
 231     if (r == -1)
 232       return -1;
 233   }
 234   /* TestOutputList for find (0) */
 235   {
 236     char directory[] = "/";
 237     char **r;
 238     int i;
 239     suppress_error = 0;
 240     r = guestfs_find (g, directory);
 241     if (r == NULL)
 242       return -1;
 243     if (!r[0]) {
 244       fprintf (stderr, "test_find_0: short list returned from command\n");
 245       print_strings (r);
 246       return -1;
 247     }
 248     {
 249       char expected[] = "lost+found";
 250       if (strcmp (r[0], expected) != 0) {
 251         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 252         return -1;
 253       }
 254     }
 255     if (r[1] != NULL) {
 256       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 257       print_strings (r);
 258       return -1;
 259     }
 260     for (i = 0; r[i] != NULL; ++i)
 261       free (r[i]);
 262     free (r);
 263   }
 264   return 0;
 265 }
 266
 267 static int test_find_1_skip (void)
 268 {
 269   const char *str;
 270
 271   str = getenv ("SKIP_TEST_FIND_1");
 272   if (str && strcmp (str, "1") == 0) return 1;
 273   str = getenv ("SKIP_TEST_FIND");
 274   if (str && strcmp (str, "1") == 0) return 1;
 275   return 0;
 276 }
 277
 278 static int test_find_1 (void)
 279 {
 280   if (test_find_1_skip ()) {
 281     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
 282     return 0;
 283   }
 284
 285   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
 286   {
 287     char device[] = "/dev/sda";
 288     device[5] = devchar;
 289     int r;
 290     suppress_error = 0;
 291     r = guestfs_blockdev_setrw (g, device);
 292     if (r == -1)
 293       return -1;
 294   }
 295   {
 296     int r;
 297     suppress_error = 0;
 298     r = guestfs_umount_all (g);
 299     if (r == -1)
 300       return -1;
 301   }
 302   {
 303     int r;
 304     suppress_error = 0;
 305     r = guestfs_lvm_remove_all (g);
 306     if (r == -1)
 307       return -1;
 308   }
 309   {
 310     char device[] = "/dev/sda";
 311     device[5] = devchar;
 312     char lines_0[] = ",";
 313     char *lines[] = {
 314       lines_0,
 315       NULL
 316     };
 317     int r;
 318     suppress_error = 0;
 319     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 320     if (r == -1)
 321       return -1;
 322   }
 323   {
 324     char fstype[] = "ext2";
 325     char device[] = "/dev/sda1";
 326     device[5] = devchar;
 327     int r;
 328     suppress_error = 0;
 329     r = guestfs_mkfs (g, fstype, device);
 330     if (r == -1)
 331       return -1;
 332   }
 333   {
 334     char device[] = "/dev/sda1";
 335     device[5] = devchar;
 336     char mountpoint[] = "/";
 337     int r;
 338     suppress_error = 0;
 339     r = guestfs_mount (g, device, mountpoint);
 340     if (r == -1)
 341       return -1;
 342   }
 343   /* TestOutputList for find (1) */
 344   {
 345     char path[] = "/a";
 346     int r;
 347     suppress_error = 0;
 348     r = guestfs_touch (g, path);
 349     if (r == -1)
 350       return -1;
 351   }
 352   {
 353     char path[] = "/b";
 354     int r;
 355     suppress_error = 0;
 356     r = guestfs_mkdir (g, path);
 357     if (r == -1)
 358       return -1;
 359   }
 360   {
 361     char path[] = "/b/c";
 362     int r;
 363     suppress_error = 0;
 364     r = guestfs_touch (g, path);
 365     if (r == -1)
 366       return -1;
 367   }
 368   {
 369     char directory[] = "/";
 370     char **r;
 371     int i;
 372     suppress_error = 0;
 373     r = guestfs_find (g, directory);
 374     if (r == NULL)
 375       return -1;
 376     if (!r[0]) {
 377       fprintf (stderr, "test_find_1: short list returned from command\n");
 378       print_strings (r);
 379       return -1;
 380     }
 381     {
 382       char expected[] = "a";
 383       if (strcmp (r[0], expected) != 0) {
 384         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 385         return -1;
 386       }
 387     }
 388     if (!r[1]) {
 389       fprintf (stderr, "test_find_1: short list returned from command\n");
 390       print_strings (r);
 391       return -1;
 392     }
 393     {
 394       char expected[] = "b";
 395       if (strcmp (r[1], expected) != 0) {
 396         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 397         return -1;
 398       }
 399     }
 400     if (!r[2]) {
 401       fprintf (stderr, "test_find_1: short list returned from command\n");
 402       print_strings (r);
 403       return -1;
 404     }
 405     {
 406       char expected[] = "b/c";
 407       if (strcmp (r[2], expected) != 0) {
 408         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 409         return -1;
 410       }
 411     }
 412     if (!r[3]) {
 413       fprintf (stderr, "test_find_1: short list returned from command\n");
 414       print_strings (r);
 415       return -1;
 416     }
 417     {
 418       char expected[] = "lost+found";
 419       if (strcmp (r[3], expected) != 0) {
 420         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 421         return -1;
 422       }
 423     }
 424     if (r[4] != NULL) {
 425       fprintf (stderr, "test_find_1: extra elements returned from command\n");
 426       print_strings (r);
 427       return -1;
 428     }
 429     for (i = 0; r[i] != NULL; ++i)
 430       free (r[i]);
 431     free (r);
 432   }
 433   return 0;
 434 }
 435
 436 static int test_find_2_skip (void)
 437 {
 438   const char *str;
 439
 440   str = getenv ("SKIP_TEST_FIND_2");
 441   if (str && strcmp (str, "1") == 0) return 1;
 442   str = getenv ("SKIP_TEST_FIND");
 443   if (str && strcmp (str, "1") == 0) return 1;
 444   return 0;
 445 }
 446
 447 static int test_find_2 (void)
 448 {
 449   if (test_find_2_skip ()) {
 450     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
 451     return 0;
 452   }
 453
 454   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
 455   {
 456     char device[] = "/dev/sda";
 457     device[5] = devchar;
 458     int r;
 459     suppress_error = 0;
 460     r = guestfs_blockdev_setrw (g, device);
 461     if (r == -1)
 462       return -1;
 463   }
 464   {
 465     int r;
 466     suppress_error = 0;
 467     r = guestfs_umount_all (g);
 468     if (r == -1)
 469       return -1;
 470   }
 471   {
 472     int r;
 473     suppress_error = 0;
 474     r = guestfs_lvm_remove_all (g);
 475     if (r == -1)
 476       return -1;
 477   }
 478   {
 479     char device[] = "/dev/sda";
 480     device[5] = devchar;
 481     char lines_0[] = ",";
 482     char *lines[] = {
 483       lines_0,
 484       NULL
 485     };
 486     int r;
 487     suppress_error = 0;
 488     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 489     if (r == -1)
 490       return -1;
 491   }
 492   {
 493     char fstype[] = "ext2";
 494     char device[] = "/dev/sda1";
 495     device[5] = devchar;
 496     int r;
 497     suppress_error = 0;
 498     r = guestfs_mkfs (g, fstype, device);
 499     if (r == -1)
 500       return -1;
 501   }
 502   {
 503     char device[] = "/dev/sda1";
 504     device[5] = devchar;
 505     char mountpoint[] = "/";
 506     int r;
 507     suppress_error = 0;
 508     r = guestfs_mount (g, device, mountpoint);
 509     if (r == -1)
 510       return -1;
 511   }
 512   /* TestOutputList for find (2) */
 513   {
 514     char path[] = "/a/b/c";
 515     int r;
 516     suppress_error = 0;
 517     r = guestfs_mkdir_p (g, path);
 518     if (r == -1)
 519       return -1;
 520   }
 521   {
 522     char path[] = "/a/b/c/d";
 523     int r;
 524     suppress_error = 0;
 525     r = guestfs_touch (g, path);
 526     if (r == -1)
 527       return -1;
 528   }
 529   {
 530     char directory[] = "/a/b/";
 531     char **r;
 532     int i;
 533     suppress_error = 0;
 534     r = guestfs_find (g, directory);
 535     if (r == NULL)
 536       return -1;
 537     if (!r[0]) {
 538       fprintf (stderr, "test_find_2: short list returned from command\n");
 539       print_strings (r);
 540       return -1;
 541     }
 542     {
 543       char expected[] = "c";
 544       if (strcmp (r[0], expected) != 0) {
 545         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 546         return -1;
 547       }
 548     }
 549     if (!r[1]) {
 550       fprintf (stderr, "test_find_2: short list returned from command\n");
 551       print_strings (r);
 552       return -1;
 553     }
 554     {
 555       char expected[] = "c/d";
 556       if (strcmp (r[1], expected) != 0) {
 557         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 558         return -1;
 559       }
 560     }
 561     if (r[2] != NULL) {
 562       fprintf (stderr, "test_find_2: extra elements returned from command\n");
 563       print_strings (r);
 564       return -1;
 565     }
 566     for (i = 0; r[i] != NULL; ++i)
 567       free (r[i]);
 568     free (r);
 569   }
 570   return 0;
 571 }
 572
 573 static int test_lvresize_0_skip (void)
 574 {
 575   const char *str;
 576
 577   str = getenv ("SKIP_TEST_LVRESIZE_0");
 578   if (str && strcmp (str, "1") == 0) return 1;
 579   str = getenv ("SKIP_TEST_LVRESIZE");
 580   if (str && strcmp (str, "1") == 0) return 1;
 581   return 0;
 582 }
 583
 584 static int test_lvresize_0 (void)
 585 {
 586   if (test_lvresize_0_skip ()) {
 587     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
 588     return 0;
 589   }
 590
 591   /* InitNone|InitEmpty for test_lvresize_0 */
 592   {
 593     char device[] = "/dev/sda";
 594     device[5] = devchar;
 595     int r;
 596     suppress_error = 0;
 597     r = guestfs_blockdev_setrw (g, device);
 598     if (r == -1)
 599       return -1;
 600   }
 601   {
 602     int r;
 603     suppress_error = 0;
 604     r = guestfs_umount_all (g);
 605     if (r == -1)
 606       return -1;
 607   }
 608   {
 609     int r;
 610     suppress_error = 0;
 611     r = guestfs_lvm_remove_all (g);
 612     if (r == -1)
 613       return -1;
 614   }
 615   /* TestOutput for lvresize (0) */
 616   char expected[] = "test content";
 617   {
 618     char device[] = "/dev/sda";
 619     device[5] = devchar;
 620     char lines_0[] = ",";
 621     char *lines[] = {
 622       lines_0,
 623       NULL
 624     };
 625     int r;
 626     suppress_error = 0;
 627     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 628     if (r == -1)
 629       return -1;
 630   }
 631   {
 632     char device[] = "/dev/sda1";
 633     device[5] = devchar;
 634     int r;
 635     suppress_error = 0;
 636     r = guestfs_pvcreate (g, device);
 637     if (r == -1)
 638       return -1;
 639   }
 640   {
 641     char volgroup[] = "VG";
 642     char physvols_0[] = "/dev/sda1";
 643     physvols_0[5] = devchar;
 644     char *physvols[] = {
 645       physvols_0,
 646       NULL
 647     };
 648     int r;
 649     suppress_error = 0;
 650     r = guestfs_vgcreate (g, volgroup, physvols);
 651     if (r == -1)
 652       return -1;
 653   }
 654   {
 655     char logvol[] = "LV";
 656     char volgroup[] = "VG";
 657     int r;
 658     suppress_error = 0;
 659     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 660     if (r == -1)
 661       return -1;
 662   }
 663   {
 664     char fstype[] = "ext2";
 665     char device[] = "/dev/VG/LV";
 666     int r;
 667     suppress_error = 0;
 668     r = guestfs_mkfs (g, fstype, device);
 669     if (r == -1)
 670       return -1;
 671   }
 672   {
 673     char device[] = "/dev/VG/LV";
 674     char mountpoint[] = "/";
 675     int r;
 676     suppress_error = 0;
 677     r = guestfs_mount (g, device, mountpoint);
 678     if (r == -1)
 679       return -1;
 680   }
 681   {
 682     char path[] = "/new";
 683     char content[] = "test content";
 684     int r;
 685     suppress_error = 0;
 686     r = guestfs_write_file (g, path, content, 0);
 687     if (r == -1)
 688       return -1;
 689   }
 690   {
 691     char pathordevice[] = "/";
 692     int r;
 693     suppress_error = 0;
 694     r = guestfs_umount (g, pathordevice);
 695     if (r == -1)
 696       return -1;
 697   }
 698   {
 699     char device[] = "/dev/VG/LV";
 700     int r;
 701     suppress_error = 0;
 702     r = guestfs_lvresize (g, device, 20);
 703     if (r == -1)
 704       return -1;
 705   }
 706   {
 707     char device[] = "/dev/VG/LV";
 708     int r;
 709     suppress_error = 0;
 710     r = guestfs_e2fsck_f (g, device);
 711     if (r == -1)
 712       return -1;
 713   }
 714   {
 715     char device[] = "/dev/VG/LV";
 716     int r;
 717     suppress_error = 0;
 718     r = guestfs_resize2fs (g, device);
 719     if (r == -1)
 720       return -1;
 721   }
 722   {
 723     char device[] = "/dev/VG/LV";
 724     char mountpoint[] = "/";
 725     int r;
 726     suppress_error = 0;
 727     r = guestfs_mount (g, device, mountpoint);
 728     if (r == -1)
 729       return -1;
 730   }
 731   {
 732     char path[] = "/new";
 733     char *r;
 734     suppress_error = 0;
 735     r = guestfs_cat (g, path);
 736     if (r == NULL)
 737       return -1;
 738     if (strcmp (r, expected) != 0) {
 739       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 740       return -1;
 741     }
 742     free (r);
 743   }
 744   return 0;
 745 }
 746
 747 static int test_zerofree_0_skip (void)
 748 {
 749   const char *str;
 750
 751   str = getenv ("SKIP_TEST_ZEROFREE_0");
 752   if (str && strcmp (str, "1") == 0) return 1;
 753   str = getenv ("SKIP_TEST_ZEROFREE");
 754   if (str && strcmp (str, "1") == 0) return 1;
 755   return 0;
 756 }
 757
 758 static int test_zerofree_0 (void)
 759 {
 760   if (test_zerofree_0_skip ()) {
 761     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
 762     return 0;
 763   }
 764
 765   /* InitNone|InitEmpty for test_zerofree_0 */
 766   {
 767     char device[] = "/dev/sda";
 768     device[5] = devchar;
 769     int r;
 770     suppress_error = 0;
 771     r = guestfs_blockdev_setrw (g, device);
 772     if (r == -1)
 773       return -1;
 774   }
 775   {
 776     int r;
 777     suppress_error = 0;
 778     r = guestfs_umount_all (g);
 779     if (r == -1)
 780       return -1;
 781   }
 782   {
 783     int r;
 784     suppress_error = 0;
 785     r = guestfs_lvm_remove_all (g);
 786     if (r == -1)
 787       return -1;
 788   }
 789   /* TestOutput for zerofree (0) */
 790   char expected[] = "test file";
 791   {
 792     char device[] = "/dev/sda";
 793     device[5] = devchar;
 794     char lines_0[] = ",";
 795     char *lines[] = {
 796       lines_0,
 797       NULL
 798     };
 799     int r;
 800     suppress_error = 0;
 801     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 802     if (r == -1)
 803       return -1;
 804   }
 805   {
 806     char fstype[] = "ext3";
 807     char device[] = "/dev/sda1";
 808     device[5] = devchar;
 809     int r;
 810     suppress_error = 0;
 811     r = guestfs_mkfs (g, fstype, device);
 812     if (r == -1)
 813       return -1;
 814   }
 815   {
 816     char device[] = "/dev/sda1";
 817     device[5] = devchar;
 818     char mountpoint[] = "/";
 819     int r;
 820     suppress_error = 0;
 821     r = guestfs_mount (g, device, mountpoint);
 822     if (r == -1)
 823       return -1;
 824   }
 825   {
 826     char path[] = "/new";
 827     char content[] = "test file";
 828     int r;
 829     suppress_error = 0;
 830     r = guestfs_write_file (g, path, content, 0);
 831     if (r == -1)
 832       return -1;
 833   }
 834   {
 835     char pathordevice[] = "/dev/sda1";
 836     pathordevice[5] = devchar;
 837     int r;
 838     suppress_error = 0;
 839     r = guestfs_umount (g, pathordevice);
 840     if (r == -1)
 841       return -1;
 842   }
 843   {
 844     char device[] = "/dev/sda1";
 845     device[5] = devchar;
 846     int r;
 847     suppress_error = 0;
 848     r = guestfs_zerofree (g, device);
 849     if (r == -1)
 850       return -1;
 851   }
 852   {
 853     char device[] = "/dev/sda1";
 854     device[5] = devchar;
 855     char mountpoint[] = "/";
 856     int r;
 857     suppress_error = 0;
 858     r = guestfs_mount (g, device, mountpoint);
 859     if (r == -1)
 860       return -1;
 861   }
 862   {
 863     char path[] = "/new";
 864     char *r;
 865     suppress_error = 0;
 866     r = guestfs_cat (g, path);
 867     if (r == NULL)
 868       return -1;
 869     if (strcmp (r, expected) != 0) {
 870       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
 871       return -1;
 872     }
 873     free (r);
 874   }
 875   return 0;
 876 }
 877
 878 static int test_hexdump_0_skip (void)
 879 {
 880   const char *str;
 881
 882   str = getenv ("SKIP_TEST_HEXDUMP_0");
 883   if (str && strcmp (str, "1") == 0) return 1;
 884   str = getenv ("SKIP_TEST_HEXDUMP");
 885   if (str && strcmp (str, "1") == 0) return 1;
 886   return 0;
 887 }
 888
 889 static int test_hexdump_0 (void)
 890 {
 891   if (test_hexdump_0_skip ()) {
 892     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
 893     return 0;
 894   }
 895
 896   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
 897   {
 898     char device[] = "/dev/sda";
 899     device[5] = devchar;
 900     int r;
 901     suppress_error = 0;
 902     r = guestfs_blockdev_setrw (g, device);
 903     if (r == -1)
 904       return -1;
 905   }
 906   {
 907     int r;
 908     suppress_error = 0;
 909     r = guestfs_umount_all (g);
 910     if (r == -1)
 911       return -1;
 912   }
 913   {
 914     int r;
 915     suppress_error = 0;
 916     r = guestfs_lvm_remove_all (g);
 917     if (r == -1)
 918       return -1;
 919   }
 920   {
 921     char device[] = "/dev/sda";
 922     device[5] = devchar;
 923     char lines_0[] = ",";
 924     char *lines[] = {
 925       lines_0,
 926       NULL
 927     };
 928     int r;
 929     suppress_error = 0;
 930     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 931     if (r == -1)
 932       return -1;
 933   }
 934   {
 935     char fstype[] = "ext2";
 936     char device[] = "/dev/sda1";
 937     device[5] = devchar;
 938     int r;
 939     suppress_error = 0;
 940     r = guestfs_mkfs (g, fstype, device);
 941     if (r == -1)
 942       return -1;
 943   }
 944   {
 945     char device[] = "/dev/sda1";
 946     device[5] = devchar;
 947     char mountpoint[] = "/";
 948     int r;
 949     suppress_error = 0;
 950     r = guestfs_mount (g, device, mountpoint);
 951     if (r == -1)
 952       return -1;
 953   }
 954   /* TestOutput for hexdump (0) */
 955   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
 956   {
 957     char path[] = "/new";
 958     char content[] = "hello\nworld\n";
 959     int r;
 960     suppress_error = 0;
 961     r = guestfs_write_file (g, path, content, 12);
 962     if (r == -1)
 963       return -1;
 964   }
 965   {
 966     char path[] = "/new";
 967     char *r;
 968     suppress_error = 0;
 969     r = guestfs_hexdump (g, path);
 970     if (r == NULL)
 971       return -1;
 972     if (strcmp (r, expected) != 0) {
 973       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
 974       return -1;
 975     }
 976     free (r);
 977   }
 978   return 0;
 979 }
 980
 981 static int test_strings_e_0_skip (void)
 982 {
 983   const char *str;
 984
 985   str = getenv ("SKIP_TEST_STRINGS_E_0");
 986   if (str && strcmp (str, "1") == 0) return 1;
 987   str = getenv ("SKIP_TEST_STRINGS_E");
 988   if (str && strcmp (str, "1") == 0) return 1;
 989   return 0;
 990 }
 991
 992 static int test_strings_e_0 (void)
 993 {
 994   if (test_strings_e_0_skip ()) {
 995     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
 996     return 0;
 997   }
 998
 999   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1000   {
1001     char device[] = "/dev/sda";
1002     device[5] = devchar;
1003     int r;
1004     suppress_error = 0;
1005     r = guestfs_blockdev_setrw (g, device);
1006     if (r == -1)
1007       return -1;
1008   }
1009   {
1010     int r;
1011     suppress_error = 0;
1012     r = guestfs_umount_all (g);
1013     if (r == -1)
1014       return -1;
1015   }
1016   {
1017     int r;
1018     suppress_error = 0;
1019     r = guestfs_lvm_remove_all (g);
1020     if (r == -1)
1021       return -1;
1022   }
1023   {
1024     char device[] = "/dev/sda";
1025     device[5] = devchar;
1026     char lines_0[] = ",";
1027     char *lines[] = {
1028       lines_0,
1029       NULL
1030     };
1031     int r;
1032     suppress_error = 0;
1033     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1034     if (r == -1)
1035       return -1;
1036   }
1037   {
1038     char fstype[] = "ext2";
1039     char device[] = "/dev/sda1";
1040     device[5] = devchar;
1041     int r;
1042     suppress_error = 0;
1043     r = guestfs_mkfs (g, fstype, device);
1044     if (r == -1)
1045       return -1;
1046   }
1047   {
1048     char device[] = "/dev/sda1";
1049     device[5] = devchar;
1050     char mountpoint[] = "/";
1051     int r;
1052     suppress_error = 0;
1053     r = guestfs_mount (g, device, mountpoint);
1054     if (r == -1)
1055       return -1;
1056   }
1057   /* TestOutputList for strings_e (0) */
1058   {
1059     char path[] = "/new";
1060     char content[] = "hello\nworld\n";
1061     int r;
1062     suppress_error = 0;
1063     r = guestfs_write_file (g, path, content, 0);
1064     if (r == -1)
1065       return -1;
1066   }
1067   {
1068     char encoding[] = "b";
1069     char path[] = "/new";
1070     char **r;
1071     int i;
1072     suppress_error = 0;
1073     r = guestfs_strings_e (g, encoding, path);
1074     if (r == NULL)
1075       return -1;
1076     if (r[0] != NULL) {
1077       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1078       print_strings (r);
1079       return -1;
1080     }
1081     for (i = 0; r[i] != NULL; ++i)
1082       free (r[i]);
1083     free (r);
1084   }
1085   return 0;
1086 }
1087
1088 static int test_strings_e_1_skip (void)
1089 {
1090   const char *str;
1091
1092   str = getenv ("SKIP_TEST_STRINGS_E_1");
1093   if (str && strcmp (str, "1") == 0) return 1;
1094   str = getenv ("SKIP_TEST_STRINGS_E");
1095   if (str && strcmp (str, "1") == 0) return 1;
1096   return 0;
1097 }
1098
1099 static int test_strings_e_1 (void)
1100 {
1101   if (test_strings_e_1_skip ()) {
1102     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1103     return 0;
1104   }
1105
1106   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1107   return 0;
1108 }
1109
1110 static int test_strings_0_skip (void)
1111 {
1112   const char *str;
1113
1114   str = getenv ("SKIP_TEST_STRINGS_0");
1115   if (str && strcmp (str, "1") == 0) return 1;
1116   str = getenv ("SKIP_TEST_STRINGS");
1117   if (str && strcmp (str, "1") == 0) return 1;
1118   return 0;
1119 }
1120
1121 static int test_strings_0 (void)
1122 {
1123   if (test_strings_0_skip ()) {
1124     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1125     return 0;
1126   }
1127
1128   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1129   {
1130     char device[] = "/dev/sda";
1131     device[5] = devchar;
1132     int r;
1133     suppress_error = 0;
1134     r = guestfs_blockdev_setrw (g, device);
1135     if (r == -1)
1136       return -1;
1137   }
1138   {
1139     int r;
1140     suppress_error = 0;
1141     r = guestfs_umount_all (g);
1142     if (r == -1)
1143       return -1;
1144   }
1145   {
1146     int r;
1147     suppress_error = 0;
1148     r = guestfs_lvm_remove_all (g);
1149     if (r == -1)
1150       return -1;
1151   }
1152   {
1153     char device[] = "/dev/sda";
1154     device[5] = devchar;
1155     char lines_0[] = ",";
1156     char *lines[] = {
1157       lines_0,
1158       NULL
1159     };
1160     int r;
1161     suppress_error = 0;
1162     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1163     if (r == -1)
1164       return -1;
1165   }
1166   {
1167     char fstype[] = "ext2";
1168     char device[] = "/dev/sda1";
1169     device[5] = devchar;
1170     int r;
1171     suppress_error = 0;
1172     r = guestfs_mkfs (g, fstype, device);
1173     if (r == -1)
1174       return -1;
1175   }
1176   {
1177     char device[] = "/dev/sda1";
1178     device[5] = devchar;
1179     char mountpoint[] = "/";
1180     int r;
1181     suppress_error = 0;
1182     r = guestfs_mount (g, device, mountpoint);
1183     if (r == -1)
1184       return -1;
1185   }
1186   /* TestOutputList for strings (0) */
1187   {
1188     char path[] = "/new";
1189     char content[] = "hello\nworld\n";
1190     int r;
1191     suppress_error = 0;
1192     r = guestfs_write_file (g, path, content, 0);
1193     if (r == -1)
1194       return -1;
1195   }
1196   {
1197     char path[] = "/new";
1198     char **r;
1199     int i;
1200     suppress_error = 0;
1201     r = guestfs_strings (g, path);
1202     if (r == NULL)
1203       return -1;
1204     if (!r[0]) {
1205       fprintf (stderr, "test_strings_0: short list returned from command\n");
1206       print_strings (r);
1207       return -1;
1208     }
1209     {
1210       char expected[] = "hello";
1211       if (strcmp (r[0], expected) != 0) {
1212         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1213         return -1;
1214       }
1215     }
1216     if (!r[1]) {
1217       fprintf (stderr, "test_strings_0: short list returned from command\n");
1218       print_strings (r);
1219       return -1;
1220     }
1221     {
1222       char expected[] = "world";
1223       if (strcmp (r[1], expected) != 0) {
1224         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1225         return -1;
1226       }
1227     }
1228     if (r[2] != NULL) {
1229       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1230       print_strings (r);
1231       return -1;
1232     }
1233     for (i = 0; r[i] != NULL; ++i)
1234       free (r[i]);
1235     free (r);
1236   }
1237   return 0;
1238 }
1239
1240 static int test_strings_1_skip (void)
1241 {
1242   const char *str;
1243
1244   str = getenv ("SKIP_TEST_STRINGS_1");
1245   if (str && strcmp (str, "1") == 0) return 1;
1246   str = getenv ("SKIP_TEST_STRINGS");
1247   if (str && strcmp (str, "1") == 0) return 1;
1248   return 0;
1249 }
1250
1251 static int test_strings_1 (void)
1252 {
1253   if (test_strings_1_skip ()) {
1254     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1255     return 0;
1256   }
1257
1258   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1259   {
1260     char device[] = "/dev/sda";
1261     device[5] = devchar;
1262     int r;
1263     suppress_error = 0;
1264     r = guestfs_blockdev_setrw (g, device);
1265     if (r == -1)
1266       return -1;
1267   }
1268   {
1269     int r;
1270     suppress_error = 0;
1271     r = guestfs_umount_all (g);
1272     if (r == -1)
1273       return -1;
1274   }
1275   {
1276     int r;
1277     suppress_error = 0;
1278     r = guestfs_lvm_remove_all (g);
1279     if (r == -1)
1280       return -1;
1281   }
1282   {
1283     char device[] = "/dev/sda";
1284     device[5] = devchar;
1285     char lines_0[] = ",";
1286     char *lines[] = {
1287       lines_0,
1288       NULL
1289     };
1290     int r;
1291     suppress_error = 0;
1292     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1293     if (r == -1)
1294       return -1;
1295   }
1296   {
1297     char fstype[] = "ext2";
1298     char device[] = "/dev/sda1";
1299     device[5] = devchar;
1300     int r;
1301     suppress_error = 0;
1302     r = guestfs_mkfs (g, fstype, device);
1303     if (r == -1)
1304       return -1;
1305   }
1306   {
1307     char device[] = "/dev/sda1";
1308     device[5] = devchar;
1309     char mountpoint[] = "/";
1310     int r;
1311     suppress_error = 0;
1312     r = guestfs_mount (g, device, mountpoint);
1313     if (r == -1)
1314       return -1;
1315   }
1316   /* TestOutputList for strings (1) */
1317   {
1318     char path[] = "/new";
1319     int r;
1320     suppress_error = 0;
1321     r = guestfs_touch (g, path);
1322     if (r == -1)
1323       return -1;
1324   }
1325   {
1326     char path[] = "/new";
1327     char **r;
1328     int i;
1329     suppress_error = 0;
1330     r = guestfs_strings (g, path);
1331     if (r == NULL)
1332       return -1;
1333     if (r[0] != NULL) {
1334       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1335       print_strings (r);
1336       return -1;
1337     }
1338     for (i = 0; r[i] != NULL; ++i)
1339       free (r[i]);
1340     free (r);
1341   }
1342   return 0;
1343 }
1344
1345 static int test_equal_0_skip (void)
1346 {
1347   const char *str;
1348
1349   str = getenv ("SKIP_TEST_EQUAL_0");
1350   if (str && strcmp (str, "1") == 0) return 1;
1351   str = getenv ("SKIP_TEST_EQUAL");
1352   if (str && strcmp (str, "1") == 0) return 1;
1353   return 0;
1354 }
1355
1356 static int test_equal_0 (void)
1357 {
1358   if (test_equal_0_skip ()) {
1359     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1360     return 0;
1361   }
1362
1363   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1364   {
1365     char device[] = "/dev/sda";
1366     device[5] = devchar;
1367     int r;
1368     suppress_error = 0;
1369     r = guestfs_blockdev_setrw (g, device);
1370     if (r == -1)
1371       return -1;
1372   }
1373   {
1374     int r;
1375     suppress_error = 0;
1376     r = guestfs_umount_all (g);
1377     if (r == -1)
1378       return -1;
1379   }
1380   {
1381     int r;
1382     suppress_error = 0;
1383     r = guestfs_lvm_remove_all (g);
1384     if (r == -1)
1385       return -1;
1386   }
1387   {
1388     char device[] = "/dev/sda";
1389     device[5] = devchar;
1390     char lines_0[] = ",";
1391     char *lines[] = {
1392       lines_0,
1393       NULL
1394     };
1395     int r;
1396     suppress_error = 0;
1397     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1398     if (r == -1)
1399       return -1;
1400   }
1401   {
1402     char fstype[] = "ext2";
1403     char device[] = "/dev/sda1";
1404     device[5] = devchar;
1405     int r;
1406     suppress_error = 0;
1407     r = guestfs_mkfs (g, fstype, device);
1408     if (r == -1)
1409       return -1;
1410   }
1411   {
1412     char device[] = "/dev/sda1";
1413     device[5] = devchar;
1414     char mountpoint[] = "/";
1415     int r;
1416     suppress_error = 0;
1417     r = guestfs_mount (g, device, mountpoint);
1418     if (r == -1)
1419       return -1;
1420   }
1421   /* TestOutputTrue for equal (0) */
1422   {
1423     char path[] = "/file1";
1424     char content[] = "contents of a file";
1425     int r;
1426     suppress_error = 0;
1427     r = guestfs_write_file (g, path, content, 0);
1428     if (r == -1)
1429       return -1;
1430   }
1431   {
1432     char src[] = "/file1";
1433     char dest[] = "/file2";
1434     int r;
1435     suppress_error = 0;
1436     r = guestfs_cp (g, src, dest);
1437     if (r == -1)
1438       return -1;
1439   }
1440   {
1441     char file1[] = "/file1";
1442     char file2[] = "/file2";
1443     int r;
1444     suppress_error = 0;
1445     r = guestfs_equal (g, file1, file2);
1446     if (r == -1)
1447       return -1;
1448     if (!r) {
1449       fprintf (stderr, "test_equal_0: expected true, got false\n");
1450       return -1;
1451     }
1452   }
1453   return 0;
1454 }
1455
1456 static int test_equal_1_skip (void)
1457 {
1458   const char *str;
1459
1460   str = getenv ("SKIP_TEST_EQUAL_1");
1461   if (str && strcmp (str, "1") == 0) return 1;
1462   str = getenv ("SKIP_TEST_EQUAL");
1463   if (str && strcmp (str, "1") == 0) return 1;
1464   return 0;
1465 }
1466
1467 static int test_equal_1 (void)
1468 {
1469   if (test_equal_1_skip ()) {
1470     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1471     return 0;
1472   }
1473
1474   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1475   {
1476     char device[] = "/dev/sda";
1477     device[5] = devchar;
1478     int r;
1479     suppress_error = 0;
1480     r = guestfs_blockdev_setrw (g, device);
1481     if (r == -1)
1482       return -1;
1483   }
1484   {
1485     int r;
1486     suppress_error = 0;
1487     r = guestfs_umount_all (g);
1488     if (r == -1)
1489       return -1;
1490   }
1491   {
1492     int r;
1493     suppress_error = 0;
1494     r = guestfs_lvm_remove_all (g);
1495     if (r == -1)
1496       return -1;
1497   }
1498   {
1499     char device[] = "/dev/sda";
1500     device[5] = devchar;
1501     char lines_0[] = ",";
1502     char *lines[] = {
1503       lines_0,
1504       NULL
1505     };
1506     int r;
1507     suppress_error = 0;
1508     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1509     if (r == -1)
1510       return -1;
1511   }
1512   {
1513     char fstype[] = "ext2";
1514     char device[] = "/dev/sda1";
1515     device[5] = devchar;
1516     int r;
1517     suppress_error = 0;
1518     r = guestfs_mkfs (g, fstype, device);
1519     if (r == -1)
1520       return -1;
1521   }
1522   {
1523     char device[] = "/dev/sda1";
1524     device[5] = devchar;
1525     char mountpoint[] = "/";
1526     int r;
1527     suppress_error = 0;
1528     r = guestfs_mount (g, device, mountpoint);
1529     if (r == -1)
1530       return -1;
1531   }
1532   /* TestOutputFalse for equal (1) */
1533   {
1534     char path[] = "/file1";
1535     char content[] = "contents of a file";
1536     int r;
1537     suppress_error = 0;
1538     r = guestfs_write_file (g, path, content, 0);
1539     if (r == -1)
1540       return -1;
1541   }
1542   {
1543     char path[] = "/file2";
1544     char content[] = "contents of another file";
1545     int r;
1546     suppress_error = 0;
1547     r = guestfs_write_file (g, path, content, 0);
1548     if (r == -1)
1549       return -1;
1550   }
1551   {
1552     char file1[] = "/file1";
1553     char file2[] = "/file2";
1554     int r;
1555     suppress_error = 0;
1556     r = guestfs_equal (g, file1, file2);
1557     if (r == -1)
1558       return -1;
1559     if (r) {
1560       fprintf (stderr, "test_equal_1: expected false, got true\n");
1561       return -1;
1562     }
1563   }
1564   return 0;
1565 }
1566
1567 static int test_equal_2_skip (void)
1568 {
1569   const char *str;
1570
1571   str = getenv ("SKIP_TEST_EQUAL_2");
1572   if (str && strcmp (str, "1") == 0) return 1;
1573   str = getenv ("SKIP_TEST_EQUAL");
1574   if (str && strcmp (str, "1") == 0) return 1;
1575   return 0;
1576 }
1577
1578 static int test_equal_2 (void)
1579 {
1580   if (test_equal_2_skip ()) {
1581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1582     return 0;
1583   }
1584
1585   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1586   {
1587     char device[] = "/dev/sda";
1588     device[5] = devchar;
1589     int r;
1590     suppress_error = 0;
1591     r = guestfs_blockdev_setrw (g, device);
1592     if (r == -1)
1593       return -1;
1594   }
1595   {
1596     int r;
1597     suppress_error = 0;
1598     r = guestfs_umount_all (g);
1599     if (r == -1)
1600       return -1;
1601   }
1602   {
1603     int r;
1604     suppress_error = 0;
1605     r = guestfs_lvm_remove_all (g);
1606     if (r == -1)
1607       return -1;
1608   }
1609   {
1610     char device[] = "/dev/sda";
1611     device[5] = devchar;
1612     char lines_0[] = ",";
1613     char *lines[] = {
1614       lines_0,
1615       NULL
1616     };
1617     int r;
1618     suppress_error = 0;
1619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1620     if (r == -1)
1621       return -1;
1622   }
1623   {
1624     char fstype[] = "ext2";
1625     char device[] = "/dev/sda1";
1626     device[5] = devchar;
1627     int r;
1628     suppress_error = 0;
1629     r = guestfs_mkfs (g, fstype, device);
1630     if (r == -1)
1631       return -1;
1632   }
1633   {
1634     char device[] = "/dev/sda1";
1635     device[5] = devchar;
1636     char mountpoint[] = "/";
1637     int r;
1638     suppress_error = 0;
1639     r = guestfs_mount (g, device, mountpoint);
1640     if (r == -1)
1641       return -1;
1642   }
1643   /* TestLastFail for equal (2) */
1644   {
1645     char file1[] = "/file1";
1646     char file2[] = "/file2";
1647     int r;
1648     suppress_error = 1;
1649     r = guestfs_equal (g, file1, file2);
1650     if (r != -1)
1651       return -1;
1652   }
1653   return 0;
1654 }
1655
1656 static int test_ping_daemon_0_skip (void)
1657 {
1658   const char *str;
1659
1660   str = getenv ("SKIP_TEST_PING_DAEMON_0");
1661   if (str && strcmp (str, "1") == 0) return 1;
1662   str = getenv ("SKIP_TEST_PING_DAEMON");
1663   if (str && strcmp (str, "1") == 0) return 1;
1664   return 0;
1665 }
1666
1667 static int test_ping_daemon_0 (void)
1668 {
1669   if (test_ping_daemon_0_skip ()) {
1670     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1671     return 0;
1672   }
1673
1674   /* InitNone|InitEmpty for test_ping_daemon_0 */
1675   {
1676     char device[] = "/dev/sda";
1677     device[5] = devchar;
1678     int r;
1679     suppress_error = 0;
1680     r = guestfs_blockdev_setrw (g, device);
1681     if (r == -1)
1682       return -1;
1683   }
1684   {
1685     int r;
1686     suppress_error = 0;
1687     r = guestfs_umount_all (g);
1688     if (r == -1)
1689       return -1;
1690   }
1691   {
1692     int r;
1693     suppress_error = 0;
1694     r = guestfs_lvm_remove_all (g);
1695     if (r == -1)
1696       return -1;
1697   }
1698   /* TestRun for ping_daemon (0) */
1699   {
1700     int r;
1701     suppress_error = 0;
1702     r = guestfs_ping_daemon (g);
1703     if (r == -1)
1704       return -1;
1705   }
1706   return 0;
1707 }
1708
1709 static int test_dmesg_0_skip (void)
1710 {
1711   const char *str;
1712
1713   str = getenv ("SKIP_TEST_DMESG_0");
1714   if (str && strcmp (str, "1") == 0) return 1;
1715   str = getenv ("SKIP_TEST_DMESG");
1716   if (str && strcmp (str, "1") == 0) return 1;
1717   return 0;
1718 }
1719
1720 static int test_dmesg_0 (void)
1721 {
1722   if (test_dmesg_0_skip ()) {
1723     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1724     return 0;
1725   }
1726
1727   /* InitNone|InitEmpty for test_dmesg_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 dmesg (0) */
1752   {
1753     char *r;
1754     suppress_error = 0;
1755     r = guestfs_dmesg (g);
1756     if (r == NULL)
1757       return -1;
1758     free (r);
1759   }
1760   return 0;
1761 }
1762
1763 static int test_drop_caches_0_skip (void)
1764 {
1765   const char *str;
1766
1767   str = getenv ("SKIP_TEST_DROP_CACHES_0");
1768   if (str && strcmp (str, "1") == 0) return 1;
1769   str = getenv ("SKIP_TEST_DROP_CACHES");
1770   if (str && strcmp (str, "1") == 0) return 1;
1771   return 0;
1772 }
1773
1774 static int test_drop_caches_0 (void)
1775 {
1776   if (test_drop_caches_0_skip ()) {
1777     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1778     return 0;
1779   }
1780
1781   /* InitNone|InitEmpty for test_drop_caches_0 */
1782   {
1783     char device[] = "/dev/sda";
1784     device[5] = devchar;
1785     int r;
1786     suppress_error = 0;
1787     r = guestfs_blockdev_setrw (g, device);
1788     if (r == -1)
1789       return -1;
1790   }
1791   {
1792     int r;
1793     suppress_error = 0;
1794     r = guestfs_umount_all (g);
1795     if (r == -1)
1796       return -1;
1797   }
1798   {
1799     int r;
1800     suppress_error = 0;
1801     r = guestfs_lvm_remove_all (g);
1802     if (r == -1)
1803       return -1;
1804   }
1805   /* TestRun for drop_caches (0) */
1806   {
1807     int r;
1808     suppress_error = 0;
1809     r = guestfs_drop_caches (g, 3);
1810     if (r == -1)
1811       return -1;
1812   }
1813   return 0;
1814 }
1815
1816 static int test_mv_0_skip (void)
1817 {
1818   const char *str;
1819
1820   str = getenv ("SKIP_TEST_MV_0");
1821   if (str && strcmp (str, "1") == 0) return 1;
1822   str = getenv ("SKIP_TEST_MV");
1823   if (str && strcmp (str, "1") == 0) return 1;
1824   return 0;
1825 }
1826
1827 static int test_mv_0 (void)
1828 {
1829   if (test_mv_0_skip ()) {
1830     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
1831     return 0;
1832   }
1833
1834   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
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   {
1859     char device[] = "/dev/sda";
1860     device[5] = devchar;
1861     char lines_0[] = ",";
1862     char *lines[] = {
1863       lines_0,
1864       NULL
1865     };
1866     int r;
1867     suppress_error = 0;
1868     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1869     if (r == -1)
1870       return -1;
1871   }
1872   {
1873     char fstype[] = "ext2";
1874     char device[] = "/dev/sda1";
1875     device[5] = devchar;
1876     int r;
1877     suppress_error = 0;
1878     r = guestfs_mkfs (g, fstype, device);
1879     if (r == -1)
1880       return -1;
1881   }
1882   {
1883     char device[] = "/dev/sda1";
1884     device[5] = devchar;
1885     char mountpoint[] = "/";
1886     int r;
1887     suppress_error = 0;
1888     r = guestfs_mount (g, device, mountpoint);
1889     if (r == -1)
1890       return -1;
1891   }
1892   /* TestOutput for mv (0) */
1893   char expected[] = "file content";
1894   {
1895     char path[] = "/old";
1896     char content[] = "file content";
1897     int r;
1898     suppress_error = 0;
1899     r = guestfs_write_file (g, path, content, 0);
1900     if (r == -1)
1901       return -1;
1902   }
1903   {
1904     char src[] = "/old";
1905     char dest[] = "/new";
1906     int r;
1907     suppress_error = 0;
1908     r = guestfs_mv (g, src, dest);
1909     if (r == -1)
1910       return -1;
1911   }
1912   {
1913     char path[] = "/new";
1914     char *r;
1915     suppress_error = 0;
1916     r = guestfs_cat (g, path);
1917     if (r == NULL)
1918       return -1;
1919     if (strcmp (r, expected) != 0) {
1920       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1921       return -1;
1922     }
1923     free (r);
1924   }
1925   return 0;
1926 }
1927
1928 static int test_mv_1_skip (void)
1929 {
1930   const char *str;
1931
1932   str = getenv ("SKIP_TEST_MV_1");
1933   if (str && strcmp (str, "1") == 0) return 1;
1934   str = getenv ("SKIP_TEST_MV");
1935   if (str && strcmp (str, "1") == 0) return 1;
1936   return 0;
1937 }
1938
1939 static int test_mv_1 (void)
1940 {
1941   if (test_mv_1_skip ()) {
1942     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
1943     return 0;
1944   }
1945
1946   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1947   {
1948     char device[] = "/dev/sda";
1949     device[5] = devchar;
1950     int r;
1951     suppress_error = 0;
1952     r = guestfs_blockdev_setrw (g, device);
1953     if (r == -1)
1954       return -1;
1955   }
1956   {
1957     int r;
1958     suppress_error = 0;
1959     r = guestfs_umount_all (g);
1960     if (r == -1)
1961       return -1;
1962   }
1963   {
1964     int r;
1965     suppress_error = 0;
1966     r = guestfs_lvm_remove_all (g);
1967     if (r == -1)
1968       return -1;
1969   }
1970   {
1971     char device[] = "/dev/sda";
1972     device[5] = devchar;
1973     char lines_0[] = ",";
1974     char *lines[] = {
1975       lines_0,
1976       NULL
1977     };
1978     int r;
1979     suppress_error = 0;
1980     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1981     if (r == -1)
1982       return -1;
1983   }
1984   {
1985     char fstype[] = "ext2";
1986     char device[] = "/dev/sda1";
1987     device[5] = devchar;
1988     int r;
1989     suppress_error = 0;
1990     r = guestfs_mkfs (g, fstype, device);
1991     if (r == -1)
1992       return -1;
1993   }
1994   {
1995     char device[] = "/dev/sda1";
1996     device[5] = devchar;
1997     char mountpoint[] = "/";
1998     int r;
1999     suppress_error = 0;
2000     r = guestfs_mount (g, device, mountpoint);
2001     if (r == -1)
2002       return -1;
2003   }
2004   /* TestOutputFalse for mv (1) */
2005   {
2006     char path[] = "/old";
2007     char content[] = "file content";
2008     int r;
2009     suppress_error = 0;
2010     r = guestfs_write_file (g, path, content, 0);
2011     if (r == -1)
2012       return -1;
2013   }
2014   {
2015     char src[] = "/old";
2016     char dest[] = "/new";
2017     int r;
2018     suppress_error = 0;
2019     r = guestfs_mv (g, src, dest);
2020     if (r == -1)
2021       return -1;
2022   }
2023   {
2024     char path[] = "/old";
2025     int r;
2026     suppress_error = 0;
2027     r = guestfs_is_file (g, path);
2028     if (r == -1)
2029       return -1;
2030     if (r) {
2031       fprintf (stderr, "test_mv_1: expected false, got true\n");
2032       return -1;
2033     }
2034   }
2035   return 0;
2036 }
2037
2038 static int test_cp_a_0_skip (void)
2039 {
2040   const char *str;
2041
2042   str = getenv ("SKIP_TEST_CP_A_0");
2043   if (str && strcmp (str, "1") == 0) return 1;
2044   str = getenv ("SKIP_TEST_CP_A");
2045   if (str && strcmp (str, "1") == 0) return 1;
2046   return 0;
2047 }
2048
2049 static int test_cp_a_0 (void)
2050 {
2051   if (test_cp_a_0_skip ()) {
2052     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2053     return 0;
2054   }
2055
2056   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2057   {
2058     char device[] = "/dev/sda";
2059     device[5] = devchar;
2060     int r;
2061     suppress_error = 0;
2062     r = guestfs_blockdev_setrw (g, device);
2063     if (r == -1)
2064       return -1;
2065   }
2066   {
2067     int r;
2068     suppress_error = 0;
2069     r = guestfs_umount_all (g);
2070     if (r == -1)
2071       return -1;
2072   }
2073   {
2074     int r;
2075     suppress_error = 0;
2076     r = guestfs_lvm_remove_all (g);
2077     if (r == -1)
2078       return -1;
2079   }
2080   {
2081     char device[] = "/dev/sda";
2082     device[5] = devchar;
2083     char lines_0[] = ",";
2084     char *lines[] = {
2085       lines_0,
2086       NULL
2087     };
2088     int r;
2089     suppress_error = 0;
2090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2091     if (r == -1)
2092       return -1;
2093   }
2094   {
2095     char fstype[] = "ext2";
2096     char device[] = "/dev/sda1";
2097     device[5] = devchar;
2098     int r;
2099     suppress_error = 0;
2100     r = guestfs_mkfs (g, fstype, device);
2101     if (r == -1)
2102       return -1;
2103   }
2104   {
2105     char device[] = "/dev/sda1";
2106     device[5] = devchar;
2107     char mountpoint[] = "/";
2108     int r;
2109     suppress_error = 0;
2110     r = guestfs_mount (g, device, mountpoint);
2111     if (r == -1)
2112       return -1;
2113   }
2114   /* TestOutput for cp_a (0) */
2115   char expected[] = "file content";
2116   {
2117     char path[] = "/olddir";
2118     int r;
2119     suppress_error = 0;
2120     r = guestfs_mkdir (g, path);
2121     if (r == -1)
2122       return -1;
2123   }
2124   {
2125     char path[] = "/newdir";
2126     int r;
2127     suppress_error = 0;
2128     r = guestfs_mkdir (g, path);
2129     if (r == -1)
2130       return -1;
2131   }
2132   {
2133     char path[] = "/olddir/file";
2134     char content[] = "file content";
2135     int r;
2136     suppress_error = 0;
2137     r = guestfs_write_file (g, path, content, 0);
2138     if (r == -1)
2139       return -1;
2140   }
2141   {
2142     char src[] = "/olddir";
2143     char dest[] = "/newdir";
2144     int r;
2145     suppress_error = 0;
2146     r = guestfs_cp_a (g, src, dest);
2147     if (r == -1)
2148       return -1;
2149   }
2150   {
2151     char path[] = "/newdir/olddir/file";
2152     char *r;
2153     suppress_error = 0;
2154     r = guestfs_cat (g, path);
2155     if (r == NULL)
2156       return -1;
2157     if (strcmp (r, expected) != 0) {
2158       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2159       return -1;
2160     }
2161     free (r);
2162   }
2163   return 0;
2164 }
2165
2166 static int test_cp_0_skip (void)
2167 {
2168   const char *str;
2169
2170   str = getenv ("SKIP_TEST_CP_0");
2171   if (str && strcmp (str, "1") == 0) return 1;
2172   str = getenv ("SKIP_TEST_CP");
2173   if (str && strcmp (str, "1") == 0) return 1;
2174   return 0;
2175 }
2176
2177 static int test_cp_0 (void)
2178 {
2179   if (test_cp_0_skip ()) {
2180     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2181     return 0;
2182   }
2183
2184   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2185   {
2186     char device[] = "/dev/sda";
2187     device[5] = devchar;
2188     int r;
2189     suppress_error = 0;
2190     r = guestfs_blockdev_setrw (g, device);
2191     if (r == -1)
2192       return -1;
2193   }
2194   {
2195     int r;
2196     suppress_error = 0;
2197     r = guestfs_umount_all (g);
2198     if (r == -1)
2199       return -1;
2200   }
2201   {
2202     int r;
2203     suppress_error = 0;
2204     r = guestfs_lvm_remove_all (g);
2205     if (r == -1)
2206       return -1;
2207   }
2208   {
2209     char device[] = "/dev/sda";
2210     device[5] = devchar;
2211     char lines_0[] = ",";
2212     char *lines[] = {
2213       lines_0,
2214       NULL
2215     };
2216     int r;
2217     suppress_error = 0;
2218     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2219     if (r == -1)
2220       return -1;
2221   }
2222   {
2223     char fstype[] = "ext2";
2224     char device[] = "/dev/sda1";
2225     device[5] = devchar;
2226     int r;
2227     suppress_error = 0;
2228     r = guestfs_mkfs (g, fstype, device);
2229     if (r == -1)
2230       return -1;
2231   }
2232   {
2233     char device[] = "/dev/sda1";
2234     device[5] = devchar;
2235     char mountpoint[] = "/";
2236     int r;
2237     suppress_error = 0;
2238     r = guestfs_mount (g, device, mountpoint);
2239     if (r == -1)
2240       return -1;
2241   }
2242   /* TestOutput for cp (0) */
2243   char expected[] = "file content";
2244   {
2245     char path[] = "/old";
2246     char content[] = "file content";
2247     int r;
2248     suppress_error = 0;
2249     r = guestfs_write_file (g, path, content, 0);
2250     if (r == -1)
2251       return -1;
2252   }
2253   {
2254     char src[] = "/old";
2255     char dest[] = "/new";
2256     int r;
2257     suppress_error = 0;
2258     r = guestfs_cp (g, src, dest);
2259     if (r == -1)
2260       return -1;
2261   }
2262   {
2263     char path[] = "/new";
2264     char *r;
2265     suppress_error = 0;
2266     r = guestfs_cat (g, path);
2267     if (r == NULL)
2268       return -1;
2269     if (strcmp (r, expected) != 0) {
2270       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2271       return -1;
2272     }
2273     free (r);
2274   }
2275   return 0;
2276 }
2277
2278 static int test_cp_1_skip (void)
2279 {
2280   const char *str;
2281
2282   str = getenv ("SKIP_TEST_CP_1");
2283   if (str && strcmp (str, "1") == 0) return 1;
2284   str = getenv ("SKIP_TEST_CP");
2285   if (str && strcmp (str, "1") == 0) return 1;
2286   return 0;
2287 }
2288
2289 static int test_cp_1 (void)
2290 {
2291   if (test_cp_1_skip ()) {
2292     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2293     return 0;
2294   }
2295
2296   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2297   {
2298     char device[] = "/dev/sda";
2299     device[5] = devchar;
2300     int r;
2301     suppress_error = 0;
2302     r = guestfs_blockdev_setrw (g, device);
2303     if (r == -1)
2304       return -1;
2305   }
2306   {
2307     int r;
2308     suppress_error = 0;
2309     r = guestfs_umount_all (g);
2310     if (r == -1)
2311       return -1;
2312   }
2313   {
2314     int r;
2315     suppress_error = 0;
2316     r = guestfs_lvm_remove_all (g);
2317     if (r == -1)
2318       return -1;
2319   }
2320   {
2321     char device[] = "/dev/sda";
2322     device[5] = devchar;
2323     char lines_0[] = ",";
2324     char *lines[] = {
2325       lines_0,
2326       NULL
2327     };
2328     int r;
2329     suppress_error = 0;
2330     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2331     if (r == -1)
2332       return -1;
2333   }
2334   {
2335     char fstype[] = "ext2";
2336     char device[] = "/dev/sda1";
2337     device[5] = devchar;
2338     int r;
2339     suppress_error = 0;
2340     r = guestfs_mkfs (g, fstype, device);
2341     if (r == -1)
2342       return -1;
2343   }
2344   {
2345     char device[] = "/dev/sda1";
2346     device[5] = devchar;
2347     char mountpoint[] = "/";
2348     int r;
2349     suppress_error = 0;
2350     r = guestfs_mount (g, device, mountpoint);
2351     if (r == -1)
2352       return -1;
2353   }
2354   /* TestOutputTrue for cp (1) */
2355   {
2356     char path[] = "/old";
2357     char content[] = "file content";
2358     int r;
2359     suppress_error = 0;
2360     r = guestfs_write_file (g, path, content, 0);
2361     if (r == -1)
2362       return -1;
2363   }
2364   {
2365     char src[] = "/old";
2366     char dest[] = "/new";
2367     int r;
2368     suppress_error = 0;
2369     r = guestfs_cp (g, src, dest);
2370     if (r == -1)
2371       return -1;
2372   }
2373   {
2374     char path[] = "/old";
2375     int r;
2376     suppress_error = 0;
2377     r = guestfs_is_file (g, path);
2378     if (r == -1)
2379       return -1;
2380     if (!r) {
2381       fprintf (stderr, "test_cp_1: expected true, got false\n");
2382       return -1;
2383     }
2384   }
2385   return 0;
2386 }
2387
2388 static int test_cp_2_skip (void)
2389 {
2390   const char *str;
2391
2392   str = getenv ("SKIP_TEST_CP_2");
2393   if (str && strcmp (str, "1") == 0) return 1;
2394   str = getenv ("SKIP_TEST_CP");
2395   if (str && strcmp (str, "1") == 0) return 1;
2396   return 0;
2397 }
2398
2399 static int test_cp_2 (void)
2400 {
2401   if (test_cp_2_skip ()) {
2402     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2403     return 0;
2404   }
2405
2406   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2407   {
2408     char device[] = "/dev/sda";
2409     device[5] = devchar;
2410     int r;
2411     suppress_error = 0;
2412     r = guestfs_blockdev_setrw (g, device);
2413     if (r == -1)
2414       return -1;
2415   }
2416   {
2417     int r;
2418     suppress_error = 0;
2419     r = guestfs_umount_all (g);
2420     if (r == -1)
2421       return -1;
2422   }
2423   {
2424     int r;
2425     suppress_error = 0;
2426     r = guestfs_lvm_remove_all (g);
2427     if (r == -1)
2428       return -1;
2429   }
2430   {
2431     char device[] = "/dev/sda";
2432     device[5] = devchar;
2433     char lines_0[] = ",";
2434     char *lines[] = {
2435       lines_0,
2436       NULL
2437     };
2438     int r;
2439     suppress_error = 0;
2440     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2441     if (r == -1)
2442       return -1;
2443   }
2444   {
2445     char fstype[] = "ext2";
2446     char device[] = "/dev/sda1";
2447     device[5] = devchar;
2448     int r;
2449     suppress_error = 0;
2450     r = guestfs_mkfs (g, fstype, device);
2451     if (r == -1)
2452       return -1;
2453   }
2454   {
2455     char device[] = "/dev/sda1";
2456     device[5] = devchar;
2457     char mountpoint[] = "/";
2458     int r;
2459     suppress_error = 0;
2460     r = guestfs_mount (g, device, mountpoint);
2461     if (r == -1)
2462       return -1;
2463   }
2464   /* TestOutput for cp (2) */
2465   char expected[] = "file content";
2466   {
2467     char path[] = "/old";
2468     char content[] = "file content";
2469     int r;
2470     suppress_error = 0;
2471     r = guestfs_write_file (g, path, content, 0);
2472     if (r == -1)
2473       return -1;
2474   }
2475   {
2476     char path[] = "/dir";
2477     int r;
2478     suppress_error = 0;
2479     r = guestfs_mkdir (g, path);
2480     if (r == -1)
2481       return -1;
2482   }
2483   {
2484     char src[] = "/old";
2485     char dest[] = "/dir/new";
2486     int r;
2487     suppress_error = 0;
2488     r = guestfs_cp (g, src, dest);
2489     if (r == -1)
2490       return -1;
2491   }
2492   {
2493     char path[] = "/dir/new";
2494     char *r;
2495     suppress_error = 0;
2496     r = guestfs_cat (g, path);
2497     if (r == NULL)
2498       return -1;
2499     if (strcmp (r, expected) != 0) {
2500       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2501       return -1;
2502     }
2503     free (r);
2504   }
2505   return 0;
2506 }
2507
2508 static int test_grub_install_0_skip (void)
2509 {
2510   const char *str;
2511
2512   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2513   if (str && strcmp (str, "1") == 0) return 1;
2514   str = getenv ("SKIP_TEST_GRUB_INSTALL");
2515   if (str && strcmp (str, "1") == 0) return 1;
2516   return 0;
2517 }
2518
2519 static int test_grub_install_0 (void)
2520 {
2521   if (test_grub_install_0_skip ()) {
2522     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2523     return 0;
2524   }
2525
2526   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2527   {
2528     char device[] = "/dev/sda";
2529     device[5] = devchar;
2530     int r;
2531     suppress_error = 0;
2532     r = guestfs_blockdev_setrw (g, device);
2533     if (r == -1)
2534       return -1;
2535   }
2536   {
2537     int r;
2538     suppress_error = 0;
2539     r = guestfs_umount_all (g);
2540     if (r == -1)
2541       return -1;
2542   }
2543   {
2544     int r;
2545     suppress_error = 0;
2546     r = guestfs_lvm_remove_all (g);
2547     if (r == -1)
2548       return -1;
2549   }
2550   {
2551     char device[] = "/dev/sda";
2552     device[5] = devchar;
2553     char lines_0[] = ",";
2554     char *lines[] = {
2555       lines_0,
2556       NULL
2557     };
2558     int r;
2559     suppress_error = 0;
2560     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2561     if (r == -1)
2562       return -1;
2563   }
2564   {
2565     char fstype[] = "ext2";
2566     char device[] = "/dev/sda1";
2567     device[5] = devchar;
2568     int r;
2569     suppress_error = 0;
2570     r = guestfs_mkfs (g, fstype, device);
2571     if (r == -1)
2572       return -1;
2573   }
2574   {
2575     char device[] = "/dev/sda1";
2576     device[5] = devchar;
2577     char mountpoint[] = "/";
2578     int r;
2579     suppress_error = 0;
2580     r = guestfs_mount (g, device, mountpoint);
2581     if (r == -1)
2582       return -1;
2583   }
2584   /* TestOutputTrue for grub_install (0) */
2585   {
2586     char root[] = "/";
2587     char device[] = "/dev/sda1";
2588     device[5] = devchar;
2589     int r;
2590     suppress_error = 0;
2591     r = guestfs_grub_install (g, root, device);
2592     if (r == -1)
2593       return -1;
2594   }
2595   {
2596     char path[] = "/boot";
2597     int r;
2598     suppress_error = 0;
2599     r = guestfs_is_dir (g, path);
2600     if (r == -1)
2601       return -1;
2602     if (!r) {
2603       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2604       return -1;
2605     }
2606   }
2607   return 0;
2608 }
2609
2610 static int test_zero_0_skip (void)
2611 {
2612   const char *str;
2613
2614   str = getenv ("SKIP_TEST_ZERO_0");
2615   if (str && strcmp (str, "1") == 0) return 1;
2616   str = getenv ("SKIP_TEST_ZERO");
2617   if (str && strcmp (str, "1") == 0) return 1;
2618   return 0;
2619 }
2620
2621 static int test_zero_0 (void)
2622 {
2623   if (test_zero_0_skip ()) {
2624     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2625     return 0;
2626   }
2627
2628   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2629   {
2630     char device[] = "/dev/sda";
2631     device[5] = devchar;
2632     int r;
2633     suppress_error = 0;
2634     r = guestfs_blockdev_setrw (g, device);
2635     if (r == -1)
2636       return -1;
2637   }
2638   {
2639     int r;
2640     suppress_error = 0;
2641     r = guestfs_umount_all (g);
2642     if (r == -1)
2643       return -1;
2644   }
2645   {
2646     int r;
2647     suppress_error = 0;
2648     r = guestfs_lvm_remove_all (g);
2649     if (r == -1)
2650       return -1;
2651   }
2652   {
2653     char device[] = "/dev/sda";
2654     device[5] = devchar;
2655     char lines_0[] = ",";
2656     char *lines[] = {
2657       lines_0,
2658       NULL
2659     };
2660     int r;
2661     suppress_error = 0;
2662     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2663     if (r == -1)
2664       return -1;
2665   }
2666   {
2667     char fstype[] = "ext2";
2668     char device[] = "/dev/sda1";
2669     device[5] = devchar;
2670     int r;
2671     suppress_error = 0;
2672     r = guestfs_mkfs (g, fstype, device);
2673     if (r == -1)
2674       return -1;
2675   }
2676   {
2677     char device[] = "/dev/sda1";
2678     device[5] = devchar;
2679     char mountpoint[] = "/";
2680     int r;
2681     suppress_error = 0;
2682     r = guestfs_mount (g, device, mountpoint);
2683     if (r == -1)
2684       return -1;
2685   }
2686   /* TestOutput for zero (0) */
2687   char expected[] = "data";
2688   {
2689     char pathordevice[] = "/dev/sda1";
2690     pathordevice[5] = devchar;
2691     int r;
2692     suppress_error = 0;
2693     r = guestfs_umount (g, pathordevice);
2694     if (r == -1)
2695       return -1;
2696   }
2697   {
2698     char device[] = "/dev/sda1";
2699     device[5] = devchar;
2700     int r;
2701     suppress_error = 0;
2702     r = guestfs_zero (g, device);
2703     if (r == -1)
2704       return -1;
2705   }
2706   {
2707     char path[] = "/dev/sda1";
2708     path[5] = devchar;
2709     char *r;
2710     suppress_error = 0;
2711     r = guestfs_file (g, path);
2712     if (r == NULL)
2713       return -1;
2714     if (strcmp (r, expected) != 0) {
2715       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2716       return -1;
2717     }
2718     free (r);
2719   }
2720   return 0;
2721 }
2722
2723 static int test_fsck_0_skip (void)
2724 {
2725   const char *str;
2726
2727   str = getenv ("SKIP_TEST_FSCK_0");
2728   if (str && strcmp (str, "1") == 0) return 1;
2729   str = getenv ("SKIP_TEST_FSCK");
2730   if (str && strcmp (str, "1") == 0) return 1;
2731   return 0;
2732 }
2733
2734 static int test_fsck_0 (void)
2735 {
2736   if (test_fsck_0_skip ()) {
2737     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2738     return 0;
2739   }
2740
2741   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2742   {
2743     char device[] = "/dev/sda";
2744     device[5] = devchar;
2745     int r;
2746     suppress_error = 0;
2747     r = guestfs_blockdev_setrw (g, device);
2748     if (r == -1)
2749       return -1;
2750   }
2751   {
2752     int r;
2753     suppress_error = 0;
2754     r = guestfs_umount_all (g);
2755     if (r == -1)
2756       return -1;
2757   }
2758   {
2759     int r;
2760     suppress_error = 0;
2761     r = guestfs_lvm_remove_all (g);
2762     if (r == -1)
2763       return -1;
2764   }
2765   {
2766     char device[] = "/dev/sda";
2767     device[5] = devchar;
2768     char lines_0[] = ",";
2769     char *lines[] = {
2770       lines_0,
2771       NULL
2772     };
2773     int r;
2774     suppress_error = 0;
2775     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2776     if (r == -1)
2777       return -1;
2778   }
2779   {
2780     char fstype[] = "ext2";
2781     char device[] = "/dev/sda1";
2782     device[5] = devchar;
2783     int r;
2784     suppress_error = 0;
2785     r = guestfs_mkfs (g, fstype, device);
2786     if (r == -1)
2787       return -1;
2788   }
2789   {
2790     char device[] = "/dev/sda1";
2791     device[5] = devchar;
2792     char mountpoint[] = "/";
2793     int r;
2794     suppress_error = 0;
2795     r = guestfs_mount (g, device, mountpoint);
2796     if (r == -1)
2797       return -1;
2798   }
2799   /* TestOutputInt for fsck (0) */
2800   {
2801     char pathordevice[] = "/dev/sda1";
2802     pathordevice[5] = devchar;
2803     int r;
2804     suppress_error = 0;
2805     r = guestfs_umount (g, pathordevice);
2806     if (r == -1)
2807       return -1;
2808   }
2809   {
2810     char fstype[] = "ext2";
2811     char device[] = "/dev/sda1";
2812     device[5] = devchar;
2813     int r;
2814     suppress_error = 0;
2815     r = guestfs_fsck (g, fstype, device);
2816     if (r == -1)
2817       return -1;
2818     if (r != 0) {
2819       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
2820       return -1;
2821     }
2822   }
2823   return 0;
2824 }
2825
2826 static int test_fsck_1_skip (void)
2827 {
2828   const char *str;
2829
2830   str = getenv ("SKIP_TEST_FSCK_1");
2831   if (str && strcmp (str, "1") == 0) return 1;
2832   str = getenv ("SKIP_TEST_FSCK");
2833   if (str && strcmp (str, "1") == 0) return 1;
2834   return 0;
2835 }
2836
2837 static int test_fsck_1 (void)
2838 {
2839   if (test_fsck_1_skip ()) {
2840     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
2841     return 0;
2842   }
2843
2844   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2845   {
2846     char device[] = "/dev/sda";
2847     device[5] = devchar;
2848     int r;
2849     suppress_error = 0;
2850     r = guestfs_blockdev_setrw (g, device);
2851     if (r == -1)
2852       return -1;
2853   }
2854   {
2855     int r;
2856     suppress_error = 0;
2857     r = guestfs_umount_all (g);
2858     if (r == -1)
2859       return -1;
2860   }
2861   {
2862     int r;
2863     suppress_error = 0;
2864     r = guestfs_lvm_remove_all (g);
2865     if (r == -1)
2866       return -1;
2867   }
2868   {
2869     char device[] = "/dev/sda";
2870     device[5] = devchar;
2871     char lines_0[] = ",";
2872     char *lines[] = {
2873       lines_0,
2874       NULL
2875     };
2876     int r;
2877     suppress_error = 0;
2878     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2879     if (r == -1)
2880       return -1;
2881   }
2882   {
2883     char fstype[] = "ext2";
2884     char device[] = "/dev/sda1";
2885     device[5] = devchar;
2886     int r;
2887     suppress_error = 0;
2888     r = guestfs_mkfs (g, fstype, device);
2889     if (r == -1)
2890       return -1;
2891   }
2892   {
2893     char device[] = "/dev/sda1";
2894     device[5] = devchar;
2895     char mountpoint[] = "/";
2896     int r;
2897     suppress_error = 0;
2898     r = guestfs_mount (g, device, mountpoint);
2899     if (r == -1)
2900       return -1;
2901   }
2902   /* TestOutputInt for fsck (1) */
2903   {
2904     char pathordevice[] = "/dev/sda1";
2905     pathordevice[5] = devchar;
2906     int r;
2907     suppress_error = 0;
2908     r = guestfs_umount (g, pathordevice);
2909     if (r == -1)
2910       return -1;
2911   }
2912   {
2913     char device[] = "/dev/sda1";
2914     device[5] = devchar;
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_zero (g, device);
2918     if (r == -1)
2919       return -1;
2920   }
2921   {
2922     char fstype[] = "ext2";
2923     char device[] = "/dev/sda1";
2924     device[5] = devchar;
2925     int r;
2926     suppress_error = 0;
2927     r = guestfs_fsck (g, fstype, device);
2928     if (r == -1)
2929       return -1;
2930     if (r != 8) {
2931       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
2932       return -1;
2933     }
2934   }
2935   return 0;
2936 }
2937
2938 static int test_set_e2uuid_0_skip (void)
2939 {
2940   const char *str;
2941
2942   str = getenv ("SKIP_TEST_SET_E2UUID_0");
2943   if (str && strcmp (str, "1") == 0) return 1;
2944   str = getenv ("SKIP_TEST_SET_E2UUID");
2945   if (str && strcmp (str, "1") == 0) return 1;
2946   return 0;
2947 }
2948
2949 static int test_set_e2uuid_0 (void)
2950 {
2951   if (test_set_e2uuid_0_skip ()) {
2952     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
2953     return 0;
2954   }
2955
2956   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2957   {
2958     char device[] = "/dev/sda";
2959     device[5] = devchar;
2960     int r;
2961     suppress_error = 0;
2962     r = guestfs_blockdev_setrw (g, device);
2963     if (r == -1)
2964       return -1;
2965   }
2966   {
2967     int r;
2968     suppress_error = 0;
2969     r = guestfs_umount_all (g);
2970     if (r == -1)
2971       return -1;
2972   }
2973   {
2974     int r;
2975     suppress_error = 0;
2976     r = guestfs_lvm_remove_all (g);
2977     if (r == -1)
2978       return -1;
2979   }
2980   {
2981     char device[] = "/dev/sda";
2982     device[5] = devchar;
2983     char lines_0[] = ",";
2984     char *lines[] = {
2985       lines_0,
2986       NULL
2987     };
2988     int r;
2989     suppress_error = 0;
2990     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2991     if (r == -1)
2992       return -1;
2993   }
2994   {
2995     char fstype[] = "ext2";
2996     char device[] = "/dev/sda1";
2997     device[5] = devchar;
2998     int r;
2999     suppress_error = 0;
3000     r = guestfs_mkfs (g, fstype, device);
3001     if (r == -1)
3002       return -1;
3003   }
3004   {
3005     char device[] = "/dev/sda1";
3006     device[5] = devchar;
3007     char mountpoint[] = "/";
3008     int r;
3009     suppress_error = 0;
3010     r = guestfs_mount (g, device, mountpoint);
3011     if (r == -1)
3012       return -1;
3013   }
3014   /* TestOutput for set_e2uuid (0) */
3015   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3016   {
3017     char device[] = "/dev/sda1";
3018     device[5] = devchar;
3019     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3020     int r;
3021     suppress_error = 0;
3022     r = guestfs_set_e2uuid (g, device, uuid);
3023     if (r == -1)
3024       return -1;
3025   }
3026   {
3027     char device[] = "/dev/sda1";
3028     device[5] = devchar;
3029     char *r;
3030     suppress_error = 0;
3031     r = guestfs_get_e2uuid (g, device);
3032     if (r == NULL)
3033       return -1;
3034     if (strcmp (r, expected) != 0) {
3035       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3036       return -1;
3037     }
3038     free (r);
3039   }
3040   return 0;
3041 }
3042
3043 static int test_set_e2uuid_1_skip (void)
3044 {
3045   const char *str;
3046
3047   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3048   if (str && strcmp (str, "1") == 0) return 1;
3049   str = getenv ("SKIP_TEST_SET_E2UUID");
3050   if (str && strcmp (str, "1") == 0) return 1;
3051   return 0;
3052 }
3053
3054 static int test_set_e2uuid_1 (void)
3055 {
3056   if (test_set_e2uuid_1_skip ()) {
3057     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3058     return 0;
3059   }
3060
3061   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3062   {
3063     char device[] = "/dev/sda";
3064     device[5] = devchar;
3065     int r;
3066     suppress_error = 0;
3067     r = guestfs_blockdev_setrw (g, device);
3068     if (r == -1)
3069       return -1;
3070   }
3071   {
3072     int r;
3073     suppress_error = 0;
3074     r = guestfs_umount_all (g);
3075     if (r == -1)
3076       return -1;
3077   }
3078   {
3079     int r;
3080     suppress_error = 0;
3081     r = guestfs_lvm_remove_all (g);
3082     if (r == -1)
3083       return -1;
3084   }
3085   {
3086     char device[] = "/dev/sda";
3087     device[5] = devchar;
3088     char lines_0[] = ",";
3089     char *lines[] = {
3090       lines_0,
3091       NULL
3092     };
3093     int r;
3094     suppress_error = 0;
3095     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3096     if (r == -1)
3097       return -1;
3098   }
3099   {
3100     char fstype[] = "ext2";
3101     char device[] = "/dev/sda1";
3102     device[5] = devchar;
3103     int r;
3104     suppress_error = 0;
3105     r = guestfs_mkfs (g, fstype, device);
3106     if (r == -1)
3107       return -1;
3108   }
3109   {
3110     char device[] = "/dev/sda1";
3111     device[5] = devchar;
3112     char mountpoint[] = "/";
3113     int r;
3114     suppress_error = 0;
3115     r = guestfs_mount (g, device, mountpoint);
3116     if (r == -1)
3117       return -1;
3118   }
3119   /* TestOutput for set_e2uuid (1) */
3120   char expected[] = "";
3121   {
3122     char device[] = "/dev/sda1";
3123     device[5] = devchar;
3124     char uuid[] = "clear";
3125     int r;
3126     suppress_error = 0;
3127     r = guestfs_set_e2uuid (g, device, uuid);
3128     if (r == -1)
3129       return -1;
3130   }
3131   {
3132     char device[] = "/dev/sda1";
3133     device[5] = devchar;
3134     char *r;
3135     suppress_error = 0;
3136     r = guestfs_get_e2uuid (g, device);
3137     if (r == NULL)
3138       return -1;
3139     if (strcmp (r, expected) != 0) {
3140       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3141       return -1;
3142     }
3143     free (r);
3144   }
3145   return 0;
3146 }
3147
3148 static int test_set_e2uuid_2_skip (void)
3149 {
3150   const char *str;
3151
3152   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3153   if (str && strcmp (str, "1") == 0) return 1;
3154   str = getenv ("SKIP_TEST_SET_E2UUID");
3155   if (str && strcmp (str, "1") == 0) return 1;
3156   return 0;
3157 }
3158
3159 static int test_set_e2uuid_2 (void)
3160 {
3161   if (test_set_e2uuid_2_skip ()) {
3162     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3163     return 0;
3164   }
3165
3166   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3167   {
3168     char device[] = "/dev/sda";
3169     device[5] = devchar;
3170     int r;
3171     suppress_error = 0;
3172     r = guestfs_blockdev_setrw (g, device);
3173     if (r == -1)
3174       return -1;
3175   }
3176   {
3177     int r;
3178     suppress_error = 0;
3179     r = guestfs_umount_all (g);
3180     if (r == -1)
3181       return -1;
3182   }
3183   {
3184     int r;
3185     suppress_error = 0;
3186     r = guestfs_lvm_remove_all (g);
3187     if (r == -1)
3188       return -1;
3189   }
3190   {
3191     char device[] = "/dev/sda";
3192     device[5] = devchar;
3193     char lines_0[] = ",";
3194     char *lines[] = {
3195       lines_0,
3196       NULL
3197     };
3198     int r;
3199     suppress_error = 0;
3200     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3201     if (r == -1)
3202       return -1;
3203   }
3204   {
3205     char fstype[] = "ext2";
3206     char device[] = "/dev/sda1";
3207     device[5] = devchar;
3208     int r;
3209     suppress_error = 0;
3210     r = guestfs_mkfs (g, fstype, device);
3211     if (r == -1)
3212       return -1;
3213   }
3214   {
3215     char device[] = "/dev/sda1";
3216     device[5] = devchar;
3217     char mountpoint[] = "/";
3218     int r;
3219     suppress_error = 0;
3220     r = guestfs_mount (g, device, mountpoint);
3221     if (r == -1)
3222       return -1;
3223   }
3224   /* TestRun for set_e2uuid (2) */
3225   {
3226     char device[] = "/dev/sda1";
3227     device[5] = devchar;
3228     char uuid[] = "random";
3229     int r;
3230     suppress_error = 0;
3231     r = guestfs_set_e2uuid (g, device, uuid);
3232     if (r == -1)
3233       return -1;
3234   }
3235   return 0;
3236 }
3237
3238 static int test_set_e2uuid_3_skip (void)
3239 {
3240   const char *str;
3241
3242   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3243   if (str && strcmp (str, "1") == 0) return 1;
3244   str = getenv ("SKIP_TEST_SET_E2UUID");
3245   if (str && strcmp (str, "1") == 0) return 1;
3246   return 0;
3247 }
3248
3249 static int test_set_e2uuid_3 (void)
3250 {
3251   if (test_set_e2uuid_3_skip ()) {
3252     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3253     return 0;
3254   }
3255
3256   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3257   {
3258     char device[] = "/dev/sda";
3259     device[5] = devchar;
3260     int r;
3261     suppress_error = 0;
3262     r = guestfs_blockdev_setrw (g, device);
3263     if (r == -1)
3264       return -1;
3265   }
3266   {
3267     int r;
3268     suppress_error = 0;
3269     r = guestfs_umount_all (g);
3270     if (r == -1)
3271       return -1;
3272   }
3273   {
3274     int r;
3275     suppress_error = 0;
3276     r = guestfs_lvm_remove_all (g);
3277     if (r == -1)
3278       return -1;
3279   }
3280   {
3281     char device[] = "/dev/sda";
3282     device[5] = devchar;
3283     char lines_0[] = ",";
3284     char *lines[] = {
3285       lines_0,
3286       NULL
3287     };
3288     int r;
3289     suppress_error = 0;
3290     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3291     if (r == -1)
3292       return -1;
3293   }
3294   {
3295     char fstype[] = "ext2";
3296     char device[] = "/dev/sda1";
3297     device[5] = devchar;
3298     int r;
3299     suppress_error = 0;
3300     r = guestfs_mkfs (g, fstype, device);
3301     if (r == -1)
3302       return -1;
3303   }
3304   {
3305     char device[] = "/dev/sda1";
3306     device[5] = devchar;
3307     char mountpoint[] = "/";
3308     int r;
3309     suppress_error = 0;
3310     r = guestfs_mount (g, device, mountpoint);
3311     if (r == -1)
3312       return -1;
3313   }
3314   /* TestRun for set_e2uuid (3) */
3315   {
3316     char device[] = "/dev/sda1";
3317     device[5] = devchar;
3318     char uuid[] = "time";
3319     int r;
3320     suppress_error = 0;
3321     r = guestfs_set_e2uuid (g, device, uuid);
3322     if (r == -1)
3323       return -1;
3324   }
3325   return 0;
3326 }
3327
3328 static int test_set_e2label_0_skip (void)
3329 {
3330   const char *str;
3331
3332   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3333   if (str && strcmp (str, "1") == 0) return 1;
3334   str = getenv ("SKIP_TEST_SET_E2LABEL");
3335   if (str && strcmp (str, "1") == 0) return 1;
3336   return 0;
3337 }
3338
3339 static int test_set_e2label_0 (void)
3340 {
3341   if (test_set_e2label_0_skip ()) {
3342     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3343     return 0;
3344   }
3345
3346   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3347   {
3348     char device[] = "/dev/sda";
3349     device[5] = devchar;
3350     int r;
3351     suppress_error = 0;
3352     r = guestfs_blockdev_setrw (g, device);
3353     if (r == -1)
3354       return -1;
3355   }
3356   {
3357     int r;
3358     suppress_error = 0;
3359     r = guestfs_umount_all (g);
3360     if (r == -1)
3361       return -1;
3362   }
3363   {
3364     int r;
3365     suppress_error = 0;
3366     r = guestfs_lvm_remove_all (g);
3367     if (r == -1)
3368       return -1;
3369   }
3370   {
3371     char device[] = "/dev/sda";
3372     device[5] = devchar;
3373     char lines_0[] = ",";
3374     char *lines[] = {
3375       lines_0,
3376       NULL
3377     };
3378     int r;
3379     suppress_error = 0;
3380     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3381     if (r == -1)
3382       return -1;
3383   }
3384   {
3385     char fstype[] = "ext2";
3386     char device[] = "/dev/sda1";
3387     device[5] = devchar;
3388     int r;
3389     suppress_error = 0;
3390     r = guestfs_mkfs (g, fstype, device);
3391     if (r == -1)
3392       return -1;
3393   }
3394   {
3395     char device[] = "/dev/sda1";
3396     device[5] = devchar;
3397     char mountpoint[] = "/";
3398     int r;
3399     suppress_error = 0;
3400     r = guestfs_mount (g, device, mountpoint);
3401     if (r == -1)
3402       return -1;
3403   }
3404   /* TestOutput for set_e2label (0) */
3405   char expected[] = "testlabel";
3406   {
3407     char device[] = "/dev/sda1";
3408     device[5] = devchar;
3409     char label[] = "testlabel";
3410     int r;
3411     suppress_error = 0;
3412     r = guestfs_set_e2label (g, device, label);
3413     if (r == -1)
3414       return -1;
3415   }
3416   {
3417     char device[] = "/dev/sda1";
3418     device[5] = devchar;
3419     char *r;
3420     suppress_error = 0;
3421     r = guestfs_get_e2label (g, device);
3422     if (r == NULL)
3423       return -1;
3424     if (strcmp (r, expected) != 0) {
3425       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3426       return -1;
3427     }
3428     free (r);
3429   }
3430   return 0;
3431 }
3432
3433 static int test_pvremove_0_skip (void)
3434 {
3435   const char *str;
3436
3437   str = getenv ("SKIP_TEST_PVREMOVE_0");
3438   if (str && strcmp (str, "1") == 0) return 1;
3439   str = getenv ("SKIP_TEST_PVREMOVE");
3440   if (str && strcmp (str, "1") == 0) return 1;
3441   return 0;
3442 }
3443
3444 static int test_pvremove_0 (void)
3445 {
3446   if (test_pvremove_0_skip ()) {
3447     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3448     return 0;
3449   }
3450
3451   /* InitNone|InitEmpty for test_pvremove_0 */
3452   {
3453     char device[] = "/dev/sda";
3454     device[5] = devchar;
3455     int r;
3456     suppress_error = 0;
3457     r = guestfs_blockdev_setrw (g, device);
3458     if (r == -1)
3459       return -1;
3460   }
3461   {
3462     int r;
3463     suppress_error = 0;
3464     r = guestfs_umount_all (g);
3465     if (r == -1)
3466       return -1;
3467   }
3468   {
3469     int r;
3470     suppress_error = 0;
3471     r = guestfs_lvm_remove_all (g);
3472     if (r == -1)
3473       return -1;
3474   }
3475   /* TestOutputList for pvremove (0) */
3476   {
3477     char device[] = "/dev/sda";
3478     device[5] = devchar;
3479     char lines_0[] = ",";
3480     char *lines[] = {
3481       lines_0,
3482       NULL
3483     };
3484     int r;
3485     suppress_error = 0;
3486     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3487     if (r == -1)
3488       return -1;
3489   }
3490   {
3491     char device[] = "/dev/sda1";
3492     device[5] = devchar;
3493     int r;
3494     suppress_error = 0;
3495     r = guestfs_pvcreate (g, device);
3496     if (r == -1)
3497       return -1;
3498   }
3499   {
3500     char volgroup[] = "VG";
3501     char physvols_0[] = "/dev/sda1";
3502     physvols_0[5] = devchar;
3503     char *physvols[] = {
3504       physvols_0,
3505       NULL
3506     };
3507     int r;
3508     suppress_error = 0;
3509     r = guestfs_vgcreate (g, volgroup, physvols);
3510     if (r == -1)
3511       return -1;
3512   }
3513   {
3514     char logvol[] = "LV1";
3515     char volgroup[] = "VG";
3516     int r;
3517     suppress_error = 0;
3518     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3519     if (r == -1)
3520       return -1;
3521   }
3522   {
3523     char logvol[] = "LV2";
3524     char volgroup[] = "VG";
3525     int r;
3526     suppress_error = 0;
3527     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3528     if (r == -1)
3529       return -1;
3530   }
3531   {
3532     char vgname[] = "VG";
3533     int r;
3534     suppress_error = 0;
3535     r = guestfs_vgremove (g, vgname);
3536     if (r == -1)
3537       return -1;
3538   }
3539   {
3540     char device[] = "/dev/sda1";
3541     device[5] = devchar;
3542     int r;
3543     suppress_error = 0;
3544     r = guestfs_pvremove (g, device);
3545     if (r == -1)
3546       return -1;
3547   }
3548   {
3549     char **r;
3550     int i;
3551     suppress_error = 0;
3552     r = guestfs_lvs (g);
3553     if (r == NULL)
3554       return -1;
3555     if (r[0] != NULL) {
3556       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3557       print_strings (r);
3558       return -1;
3559     }
3560     for (i = 0; r[i] != NULL; ++i)
3561       free (r[i]);
3562     free (r);
3563   }
3564   return 0;
3565 }
3566
3567 static int test_pvremove_1_skip (void)
3568 {
3569   const char *str;
3570
3571   str = getenv ("SKIP_TEST_PVREMOVE_1");
3572   if (str && strcmp (str, "1") == 0) return 1;
3573   str = getenv ("SKIP_TEST_PVREMOVE");
3574   if (str && strcmp (str, "1") == 0) return 1;
3575   return 0;
3576 }
3577
3578 static int test_pvremove_1 (void)
3579 {
3580   if (test_pvremove_1_skip ()) {
3581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3582     return 0;
3583   }
3584
3585   /* InitNone|InitEmpty for test_pvremove_1 */
3586   {
3587     char device[] = "/dev/sda";
3588     device[5] = devchar;
3589     int r;
3590     suppress_error = 0;
3591     r = guestfs_blockdev_setrw (g, device);
3592     if (r == -1)
3593       return -1;
3594   }
3595   {
3596     int r;
3597     suppress_error = 0;
3598     r = guestfs_umount_all (g);
3599     if (r == -1)
3600       return -1;
3601   }
3602   {
3603     int r;
3604     suppress_error = 0;
3605     r = guestfs_lvm_remove_all (g);
3606     if (r == -1)
3607       return -1;
3608   }
3609   /* TestOutputList for pvremove (1) */
3610   {
3611     char device[] = "/dev/sda";
3612     device[5] = devchar;
3613     char lines_0[] = ",";
3614     char *lines[] = {
3615       lines_0,
3616       NULL
3617     };
3618     int r;
3619     suppress_error = 0;
3620     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3621     if (r == -1)
3622       return -1;
3623   }
3624   {
3625     char device[] = "/dev/sda1";
3626     device[5] = devchar;
3627     int r;
3628     suppress_error = 0;
3629     r = guestfs_pvcreate (g, device);
3630     if (r == -1)
3631       return -1;
3632   }
3633   {
3634     char volgroup[] = "VG";
3635     char physvols_0[] = "/dev/sda1";
3636     physvols_0[5] = devchar;
3637     char *physvols[] = {
3638       physvols_0,
3639       NULL
3640     };
3641     int r;
3642     suppress_error = 0;
3643     r = guestfs_vgcreate (g, volgroup, physvols);
3644     if (r == -1)
3645       return -1;
3646   }
3647   {
3648     char logvol[] = "LV1";
3649     char volgroup[] = "VG";
3650     int r;
3651     suppress_error = 0;
3652     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3653     if (r == -1)
3654       return -1;
3655   }
3656   {
3657     char logvol[] = "LV2";
3658     char volgroup[] = "VG";
3659     int r;
3660     suppress_error = 0;
3661     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3662     if (r == -1)
3663       return -1;
3664   }
3665   {
3666     char vgname[] = "VG";
3667     int r;
3668     suppress_error = 0;
3669     r = guestfs_vgremove (g, vgname);
3670     if (r == -1)
3671       return -1;
3672   }
3673   {
3674     char device[] = "/dev/sda1";
3675     device[5] = devchar;
3676     int r;
3677     suppress_error = 0;
3678     r = guestfs_pvremove (g, device);
3679     if (r == -1)
3680       return -1;
3681   }
3682   {
3683     char **r;
3684     int i;
3685     suppress_error = 0;
3686     r = guestfs_vgs (g);
3687     if (r == NULL)
3688       return -1;
3689     if (r[0] != NULL) {
3690       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3691       print_strings (r);
3692       return -1;
3693     }
3694     for (i = 0; r[i] != NULL; ++i)
3695       free (r[i]);
3696     free (r);
3697   }
3698   return 0;
3699 }
3700
3701 static int test_pvremove_2_skip (void)
3702 {
3703   const char *str;
3704
3705   str = getenv ("SKIP_TEST_PVREMOVE_2");
3706   if (str && strcmp (str, "1") == 0) return 1;
3707   str = getenv ("SKIP_TEST_PVREMOVE");
3708   if (str && strcmp (str, "1") == 0) return 1;
3709   return 0;
3710 }
3711
3712 static int test_pvremove_2 (void)
3713 {
3714   if (test_pvremove_2_skip ()) {
3715     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3716     return 0;
3717   }
3718
3719   /* InitNone|InitEmpty for test_pvremove_2 */
3720   {
3721     char device[] = "/dev/sda";
3722     device[5] = devchar;
3723     int r;
3724     suppress_error = 0;
3725     r = guestfs_blockdev_setrw (g, device);
3726     if (r == -1)
3727       return -1;
3728   }
3729   {
3730     int r;
3731     suppress_error = 0;
3732     r = guestfs_umount_all (g);
3733     if (r == -1)
3734       return -1;
3735   }
3736   {
3737     int r;
3738     suppress_error = 0;
3739     r = guestfs_lvm_remove_all (g);
3740     if (r == -1)
3741       return -1;
3742   }
3743   /* TestOutputList for pvremove (2) */
3744   {
3745     char device[] = "/dev/sda";
3746     device[5] = devchar;
3747     char lines_0[] = ",";
3748     char *lines[] = {
3749       lines_0,
3750       NULL
3751     };
3752     int r;
3753     suppress_error = 0;
3754     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3755     if (r == -1)
3756       return -1;
3757   }
3758   {
3759     char device[] = "/dev/sda1";
3760     device[5] = devchar;
3761     int r;
3762     suppress_error = 0;
3763     r = guestfs_pvcreate (g, device);
3764     if (r == -1)
3765       return -1;
3766   }
3767   {
3768     char volgroup[] = "VG";
3769     char physvols_0[] = "/dev/sda1";
3770     physvols_0[5] = devchar;
3771     char *physvols[] = {
3772       physvols_0,
3773       NULL
3774     };
3775     int r;
3776     suppress_error = 0;
3777     r = guestfs_vgcreate (g, volgroup, physvols);
3778     if (r == -1)
3779       return -1;
3780   }
3781   {
3782     char logvol[] = "LV1";
3783     char volgroup[] = "VG";
3784     int r;
3785     suppress_error = 0;
3786     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3787     if (r == -1)
3788       return -1;
3789   }
3790   {
3791     char logvol[] = "LV2";
3792     char volgroup[] = "VG";
3793     int r;
3794     suppress_error = 0;
3795     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3796     if (r == -1)
3797       return -1;
3798   }
3799   {
3800     char vgname[] = "VG";
3801     int r;
3802     suppress_error = 0;
3803     r = guestfs_vgremove (g, vgname);
3804     if (r == -1)
3805       return -1;
3806   }
3807   {
3808     char device[] = "/dev/sda1";
3809     device[5] = devchar;
3810     int r;
3811     suppress_error = 0;
3812     r = guestfs_pvremove (g, device);
3813     if (r == -1)
3814       return -1;
3815   }
3816   {
3817     char **r;
3818     int i;
3819     suppress_error = 0;
3820     r = guestfs_pvs (g);
3821     if (r == NULL)
3822       return -1;
3823     if (r[0] != NULL) {
3824       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3825       print_strings (r);
3826       return -1;
3827     }
3828     for (i = 0; r[i] != NULL; ++i)
3829       free (r[i]);
3830     free (r);
3831   }
3832   return 0;
3833 }
3834
3835 static int test_vgremove_0_skip (void)
3836 {
3837   const char *str;
3838
3839   str = getenv ("SKIP_TEST_VGREMOVE_0");
3840   if (str && strcmp (str, "1") == 0) return 1;
3841   str = getenv ("SKIP_TEST_VGREMOVE");
3842   if (str && strcmp (str, "1") == 0) return 1;
3843   return 0;
3844 }
3845
3846 static int test_vgremove_0 (void)
3847 {
3848   if (test_vgremove_0_skip ()) {
3849     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
3850     return 0;
3851   }
3852
3853   /* InitNone|InitEmpty for test_vgremove_0 */
3854   {
3855     char device[] = "/dev/sda";
3856     device[5] = devchar;
3857     int r;
3858     suppress_error = 0;
3859     r = guestfs_blockdev_setrw (g, device);
3860     if (r == -1)
3861       return -1;
3862   }
3863   {
3864     int r;
3865     suppress_error = 0;
3866     r = guestfs_umount_all (g);
3867     if (r == -1)
3868       return -1;
3869   }
3870   {
3871     int r;
3872     suppress_error = 0;
3873     r = guestfs_lvm_remove_all (g);
3874     if (r == -1)
3875       return -1;
3876   }
3877   /* TestOutputList for vgremove (0) */
3878   {
3879     char device[] = "/dev/sda";
3880     device[5] = devchar;
3881     char lines_0[] = ",";
3882     char *lines[] = {
3883       lines_0,
3884       NULL
3885     };
3886     int r;
3887     suppress_error = 0;
3888     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3889     if (r == -1)
3890       return -1;
3891   }
3892   {
3893     char device[] = "/dev/sda1";
3894     device[5] = devchar;
3895     int r;
3896     suppress_error = 0;
3897     r = guestfs_pvcreate (g, device);
3898     if (r == -1)
3899       return -1;
3900   }
3901   {
3902     char volgroup[] = "VG";
3903     char physvols_0[] = "/dev/sda1";
3904     physvols_0[5] = devchar;
3905     char *physvols[] = {
3906       physvols_0,
3907       NULL
3908     };
3909     int r;
3910     suppress_error = 0;
3911     r = guestfs_vgcreate (g, volgroup, physvols);
3912     if (r == -1)
3913       return -1;
3914   }
3915   {
3916     char logvol[] = "LV1";
3917     char volgroup[] = "VG";
3918     int r;
3919     suppress_error = 0;
3920     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3921     if (r == -1)
3922       return -1;
3923   }
3924   {
3925     char logvol[] = "LV2";
3926     char volgroup[] = "VG";
3927     int r;
3928     suppress_error = 0;
3929     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3930     if (r == -1)
3931       return -1;
3932   }
3933   {
3934     char vgname[] = "VG";
3935     int r;
3936     suppress_error = 0;
3937     r = guestfs_vgremove (g, vgname);
3938     if (r == -1)
3939       return -1;
3940   }
3941   {
3942     char **r;
3943     int i;
3944     suppress_error = 0;
3945     r = guestfs_lvs (g);
3946     if (r == NULL)
3947       return -1;
3948     if (r[0] != NULL) {
3949       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3950       print_strings (r);
3951       return -1;
3952     }
3953     for (i = 0; r[i] != NULL; ++i)
3954       free (r[i]);
3955     free (r);
3956   }
3957   return 0;
3958 }
3959
3960 static int test_vgremove_1_skip (void)
3961 {
3962   const char *str;
3963
3964   str = getenv ("SKIP_TEST_VGREMOVE_1");
3965   if (str && strcmp (str, "1") == 0) return 1;
3966   str = getenv ("SKIP_TEST_VGREMOVE");
3967   if (str && strcmp (str, "1") == 0) return 1;
3968   return 0;
3969 }
3970
3971 static int test_vgremove_1 (void)
3972 {
3973   if (test_vgremove_1_skip ()) {
3974     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
3975     return 0;
3976   }
3977
3978   /* InitNone|InitEmpty for test_vgremove_1 */
3979   {
3980     char device[] = "/dev/sda";
3981     device[5] = devchar;
3982     int r;
3983     suppress_error = 0;
3984     r = guestfs_blockdev_setrw (g, device);
3985     if (r == -1)
3986       return -1;
3987   }
3988   {
3989     int r;
3990     suppress_error = 0;
3991     r = guestfs_umount_all (g);
3992     if (r == -1)
3993       return -1;
3994   }
3995   {
3996     int r;
3997     suppress_error = 0;
3998     r = guestfs_lvm_remove_all (g);
3999     if (r == -1)
4000       return -1;
4001   }
4002   /* TestOutputList for vgremove (1) */
4003   {
4004     char device[] = "/dev/sda";
4005     device[5] = devchar;
4006     char lines_0[] = ",";
4007     char *lines[] = {
4008       lines_0,
4009       NULL
4010     };
4011     int r;
4012     suppress_error = 0;
4013     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4014     if (r == -1)
4015       return -1;
4016   }
4017   {
4018     char device[] = "/dev/sda1";
4019     device[5] = devchar;
4020     int r;
4021     suppress_error = 0;
4022     r = guestfs_pvcreate (g, device);
4023     if (r == -1)
4024       return -1;
4025   }
4026   {
4027     char volgroup[] = "VG";
4028     char physvols_0[] = "/dev/sda1";
4029     physvols_0[5] = devchar;
4030     char *physvols[] = {
4031       physvols_0,
4032       NULL
4033     };
4034     int r;
4035     suppress_error = 0;
4036     r = guestfs_vgcreate (g, volgroup, physvols);
4037     if (r == -1)
4038       return -1;
4039   }
4040   {
4041     char logvol[] = "LV1";
4042     char volgroup[] = "VG";
4043     int r;
4044     suppress_error = 0;
4045     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4046     if (r == -1)
4047       return -1;
4048   }
4049   {
4050     char logvol[] = "LV2";
4051     char volgroup[] = "VG";
4052     int r;
4053     suppress_error = 0;
4054     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4055     if (r == -1)
4056       return -1;
4057   }
4058   {
4059     char vgname[] = "VG";
4060     int r;
4061     suppress_error = 0;
4062     r = guestfs_vgremove (g, vgname);
4063     if (r == -1)
4064       return -1;
4065   }
4066   {
4067     char **r;
4068     int i;
4069     suppress_error = 0;
4070     r = guestfs_vgs (g);
4071     if (r == NULL)
4072       return -1;
4073     if (r[0] != NULL) {
4074       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4075       print_strings (r);
4076       return -1;
4077     }
4078     for (i = 0; r[i] != NULL; ++i)
4079       free (r[i]);
4080     free (r);
4081   }
4082   return 0;
4083 }
4084
4085 static int test_lvremove_0_skip (void)
4086 {
4087   const char *str;
4088
4089   str = getenv ("SKIP_TEST_LVREMOVE_0");
4090   if (str && strcmp (str, "1") == 0) return 1;
4091   str = getenv ("SKIP_TEST_LVREMOVE");
4092   if (str && strcmp (str, "1") == 0) return 1;
4093   return 0;
4094 }
4095
4096 static int test_lvremove_0 (void)
4097 {
4098   if (test_lvremove_0_skip ()) {
4099     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4100     return 0;
4101   }
4102
4103   /* InitNone|InitEmpty for test_lvremove_0 */
4104   {
4105     char device[] = "/dev/sda";
4106     device[5] = devchar;
4107     int r;
4108     suppress_error = 0;
4109     r = guestfs_blockdev_setrw (g, device);
4110     if (r == -1)
4111       return -1;
4112   }
4113   {
4114     int r;
4115     suppress_error = 0;
4116     r = guestfs_umount_all (g);
4117     if (r == -1)
4118       return -1;
4119   }
4120   {
4121     int r;
4122     suppress_error = 0;
4123     r = guestfs_lvm_remove_all (g);
4124     if (r == -1)
4125       return -1;
4126   }
4127   /* TestOutputList for lvremove (0) */
4128   {
4129     char device[] = "/dev/sda";
4130     device[5] = devchar;
4131     char lines_0[] = ",";
4132     char *lines[] = {
4133       lines_0,
4134       NULL
4135     };
4136     int r;
4137     suppress_error = 0;
4138     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4139     if (r == -1)
4140       return -1;
4141   }
4142   {
4143     char device[] = "/dev/sda1";
4144     device[5] = devchar;
4145     int r;
4146     suppress_error = 0;
4147     r = guestfs_pvcreate (g, device);
4148     if (r == -1)
4149       return -1;
4150   }
4151   {
4152     char volgroup[] = "VG";
4153     char physvols_0[] = "/dev/sda1";
4154     physvols_0[5] = devchar;
4155     char *physvols[] = {
4156       physvols_0,
4157       NULL
4158     };
4159     int r;
4160     suppress_error = 0;
4161     r = guestfs_vgcreate (g, volgroup, physvols);
4162     if (r == -1)
4163       return -1;
4164   }
4165   {
4166     char logvol[] = "LV1";
4167     char volgroup[] = "VG";
4168     int r;
4169     suppress_error = 0;
4170     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4171     if (r == -1)
4172       return -1;
4173   }
4174   {
4175     char logvol[] = "LV2";
4176     char volgroup[] = "VG";
4177     int r;
4178     suppress_error = 0;
4179     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4180     if (r == -1)
4181       return -1;
4182   }
4183   {
4184     char device[] = "/dev/VG/LV1";
4185     int r;
4186     suppress_error = 0;
4187     r = guestfs_lvremove (g, device);
4188     if (r == -1)
4189       return -1;
4190   }
4191   {
4192     char **r;
4193     int i;
4194     suppress_error = 0;
4195     r = guestfs_lvs (g);
4196     if (r == NULL)
4197       return -1;
4198     if (!r[0]) {
4199       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4200       print_strings (r);
4201       return -1;
4202     }
4203     {
4204       char expected[] = "/dev/VG/LV2";
4205       if (strcmp (r[0], expected) != 0) {
4206         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4207         return -1;
4208       }
4209     }
4210     if (r[1] != NULL) {
4211       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4212       print_strings (r);
4213       return -1;
4214     }
4215     for (i = 0; r[i] != NULL; ++i)
4216       free (r[i]);
4217     free (r);
4218   }
4219   return 0;
4220 }
4221
4222 static int test_lvremove_1_skip (void)
4223 {
4224   const char *str;
4225
4226   str = getenv ("SKIP_TEST_LVREMOVE_1");
4227   if (str && strcmp (str, "1") == 0) return 1;
4228   str = getenv ("SKIP_TEST_LVREMOVE");
4229   if (str && strcmp (str, "1") == 0) return 1;
4230   return 0;
4231 }
4232
4233 static int test_lvremove_1 (void)
4234 {
4235   if (test_lvremove_1_skip ()) {
4236     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4237     return 0;
4238   }
4239
4240   /* InitNone|InitEmpty for test_lvremove_1 */
4241   {
4242     char device[] = "/dev/sda";
4243     device[5] = devchar;
4244     int r;
4245     suppress_error = 0;
4246     r = guestfs_blockdev_setrw (g, device);
4247     if (r == -1)
4248       return -1;
4249   }
4250   {
4251     int r;
4252     suppress_error = 0;
4253     r = guestfs_umount_all (g);
4254     if (r == -1)
4255       return -1;
4256   }
4257   {
4258     int r;
4259     suppress_error = 0;
4260     r = guestfs_lvm_remove_all (g);
4261     if (r == -1)
4262       return -1;
4263   }
4264   /* TestOutputList for lvremove (1) */
4265   {
4266     char device[] = "/dev/sda";
4267     device[5] = devchar;
4268     char lines_0[] = ",";
4269     char *lines[] = {
4270       lines_0,
4271       NULL
4272     };
4273     int r;
4274     suppress_error = 0;
4275     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4276     if (r == -1)
4277       return -1;
4278   }
4279   {
4280     char device[] = "/dev/sda1";
4281     device[5] = devchar;
4282     int r;
4283     suppress_error = 0;
4284     r = guestfs_pvcreate (g, device);
4285     if (r == -1)
4286       return -1;
4287   }
4288   {
4289     char volgroup[] = "VG";
4290     char physvols_0[] = "/dev/sda1";
4291     physvols_0[5] = devchar;
4292     char *physvols[] = {
4293       physvols_0,
4294       NULL
4295     };
4296     int r;
4297     suppress_error = 0;
4298     r = guestfs_vgcreate (g, volgroup, physvols);
4299     if (r == -1)
4300       return -1;
4301   }
4302   {
4303     char logvol[] = "LV1";
4304     char volgroup[] = "VG";
4305     int r;
4306     suppress_error = 0;
4307     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4308     if (r == -1)
4309       return -1;
4310   }
4311   {
4312     char logvol[] = "LV2";
4313     char volgroup[] = "VG";
4314     int r;
4315     suppress_error = 0;
4316     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4317     if (r == -1)
4318       return -1;
4319   }
4320   {
4321     char device[] = "/dev/VG";
4322     int r;
4323     suppress_error = 0;
4324     r = guestfs_lvremove (g, device);
4325     if (r == -1)
4326       return -1;
4327   }
4328   {
4329     char **r;
4330     int i;
4331     suppress_error = 0;
4332     r = guestfs_lvs (g);
4333     if (r == NULL)
4334       return -1;
4335     if (r[0] != NULL) {
4336       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4337       print_strings (r);
4338       return -1;
4339     }
4340     for (i = 0; r[i] != NULL; ++i)
4341       free (r[i]);
4342     free (r);
4343   }
4344   return 0;
4345 }
4346
4347 static int test_lvremove_2_skip (void)
4348 {
4349   const char *str;
4350
4351   str = getenv ("SKIP_TEST_LVREMOVE_2");
4352   if (str && strcmp (str, "1") == 0) return 1;
4353   str = getenv ("SKIP_TEST_LVREMOVE");
4354   if (str && strcmp (str, "1") == 0) return 1;
4355   return 0;
4356 }
4357
4358 static int test_lvremove_2 (void)
4359 {
4360   if (test_lvremove_2_skip ()) {
4361     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4362     return 0;
4363   }
4364
4365   /* InitNone|InitEmpty for test_lvremove_2 */
4366   {
4367     char device[] = "/dev/sda";
4368     device[5] = devchar;
4369     int r;
4370     suppress_error = 0;
4371     r = guestfs_blockdev_setrw (g, device);
4372     if (r == -1)
4373       return -1;
4374   }
4375   {
4376     int r;
4377     suppress_error = 0;
4378     r = guestfs_umount_all (g);
4379     if (r == -1)
4380       return -1;
4381   }
4382   {
4383     int r;
4384     suppress_error = 0;
4385     r = guestfs_lvm_remove_all (g);
4386     if (r == -1)
4387       return -1;
4388   }
4389   /* TestOutputList for lvremove (2) */
4390   {
4391     char device[] = "/dev/sda";
4392     device[5] = devchar;
4393     char lines_0[] = ",";
4394     char *lines[] = {
4395       lines_0,
4396       NULL
4397     };
4398     int r;
4399     suppress_error = 0;
4400     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4401     if (r == -1)
4402       return -1;
4403   }
4404   {
4405     char device[] = "/dev/sda1";
4406     device[5] = devchar;
4407     int r;
4408     suppress_error = 0;
4409     r = guestfs_pvcreate (g, device);
4410     if (r == -1)
4411       return -1;
4412   }
4413   {
4414     char volgroup[] = "VG";
4415     char physvols_0[] = "/dev/sda1";
4416     physvols_0[5] = devchar;
4417     char *physvols[] = {
4418       physvols_0,
4419       NULL
4420     };
4421     int r;
4422     suppress_error = 0;
4423     r = guestfs_vgcreate (g, volgroup, physvols);
4424     if (r == -1)
4425       return -1;
4426   }
4427   {
4428     char logvol[] = "LV1";
4429     char volgroup[] = "VG";
4430     int r;
4431     suppress_error = 0;
4432     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4433     if (r == -1)
4434       return -1;
4435   }
4436   {
4437     char logvol[] = "LV2";
4438     char volgroup[] = "VG";
4439     int r;
4440     suppress_error = 0;
4441     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4442     if (r == -1)
4443       return -1;
4444   }
4445   {
4446     char device[] = "/dev/VG";
4447     int r;
4448     suppress_error = 0;
4449     r = guestfs_lvremove (g, device);
4450     if (r == -1)
4451       return -1;
4452   }
4453   {
4454     char **r;
4455     int i;
4456     suppress_error = 0;
4457     r = guestfs_vgs (g);
4458     if (r == NULL)
4459       return -1;
4460     if (!r[0]) {
4461       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4462       print_strings (r);
4463       return -1;
4464     }
4465     {
4466       char expected[] = "VG";
4467       if (strcmp (r[0], expected) != 0) {
4468         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4469         return -1;
4470       }
4471     }
4472     if (r[1] != NULL) {
4473       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4474       print_strings (r);
4475       return -1;
4476     }
4477     for (i = 0; r[i] != NULL; ++i)
4478       free (r[i]);
4479     free (r);
4480   }
4481   return 0;
4482 }
4483
4484 static int test_mount_ro_0_skip (void)
4485 {
4486   const char *str;
4487
4488   str = getenv ("SKIP_TEST_MOUNT_RO_0");
4489   if (str && strcmp (str, "1") == 0) return 1;
4490   str = getenv ("SKIP_TEST_MOUNT_RO");
4491   if (str && strcmp (str, "1") == 0) return 1;
4492   return 0;
4493 }
4494
4495 static int test_mount_ro_0 (void)
4496 {
4497   if (test_mount_ro_0_skip ()) {
4498     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4499     return 0;
4500   }
4501
4502   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4503   {
4504     char device[] = "/dev/sda";
4505     device[5] = devchar;
4506     int r;
4507     suppress_error = 0;
4508     r = guestfs_blockdev_setrw (g, device);
4509     if (r == -1)
4510       return -1;
4511   }
4512   {
4513     int r;
4514     suppress_error = 0;
4515     r = guestfs_umount_all (g);
4516     if (r == -1)
4517       return -1;
4518   }
4519   {
4520     int r;
4521     suppress_error = 0;
4522     r = guestfs_lvm_remove_all (g);
4523     if (r == -1)
4524       return -1;
4525   }
4526   {
4527     char device[] = "/dev/sda";
4528     device[5] = devchar;
4529     char lines_0[] = ",";
4530     char *lines[] = {
4531       lines_0,
4532       NULL
4533     };
4534     int r;
4535     suppress_error = 0;
4536     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4537     if (r == -1)
4538       return -1;
4539   }
4540   {
4541     char fstype[] = "ext2";
4542     char device[] = "/dev/sda1";
4543     device[5] = devchar;
4544     int r;
4545     suppress_error = 0;
4546     r = guestfs_mkfs (g, fstype, device);
4547     if (r == -1)
4548       return -1;
4549   }
4550   {
4551     char device[] = "/dev/sda1";
4552     device[5] = devchar;
4553     char mountpoint[] = "/";
4554     int r;
4555     suppress_error = 0;
4556     r = guestfs_mount (g, device, mountpoint);
4557     if (r == -1)
4558       return -1;
4559   }
4560   /* TestLastFail for mount_ro (0) */
4561   {
4562     char pathordevice[] = "/";
4563     int r;
4564     suppress_error = 0;
4565     r = guestfs_umount (g, pathordevice);
4566     if (r == -1)
4567       return -1;
4568   }
4569   {
4570     char device[] = "/dev/sda1";
4571     device[5] = devchar;
4572     char mountpoint[] = "/";
4573     int r;
4574     suppress_error = 0;
4575     r = guestfs_mount_ro (g, device, mountpoint);
4576     if (r == -1)
4577       return -1;
4578   }
4579   {
4580     char path[] = "/new";
4581     int r;
4582     suppress_error = 1;
4583     r = guestfs_touch (g, path);
4584     if (r != -1)
4585       return -1;
4586   }
4587   return 0;
4588 }
4589
4590 static int test_mount_ro_1_skip (void)
4591 {
4592   const char *str;
4593
4594   str = getenv ("SKIP_TEST_MOUNT_RO_1");
4595   if (str && strcmp (str, "1") == 0) return 1;
4596   str = getenv ("SKIP_TEST_MOUNT_RO");
4597   if (str && strcmp (str, "1") == 0) return 1;
4598   return 0;
4599 }
4600
4601 static int test_mount_ro_1 (void)
4602 {
4603   if (test_mount_ro_1_skip ()) {
4604     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4605     return 0;
4606   }
4607
4608   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4609   {
4610     char device[] = "/dev/sda";
4611     device[5] = devchar;
4612     int r;
4613     suppress_error = 0;
4614     r = guestfs_blockdev_setrw (g, device);
4615     if (r == -1)
4616       return -1;
4617   }
4618   {
4619     int r;
4620     suppress_error = 0;
4621     r = guestfs_umount_all (g);
4622     if (r == -1)
4623       return -1;
4624   }
4625   {
4626     int r;
4627     suppress_error = 0;
4628     r = guestfs_lvm_remove_all (g);
4629     if (r == -1)
4630       return -1;
4631   }
4632   {
4633     char device[] = "/dev/sda";
4634     device[5] = devchar;
4635     char lines_0[] = ",";
4636     char *lines[] = {
4637       lines_0,
4638       NULL
4639     };
4640     int r;
4641     suppress_error = 0;
4642     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4643     if (r == -1)
4644       return -1;
4645   }
4646   {
4647     char fstype[] = "ext2";
4648     char device[] = "/dev/sda1";
4649     device[5] = devchar;
4650     int r;
4651     suppress_error = 0;
4652     r = guestfs_mkfs (g, fstype, device);
4653     if (r == -1)
4654       return -1;
4655   }
4656   {
4657     char device[] = "/dev/sda1";
4658     device[5] = devchar;
4659     char mountpoint[] = "/";
4660     int r;
4661     suppress_error = 0;
4662     r = guestfs_mount (g, device, mountpoint);
4663     if (r == -1)
4664       return -1;
4665   }
4666   /* TestOutput for mount_ro (1) */
4667   char expected[] = "data";
4668   {
4669     char path[] = "/new";
4670     char content[] = "data";
4671     int r;
4672     suppress_error = 0;
4673     r = guestfs_write_file (g, path, content, 0);
4674     if (r == -1)
4675       return -1;
4676   }
4677   {
4678     char pathordevice[] = "/";
4679     int r;
4680     suppress_error = 0;
4681     r = guestfs_umount (g, pathordevice);
4682     if (r == -1)
4683       return -1;
4684   }
4685   {
4686     char device[] = "/dev/sda1";
4687     device[5] = devchar;
4688     char mountpoint[] = "/";
4689     int r;
4690     suppress_error = 0;
4691     r = guestfs_mount_ro (g, device, mountpoint);
4692     if (r == -1)
4693       return -1;
4694   }
4695   {
4696     char path[] = "/new";
4697     char *r;
4698     suppress_error = 0;
4699     r = guestfs_cat (g, path);
4700     if (r == NULL)
4701       return -1;
4702     if (strcmp (r, expected) != 0) {
4703       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4704       return -1;
4705     }
4706     free (r);
4707   }
4708   return 0;
4709 }
4710
4711 static int test_tgz_in_0_skip (void)
4712 {
4713   const char *str;
4714
4715   str = getenv ("SKIP_TEST_TGZ_IN_0");
4716   if (str && strcmp (str, "1") == 0) return 1;
4717   str = getenv ("SKIP_TEST_TGZ_IN");
4718   if (str && strcmp (str, "1") == 0) return 1;
4719   return 0;
4720 }
4721
4722 static int test_tgz_in_0 (void)
4723 {
4724   if (test_tgz_in_0_skip ()) {
4725     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4726     return 0;
4727   }
4728
4729   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4730   {
4731     char device[] = "/dev/sda";
4732     device[5] = devchar;
4733     int r;
4734     suppress_error = 0;
4735     r = guestfs_blockdev_setrw (g, device);
4736     if (r == -1)
4737       return -1;
4738   }
4739   {
4740     int r;
4741     suppress_error = 0;
4742     r = guestfs_umount_all (g);
4743     if (r == -1)
4744       return -1;
4745   }
4746   {
4747     int r;
4748     suppress_error = 0;
4749     r = guestfs_lvm_remove_all (g);
4750     if (r == -1)
4751       return -1;
4752   }
4753   {
4754     char device[] = "/dev/sda";
4755     device[5] = devchar;
4756     char lines_0[] = ",";
4757     char *lines[] = {
4758       lines_0,
4759       NULL
4760     };
4761     int r;
4762     suppress_error = 0;
4763     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4764     if (r == -1)
4765       return -1;
4766   }
4767   {
4768     char fstype[] = "ext2";
4769     char device[] = "/dev/sda1";
4770     device[5] = devchar;
4771     int r;
4772     suppress_error = 0;
4773     r = guestfs_mkfs (g, fstype, device);
4774     if (r == -1)
4775       return -1;
4776   }
4777   {
4778     char device[] = "/dev/sda1";
4779     device[5] = devchar;
4780     char mountpoint[] = "/";
4781     int r;
4782     suppress_error = 0;
4783     r = guestfs_mount (g, device, mountpoint);
4784     if (r == -1)
4785       return -1;
4786   }
4787   /* TestOutput for tgz_in (0) */
4788   char expected[] = "hello\n";
4789   {
4790     char directory[] = "/";
4791     int r;
4792     suppress_error = 0;
4793     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
4794     if (r == -1)
4795       return -1;
4796   }
4797   {
4798     char path[] = "/hello";
4799     char *r;
4800     suppress_error = 0;
4801     r = guestfs_cat (g, path);
4802     if (r == NULL)
4803       return -1;
4804     if (strcmp (r, expected) != 0) {
4805       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4806       return -1;
4807     }
4808     free (r);
4809   }
4810   return 0;
4811 }
4812
4813 static int test_tar_in_0_skip (void)
4814 {
4815   const char *str;
4816
4817   str = getenv ("SKIP_TEST_TAR_IN_0");
4818   if (str && strcmp (str, "1") == 0) return 1;
4819   str = getenv ("SKIP_TEST_TAR_IN");
4820   if (str && strcmp (str, "1") == 0) return 1;
4821   return 0;
4822 }
4823
4824 static int test_tar_in_0 (void)
4825 {
4826   if (test_tar_in_0_skip ()) {
4827     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
4828     return 0;
4829   }
4830
4831   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4832   {
4833     char device[] = "/dev/sda";
4834     device[5] = devchar;
4835     int r;
4836     suppress_error = 0;
4837     r = guestfs_blockdev_setrw (g, device);
4838     if (r == -1)
4839       return -1;
4840   }
4841   {
4842     int r;
4843     suppress_error = 0;
4844     r = guestfs_umount_all (g);
4845     if (r == -1)
4846       return -1;
4847   }
4848   {
4849     int r;
4850     suppress_error = 0;
4851     r = guestfs_lvm_remove_all (g);
4852     if (r == -1)
4853       return -1;
4854   }
4855   {
4856     char device[] = "/dev/sda";
4857     device[5] = devchar;
4858     char lines_0[] = ",";
4859     char *lines[] = {
4860       lines_0,
4861       NULL
4862     };
4863     int r;
4864     suppress_error = 0;
4865     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4866     if (r == -1)
4867       return -1;
4868   }
4869   {
4870     char fstype[] = "ext2";
4871     char device[] = "/dev/sda1";
4872     device[5] = devchar;
4873     int r;
4874     suppress_error = 0;
4875     r = guestfs_mkfs (g, fstype, device);
4876     if (r == -1)
4877       return -1;
4878   }
4879   {
4880     char device[] = "/dev/sda1";
4881     device[5] = devchar;
4882     char mountpoint[] = "/";
4883     int r;
4884     suppress_error = 0;
4885     r = guestfs_mount (g, device, mountpoint);
4886     if (r == -1)
4887       return -1;
4888   }
4889   /* TestOutput for tar_in (0) */
4890   char expected[] = "hello\n";
4891   {
4892     char directory[] = "/";
4893     int r;
4894     suppress_error = 0;
4895     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
4896     if (r == -1)
4897       return -1;
4898   }
4899   {
4900     char path[] = "/hello";
4901     char *r;
4902     suppress_error = 0;
4903     r = guestfs_cat (g, path);
4904     if (r == NULL)
4905       return -1;
4906     if (strcmp (r, expected) != 0) {
4907       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4908       return -1;
4909     }
4910     free (r);
4911   }
4912   return 0;
4913 }
4914
4915 static int test_checksum_0_skip (void)
4916 {
4917   const char *str;
4918
4919   str = getenv ("SKIP_TEST_CHECKSUM_0");
4920   if (str && strcmp (str, "1") == 0) return 1;
4921   str = getenv ("SKIP_TEST_CHECKSUM");
4922   if (str && strcmp (str, "1") == 0) return 1;
4923   return 0;
4924 }
4925
4926 static int test_checksum_0 (void)
4927 {
4928   if (test_checksum_0_skip ()) {
4929     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
4930     return 0;
4931   }
4932
4933   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4934   {
4935     char device[] = "/dev/sda";
4936     device[5] = devchar;
4937     int r;
4938     suppress_error = 0;
4939     r = guestfs_blockdev_setrw (g, device);
4940     if (r == -1)
4941       return -1;
4942   }
4943   {
4944     int r;
4945     suppress_error = 0;
4946     r = guestfs_umount_all (g);
4947     if (r == -1)
4948       return -1;
4949   }
4950   {
4951     int r;
4952     suppress_error = 0;
4953     r = guestfs_lvm_remove_all (g);
4954     if (r == -1)
4955       return -1;
4956   }
4957   {
4958     char device[] = "/dev/sda";
4959     device[5] = devchar;
4960     char lines_0[] = ",";
4961     char *lines[] = {
4962       lines_0,
4963       NULL
4964     };
4965     int r;
4966     suppress_error = 0;
4967     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4968     if (r == -1)
4969       return -1;
4970   }
4971   {
4972     char fstype[] = "ext2";
4973     char device[] = "/dev/sda1";
4974     device[5] = devchar;
4975     int r;
4976     suppress_error = 0;
4977     r = guestfs_mkfs (g, fstype, device);
4978     if (r == -1)
4979       return -1;
4980   }
4981   {
4982     char device[] = "/dev/sda1";
4983     device[5] = devchar;
4984     char mountpoint[] = "/";
4985     int r;
4986     suppress_error = 0;
4987     r = guestfs_mount (g, device, mountpoint);
4988     if (r == -1)
4989       return -1;
4990   }
4991   /* TestOutput for checksum (0) */
4992   char expected[] = "935282863";
4993   {
4994     char path[] = "/new";
4995     char content[] = "test\n";
4996     int r;
4997     suppress_error = 0;
4998     r = guestfs_write_file (g, path, content, 0);
4999     if (r == -1)
5000       return -1;
5001   }
5002   {
5003     char csumtype[] = "crc";
5004     char path[] = "/new";
5005     char *r;
5006     suppress_error = 0;
5007     r = guestfs_checksum (g, csumtype, path);
5008     if (r == NULL)
5009       return -1;
5010     if (strcmp (r, expected) != 0) {
5011       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5012       return -1;
5013     }
5014     free (r);
5015   }
5016   return 0;
5017 }
5018
5019 static int test_checksum_1_skip (void)
5020 {
5021   const char *str;
5022
5023   str = getenv ("SKIP_TEST_CHECKSUM_1");
5024   if (str && strcmp (str, "1") == 0) return 1;
5025   str = getenv ("SKIP_TEST_CHECKSUM");
5026   if (str && strcmp (str, "1") == 0) return 1;
5027   return 0;
5028 }
5029
5030 static int test_checksum_1 (void)
5031 {
5032   if (test_checksum_1_skip ()) {
5033     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5034     return 0;
5035   }
5036
5037   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5038   {
5039     char device[] = "/dev/sda";
5040     device[5] = devchar;
5041     int r;
5042     suppress_error = 0;
5043     r = guestfs_blockdev_setrw (g, device);
5044     if (r == -1)
5045       return -1;
5046   }
5047   {
5048     int r;
5049     suppress_error = 0;
5050     r = guestfs_umount_all (g);
5051     if (r == -1)
5052       return -1;
5053   }
5054   {
5055     int r;
5056     suppress_error = 0;
5057     r = guestfs_lvm_remove_all (g);
5058     if (r == -1)
5059       return -1;
5060   }
5061   {
5062     char device[] = "/dev/sda";
5063     device[5] = devchar;
5064     char lines_0[] = ",";
5065     char *lines[] = {
5066       lines_0,
5067       NULL
5068     };
5069     int r;
5070     suppress_error = 0;
5071     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5072     if (r == -1)
5073       return -1;
5074   }
5075   {
5076     char fstype[] = "ext2";
5077     char device[] = "/dev/sda1";
5078     device[5] = devchar;
5079     int r;
5080     suppress_error = 0;
5081     r = guestfs_mkfs (g, fstype, device);
5082     if (r == -1)
5083       return -1;
5084   }
5085   {
5086     char device[] = "/dev/sda1";
5087     device[5] = devchar;
5088     char mountpoint[] = "/";
5089     int r;
5090     suppress_error = 0;
5091     r = guestfs_mount (g, device, mountpoint);
5092     if (r == -1)
5093       return -1;
5094   }
5095   /* TestLastFail for checksum (1) */
5096   {
5097     char csumtype[] = "crc";
5098     char path[] = "/new";
5099     char *r;
5100     suppress_error = 1;
5101     r = guestfs_checksum (g, csumtype, path);
5102     if (r != NULL)
5103       return -1;
5104     free (r);
5105   }
5106   return 0;
5107 }
5108
5109 static int test_checksum_2_skip (void)
5110 {
5111   const char *str;
5112
5113   str = getenv ("SKIP_TEST_CHECKSUM_2");
5114   if (str && strcmp (str, "1") == 0) return 1;
5115   str = getenv ("SKIP_TEST_CHECKSUM");
5116   if (str && strcmp (str, "1") == 0) return 1;
5117   return 0;
5118 }
5119
5120 static int test_checksum_2 (void)
5121 {
5122   if (test_checksum_2_skip ()) {
5123     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5124     return 0;
5125   }
5126
5127   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5128   {
5129     char device[] = "/dev/sda";
5130     device[5] = devchar;
5131     int r;
5132     suppress_error = 0;
5133     r = guestfs_blockdev_setrw (g, device);
5134     if (r == -1)
5135       return -1;
5136   }
5137   {
5138     int r;
5139     suppress_error = 0;
5140     r = guestfs_umount_all (g);
5141     if (r == -1)
5142       return -1;
5143   }
5144   {
5145     int r;
5146     suppress_error = 0;
5147     r = guestfs_lvm_remove_all (g);
5148     if (r == -1)
5149       return -1;
5150   }
5151   {
5152     char device[] = "/dev/sda";
5153     device[5] = devchar;
5154     char lines_0[] = ",";
5155     char *lines[] = {
5156       lines_0,
5157       NULL
5158     };
5159     int r;
5160     suppress_error = 0;
5161     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5162     if (r == -1)
5163       return -1;
5164   }
5165   {
5166     char fstype[] = "ext2";
5167     char device[] = "/dev/sda1";
5168     device[5] = devchar;
5169     int r;
5170     suppress_error = 0;
5171     r = guestfs_mkfs (g, fstype, device);
5172     if (r == -1)
5173       return -1;
5174   }
5175   {
5176     char device[] = "/dev/sda1";
5177     device[5] = devchar;
5178     char mountpoint[] = "/";
5179     int r;
5180     suppress_error = 0;
5181     r = guestfs_mount (g, device, mountpoint);
5182     if (r == -1)
5183       return -1;
5184   }
5185   /* TestOutput for checksum (2) */
5186   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5187   {
5188     char path[] = "/new";
5189     char content[] = "test\n";
5190     int r;
5191     suppress_error = 0;
5192     r = guestfs_write_file (g, path, content, 0);
5193     if (r == -1)
5194       return -1;
5195   }
5196   {
5197     char csumtype[] = "md5";
5198     char path[] = "/new";
5199     char *r;
5200     suppress_error = 0;
5201     r = guestfs_checksum (g, csumtype, path);
5202     if (r == NULL)
5203       return -1;
5204     if (strcmp (r, expected) != 0) {
5205       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5206       return -1;
5207     }
5208     free (r);
5209   }
5210   return 0;
5211 }
5212
5213 static int test_checksum_3_skip (void)
5214 {
5215   const char *str;
5216
5217   str = getenv ("SKIP_TEST_CHECKSUM_3");
5218   if (str && strcmp (str, "1") == 0) return 1;
5219   str = getenv ("SKIP_TEST_CHECKSUM");
5220   if (str && strcmp (str, "1") == 0) return 1;
5221   return 0;
5222 }
5223
5224 static int test_checksum_3 (void)
5225 {
5226   if (test_checksum_3_skip ()) {
5227     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5228     return 0;
5229   }
5230
5231   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5232   {
5233     char device[] = "/dev/sda";
5234     device[5] = devchar;
5235     int r;
5236     suppress_error = 0;
5237     r = guestfs_blockdev_setrw (g, device);
5238     if (r == -1)
5239       return -1;
5240   }
5241   {
5242     int r;
5243     suppress_error = 0;
5244     r = guestfs_umount_all (g);
5245     if (r == -1)
5246       return -1;
5247   }
5248   {
5249     int r;
5250     suppress_error = 0;
5251     r = guestfs_lvm_remove_all (g);
5252     if (r == -1)
5253       return -1;
5254   }
5255   {
5256     char device[] = "/dev/sda";
5257     device[5] = devchar;
5258     char lines_0[] = ",";
5259     char *lines[] = {
5260       lines_0,
5261       NULL
5262     };
5263     int r;
5264     suppress_error = 0;
5265     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5266     if (r == -1)
5267       return -1;
5268   }
5269   {
5270     char fstype[] = "ext2";
5271     char device[] = "/dev/sda1";
5272     device[5] = devchar;
5273     int r;
5274     suppress_error = 0;
5275     r = guestfs_mkfs (g, fstype, device);
5276     if (r == -1)
5277       return -1;
5278   }
5279   {
5280     char device[] = "/dev/sda1";
5281     device[5] = devchar;
5282     char mountpoint[] = "/";
5283     int r;
5284     suppress_error = 0;
5285     r = guestfs_mount (g, device, mountpoint);
5286     if (r == -1)
5287       return -1;
5288   }
5289   /* TestOutput for checksum (3) */
5290   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5291   {
5292     char path[] = "/new";
5293     char content[] = "test\n";
5294     int r;
5295     suppress_error = 0;
5296     r = guestfs_write_file (g, path, content, 0);
5297     if (r == -1)
5298       return -1;
5299   }
5300   {
5301     char csumtype[] = "sha1";
5302     char path[] = "/new";
5303     char *r;
5304     suppress_error = 0;
5305     r = guestfs_checksum (g, csumtype, path);
5306     if (r == NULL)
5307       return -1;
5308     if (strcmp (r, expected) != 0) {
5309       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5310       return -1;
5311     }
5312     free (r);
5313   }
5314   return 0;
5315 }
5316
5317 static int test_checksum_4_skip (void)
5318 {
5319   const char *str;
5320
5321   str = getenv ("SKIP_TEST_CHECKSUM_4");
5322   if (str && strcmp (str, "1") == 0) return 1;
5323   str = getenv ("SKIP_TEST_CHECKSUM");
5324   if (str && strcmp (str, "1") == 0) return 1;
5325   return 0;
5326 }
5327
5328 static int test_checksum_4 (void)
5329 {
5330   if (test_checksum_4_skip ()) {
5331     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5332     return 0;
5333   }
5334
5335   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5336   {
5337     char device[] = "/dev/sda";
5338     device[5] = devchar;
5339     int r;
5340     suppress_error = 0;
5341     r = guestfs_blockdev_setrw (g, device);
5342     if (r == -1)
5343       return -1;
5344   }
5345   {
5346     int r;
5347     suppress_error = 0;
5348     r = guestfs_umount_all (g);
5349     if (r == -1)
5350       return -1;
5351   }
5352   {
5353     int r;
5354     suppress_error = 0;
5355     r = guestfs_lvm_remove_all (g);
5356     if (r == -1)
5357       return -1;
5358   }
5359   {
5360     char device[] = "/dev/sda";
5361     device[5] = devchar;
5362     char lines_0[] = ",";
5363     char *lines[] = {
5364       lines_0,
5365       NULL
5366     };
5367     int r;
5368     suppress_error = 0;
5369     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5370     if (r == -1)
5371       return -1;
5372   }
5373   {
5374     char fstype[] = "ext2";
5375     char device[] = "/dev/sda1";
5376     device[5] = devchar;
5377     int r;
5378     suppress_error = 0;
5379     r = guestfs_mkfs (g, fstype, device);
5380     if (r == -1)
5381       return -1;
5382   }
5383   {
5384     char device[] = "/dev/sda1";
5385     device[5] = devchar;
5386     char mountpoint[] = "/";
5387     int r;
5388     suppress_error = 0;
5389     r = guestfs_mount (g, device, mountpoint);
5390     if (r == -1)
5391       return -1;
5392   }
5393   /* TestOutput for checksum (4) */
5394   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5395   {
5396     char path[] = "/new";
5397     char content[] = "test\n";
5398     int r;
5399     suppress_error = 0;
5400     r = guestfs_write_file (g, path, content, 0);
5401     if (r == -1)
5402       return -1;
5403   }
5404   {
5405     char csumtype[] = "sha224";
5406     char path[] = "/new";
5407     char *r;
5408     suppress_error = 0;
5409     r = guestfs_checksum (g, csumtype, path);
5410     if (r == NULL)
5411       return -1;
5412     if (strcmp (r, expected) != 0) {
5413       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5414       return -1;
5415     }
5416     free (r);
5417   }
5418   return 0;
5419 }
5420
5421 static int test_checksum_5_skip (void)
5422 {
5423   const char *str;
5424
5425   str = getenv ("SKIP_TEST_CHECKSUM_5");
5426   if (str && strcmp (str, "1") == 0) return 1;
5427   str = getenv ("SKIP_TEST_CHECKSUM");
5428   if (str && strcmp (str, "1") == 0) return 1;
5429   return 0;
5430 }
5431
5432 static int test_checksum_5 (void)
5433 {
5434   if (test_checksum_5_skip ()) {
5435     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5436     return 0;
5437   }
5438
5439   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5440   {
5441     char device[] = "/dev/sda";
5442     device[5] = devchar;
5443     int r;
5444     suppress_error = 0;
5445     r = guestfs_blockdev_setrw (g, device);
5446     if (r == -1)
5447       return -1;
5448   }
5449   {
5450     int r;
5451     suppress_error = 0;
5452     r = guestfs_umount_all (g);
5453     if (r == -1)
5454       return -1;
5455   }
5456   {
5457     int r;
5458     suppress_error = 0;
5459     r = guestfs_lvm_remove_all (g);
5460     if (r == -1)
5461       return -1;
5462   }
5463   {
5464     char device[] = "/dev/sda";
5465     device[5] = devchar;
5466     char lines_0[] = ",";
5467     char *lines[] = {
5468       lines_0,
5469       NULL
5470     };
5471     int r;
5472     suppress_error = 0;
5473     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5474     if (r == -1)
5475       return -1;
5476   }
5477   {
5478     char fstype[] = "ext2";
5479     char device[] = "/dev/sda1";
5480     device[5] = devchar;
5481     int r;
5482     suppress_error = 0;
5483     r = guestfs_mkfs (g, fstype, device);
5484     if (r == -1)
5485       return -1;
5486   }
5487   {
5488     char device[] = "/dev/sda1";
5489     device[5] = devchar;
5490     char mountpoint[] = "/";
5491     int r;
5492     suppress_error = 0;
5493     r = guestfs_mount (g, device, mountpoint);
5494     if (r == -1)
5495       return -1;
5496   }
5497   /* TestOutput for checksum (5) */
5498   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5499   {
5500     char path[] = "/new";
5501     char content[] = "test\n";
5502     int r;
5503     suppress_error = 0;
5504     r = guestfs_write_file (g, path, content, 0);
5505     if (r == -1)
5506       return -1;
5507   }
5508   {
5509     char csumtype[] = "sha256";
5510     char path[] = "/new";
5511     char *r;
5512     suppress_error = 0;
5513     r = guestfs_checksum (g, csumtype, path);
5514     if (r == NULL)
5515       return -1;
5516     if (strcmp (r, expected) != 0) {
5517       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5518       return -1;
5519     }
5520     free (r);
5521   }
5522   return 0;
5523 }
5524
5525 static int test_checksum_6_skip (void)
5526 {
5527   const char *str;
5528
5529   str = getenv ("SKIP_TEST_CHECKSUM_6");
5530   if (str && strcmp (str, "1") == 0) return 1;
5531   str = getenv ("SKIP_TEST_CHECKSUM");
5532   if (str && strcmp (str, "1") == 0) return 1;
5533   return 0;
5534 }
5535
5536 static int test_checksum_6 (void)
5537 {
5538   if (test_checksum_6_skip ()) {
5539     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5540     return 0;
5541   }
5542
5543   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5544   {
5545     char device[] = "/dev/sda";
5546     device[5] = devchar;
5547     int r;
5548     suppress_error = 0;
5549     r = guestfs_blockdev_setrw (g, device);
5550     if (r == -1)
5551       return -1;
5552   }
5553   {
5554     int r;
5555     suppress_error = 0;
5556     r = guestfs_umount_all (g);
5557     if (r == -1)
5558       return -1;
5559   }
5560   {
5561     int r;
5562     suppress_error = 0;
5563     r = guestfs_lvm_remove_all (g);
5564     if (r == -1)
5565       return -1;
5566   }
5567   {
5568     char device[] = "/dev/sda";
5569     device[5] = devchar;
5570     char lines_0[] = ",";
5571     char *lines[] = {
5572       lines_0,
5573       NULL
5574     };
5575     int r;
5576     suppress_error = 0;
5577     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5578     if (r == -1)
5579       return -1;
5580   }
5581   {
5582     char fstype[] = "ext2";
5583     char device[] = "/dev/sda1";
5584     device[5] = devchar;
5585     int r;
5586     suppress_error = 0;
5587     r = guestfs_mkfs (g, fstype, device);
5588     if (r == -1)
5589       return -1;
5590   }
5591   {
5592     char device[] = "/dev/sda1";
5593     device[5] = devchar;
5594     char mountpoint[] = "/";
5595     int r;
5596     suppress_error = 0;
5597     r = guestfs_mount (g, device, mountpoint);
5598     if (r == -1)
5599       return -1;
5600   }
5601   /* TestOutput for checksum (6) */
5602   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5603   {
5604     char path[] = "/new";
5605     char content[] = "test\n";
5606     int r;
5607     suppress_error = 0;
5608     r = guestfs_write_file (g, path, content, 0);
5609     if (r == -1)
5610       return -1;
5611   }
5612   {
5613     char csumtype[] = "sha384";
5614     char path[] = "/new";
5615     char *r;
5616     suppress_error = 0;
5617     r = guestfs_checksum (g, csumtype, path);
5618     if (r == NULL)
5619       return -1;
5620     if (strcmp (r, expected) != 0) {
5621       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5622       return -1;
5623     }
5624     free (r);
5625   }
5626   return 0;
5627 }
5628
5629 static int test_checksum_7_skip (void)
5630 {
5631   const char *str;
5632
5633   str = getenv ("SKIP_TEST_CHECKSUM_7");
5634   if (str && strcmp (str, "1") == 0) return 1;
5635   str = getenv ("SKIP_TEST_CHECKSUM");
5636   if (str && strcmp (str, "1") == 0) return 1;
5637   return 0;
5638 }
5639
5640 static int test_checksum_7 (void)
5641 {
5642   if (test_checksum_7_skip ()) {
5643     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5644     return 0;
5645   }
5646
5647   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5648   {
5649     char device[] = "/dev/sda";
5650     device[5] = devchar;
5651     int r;
5652     suppress_error = 0;
5653     r = guestfs_blockdev_setrw (g, device);
5654     if (r == -1)
5655       return -1;
5656   }
5657   {
5658     int r;
5659     suppress_error = 0;
5660     r = guestfs_umount_all (g);
5661     if (r == -1)
5662       return -1;
5663   }
5664   {
5665     int r;
5666     suppress_error = 0;
5667     r = guestfs_lvm_remove_all (g);
5668     if (r == -1)
5669       return -1;
5670   }
5671   {
5672     char device[] = "/dev/sda";
5673     device[5] = devchar;
5674     char lines_0[] = ",";
5675     char *lines[] = {
5676       lines_0,
5677       NULL
5678     };
5679     int r;
5680     suppress_error = 0;
5681     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5682     if (r == -1)
5683       return -1;
5684   }
5685   {
5686     char fstype[] = "ext2";
5687     char device[] = "/dev/sda1";
5688     device[5] = devchar;
5689     int r;
5690     suppress_error = 0;
5691     r = guestfs_mkfs (g, fstype, device);
5692     if (r == -1)
5693       return -1;
5694   }
5695   {
5696     char device[] = "/dev/sda1";
5697     device[5] = devchar;
5698     char mountpoint[] = "/";
5699     int r;
5700     suppress_error = 0;
5701     r = guestfs_mount (g, device, mountpoint);
5702     if (r == -1)
5703       return -1;
5704   }
5705   /* TestOutput for checksum (7) */
5706   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5707   {
5708     char path[] = "/new";
5709     char content[] = "test\n";
5710     int r;
5711     suppress_error = 0;
5712     r = guestfs_write_file (g, path, content, 0);
5713     if (r == -1)
5714       return -1;
5715   }
5716   {
5717     char csumtype[] = "sha512";
5718     char path[] = "/new";
5719     char *r;
5720     suppress_error = 0;
5721     r = guestfs_checksum (g, csumtype, path);
5722     if (r == NULL)
5723       return -1;
5724     if (strcmp (r, expected) != 0) {
5725       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5726       return -1;
5727     }
5728     free (r);
5729   }
5730   return 0;
5731 }
5732
5733 static int test_checksum_8_skip (void)
5734 {
5735   const char *str;
5736
5737   str = getenv ("SKIP_TEST_CHECKSUM_8");
5738   if (str && strcmp (str, "1") == 0) return 1;
5739   str = getenv ("SKIP_TEST_CHECKSUM");
5740   if (str && strcmp (str, "1") == 0) return 1;
5741   return 0;
5742 }
5743
5744 static int test_checksum_8 (void)
5745 {
5746   if (test_checksum_8_skip ()) {
5747     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
5748     return 0;
5749   }
5750
5751   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
5752   {
5753     char device[] = "/dev/sda";
5754     device[5] = devchar;
5755     int r;
5756     suppress_error = 0;
5757     r = guestfs_blockdev_setrw (g, device);
5758     if (r == -1)
5759       return -1;
5760   }
5761   {
5762     int r;
5763     suppress_error = 0;
5764     r = guestfs_umount_all (g);
5765     if (r == -1)
5766       return -1;
5767   }
5768   {
5769     int r;
5770     suppress_error = 0;
5771     r = guestfs_lvm_remove_all (g);
5772     if (r == -1)
5773       return -1;
5774   }
5775   {
5776     char device[] = "/dev/sda";
5777     device[5] = devchar;
5778     char lines_0[] = ",";
5779     char *lines[] = {
5780       lines_0,
5781       NULL
5782     };
5783     int r;
5784     suppress_error = 0;
5785     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5786     if (r == -1)
5787       return -1;
5788   }
5789   {
5790     char fstype[] = "ext2";
5791     char device[] = "/dev/sda1";
5792     device[5] = devchar;
5793     int r;
5794     suppress_error = 0;
5795     r = guestfs_mkfs (g, fstype, device);
5796     if (r == -1)
5797       return -1;
5798   }
5799   {
5800     char device[] = "/dev/sda1";
5801     device[5] = devchar;
5802     char mountpoint[] = "/";
5803     int r;
5804     suppress_error = 0;
5805     r = guestfs_mount (g, device, mountpoint);
5806     if (r == -1)
5807       return -1;
5808   }
5809   /* TestOutput for checksum (8) */
5810   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
5811   {
5812     char device[] = "/dev/sdd";
5813     device[5] = devchar;
5814     char mountpoint[] = "/";
5815     int r;
5816     suppress_error = 0;
5817     r = guestfs_mount (g, device, mountpoint);
5818     if (r == -1)
5819       return -1;
5820   }
5821   {
5822     char csumtype[] = "md5";
5823     char path[] = "/known-3";
5824     char *r;
5825     suppress_error = 0;
5826     r = guestfs_checksum (g, csumtype, path);
5827     if (r == NULL)
5828       return -1;
5829     if (strcmp (r, expected) != 0) {
5830       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
5831       return -1;
5832     }
5833     free (r);
5834   }
5835   return 0;
5836 }
5837
5838 static int test_download_0_skip (void)
5839 {
5840   const char *str;
5841
5842   str = getenv ("SKIP_TEST_DOWNLOAD_0");
5843   if (str && strcmp (str, "1") == 0) return 1;
5844   str = getenv ("SKIP_TEST_DOWNLOAD");
5845   if (str && strcmp (str, "1") == 0) return 1;
5846   return 0;
5847 }
5848
5849 static int test_download_0 (void)
5850 {
5851   if (test_download_0_skip ()) {
5852     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5853     return 0;
5854   }
5855
5856   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5857   {
5858     char device[] = "/dev/sda";
5859     device[5] = devchar;
5860     int r;
5861     suppress_error = 0;
5862     r = guestfs_blockdev_setrw (g, device);
5863     if (r == -1)
5864       return -1;
5865   }
5866   {
5867     int r;
5868     suppress_error = 0;
5869     r = guestfs_umount_all (g);
5870     if (r == -1)
5871       return -1;
5872   }
5873   {
5874     int r;
5875     suppress_error = 0;
5876     r = guestfs_lvm_remove_all (g);
5877     if (r == -1)
5878       return -1;
5879   }
5880   {
5881     char device[] = "/dev/sda";
5882     device[5] = devchar;
5883     char lines_0[] = ",";
5884     char *lines[] = {
5885       lines_0,
5886       NULL
5887     };
5888     int r;
5889     suppress_error = 0;
5890     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5891     if (r == -1)
5892       return -1;
5893   }
5894   {
5895     char fstype[] = "ext2";
5896     char device[] = "/dev/sda1";
5897     device[5] = devchar;
5898     int r;
5899     suppress_error = 0;
5900     r = guestfs_mkfs (g, fstype, device);
5901     if (r == -1)
5902       return -1;
5903   }
5904   {
5905     char device[] = "/dev/sda1";
5906     device[5] = devchar;
5907     char mountpoint[] = "/";
5908     int r;
5909     suppress_error = 0;
5910     r = guestfs_mount (g, device, mountpoint);
5911     if (r == -1)
5912       return -1;
5913   }
5914   /* TestOutput for download (0) */
5915   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5916   {
5917     char remotefilename[] = "/COPYING.LIB";
5918     int r;
5919     suppress_error = 0;
5920     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5921     if (r == -1)
5922       return -1;
5923   }
5924   {
5925     char remotefilename[] = "/COPYING.LIB";
5926     int r;
5927     suppress_error = 0;
5928     r = guestfs_download (g, remotefilename, "testdownload.tmp");
5929     if (r == -1)
5930       return -1;
5931   }
5932   {
5933     char remotefilename[] = "/upload";
5934     int r;
5935     suppress_error = 0;
5936     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5937     if (r == -1)
5938       return -1;
5939   }
5940   {
5941     char csumtype[] = "md5";
5942     char path[] = "/upload";
5943     char *r;
5944     suppress_error = 0;
5945     r = guestfs_checksum (g, csumtype, path);
5946     if (r == NULL)
5947       return -1;
5948     if (strcmp (r, expected) != 0) {
5949       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5950       return -1;
5951     }
5952     free (r);
5953   }
5954   return 0;
5955 }
5956
5957 static int test_upload_0_skip (void)
5958 {
5959   const char *str;
5960
5961   str = getenv ("SKIP_TEST_UPLOAD_0");
5962   if (str && strcmp (str, "1") == 0) return 1;
5963   str = getenv ("SKIP_TEST_UPLOAD");
5964   if (str && strcmp (str, "1") == 0) return 1;
5965   return 0;
5966 }
5967
5968 static int test_upload_0 (void)
5969 {
5970   if (test_upload_0_skip ()) {
5971     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5972     return 0;
5973   }
5974
5975   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5976   {
5977     char device[] = "/dev/sda";
5978     device[5] = devchar;
5979     int r;
5980     suppress_error = 0;
5981     r = guestfs_blockdev_setrw (g, device);
5982     if (r == -1)
5983       return -1;
5984   }
5985   {
5986     int r;
5987     suppress_error = 0;
5988     r = guestfs_umount_all (g);
5989     if (r == -1)
5990       return -1;
5991   }
5992   {
5993     int r;
5994     suppress_error = 0;
5995     r = guestfs_lvm_remove_all (g);
5996     if (r == -1)
5997       return -1;
5998   }
5999   {
6000     char device[] = "/dev/sda";
6001     device[5] = devchar;
6002     char lines_0[] = ",";
6003     char *lines[] = {
6004       lines_0,
6005       NULL
6006     };
6007     int r;
6008     suppress_error = 0;
6009     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6010     if (r == -1)
6011       return -1;
6012   }
6013   {
6014     char fstype[] = "ext2";
6015     char device[] = "/dev/sda1";
6016     device[5] = devchar;
6017     int r;
6018     suppress_error = 0;
6019     r = guestfs_mkfs (g, fstype, device);
6020     if (r == -1)
6021       return -1;
6022   }
6023   {
6024     char device[] = "/dev/sda1";
6025     device[5] = devchar;
6026     char mountpoint[] = "/";
6027     int r;
6028     suppress_error = 0;
6029     r = guestfs_mount (g, device, mountpoint);
6030     if (r == -1)
6031       return -1;
6032   }
6033   /* TestOutput for upload (0) */
6034   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6035   {
6036     char remotefilename[] = "/COPYING.LIB";
6037     int r;
6038     suppress_error = 0;
6039     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6040     if (r == -1)
6041       return -1;
6042   }
6043   {
6044     char csumtype[] = "md5";
6045     char path[] = "/COPYING.LIB";
6046     char *r;
6047     suppress_error = 0;
6048     r = guestfs_checksum (g, csumtype, path);
6049     if (r == NULL)
6050       return -1;
6051     if (strcmp (r, expected) != 0) {
6052       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6053       return -1;
6054     }
6055     free (r);
6056   }
6057   return 0;
6058 }
6059
6060 static int test_blockdev_rereadpt_0_skip (void)
6061 {
6062   const char *str;
6063
6064   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6065   if (str && strcmp (str, "1") == 0) return 1;
6066   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6067   if (str && strcmp (str, "1") == 0) return 1;
6068   return 0;
6069 }
6070
6071 static int test_blockdev_rereadpt_0 (void)
6072 {
6073   if (test_blockdev_rereadpt_0_skip ()) {
6074     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6075     return 0;
6076   }
6077
6078   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6079   {
6080     char device[] = "/dev/sda";
6081     device[5] = devchar;
6082     int r;
6083     suppress_error = 0;
6084     r = guestfs_blockdev_setrw (g, device);
6085     if (r == -1)
6086       return -1;
6087   }
6088   {
6089     int r;
6090     suppress_error = 0;
6091     r = guestfs_umount_all (g);
6092     if (r == -1)
6093       return -1;
6094   }
6095   {
6096     int r;
6097     suppress_error = 0;
6098     r = guestfs_lvm_remove_all (g);
6099     if (r == -1)
6100       return -1;
6101   }
6102   /* TestRun for blockdev_rereadpt (0) */
6103   {
6104     char device[] = "/dev/sda";
6105     device[5] = devchar;
6106     int r;
6107     suppress_error = 0;
6108     r = guestfs_blockdev_rereadpt (g, device);
6109     if (r == -1)
6110       return -1;
6111   }
6112   return 0;
6113 }
6114
6115 static int test_blockdev_flushbufs_0_skip (void)
6116 {
6117   const char *str;
6118
6119   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6120   if (str && strcmp (str, "1") == 0) return 1;
6121   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6122   if (str && strcmp (str, "1") == 0) return 1;
6123   return 0;
6124 }
6125
6126 static int test_blockdev_flushbufs_0 (void)
6127 {
6128   if (test_blockdev_flushbufs_0_skip ()) {
6129     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6130     return 0;
6131   }
6132
6133   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6134   {
6135     char device[] = "/dev/sda";
6136     device[5] = devchar;
6137     int r;
6138     suppress_error = 0;
6139     r = guestfs_blockdev_setrw (g, device);
6140     if (r == -1)
6141       return -1;
6142   }
6143   {
6144     int r;
6145     suppress_error = 0;
6146     r = guestfs_umount_all (g);
6147     if (r == -1)
6148       return -1;
6149   }
6150   {
6151     int r;
6152     suppress_error = 0;
6153     r = guestfs_lvm_remove_all (g);
6154     if (r == -1)
6155       return -1;
6156   }
6157   /* TestRun for blockdev_flushbufs (0) */
6158   {
6159     char device[] = "/dev/sda";
6160     device[5] = devchar;
6161     int r;
6162     suppress_error = 0;
6163     r = guestfs_blockdev_flushbufs (g, device);
6164     if (r == -1)
6165       return -1;
6166   }
6167   return 0;
6168 }
6169
6170 static int test_blockdev_getsize64_0_skip (void)
6171 {
6172   const char *str;
6173
6174   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6175   if (str && strcmp (str, "1") == 0) return 1;
6176   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6177   if (str && strcmp (str, "1") == 0) return 1;
6178   return 0;
6179 }
6180
6181 static int test_blockdev_getsize64_0 (void)
6182 {
6183   if (test_blockdev_getsize64_0_skip ()) {
6184     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6185     return 0;
6186   }
6187
6188   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6189   {
6190     char device[] = "/dev/sda";
6191     device[5] = devchar;
6192     int r;
6193     suppress_error = 0;
6194     r = guestfs_blockdev_setrw (g, device);
6195     if (r == -1)
6196       return -1;
6197   }
6198   {
6199     int r;
6200     suppress_error = 0;
6201     r = guestfs_umount_all (g);
6202     if (r == -1)
6203       return -1;
6204   }
6205   {
6206     int r;
6207     suppress_error = 0;
6208     r = guestfs_lvm_remove_all (g);
6209     if (r == -1)
6210       return -1;
6211   }
6212   /* TestOutputInt for blockdev_getsize64 (0) */
6213   {
6214     char device[] = "/dev/sda";
6215     device[5] = devchar;
6216     int64_t r;
6217     suppress_error = 0;
6218     r = guestfs_blockdev_getsize64 (g, device);
6219     if (r == -1)
6220       return -1;
6221     if (r != 524288000) {
6222       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6223       return -1;
6224     }
6225   }
6226   return 0;
6227 }
6228
6229 static int test_blockdev_getsz_0_skip (void)
6230 {
6231   const char *str;
6232
6233   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6234   if (str && strcmp (str, "1") == 0) return 1;
6235   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6236   if (str && strcmp (str, "1") == 0) return 1;
6237   return 0;
6238 }
6239
6240 static int test_blockdev_getsz_0 (void)
6241 {
6242   if (test_blockdev_getsz_0_skip ()) {
6243     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6244     return 0;
6245   }
6246
6247   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6248   {
6249     char device[] = "/dev/sda";
6250     device[5] = devchar;
6251     int r;
6252     suppress_error = 0;
6253     r = guestfs_blockdev_setrw (g, device);
6254     if (r == -1)
6255       return -1;
6256   }
6257   {
6258     int r;
6259     suppress_error = 0;
6260     r = guestfs_umount_all (g);
6261     if (r == -1)
6262       return -1;
6263   }
6264   {
6265     int r;
6266     suppress_error = 0;
6267     r = guestfs_lvm_remove_all (g);
6268     if (r == -1)
6269       return -1;
6270   }
6271   /* TestOutputInt for blockdev_getsz (0) */
6272   {
6273     char device[] = "/dev/sda";
6274     device[5] = devchar;
6275     int64_t r;
6276     suppress_error = 0;
6277     r = guestfs_blockdev_getsz (g, device);
6278     if (r == -1)
6279       return -1;
6280     if (r != 1024000) {
6281       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6282       return -1;
6283     }
6284   }
6285   return 0;
6286 }
6287
6288 static int test_blockdev_getbsz_0_skip (void)
6289 {
6290   const char *str;
6291
6292   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6293   if (str && strcmp (str, "1") == 0) return 1;
6294   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6295   if (str && strcmp (str, "1") == 0) return 1;
6296   return 0;
6297 }
6298
6299 static int test_blockdev_getbsz_0 (void)
6300 {
6301   if (test_blockdev_getbsz_0_skip ()) {
6302     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6303     return 0;
6304   }
6305
6306   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6307   {
6308     char device[] = "/dev/sda";
6309     device[5] = devchar;
6310     int r;
6311     suppress_error = 0;
6312     r = guestfs_blockdev_setrw (g, device);
6313     if (r == -1)
6314       return -1;
6315   }
6316   {
6317     int r;
6318     suppress_error = 0;
6319     r = guestfs_umount_all (g);
6320     if (r == -1)
6321       return -1;
6322   }
6323   {
6324     int r;
6325     suppress_error = 0;
6326     r = guestfs_lvm_remove_all (g);
6327     if (r == -1)
6328       return -1;
6329   }
6330   /* TestOutputInt for blockdev_getbsz (0) */
6331   {
6332     char device[] = "/dev/sda";
6333     device[5] = devchar;
6334     int r;
6335     suppress_error = 0;
6336     r = guestfs_blockdev_getbsz (g, device);
6337     if (r == -1)
6338       return -1;
6339     if (r != 4096) {
6340       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6341       return -1;
6342     }
6343   }
6344   return 0;
6345 }
6346
6347 static int test_blockdev_getss_0_skip (void)
6348 {
6349   const char *str;
6350
6351   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6352   if (str && strcmp (str, "1") == 0) return 1;
6353   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6354   if (str && strcmp (str, "1") == 0) return 1;
6355   return 0;
6356 }
6357
6358 static int test_blockdev_getss_0 (void)
6359 {
6360   if (test_blockdev_getss_0_skip ()) {
6361     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6362     return 0;
6363   }
6364
6365   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6366   {
6367     char device[] = "/dev/sda";
6368     device[5] = devchar;
6369     int r;
6370     suppress_error = 0;
6371     r = guestfs_blockdev_setrw (g, device);
6372     if (r == -1)
6373       return -1;
6374   }
6375   {
6376     int r;
6377     suppress_error = 0;
6378     r = guestfs_umount_all (g);
6379     if (r == -1)
6380       return -1;
6381   }
6382   {
6383     int r;
6384     suppress_error = 0;
6385     r = guestfs_lvm_remove_all (g);
6386     if (r == -1)
6387       return -1;
6388   }
6389   /* TestOutputInt for blockdev_getss (0) */
6390   {
6391     char device[] = "/dev/sda";
6392     device[5] = devchar;
6393     int r;
6394     suppress_error = 0;
6395     r = guestfs_blockdev_getss (g, device);
6396     if (r == -1)
6397       return -1;
6398     if (r != 512) {
6399       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6400       return -1;
6401     }
6402   }
6403   return 0;
6404 }
6405
6406 static int test_blockdev_getro_0_skip (void)
6407 {
6408   const char *str;
6409
6410   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6411   if (str && strcmp (str, "1") == 0) return 1;
6412   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6413   if (str && strcmp (str, "1") == 0) return 1;
6414   return 0;
6415 }
6416
6417 static int test_blockdev_getro_0 (void)
6418 {
6419   if (test_blockdev_getro_0_skip ()) {
6420     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6421     return 0;
6422   }
6423
6424   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6425   {
6426     char device[] = "/dev/sda";
6427     device[5] = devchar;
6428     int r;
6429     suppress_error = 0;
6430     r = guestfs_blockdev_setrw (g, device);
6431     if (r == -1)
6432       return -1;
6433   }
6434   {
6435     int r;
6436     suppress_error = 0;
6437     r = guestfs_umount_all (g);
6438     if (r == -1)
6439       return -1;
6440   }
6441   {
6442     int r;
6443     suppress_error = 0;
6444     r = guestfs_lvm_remove_all (g);
6445     if (r == -1)
6446       return -1;
6447   }
6448   /* TestOutputTrue for blockdev_getro (0) */
6449   {
6450     char device[] = "/dev/sda";
6451     device[5] = devchar;
6452     int r;
6453     suppress_error = 0;
6454     r = guestfs_blockdev_setro (g, device);
6455     if (r == -1)
6456       return -1;
6457   }
6458   {
6459     char device[] = "/dev/sda";
6460     device[5] = devchar;
6461     int r;
6462     suppress_error = 0;
6463     r = guestfs_blockdev_getro (g, device);
6464     if (r == -1)
6465       return -1;
6466     if (!r) {
6467       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6468       return -1;
6469     }
6470   }
6471   return 0;
6472 }
6473
6474 static int test_blockdev_setrw_0_skip (void)
6475 {
6476   const char *str;
6477
6478   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6479   if (str && strcmp (str, "1") == 0) return 1;
6480   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6481   if (str && strcmp (str, "1") == 0) return 1;
6482   return 0;
6483 }
6484
6485 static int test_blockdev_setrw_0 (void)
6486 {
6487   if (test_blockdev_setrw_0_skip ()) {
6488     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6489     return 0;
6490   }
6491
6492   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6493   {
6494     char device[] = "/dev/sda";
6495     device[5] = devchar;
6496     int r;
6497     suppress_error = 0;
6498     r = guestfs_blockdev_setrw (g, device);
6499     if (r == -1)
6500       return -1;
6501   }
6502   {
6503     int r;
6504     suppress_error = 0;
6505     r = guestfs_umount_all (g);
6506     if (r == -1)
6507       return -1;
6508   }
6509   {
6510     int r;
6511     suppress_error = 0;
6512     r = guestfs_lvm_remove_all (g);
6513     if (r == -1)
6514       return -1;
6515   }
6516   /* TestOutputFalse for blockdev_setrw (0) */
6517   {
6518     char device[] = "/dev/sda";
6519     device[5] = devchar;
6520     int r;
6521     suppress_error = 0;
6522     r = guestfs_blockdev_setrw (g, device);
6523     if (r == -1)
6524       return -1;
6525   }
6526   {
6527     char device[] = "/dev/sda";
6528     device[5] = devchar;
6529     int r;
6530     suppress_error = 0;
6531     r = guestfs_blockdev_getro (g, device);
6532     if (r == -1)
6533       return -1;
6534     if (r) {
6535       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6536       return -1;
6537     }
6538   }
6539   return 0;
6540 }
6541
6542 static int test_blockdev_setro_0_skip (void)
6543 {
6544   const char *str;
6545
6546   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6547   if (str && strcmp (str, "1") == 0) return 1;
6548   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6549   if (str && strcmp (str, "1") == 0) return 1;
6550   return 0;
6551 }
6552
6553 static int test_blockdev_setro_0 (void)
6554 {
6555   if (test_blockdev_setro_0_skip ()) {
6556     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6557     return 0;
6558   }
6559
6560   /* InitNone|InitEmpty for test_blockdev_setro_0 */
6561   {
6562     char device[] = "/dev/sda";
6563     device[5] = devchar;
6564     int r;
6565     suppress_error = 0;
6566     r = guestfs_blockdev_setrw (g, device);
6567     if (r == -1)
6568       return -1;
6569   }
6570   {
6571     int r;
6572     suppress_error = 0;
6573     r = guestfs_umount_all (g);
6574     if (r == -1)
6575       return -1;
6576   }
6577   {
6578     int r;
6579     suppress_error = 0;
6580     r = guestfs_lvm_remove_all (g);
6581     if (r == -1)
6582       return -1;
6583   }
6584   /* TestOutputTrue for blockdev_setro (0) */
6585   {
6586     char device[] = "/dev/sda";
6587     device[5] = devchar;
6588     int r;
6589     suppress_error = 0;
6590     r = guestfs_blockdev_setro (g, device);
6591     if (r == -1)
6592       return -1;
6593   }
6594   {
6595     char device[] = "/dev/sda";
6596     device[5] = devchar;
6597     int r;
6598     suppress_error = 0;
6599     r = guestfs_blockdev_getro (g, device);
6600     if (r == -1)
6601       return -1;
6602     if (!r) {
6603       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6604       return -1;
6605     }
6606   }
6607   return 0;
6608 }
6609
6610 static int test_statvfs_0_skip (void)
6611 {
6612   const char *str;
6613
6614   str = getenv ("SKIP_TEST_STATVFS_0");
6615   if (str && strcmp (str, "1") == 0) return 1;
6616   str = getenv ("SKIP_TEST_STATVFS");
6617   if (str && strcmp (str, "1") == 0) return 1;
6618   return 0;
6619 }
6620
6621 static int test_statvfs_0 (void)
6622 {
6623   if (test_statvfs_0_skip ()) {
6624     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6625     return 0;
6626   }
6627
6628   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6629   {
6630     char device[] = "/dev/sda";
6631     device[5] = devchar;
6632     int r;
6633     suppress_error = 0;
6634     r = guestfs_blockdev_setrw (g, device);
6635     if (r == -1)
6636       return -1;
6637   }
6638   {
6639     int r;
6640     suppress_error = 0;
6641     r = guestfs_umount_all (g);
6642     if (r == -1)
6643       return -1;
6644   }
6645   {
6646     int r;
6647     suppress_error = 0;
6648     r = guestfs_lvm_remove_all (g);
6649     if (r == -1)
6650       return -1;
6651   }
6652   {
6653     char device[] = "/dev/sda";
6654     device[5] = devchar;
6655     char lines_0[] = ",";
6656     char *lines[] = {
6657       lines_0,
6658       NULL
6659     };
6660     int r;
6661     suppress_error = 0;
6662     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6663     if (r == -1)
6664       return -1;
6665   }
6666   {
6667     char fstype[] = "ext2";
6668     char device[] = "/dev/sda1";
6669     device[5] = devchar;
6670     int r;
6671     suppress_error = 0;
6672     r = guestfs_mkfs (g, fstype, device);
6673     if (r == -1)
6674       return -1;
6675   }
6676   {
6677     char device[] = "/dev/sda1";
6678     device[5] = devchar;
6679     char mountpoint[] = "/";
6680     int r;
6681     suppress_error = 0;
6682     r = guestfs_mount (g, device, mountpoint);
6683     if (r == -1)
6684       return -1;
6685   }
6686   /* TestOutputStruct for statvfs (0) */
6687   {
6688     char path[] = "/";
6689     struct guestfs_statvfs *r;
6690     suppress_error = 0;
6691     r = guestfs_statvfs (g, path);
6692     if (r == NULL)
6693       return -1;
6694     if (r->bfree != 487702) {
6695       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6696                (int) r->bfree);
6697       return -1;
6698     }
6699     if (r->blocks != 490020) {
6700       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6701                (int) r->blocks);
6702       return -1;
6703     }
6704     if (r->bsize != 1024) {
6705       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6706                (int) r->bsize);
6707       return -1;
6708     }
6709     free (r);
6710   }
6711   return 0;
6712 }
6713
6714 static int test_lstat_0_skip (void)
6715 {
6716   const char *str;
6717
6718   str = getenv ("SKIP_TEST_LSTAT_0");
6719   if (str && strcmp (str, "1") == 0) return 1;
6720   str = getenv ("SKIP_TEST_LSTAT");
6721   if (str && strcmp (str, "1") == 0) return 1;
6722   return 0;
6723 }
6724
6725 static int test_lstat_0 (void)
6726 {
6727   if (test_lstat_0_skip ()) {
6728     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6729     return 0;
6730   }
6731
6732   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6733   {
6734     char device[] = "/dev/sda";
6735     device[5] = devchar;
6736     int r;
6737     suppress_error = 0;
6738     r = guestfs_blockdev_setrw (g, device);
6739     if (r == -1)
6740       return -1;
6741   }
6742   {
6743     int r;
6744     suppress_error = 0;
6745     r = guestfs_umount_all (g);
6746     if (r == -1)
6747       return -1;
6748   }
6749   {
6750     int r;
6751     suppress_error = 0;
6752     r = guestfs_lvm_remove_all (g);
6753     if (r == -1)
6754       return -1;
6755   }
6756   {
6757     char device[] = "/dev/sda";
6758     device[5] = devchar;
6759     char lines_0[] = ",";
6760     char *lines[] = {
6761       lines_0,
6762       NULL
6763     };
6764     int r;
6765     suppress_error = 0;
6766     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6767     if (r == -1)
6768       return -1;
6769   }
6770   {
6771     char fstype[] = "ext2";
6772     char device[] = "/dev/sda1";
6773     device[5] = devchar;
6774     int r;
6775     suppress_error = 0;
6776     r = guestfs_mkfs (g, fstype, device);
6777     if (r == -1)
6778       return -1;
6779   }
6780   {
6781     char device[] = "/dev/sda1";
6782     device[5] = devchar;
6783     char mountpoint[] = "/";
6784     int r;
6785     suppress_error = 0;
6786     r = guestfs_mount (g, device, mountpoint);
6787     if (r == -1)
6788       return -1;
6789   }
6790   /* TestOutputStruct for lstat (0) */
6791   {
6792     char path[] = "/new";
6793     int r;
6794     suppress_error = 0;
6795     r = guestfs_touch (g, path);
6796     if (r == -1)
6797       return -1;
6798   }
6799   {
6800     char path[] = "/new";
6801     struct guestfs_stat *r;
6802     suppress_error = 0;
6803     r = guestfs_lstat (g, path);
6804     if (r == NULL)
6805       return -1;
6806     if (r->size != 0) {
6807       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6808                (int) r->size);
6809       return -1;
6810     }
6811     free (r);
6812   }
6813   return 0;
6814 }
6815
6816 static int test_stat_0_skip (void)
6817 {
6818   const char *str;
6819
6820   str = getenv ("SKIP_TEST_STAT_0");
6821   if (str && strcmp (str, "1") == 0) return 1;
6822   str = getenv ("SKIP_TEST_STAT");
6823   if (str && strcmp (str, "1") == 0) return 1;
6824   return 0;
6825 }
6826
6827 static int test_stat_0 (void)
6828 {
6829   if (test_stat_0_skip ()) {
6830     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6831     return 0;
6832   }
6833
6834   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6835   {
6836     char device[] = "/dev/sda";
6837     device[5] = devchar;
6838     int r;
6839     suppress_error = 0;
6840     r = guestfs_blockdev_setrw (g, device);
6841     if (r == -1)
6842       return -1;
6843   }
6844   {
6845     int r;
6846     suppress_error = 0;
6847     r = guestfs_umount_all (g);
6848     if (r == -1)
6849       return -1;
6850   }
6851   {
6852     int r;
6853     suppress_error = 0;
6854     r = guestfs_lvm_remove_all (g);
6855     if (r == -1)
6856       return -1;
6857   }
6858   {
6859     char device[] = "/dev/sda";
6860     device[5] = devchar;
6861     char lines_0[] = ",";
6862     char *lines[] = {
6863       lines_0,
6864       NULL
6865     };
6866     int r;
6867     suppress_error = 0;
6868     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6869     if (r == -1)
6870       return -1;
6871   }
6872   {
6873     char fstype[] = "ext2";
6874     char device[] = "/dev/sda1";
6875     device[5] = devchar;
6876     int r;
6877     suppress_error = 0;
6878     r = guestfs_mkfs (g, fstype, device);
6879     if (r == -1)
6880       return -1;
6881   }
6882   {
6883     char device[] = "/dev/sda1";
6884     device[5] = devchar;
6885     char mountpoint[] = "/";
6886     int r;
6887     suppress_error = 0;
6888     r = guestfs_mount (g, device, mountpoint);
6889     if (r == -1)
6890       return -1;
6891   }
6892   /* TestOutputStruct for stat (0) */
6893   {
6894     char path[] = "/new";
6895     int r;
6896     suppress_error = 0;
6897     r = guestfs_touch (g, path);
6898     if (r == -1)
6899       return -1;
6900   }
6901   {
6902     char path[] = "/new";
6903     struct guestfs_stat *r;
6904     suppress_error = 0;
6905     r = guestfs_stat (g, path);
6906     if (r == NULL)
6907       return -1;
6908     if (r->size != 0) {
6909       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6910                (int) r->size);
6911       return -1;
6912     }
6913     free (r);
6914   }
6915   return 0;
6916 }
6917
6918 static int test_command_lines_0_skip (void)
6919 {
6920   const char *str;
6921
6922   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6923   if (str && strcmp (str, "1") == 0) return 1;
6924   str = getenv ("SKIP_TEST_COMMAND_LINES");
6925   if (str && strcmp (str, "1") == 0) return 1;
6926   return 0;
6927 }
6928
6929 static int test_command_lines_0 (void)
6930 {
6931   if (test_command_lines_0_skip ()) {
6932     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6933     return 0;
6934   }
6935
6936   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6937   {
6938     char device[] = "/dev/sda";
6939     device[5] = devchar;
6940     int r;
6941     suppress_error = 0;
6942     r = guestfs_blockdev_setrw (g, device);
6943     if (r == -1)
6944       return -1;
6945   }
6946   {
6947     int r;
6948     suppress_error = 0;
6949     r = guestfs_umount_all (g);
6950     if (r == -1)
6951       return -1;
6952   }
6953   {
6954     int r;
6955     suppress_error = 0;
6956     r = guestfs_lvm_remove_all (g);
6957     if (r == -1)
6958       return -1;
6959   }
6960   {
6961     char device[] = "/dev/sda";
6962     device[5] = devchar;
6963     char lines_0[] = ",";
6964     char *lines[] = {
6965       lines_0,
6966       NULL
6967     };
6968     int r;
6969     suppress_error = 0;
6970     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6971     if (r == -1)
6972       return -1;
6973   }
6974   {
6975     char fstype[] = "ext2";
6976     char device[] = "/dev/sda1";
6977     device[5] = devchar;
6978     int r;
6979     suppress_error = 0;
6980     r = guestfs_mkfs (g, fstype, device);
6981     if (r == -1)
6982       return -1;
6983   }
6984   {
6985     char device[] = "/dev/sda1";
6986     device[5] = devchar;
6987     char mountpoint[] = "/";
6988     int r;
6989     suppress_error = 0;
6990     r = guestfs_mount (g, device, mountpoint);
6991     if (r == -1)
6992       return -1;
6993   }
6994   /* TestOutputList for command_lines (0) */
6995   {
6996     char remotefilename[] = "/test-command";
6997     int r;
6998     suppress_error = 0;
6999     r = guestfs_upload (g, "test-command", remotefilename);
7000     if (r == -1)
7001       return -1;
7002   }
7003   {
7004     char path[] = "/test-command";
7005     int r;
7006     suppress_error = 0;
7007     r = guestfs_chmod (g, 493, path);
7008     if (r == -1)
7009       return -1;
7010   }
7011   {
7012     char arguments_0[] = "/test-command";
7013     char arguments_1[] = "1";
7014     char *arguments[] = {
7015       arguments_0,
7016       arguments_1,
7017       NULL
7018     };
7019     char **r;
7020     int i;
7021     suppress_error = 0;
7022     r = guestfs_command_lines (g, arguments);
7023     if (r == NULL)
7024       return -1;
7025     if (!r[0]) {
7026       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7027       print_strings (r);
7028       return -1;
7029     }
7030     {
7031       char expected[] = "Result1";
7032       if (strcmp (r[0], expected) != 0) {
7033         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7034         return -1;
7035       }
7036     }
7037     if (r[1] != NULL) {
7038       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7039       print_strings (r);
7040       return -1;
7041     }
7042     for (i = 0; r[i] != NULL; ++i)
7043       free (r[i]);
7044     free (r);
7045   }
7046   return 0;
7047 }
7048
7049 static int test_command_lines_1_skip (void)
7050 {
7051   const char *str;
7052
7053   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7054   if (str && strcmp (str, "1") == 0) return 1;
7055   str = getenv ("SKIP_TEST_COMMAND_LINES");
7056   if (str && strcmp (str, "1") == 0) return 1;
7057   return 0;
7058 }
7059
7060 static int test_command_lines_1 (void)
7061 {
7062   if (test_command_lines_1_skip ()) {
7063     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7064     return 0;
7065   }
7066
7067   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7068   {
7069     char device[] = "/dev/sda";
7070     device[5] = devchar;
7071     int r;
7072     suppress_error = 0;
7073     r = guestfs_blockdev_setrw (g, device);
7074     if (r == -1)
7075       return -1;
7076   }
7077   {
7078     int r;
7079     suppress_error = 0;
7080     r = guestfs_umount_all (g);
7081     if (r == -1)
7082       return -1;
7083   }
7084   {
7085     int r;
7086     suppress_error = 0;
7087     r = guestfs_lvm_remove_all (g);
7088     if (r == -1)
7089       return -1;
7090   }
7091   {
7092     char device[] = "/dev/sda";
7093     device[5] = devchar;
7094     char lines_0[] = ",";
7095     char *lines[] = {
7096       lines_0,
7097       NULL
7098     };
7099     int r;
7100     suppress_error = 0;
7101     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7102     if (r == -1)
7103       return -1;
7104   }
7105   {
7106     char fstype[] = "ext2";
7107     char device[] = "/dev/sda1";
7108     device[5] = devchar;
7109     int r;
7110     suppress_error = 0;
7111     r = guestfs_mkfs (g, fstype, device);
7112     if (r == -1)
7113       return -1;
7114   }
7115   {
7116     char device[] = "/dev/sda1";
7117     device[5] = devchar;
7118     char mountpoint[] = "/";
7119     int r;
7120     suppress_error = 0;
7121     r = guestfs_mount (g, device, mountpoint);
7122     if (r == -1)
7123       return -1;
7124   }
7125   /* TestOutputList for command_lines (1) */
7126   {
7127     char remotefilename[] = "/test-command";
7128     int r;
7129     suppress_error = 0;
7130     r = guestfs_upload (g, "test-command", remotefilename);
7131     if (r == -1)
7132       return -1;
7133   }
7134   {
7135     char path[] = "/test-command";
7136     int r;
7137     suppress_error = 0;
7138     r = guestfs_chmod (g, 493, path);
7139     if (r == -1)
7140       return -1;
7141   }
7142   {
7143     char arguments_0[] = "/test-command";
7144     char arguments_1[] = "2";
7145     char *arguments[] = {
7146       arguments_0,
7147       arguments_1,
7148       NULL
7149     };
7150     char **r;
7151     int i;
7152     suppress_error = 0;
7153     r = guestfs_command_lines (g, arguments);
7154     if (r == NULL)
7155       return -1;
7156     if (!r[0]) {
7157       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7158       print_strings (r);
7159       return -1;
7160     }
7161     {
7162       char expected[] = "Result2";
7163       if (strcmp (r[0], expected) != 0) {
7164         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7165         return -1;
7166       }
7167     }
7168     if (r[1] != NULL) {
7169       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7170       print_strings (r);
7171       return -1;
7172     }
7173     for (i = 0; r[i] != NULL; ++i)
7174       free (r[i]);
7175     free (r);
7176   }
7177   return 0;
7178 }
7179
7180 static int test_command_lines_2_skip (void)
7181 {
7182   const char *str;
7183
7184   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7185   if (str && strcmp (str, "1") == 0) return 1;
7186   str = getenv ("SKIP_TEST_COMMAND_LINES");
7187   if (str && strcmp (str, "1") == 0) return 1;
7188   return 0;
7189 }
7190
7191 static int test_command_lines_2 (void)
7192 {
7193   if (test_command_lines_2_skip ()) {
7194     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7195     return 0;
7196   }
7197
7198   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7199   {
7200     char device[] = "/dev/sda";
7201     device[5] = devchar;
7202     int r;
7203     suppress_error = 0;
7204     r = guestfs_blockdev_setrw (g, device);
7205     if (r == -1)
7206       return -1;
7207   }
7208   {
7209     int r;
7210     suppress_error = 0;
7211     r = guestfs_umount_all (g);
7212     if (r == -1)
7213       return -1;
7214   }
7215   {
7216     int r;
7217     suppress_error = 0;
7218     r = guestfs_lvm_remove_all (g);
7219     if (r == -1)
7220       return -1;
7221   }
7222   {
7223     char device[] = "/dev/sda";
7224     device[5] = devchar;
7225     char lines_0[] = ",";
7226     char *lines[] = {
7227       lines_0,
7228       NULL
7229     };
7230     int r;
7231     suppress_error = 0;
7232     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7233     if (r == -1)
7234       return -1;
7235   }
7236   {
7237     char fstype[] = "ext2";
7238     char device[] = "/dev/sda1";
7239     device[5] = devchar;
7240     int r;
7241     suppress_error = 0;
7242     r = guestfs_mkfs (g, fstype, device);
7243     if (r == -1)
7244       return -1;
7245   }
7246   {
7247     char device[] = "/dev/sda1";
7248     device[5] = devchar;
7249     char mountpoint[] = "/";
7250     int r;
7251     suppress_error = 0;
7252     r = guestfs_mount (g, device, mountpoint);
7253     if (r == -1)
7254       return -1;
7255   }
7256   /* TestOutputList for command_lines (2) */
7257   {
7258     char remotefilename[] = "/test-command";
7259     int r;
7260     suppress_error = 0;
7261     r = guestfs_upload (g, "test-command", remotefilename);
7262     if (r == -1)
7263       return -1;
7264   }
7265   {
7266     char path[] = "/test-command";
7267     int r;
7268     suppress_error = 0;
7269     r = guestfs_chmod (g, 493, path);
7270     if (r == -1)
7271       return -1;
7272   }
7273   {
7274     char arguments_0[] = "/test-command";
7275     char arguments_1[] = "3";
7276     char *arguments[] = {
7277       arguments_0,
7278       arguments_1,
7279       NULL
7280     };
7281     char **r;
7282     int i;
7283     suppress_error = 0;
7284     r = guestfs_command_lines (g, arguments);
7285     if (r == NULL)
7286       return -1;
7287     if (!r[0]) {
7288       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7289       print_strings (r);
7290       return -1;
7291     }
7292     {
7293       char expected[] = "";
7294       if (strcmp (r[0], expected) != 0) {
7295         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7296         return -1;
7297       }
7298     }
7299     if (!r[1]) {
7300       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7301       print_strings (r);
7302       return -1;
7303     }
7304     {
7305       char expected[] = "Result3";
7306       if (strcmp (r[1], expected) != 0) {
7307         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7308         return -1;
7309       }
7310     }
7311     if (r[2] != NULL) {
7312       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7313       print_strings (r);
7314       return -1;
7315     }
7316     for (i = 0; r[i] != NULL; ++i)
7317       free (r[i]);
7318     free (r);
7319   }
7320   return 0;
7321 }
7322
7323 static int test_command_lines_3_skip (void)
7324 {
7325   const char *str;
7326
7327   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7328   if (str && strcmp (str, "1") == 0) return 1;
7329   str = getenv ("SKIP_TEST_COMMAND_LINES");
7330   if (str && strcmp (str, "1") == 0) return 1;
7331   return 0;
7332 }
7333
7334 static int test_command_lines_3 (void)
7335 {
7336   if (test_command_lines_3_skip ()) {
7337     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7338     return 0;
7339   }
7340
7341   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7342   {
7343     char device[] = "/dev/sda";
7344     device[5] = devchar;
7345     int r;
7346     suppress_error = 0;
7347     r = guestfs_blockdev_setrw (g, device);
7348     if (r == -1)
7349       return -1;
7350   }
7351   {
7352     int r;
7353     suppress_error = 0;
7354     r = guestfs_umount_all (g);
7355     if (r == -1)
7356       return -1;
7357   }
7358   {
7359     int r;
7360     suppress_error = 0;
7361     r = guestfs_lvm_remove_all (g);
7362     if (r == -1)
7363       return -1;
7364   }
7365   {
7366     char device[] = "/dev/sda";
7367     device[5] = devchar;
7368     char lines_0[] = ",";
7369     char *lines[] = {
7370       lines_0,
7371       NULL
7372     };
7373     int r;
7374     suppress_error = 0;
7375     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7376     if (r == -1)
7377       return -1;
7378   }
7379   {
7380     char fstype[] = "ext2";
7381     char device[] = "/dev/sda1";
7382     device[5] = devchar;
7383     int r;
7384     suppress_error = 0;
7385     r = guestfs_mkfs (g, fstype, device);
7386     if (r == -1)
7387       return -1;
7388   }
7389   {
7390     char device[] = "/dev/sda1";
7391     device[5] = devchar;
7392     char mountpoint[] = "/";
7393     int r;
7394     suppress_error = 0;
7395     r = guestfs_mount (g, device, mountpoint);
7396     if (r == -1)
7397       return -1;
7398   }
7399   /* TestOutputList for command_lines (3) */
7400   {
7401     char remotefilename[] = "/test-command";
7402     int r;
7403     suppress_error = 0;
7404     r = guestfs_upload (g, "test-command", remotefilename);
7405     if (r == -1)
7406       return -1;
7407   }
7408   {
7409     char path[] = "/test-command";
7410     int r;
7411     suppress_error = 0;
7412     r = guestfs_chmod (g, 493, path);
7413     if (r == -1)
7414       return -1;
7415   }
7416   {
7417     char arguments_0[] = "/test-command";
7418     char arguments_1[] = "4";
7419     char *arguments[] = {
7420       arguments_0,
7421       arguments_1,
7422       NULL
7423     };
7424     char **r;
7425     int i;
7426     suppress_error = 0;
7427     r = guestfs_command_lines (g, arguments);
7428     if (r == NULL)
7429       return -1;
7430     if (!r[0]) {
7431       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7432       print_strings (r);
7433       return -1;
7434     }
7435     {
7436       char expected[] = "";
7437       if (strcmp (r[0], expected) != 0) {
7438         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7439         return -1;
7440       }
7441     }
7442     if (!r[1]) {
7443       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7444       print_strings (r);
7445       return -1;
7446     }
7447     {
7448       char expected[] = "Result4";
7449       if (strcmp (r[1], expected) != 0) {
7450         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7451         return -1;
7452       }
7453     }
7454     if (r[2] != NULL) {
7455       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7456       print_strings (r);
7457       return -1;
7458     }
7459     for (i = 0; r[i] != NULL; ++i)
7460       free (r[i]);
7461     free (r);
7462   }
7463   return 0;
7464 }
7465
7466 static int test_command_lines_4_skip (void)
7467 {
7468   const char *str;
7469
7470   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7471   if (str && strcmp (str, "1") == 0) return 1;
7472   str = getenv ("SKIP_TEST_COMMAND_LINES");
7473   if (str && strcmp (str, "1") == 0) return 1;
7474   return 0;
7475 }
7476
7477 static int test_command_lines_4 (void)
7478 {
7479   if (test_command_lines_4_skip ()) {
7480     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7481     return 0;
7482   }
7483
7484   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7485   {
7486     char device[] = "/dev/sda";
7487     device[5] = devchar;
7488     int r;
7489     suppress_error = 0;
7490     r = guestfs_blockdev_setrw (g, device);
7491     if (r == -1)
7492       return -1;
7493   }
7494   {
7495     int r;
7496     suppress_error = 0;
7497     r = guestfs_umount_all (g);
7498     if (r == -1)
7499       return -1;
7500   }
7501   {
7502     int r;
7503     suppress_error = 0;
7504     r = guestfs_lvm_remove_all (g);
7505     if (r == -1)
7506       return -1;
7507   }
7508   {
7509     char device[] = "/dev/sda";
7510     device[5] = devchar;
7511     char lines_0[] = ",";
7512     char *lines[] = {
7513       lines_0,
7514       NULL
7515     };
7516     int r;
7517     suppress_error = 0;
7518     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7519     if (r == -1)
7520       return -1;
7521   }
7522   {
7523     char fstype[] = "ext2";
7524     char device[] = "/dev/sda1";
7525     device[5] = devchar;
7526     int r;
7527     suppress_error = 0;
7528     r = guestfs_mkfs (g, fstype, device);
7529     if (r == -1)
7530       return -1;
7531   }
7532   {
7533     char device[] = "/dev/sda1";
7534     device[5] = devchar;
7535     char mountpoint[] = "/";
7536     int r;
7537     suppress_error = 0;
7538     r = guestfs_mount (g, device, mountpoint);
7539     if (r == -1)
7540       return -1;
7541   }
7542   /* TestOutputList for command_lines (4) */
7543   {
7544     char remotefilename[] = "/test-command";
7545     int r;
7546     suppress_error = 0;
7547     r = guestfs_upload (g, "test-command", remotefilename);
7548     if (r == -1)
7549       return -1;
7550   }
7551   {
7552     char path[] = "/test-command";
7553     int r;
7554     suppress_error = 0;
7555     r = guestfs_chmod (g, 493, path);
7556     if (r == -1)
7557       return -1;
7558   }
7559   {
7560     char arguments_0[] = "/test-command";
7561     char arguments_1[] = "5";
7562     char *arguments[] = {
7563       arguments_0,
7564       arguments_1,
7565       NULL
7566     };
7567     char **r;
7568     int i;
7569     suppress_error = 0;
7570     r = guestfs_command_lines (g, arguments);
7571     if (r == NULL)
7572       return -1;
7573     if (!r[0]) {
7574       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7575       print_strings (r);
7576       return -1;
7577     }
7578     {
7579       char expected[] = "";
7580       if (strcmp (r[0], expected) != 0) {
7581         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7582         return -1;
7583       }
7584     }
7585     if (!r[1]) {
7586       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7587       print_strings (r);
7588       return -1;
7589     }
7590     {
7591       char expected[] = "Result5";
7592       if (strcmp (r[1], expected) != 0) {
7593         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7594         return -1;
7595       }
7596     }
7597     if (!r[2]) {
7598       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7599       print_strings (r);
7600       return -1;
7601     }
7602     {
7603       char expected[] = "";
7604       if (strcmp (r[2], expected) != 0) {
7605         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7606         return -1;
7607       }
7608     }
7609     if (r[3] != NULL) {
7610       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7611       print_strings (r);
7612       return -1;
7613     }
7614     for (i = 0; r[i] != NULL; ++i)
7615       free (r[i]);
7616     free (r);
7617   }
7618   return 0;
7619 }
7620
7621 static int test_command_lines_5_skip (void)
7622 {
7623   const char *str;
7624
7625   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7626   if (str && strcmp (str, "1") == 0) return 1;
7627   str = getenv ("SKIP_TEST_COMMAND_LINES");
7628   if (str && strcmp (str, "1") == 0) return 1;
7629   return 0;
7630 }
7631
7632 static int test_command_lines_5 (void)
7633 {
7634   if (test_command_lines_5_skip ()) {
7635     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7636     return 0;
7637   }
7638
7639   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7640   {
7641     char device[] = "/dev/sda";
7642     device[5] = devchar;
7643     int r;
7644     suppress_error = 0;
7645     r = guestfs_blockdev_setrw (g, device);
7646     if (r == -1)
7647       return -1;
7648   }
7649   {
7650     int r;
7651     suppress_error = 0;
7652     r = guestfs_umount_all (g);
7653     if (r == -1)
7654       return -1;
7655   }
7656   {
7657     int r;
7658     suppress_error = 0;
7659     r = guestfs_lvm_remove_all (g);
7660     if (r == -1)
7661       return -1;
7662   }
7663   {
7664     char device[] = "/dev/sda";
7665     device[5] = devchar;
7666     char lines_0[] = ",";
7667     char *lines[] = {
7668       lines_0,
7669       NULL
7670     };
7671     int r;
7672     suppress_error = 0;
7673     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7674     if (r == -1)
7675       return -1;
7676   }
7677   {
7678     char fstype[] = "ext2";
7679     char device[] = "/dev/sda1";
7680     device[5] = devchar;
7681     int r;
7682     suppress_error = 0;
7683     r = guestfs_mkfs (g, fstype, device);
7684     if (r == -1)
7685       return -1;
7686   }
7687   {
7688     char device[] = "/dev/sda1";
7689     device[5] = devchar;
7690     char mountpoint[] = "/";
7691     int r;
7692     suppress_error = 0;
7693     r = guestfs_mount (g, device, mountpoint);
7694     if (r == -1)
7695       return -1;
7696   }
7697   /* TestOutputList for command_lines (5) */
7698   {
7699     char remotefilename[] = "/test-command";
7700     int r;
7701     suppress_error = 0;
7702     r = guestfs_upload (g, "test-command", remotefilename);
7703     if (r == -1)
7704       return -1;
7705   }
7706   {
7707     char path[] = "/test-command";
7708     int r;
7709     suppress_error = 0;
7710     r = guestfs_chmod (g, 493, path);
7711     if (r == -1)
7712       return -1;
7713   }
7714   {
7715     char arguments_0[] = "/test-command";
7716     char arguments_1[] = "6";
7717     char *arguments[] = {
7718       arguments_0,
7719       arguments_1,
7720       NULL
7721     };
7722     char **r;
7723     int i;
7724     suppress_error = 0;
7725     r = guestfs_command_lines (g, arguments);
7726     if (r == NULL)
7727       return -1;
7728     if (!r[0]) {
7729       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7730       print_strings (r);
7731       return -1;
7732     }
7733     {
7734       char expected[] = "";
7735       if (strcmp (r[0], expected) != 0) {
7736         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7737         return -1;
7738       }
7739     }
7740     if (!r[1]) {
7741       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7742       print_strings (r);
7743       return -1;
7744     }
7745     {
7746       char expected[] = "";
7747       if (strcmp (r[1], expected) != 0) {
7748         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7749         return -1;
7750       }
7751     }
7752     if (!r[2]) {
7753       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7754       print_strings (r);
7755       return -1;
7756     }
7757     {
7758       char expected[] = "Result6";
7759       if (strcmp (r[2], expected) != 0) {
7760         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7761         return -1;
7762       }
7763     }
7764     if (!r[3]) {
7765       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7766       print_strings (r);
7767       return -1;
7768     }
7769     {
7770       char expected[] = "";
7771       if (strcmp (r[3], expected) != 0) {
7772         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7773         return -1;
7774       }
7775     }
7776     if (r[4] != NULL) {
7777       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7778       print_strings (r);
7779       return -1;
7780     }
7781     for (i = 0; r[i] != NULL; ++i)
7782       free (r[i]);
7783     free (r);
7784   }
7785   return 0;
7786 }
7787
7788 static int test_command_lines_6_skip (void)
7789 {
7790   const char *str;
7791
7792   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7793   if (str && strcmp (str, "1") == 0) return 1;
7794   str = getenv ("SKIP_TEST_COMMAND_LINES");
7795   if (str && strcmp (str, "1") == 0) return 1;
7796   return 0;
7797 }
7798
7799 static int test_command_lines_6 (void)
7800 {
7801   if (test_command_lines_6_skip ()) {
7802     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7803     return 0;
7804   }
7805
7806   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7807   {
7808     char device[] = "/dev/sda";
7809     device[5] = devchar;
7810     int r;
7811     suppress_error = 0;
7812     r = guestfs_blockdev_setrw (g, device);
7813     if (r == -1)
7814       return -1;
7815   }
7816   {
7817     int r;
7818     suppress_error = 0;
7819     r = guestfs_umount_all (g);
7820     if (r == -1)
7821       return -1;
7822   }
7823   {
7824     int r;
7825     suppress_error = 0;
7826     r = guestfs_lvm_remove_all (g);
7827     if (r == -1)
7828       return -1;
7829   }
7830   {
7831     char device[] = "/dev/sda";
7832     device[5] = devchar;
7833     char lines_0[] = ",";
7834     char *lines[] = {
7835       lines_0,
7836       NULL
7837     };
7838     int r;
7839     suppress_error = 0;
7840     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7841     if (r == -1)
7842       return -1;
7843   }
7844   {
7845     char fstype[] = "ext2";
7846     char device[] = "/dev/sda1";
7847     device[5] = devchar;
7848     int r;
7849     suppress_error = 0;
7850     r = guestfs_mkfs (g, fstype, device);
7851     if (r == -1)
7852       return -1;
7853   }
7854   {
7855     char device[] = "/dev/sda1";
7856     device[5] = devchar;
7857     char mountpoint[] = "/";
7858     int r;
7859     suppress_error = 0;
7860     r = guestfs_mount (g, device, mountpoint);
7861     if (r == -1)
7862       return -1;
7863   }
7864   /* TestOutputList for command_lines (6) */
7865   {
7866     char remotefilename[] = "/test-command";
7867     int r;
7868     suppress_error = 0;
7869     r = guestfs_upload (g, "test-command", remotefilename);
7870     if (r == -1)
7871       return -1;
7872   }
7873   {
7874     char path[] = "/test-command";
7875     int r;
7876     suppress_error = 0;
7877     r = guestfs_chmod (g, 493, path);
7878     if (r == -1)
7879       return -1;
7880   }
7881   {
7882     char arguments_0[] = "/test-command";
7883     char arguments_1[] = "7";
7884     char *arguments[] = {
7885       arguments_0,
7886       arguments_1,
7887       NULL
7888     };
7889     char **r;
7890     int i;
7891     suppress_error = 0;
7892     r = guestfs_command_lines (g, arguments);
7893     if (r == NULL)
7894       return -1;
7895     if (r[0] != NULL) {
7896       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7897       print_strings (r);
7898       return -1;
7899     }
7900     for (i = 0; r[i] != NULL; ++i)
7901       free (r[i]);
7902     free (r);
7903   }
7904   return 0;
7905 }
7906
7907 static int test_command_lines_7_skip (void)
7908 {
7909   const char *str;
7910
7911   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7912   if (str && strcmp (str, "1") == 0) return 1;
7913   str = getenv ("SKIP_TEST_COMMAND_LINES");
7914   if (str && strcmp (str, "1") == 0) return 1;
7915   return 0;
7916 }
7917
7918 static int test_command_lines_7 (void)
7919 {
7920   if (test_command_lines_7_skip ()) {
7921     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7922     return 0;
7923   }
7924
7925   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7926   {
7927     char device[] = "/dev/sda";
7928     device[5] = devchar;
7929     int r;
7930     suppress_error = 0;
7931     r = guestfs_blockdev_setrw (g, device);
7932     if (r == -1)
7933       return -1;
7934   }
7935   {
7936     int r;
7937     suppress_error = 0;
7938     r = guestfs_umount_all (g);
7939     if (r == -1)
7940       return -1;
7941   }
7942   {
7943     int r;
7944     suppress_error = 0;
7945     r = guestfs_lvm_remove_all (g);
7946     if (r == -1)
7947       return -1;
7948   }
7949   {
7950     char device[] = "/dev/sda";
7951     device[5] = devchar;
7952     char lines_0[] = ",";
7953     char *lines[] = {
7954       lines_0,
7955       NULL
7956     };
7957     int r;
7958     suppress_error = 0;
7959     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7960     if (r == -1)
7961       return -1;
7962   }
7963   {
7964     char fstype[] = "ext2";
7965     char device[] = "/dev/sda1";
7966     device[5] = devchar;
7967     int r;
7968     suppress_error = 0;
7969     r = guestfs_mkfs (g, fstype, device);
7970     if (r == -1)
7971       return -1;
7972   }
7973   {
7974     char device[] = "/dev/sda1";
7975     device[5] = devchar;
7976     char mountpoint[] = "/";
7977     int r;
7978     suppress_error = 0;
7979     r = guestfs_mount (g, device, mountpoint);
7980     if (r == -1)
7981       return -1;
7982   }
7983   /* TestOutputList for command_lines (7) */
7984   {
7985     char remotefilename[] = "/test-command";
7986     int r;
7987     suppress_error = 0;
7988     r = guestfs_upload (g, "test-command", remotefilename);
7989     if (r == -1)
7990       return -1;
7991   }
7992   {
7993     char path[] = "/test-command";
7994     int r;
7995     suppress_error = 0;
7996     r = guestfs_chmod (g, 493, path);
7997     if (r == -1)
7998       return -1;
7999   }
8000   {
8001     char arguments_0[] = "/test-command";
8002     char arguments_1[] = "8";
8003     char *arguments[] = {
8004       arguments_0,
8005       arguments_1,
8006       NULL
8007     };
8008     char **r;
8009     int i;
8010     suppress_error = 0;
8011     r = guestfs_command_lines (g, arguments);
8012     if (r == NULL)
8013       return -1;
8014     if (!r[0]) {
8015       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8016       print_strings (r);
8017       return -1;
8018     }
8019     {
8020       char expected[] = "";
8021       if (strcmp (r[0], expected) != 0) {
8022         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8023         return -1;
8024       }
8025     }
8026     if (r[1] != NULL) {
8027       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8028       print_strings (r);
8029       return -1;
8030     }
8031     for (i = 0; r[i] != NULL; ++i)
8032       free (r[i]);
8033     free (r);
8034   }
8035   return 0;
8036 }
8037
8038 static int test_command_lines_8_skip (void)
8039 {
8040   const char *str;
8041
8042   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8043   if (str && strcmp (str, "1") == 0) return 1;
8044   str = getenv ("SKIP_TEST_COMMAND_LINES");
8045   if (str && strcmp (str, "1") == 0) return 1;
8046   return 0;
8047 }
8048
8049 static int test_command_lines_8 (void)
8050 {
8051   if (test_command_lines_8_skip ()) {
8052     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8053     return 0;
8054   }
8055
8056   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8057   {
8058     char device[] = "/dev/sda";
8059     device[5] = devchar;
8060     int r;
8061     suppress_error = 0;
8062     r = guestfs_blockdev_setrw (g, device);
8063     if (r == -1)
8064       return -1;
8065   }
8066   {
8067     int r;
8068     suppress_error = 0;
8069     r = guestfs_umount_all (g);
8070     if (r == -1)
8071       return -1;
8072   }
8073   {
8074     int r;
8075     suppress_error = 0;
8076     r = guestfs_lvm_remove_all (g);
8077     if (r == -1)
8078       return -1;
8079   }
8080   {
8081     char device[] = "/dev/sda";
8082     device[5] = devchar;
8083     char lines_0[] = ",";
8084     char *lines[] = {
8085       lines_0,
8086       NULL
8087     };
8088     int r;
8089     suppress_error = 0;
8090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8091     if (r == -1)
8092       return -1;
8093   }
8094   {
8095     char fstype[] = "ext2";
8096     char device[] = "/dev/sda1";
8097     device[5] = devchar;
8098     int r;
8099     suppress_error = 0;
8100     r = guestfs_mkfs (g, fstype, device);
8101     if (r == -1)
8102       return -1;
8103   }
8104   {
8105     char device[] = "/dev/sda1";
8106     device[5] = devchar;
8107     char mountpoint[] = "/";
8108     int r;
8109     suppress_error = 0;
8110     r = guestfs_mount (g, device, mountpoint);
8111     if (r == -1)
8112       return -1;
8113   }
8114   /* TestOutputList for command_lines (8) */
8115   {
8116     char remotefilename[] = "/test-command";
8117     int r;
8118     suppress_error = 0;
8119     r = guestfs_upload (g, "test-command", remotefilename);
8120     if (r == -1)
8121       return -1;
8122   }
8123   {
8124     char path[] = "/test-command";
8125     int r;
8126     suppress_error = 0;
8127     r = guestfs_chmod (g, 493, path);
8128     if (r == -1)
8129       return -1;
8130   }
8131   {
8132     char arguments_0[] = "/test-command";
8133     char arguments_1[] = "9";
8134     char *arguments[] = {
8135       arguments_0,
8136       arguments_1,
8137       NULL
8138     };
8139     char **r;
8140     int i;
8141     suppress_error = 0;
8142     r = guestfs_command_lines (g, arguments);
8143     if (r == NULL)
8144       return -1;
8145     if (!r[0]) {
8146       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8147       print_strings (r);
8148       return -1;
8149     }
8150     {
8151       char expected[] = "";
8152       if (strcmp (r[0], expected) != 0) {
8153         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8154         return -1;
8155       }
8156     }
8157     if (!r[1]) {
8158       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8159       print_strings (r);
8160       return -1;
8161     }
8162     {
8163       char expected[] = "";
8164       if (strcmp (r[1], expected) != 0) {
8165         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8166         return -1;
8167       }
8168     }
8169     if (r[2] != NULL) {
8170       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8171       print_strings (r);
8172       return -1;
8173     }
8174     for (i = 0; r[i] != NULL; ++i)
8175       free (r[i]);
8176     free (r);
8177   }
8178   return 0;
8179 }
8180
8181 static int test_command_lines_9_skip (void)
8182 {
8183   const char *str;
8184
8185   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8186   if (str && strcmp (str, "1") == 0) return 1;
8187   str = getenv ("SKIP_TEST_COMMAND_LINES");
8188   if (str && strcmp (str, "1") == 0) return 1;
8189   return 0;
8190 }
8191
8192 static int test_command_lines_9 (void)
8193 {
8194   if (test_command_lines_9_skip ()) {
8195     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8196     return 0;
8197   }
8198
8199   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8200   {
8201     char device[] = "/dev/sda";
8202     device[5] = devchar;
8203     int r;
8204     suppress_error = 0;
8205     r = guestfs_blockdev_setrw (g, device);
8206     if (r == -1)
8207       return -1;
8208   }
8209   {
8210     int r;
8211     suppress_error = 0;
8212     r = guestfs_umount_all (g);
8213     if (r == -1)
8214       return -1;
8215   }
8216   {
8217     int r;
8218     suppress_error = 0;
8219     r = guestfs_lvm_remove_all (g);
8220     if (r == -1)
8221       return -1;
8222   }
8223   {
8224     char device[] = "/dev/sda";
8225     device[5] = devchar;
8226     char lines_0[] = ",";
8227     char *lines[] = {
8228       lines_0,
8229       NULL
8230     };
8231     int r;
8232     suppress_error = 0;
8233     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8234     if (r == -1)
8235       return -1;
8236   }
8237   {
8238     char fstype[] = "ext2";
8239     char device[] = "/dev/sda1";
8240     device[5] = devchar;
8241     int r;
8242     suppress_error = 0;
8243     r = guestfs_mkfs (g, fstype, device);
8244     if (r == -1)
8245       return -1;
8246   }
8247   {
8248     char device[] = "/dev/sda1";
8249     device[5] = devchar;
8250     char mountpoint[] = "/";
8251     int r;
8252     suppress_error = 0;
8253     r = guestfs_mount (g, device, mountpoint);
8254     if (r == -1)
8255       return -1;
8256   }
8257   /* TestOutputList for command_lines (9) */
8258   {
8259     char remotefilename[] = "/test-command";
8260     int r;
8261     suppress_error = 0;
8262     r = guestfs_upload (g, "test-command", remotefilename);
8263     if (r == -1)
8264       return -1;
8265   }
8266   {
8267     char path[] = "/test-command";
8268     int r;
8269     suppress_error = 0;
8270     r = guestfs_chmod (g, 493, path);
8271     if (r == -1)
8272       return -1;
8273   }
8274   {
8275     char arguments_0[] = "/test-command";
8276     char arguments_1[] = "10";
8277     char *arguments[] = {
8278       arguments_0,
8279       arguments_1,
8280       NULL
8281     };
8282     char **r;
8283     int i;
8284     suppress_error = 0;
8285     r = guestfs_command_lines (g, arguments);
8286     if (r == NULL)
8287       return -1;
8288     if (!r[0]) {
8289       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8290       print_strings (r);
8291       return -1;
8292     }
8293     {
8294       char expected[] = "Result10-1";
8295       if (strcmp (r[0], expected) != 0) {
8296         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8297         return -1;
8298       }
8299     }
8300     if (!r[1]) {
8301       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8302       print_strings (r);
8303       return -1;
8304     }
8305     {
8306       char expected[] = "Result10-2";
8307       if (strcmp (r[1], expected) != 0) {
8308         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8309         return -1;
8310       }
8311     }
8312     if (r[2] != NULL) {
8313       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8314       print_strings (r);
8315       return -1;
8316     }
8317     for (i = 0; r[i] != NULL; ++i)
8318       free (r[i]);
8319     free (r);
8320   }
8321   return 0;
8322 }
8323
8324 static int test_command_lines_10_skip (void)
8325 {
8326   const char *str;
8327
8328   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8329   if (str && strcmp (str, "1") == 0) return 1;
8330   str = getenv ("SKIP_TEST_COMMAND_LINES");
8331   if (str && strcmp (str, "1") == 0) return 1;
8332   return 0;
8333 }
8334
8335 static int test_command_lines_10 (void)
8336 {
8337   if (test_command_lines_10_skip ()) {
8338     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8339     return 0;
8340   }
8341
8342   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8343   {
8344     char device[] = "/dev/sda";
8345     device[5] = devchar;
8346     int r;
8347     suppress_error = 0;
8348     r = guestfs_blockdev_setrw (g, device);
8349     if (r == -1)
8350       return -1;
8351   }
8352   {
8353     int r;
8354     suppress_error = 0;
8355     r = guestfs_umount_all (g);
8356     if (r == -1)
8357       return -1;
8358   }
8359   {
8360     int r;
8361     suppress_error = 0;
8362     r = guestfs_lvm_remove_all (g);
8363     if (r == -1)
8364       return -1;
8365   }
8366   {
8367     char device[] = "/dev/sda";
8368     device[5] = devchar;
8369     char lines_0[] = ",";
8370     char *lines[] = {
8371       lines_0,
8372       NULL
8373     };
8374     int r;
8375     suppress_error = 0;
8376     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8377     if (r == -1)
8378       return -1;
8379   }
8380   {
8381     char fstype[] = "ext2";
8382     char device[] = "/dev/sda1";
8383     device[5] = devchar;
8384     int r;
8385     suppress_error = 0;
8386     r = guestfs_mkfs (g, fstype, device);
8387     if (r == -1)
8388       return -1;
8389   }
8390   {
8391     char device[] = "/dev/sda1";
8392     device[5] = devchar;
8393     char mountpoint[] = "/";
8394     int r;
8395     suppress_error = 0;
8396     r = guestfs_mount (g, device, mountpoint);
8397     if (r == -1)
8398       return -1;
8399   }
8400   /* TestOutputList for command_lines (10) */
8401   {
8402     char remotefilename[] = "/test-command";
8403     int r;
8404     suppress_error = 0;
8405     r = guestfs_upload (g, "test-command", remotefilename);
8406     if (r == -1)
8407       return -1;
8408   }
8409   {
8410     char path[] = "/test-command";
8411     int r;
8412     suppress_error = 0;
8413     r = guestfs_chmod (g, 493, path);
8414     if (r == -1)
8415       return -1;
8416   }
8417   {
8418     char arguments_0[] = "/test-command";
8419     char arguments_1[] = "11";
8420     char *arguments[] = {
8421       arguments_0,
8422       arguments_1,
8423       NULL
8424     };
8425     char **r;
8426     int i;
8427     suppress_error = 0;
8428     r = guestfs_command_lines (g, arguments);
8429     if (r == NULL)
8430       return -1;
8431     if (!r[0]) {
8432       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8433       print_strings (r);
8434       return -1;
8435     }
8436     {
8437       char expected[] = "Result11-1";
8438       if (strcmp (r[0], expected) != 0) {
8439         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8440         return -1;
8441       }
8442     }
8443     if (!r[1]) {
8444       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8445       print_strings (r);
8446       return -1;
8447     }
8448     {
8449       char expected[] = "Result11-2";
8450       if (strcmp (r[1], expected) != 0) {
8451         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8452         return -1;
8453       }
8454     }
8455     if (r[2] != NULL) {
8456       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8457       print_strings (r);
8458       return -1;
8459     }
8460     for (i = 0; r[i] != NULL; ++i)
8461       free (r[i]);
8462     free (r);
8463   }
8464   return 0;
8465 }
8466
8467 static int test_command_0_skip (void)
8468 {
8469   const char *str;
8470
8471   str = getenv ("SKIP_TEST_COMMAND_0");
8472   if (str && strcmp (str, "1") == 0) return 1;
8473   str = getenv ("SKIP_TEST_COMMAND");
8474   if (str && strcmp (str, "1") == 0) return 1;
8475   return 0;
8476 }
8477
8478 static int test_command_0 (void)
8479 {
8480   if (test_command_0_skip ()) {
8481     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8482     return 0;
8483   }
8484
8485   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8486   {
8487     char device[] = "/dev/sda";
8488     device[5] = devchar;
8489     int r;
8490     suppress_error = 0;
8491     r = guestfs_blockdev_setrw (g, device);
8492     if (r == -1)
8493       return -1;
8494   }
8495   {
8496     int r;
8497     suppress_error = 0;
8498     r = guestfs_umount_all (g);
8499     if (r == -1)
8500       return -1;
8501   }
8502   {
8503     int r;
8504     suppress_error = 0;
8505     r = guestfs_lvm_remove_all (g);
8506     if (r == -1)
8507       return -1;
8508   }
8509   {
8510     char device[] = "/dev/sda";
8511     device[5] = devchar;
8512     char lines_0[] = ",";
8513     char *lines[] = {
8514       lines_0,
8515       NULL
8516     };
8517     int r;
8518     suppress_error = 0;
8519     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8520     if (r == -1)
8521       return -1;
8522   }
8523   {
8524     char fstype[] = "ext2";
8525     char device[] = "/dev/sda1";
8526     device[5] = devchar;
8527     int r;
8528     suppress_error = 0;
8529     r = guestfs_mkfs (g, fstype, device);
8530     if (r == -1)
8531       return -1;
8532   }
8533   {
8534     char device[] = "/dev/sda1";
8535     device[5] = devchar;
8536     char mountpoint[] = "/";
8537     int r;
8538     suppress_error = 0;
8539     r = guestfs_mount (g, device, mountpoint);
8540     if (r == -1)
8541       return -1;
8542   }
8543   /* TestOutput for command (0) */
8544   char expected[] = "Result1";
8545   {
8546     char remotefilename[] = "/test-command";
8547     int r;
8548     suppress_error = 0;
8549     r = guestfs_upload (g, "test-command", remotefilename);
8550     if (r == -1)
8551       return -1;
8552   }
8553   {
8554     char path[] = "/test-command";
8555     int r;
8556     suppress_error = 0;
8557     r = guestfs_chmod (g, 493, path);
8558     if (r == -1)
8559       return -1;
8560   }
8561   {
8562     char arguments_0[] = "/test-command";
8563     char arguments_1[] = "1";
8564     char *arguments[] = {
8565       arguments_0,
8566       arguments_1,
8567       NULL
8568     };
8569     char *r;
8570     suppress_error = 0;
8571     r = guestfs_command (g, arguments);
8572     if (r == NULL)
8573       return -1;
8574     if (strcmp (r, expected) != 0) {
8575       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8576       return -1;
8577     }
8578     free (r);
8579   }
8580   return 0;
8581 }
8582
8583 static int test_command_1_skip (void)
8584 {
8585   const char *str;
8586
8587   str = getenv ("SKIP_TEST_COMMAND_1");
8588   if (str && strcmp (str, "1") == 0) return 1;
8589   str = getenv ("SKIP_TEST_COMMAND");
8590   if (str && strcmp (str, "1") == 0) return 1;
8591   return 0;
8592 }
8593
8594 static int test_command_1 (void)
8595 {
8596   if (test_command_1_skip ()) {
8597     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8598     return 0;
8599   }
8600
8601   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8602   {
8603     char device[] = "/dev/sda";
8604     device[5] = devchar;
8605     int r;
8606     suppress_error = 0;
8607     r = guestfs_blockdev_setrw (g, device);
8608     if (r == -1)
8609       return -1;
8610   }
8611   {
8612     int r;
8613     suppress_error = 0;
8614     r = guestfs_umount_all (g);
8615     if (r == -1)
8616       return -1;
8617   }
8618   {
8619     int r;
8620     suppress_error = 0;
8621     r = guestfs_lvm_remove_all (g);
8622     if (r == -1)
8623       return -1;
8624   }
8625   {
8626     char device[] = "/dev/sda";
8627     device[5] = devchar;
8628     char lines_0[] = ",";
8629     char *lines[] = {
8630       lines_0,
8631       NULL
8632     };
8633     int r;
8634     suppress_error = 0;
8635     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8636     if (r == -1)
8637       return -1;
8638   }
8639   {
8640     char fstype[] = "ext2";
8641     char device[] = "/dev/sda1";
8642     device[5] = devchar;
8643     int r;
8644     suppress_error = 0;
8645     r = guestfs_mkfs (g, fstype, device);
8646     if (r == -1)
8647       return -1;
8648   }
8649   {
8650     char device[] = "/dev/sda1";
8651     device[5] = devchar;
8652     char mountpoint[] = "/";
8653     int r;
8654     suppress_error = 0;
8655     r = guestfs_mount (g, device, mountpoint);
8656     if (r == -1)
8657       return -1;
8658   }
8659   /* TestOutput for command (1) */
8660   char expected[] = "Result2\n";
8661   {
8662     char remotefilename[] = "/test-command";
8663     int r;
8664     suppress_error = 0;
8665     r = guestfs_upload (g, "test-command", remotefilename);
8666     if (r == -1)
8667       return -1;
8668   }
8669   {
8670     char path[] = "/test-command";
8671     int r;
8672     suppress_error = 0;
8673     r = guestfs_chmod (g, 493, path);
8674     if (r == -1)
8675       return -1;
8676   }
8677   {
8678     char arguments_0[] = "/test-command";
8679     char arguments_1[] = "2";
8680     char *arguments[] = {
8681       arguments_0,
8682       arguments_1,
8683       NULL
8684     };
8685     char *r;
8686     suppress_error = 0;
8687     r = guestfs_command (g, arguments);
8688     if (r == NULL)
8689       return -1;
8690     if (strcmp (r, expected) != 0) {
8691       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8692       return -1;
8693     }
8694     free (r);
8695   }
8696   return 0;
8697 }
8698
8699 static int test_command_2_skip (void)
8700 {
8701   const char *str;
8702
8703   str = getenv ("SKIP_TEST_COMMAND_2");
8704   if (str && strcmp (str, "1") == 0) return 1;
8705   str = getenv ("SKIP_TEST_COMMAND");
8706   if (str && strcmp (str, "1") == 0) return 1;
8707   return 0;
8708 }
8709
8710 static int test_command_2 (void)
8711 {
8712   if (test_command_2_skip ()) {
8713     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8714     return 0;
8715   }
8716
8717   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8718   {
8719     char device[] = "/dev/sda";
8720     device[5] = devchar;
8721     int r;
8722     suppress_error = 0;
8723     r = guestfs_blockdev_setrw (g, device);
8724     if (r == -1)
8725       return -1;
8726   }
8727   {
8728     int r;
8729     suppress_error = 0;
8730     r = guestfs_umount_all (g);
8731     if (r == -1)
8732       return -1;
8733   }
8734   {
8735     int r;
8736     suppress_error = 0;
8737     r = guestfs_lvm_remove_all (g);
8738     if (r == -1)
8739       return -1;
8740   }
8741   {
8742     char device[] = "/dev/sda";
8743     device[5] = devchar;
8744     char lines_0[] = ",";
8745     char *lines[] = {
8746       lines_0,
8747       NULL
8748     };
8749     int r;
8750     suppress_error = 0;
8751     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8752     if (r == -1)
8753       return -1;
8754   }
8755   {
8756     char fstype[] = "ext2";
8757     char device[] = "/dev/sda1";
8758     device[5] = devchar;
8759     int r;
8760     suppress_error = 0;
8761     r = guestfs_mkfs (g, fstype, device);
8762     if (r == -1)
8763       return -1;
8764   }
8765   {
8766     char device[] = "/dev/sda1";
8767     device[5] = devchar;
8768     char mountpoint[] = "/";
8769     int r;
8770     suppress_error = 0;
8771     r = guestfs_mount (g, device, mountpoint);
8772     if (r == -1)
8773       return -1;
8774   }
8775   /* TestOutput for command (2) */
8776   char expected[] = "\nResult3";
8777   {
8778     char remotefilename[] = "/test-command";
8779     int r;
8780     suppress_error = 0;
8781     r = guestfs_upload (g, "test-command", remotefilename);
8782     if (r == -1)
8783       return -1;
8784   }
8785   {
8786     char path[] = "/test-command";
8787     int r;
8788     suppress_error = 0;
8789     r = guestfs_chmod (g, 493, path);
8790     if (r == -1)
8791       return -1;
8792   }
8793   {
8794     char arguments_0[] = "/test-command";
8795     char arguments_1[] = "3";
8796     char *arguments[] = {
8797       arguments_0,
8798       arguments_1,
8799       NULL
8800     };
8801     char *r;
8802     suppress_error = 0;
8803     r = guestfs_command (g, arguments);
8804     if (r == NULL)
8805       return -1;
8806     if (strcmp (r, expected) != 0) {
8807       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8808       return -1;
8809     }
8810     free (r);
8811   }
8812   return 0;
8813 }
8814
8815 static int test_command_3_skip (void)
8816 {
8817   const char *str;
8818
8819   str = getenv ("SKIP_TEST_COMMAND_3");
8820   if (str && strcmp (str, "1") == 0) return 1;
8821   str = getenv ("SKIP_TEST_COMMAND");
8822   if (str && strcmp (str, "1") == 0) return 1;
8823   return 0;
8824 }
8825
8826 static int test_command_3 (void)
8827 {
8828   if (test_command_3_skip ()) {
8829     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8830     return 0;
8831   }
8832
8833   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8834   {
8835     char device[] = "/dev/sda";
8836     device[5] = devchar;
8837     int r;
8838     suppress_error = 0;
8839     r = guestfs_blockdev_setrw (g, device);
8840     if (r == -1)
8841       return -1;
8842   }
8843   {
8844     int r;
8845     suppress_error = 0;
8846     r = guestfs_umount_all (g);
8847     if (r == -1)
8848       return -1;
8849   }
8850   {
8851     int r;
8852     suppress_error = 0;
8853     r = guestfs_lvm_remove_all (g);
8854     if (r == -1)
8855       return -1;
8856   }
8857   {
8858     char device[] = "/dev/sda";
8859     device[5] = devchar;
8860     char lines_0[] = ",";
8861     char *lines[] = {
8862       lines_0,
8863       NULL
8864     };
8865     int r;
8866     suppress_error = 0;
8867     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8868     if (r == -1)
8869       return -1;
8870   }
8871   {
8872     char fstype[] = "ext2";
8873     char device[] = "/dev/sda1";
8874     device[5] = devchar;
8875     int r;
8876     suppress_error = 0;
8877     r = guestfs_mkfs (g, fstype, device);
8878     if (r == -1)
8879       return -1;
8880   }
8881   {
8882     char device[] = "/dev/sda1";
8883     device[5] = devchar;
8884     char mountpoint[] = "/";
8885     int r;
8886     suppress_error = 0;
8887     r = guestfs_mount (g, device, mountpoint);
8888     if (r == -1)
8889       return -1;
8890   }
8891   /* TestOutput for command (3) */
8892   char expected[] = "\nResult4\n";
8893   {
8894     char remotefilename[] = "/test-command";
8895     int r;
8896     suppress_error = 0;
8897     r = guestfs_upload (g, "test-command", remotefilename);
8898     if (r == -1)
8899       return -1;
8900   }
8901   {
8902     char path[] = "/test-command";
8903     int r;
8904     suppress_error = 0;
8905     r = guestfs_chmod (g, 493, path);
8906     if (r == -1)
8907       return -1;
8908   }
8909   {
8910     char arguments_0[] = "/test-command";
8911     char arguments_1[] = "4";
8912     char *arguments[] = {
8913       arguments_0,
8914       arguments_1,
8915       NULL
8916     };
8917     char *r;
8918     suppress_error = 0;
8919     r = guestfs_command (g, arguments);
8920     if (r == NULL)
8921       return -1;
8922     if (strcmp (r, expected) != 0) {
8923       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8924       return -1;
8925     }
8926     free (r);
8927   }
8928   return 0;
8929 }
8930
8931 static int test_command_4_skip (void)
8932 {
8933   const char *str;
8934
8935   str = getenv ("SKIP_TEST_COMMAND_4");
8936   if (str && strcmp (str, "1") == 0) return 1;
8937   str = getenv ("SKIP_TEST_COMMAND");
8938   if (str && strcmp (str, "1") == 0) return 1;
8939   return 0;
8940 }
8941
8942 static int test_command_4 (void)
8943 {
8944   if (test_command_4_skip ()) {
8945     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8946     return 0;
8947   }
8948
8949   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8950   {
8951     char device[] = "/dev/sda";
8952     device[5] = devchar;
8953     int r;
8954     suppress_error = 0;
8955     r = guestfs_blockdev_setrw (g, device);
8956     if (r == -1)
8957       return -1;
8958   }
8959   {
8960     int r;
8961     suppress_error = 0;
8962     r = guestfs_umount_all (g);
8963     if (r == -1)
8964       return -1;
8965   }
8966   {
8967     int r;
8968     suppress_error = 0;
8969     r = guestfs_lvm_remove_all (g);
8970     if (r == -1)
8971       return -1;
8972   }
8973   {
8974     char device[] = "/dev/sda";
8975     device[5] = devchar;
8976     char lines_0[] = ",";
8977     char *lines[] = {
8978       lines_0,
8979       NULL
8980     };
8981     int r;
8982     suppress_error = 0;
8983     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8984     if (r == -1)
8985       return -1;
8986   }
8987   {
8988     char fstype[] = "ext2";
8989     char device[] = "/dev/sda1";
8990     device[5] = devchar;
8991     int r;
8992     suppress_error = 0;
8993     r = guestfs_mkfs (g, fstype, device);
8994     if (r == -1)
8995       return -1;
8996   }
8997   {
8998     char device[] = "/dev/sda1";
8999     device[5] = devchar;
9000     char mountpoint[] = "/";
9001     int r;
9002     suppress_error = 0;
9003     r = guestfs_mount (g, device, mountpoint);
9004     if (r == -1)
9005       return -1;
9006   }
9007   /* TestOutput for command (4) */
9008   char expected[] = "\nResult5\n\n";
9009   {
9010     char remotefilename[] = "/test-command";
9011     int r;
9012     suppress_error = 0;
9013     r = guestfs_upload (g, "test-command", remotefilename);
9014     if (r == -1)
9015       return -1;
9016   }
9017   {
9018     char path[] = "/test-command";
9019     int r;
9020     suppress_error = 0;
9021     r = guestfs_chmod (g, 493, path);
9022     if (r == -1)
9023       return -1;
9024   }
9025   {
9026     char arguments_0[] = "/test-command";
9027     char arguments_1[] = "5";
9028     char *arguments[] = {
9029       arguments_0,
9030       arguments_1,
9031       NULL
9032     };
9033     char *r;
9034     suppress_error = 0;
9035     r = guestfs_command (g, arguments);
9036     if (r == NULL)
9037       return -1;
9038     if (strcmp (r, expected) != 0) {
9039       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9040       return -1;
9041     }
9042     free (r);
9043   }
9044   return 0;
9045 }
9046
9047 static int test_command_5_skip (void)
9048 {
9049   const char *str;
9050
9051   str = getenv ("SKIP_TEST_COMMAND_5");
9052   if (str && strcmp (str, "1") == 0) return 1;
9053   str = getenv ("SKIP_TEST_COMMAND");
9054   if (str && strcmp (str, "1") == 0) return 1;
9055   return 0;
9056 }
9057
9058 static int test_command_5 (void)
9059 {
9060   if (test_command_5_skip ()) {
9061     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9062     return 0;
9063   }
9064
9065   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9066   {
9067     char device[] = "/dev/sda";
9068     device[5] = devchar;
9069     int r;
9070     suppress_error = 0;
9071     r = guestfs_blockdev_setrw (g, device);
9072     if (r == -1)
9073       return -1;
9074   }
9075   {
9076     int r;
9077     suppress_error = 0;
9078     r = guestfs_umount_all (g);
9079     if (r == -1)
9080       return -1;
9081   }
9082   {
9083     int r;
9084     suppress_error = 0;
9085     r = guestfs_lvm_remove_all (g);
9086     if (r == -1)
9087       return -1;
9088   }
9089   {
9090     char device[] = "/dev/sda";
9091     device[5] = devchar;
9092     char lines_0[] = ",";
9093     char *lines[] = {
9094       lines_0,
9095       NULL
9096     };
9097     int r;
9098     suppress_error = 0;
9099     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9100     if (r == -1)
9101       return -1;
9102   }
9103   {
9104     char fstype[] = "ext2";
9105     char device[] = "/dev/sda1";
9106     device[5] = devchar;
9107     int r;
9108     suppress_error = 0;
9109     r = guestfs_mkfs (g, fstype, device);
9110     if (r == -1)
9111       return -1;
9112   }
9113   {
9114     char device[] = "/dev/sda1";
9115     device[5] = devchar;
9116     char mountpoint[] = "/";
9117     int r;
9118     suppress_error = 0;
9119     r = guestfs_mount (g, device, mountpoint);
9120     if (r == -1)
9121       return -1;
9122   }
9123   /* TestOutput for command (5) */
9124   char expected[] = "\n\nResult6\n\n";
9125   {
9126     char remotefilename[] = "/test-command";
9127     int r;
9128     suppress_error = 0;
9129     r = guestfs_upload (g, "test-command", remotefilename);
9130     if (r == -1)
9131       return -1;
9132   }
9133   {
9134     char path[] = "/test-command";
9135     int r;
9136     suppress_error = 0;
9137     r = guestfs_chmod (g, 493, path);
9138     if (r == -1)
9139       return -1;
9140   }
9141   {
9142     char arguments_0[] = "/test-command";
9143     char arguments_1[] = "6";
9144     char *arguments[] = {
9145       arguments_0,
9146       arguments_1,
9147       NULL
9148     };
9149     char *r;
9150     suppress_error = 0;
9151     r = guestfs_command (g, arguments);
9152     if (r == NULL)
9153       return -1;
9154     if (strcmp (r, expected) != 0) {
9155       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9156       return -1;
9157     }
9158     free (r);
9159   }
9160   return 0;
9161 }
9162
9163 static int test_command_6_skip (void)
9164 {
9165   const char *str;
9166
9167   str = getenv ("SKIP_TEST_COMMAND_6");
9168   if (str && strcmp (str, "1") == 0) return 1;
9169   str = getenv ("SKIP_TEST_COMMAND");
9170   if (str && strcmp (str, "1") == 0) return 1;
9171   return 0;
9172 }
9173
9174 static int test_command_6 (void)
9175 {
9176   if (test_command_6_skip ()) {
9177     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9178     return 0;
9179   }
9180
9181   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9182   {
9183     char device[] = "/dev/sda";
9184     device[5] = devchar;
9185     int r;
9186     suppress_error = 0;
9187     r = guestfs_blockdev_setrw (g, device);
9188     if (r == -1)
9189       return -1;
9190   }
9191   {
9192     int r;
9193     suppress_error = 0;
9194     r = guestfs_umount_all (g);
9195     if (r == -1)
9196       return -1;
9197   }
9198   {
9199     int r;
9200     suppress_error = 0;
9201     r = guestfs_lvm_remove_all (g);
9202     if (r == -1)
9203       return -1;
9204   }
9205   {
9206     char device[] = "/dev/sda";
9207     device[5] = devchar;
9208     char lines_0[] = ",";
9209     char *lines[] = {
9210       lines_0,
9211       NULL
9212     };
9213     int r;
9214     suppress_error = 0;
9215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9216     if (r == -1)
9217       return -1;
9218   }
9219   {
9220     char fstype[] = "ext2";
9221     char device[] = "/dev/sda1";
9222     device[5] = devchar;
9223     int r;
9224     suppress_error = 0;
9225     r = guestfs_mkfs (g, fstype, device);
9226     if (r == -1)
9227       return -1;
9228   }
9229   {
9230     char device[] = "/dev/sda1";
9231     device[5] = devchar;
9232     char mountpoint[] = "/";
9233     int r;
9234     suppress_error = 0;
9235     r = guestfs_mount (g, device, mountpoint);
9236     if (r == -1)
9237       return -1;
9238   }
9239   /* TestOutput for command (6) */
9240   char expected[] = "";
9241   {
9242     char remotefilename[] = "/test-command";
9243     int r;
9244     suppress_error = 0;
9245     r = guestfs_upload (g, "test-command", remotefilename);
9246     if (r == -1)
9247       return -1;
9248   }
9249   {
9250     char path[] = "/test-command";
9251     int r;
9252     suppress_error = 0;
9253     r = guestfs_chmod (g, 493, path);
9254     if (r == -1)
9255       return -1;
9256   }
9257   {
9258     char arguments_0[] = "/test-command";
9259     char arguments_1[] = "7";
9260     char *arguments[] = {
9261       arguments_0,
9262       arguments_1,
9263       NULL
9264     };
9265     char *r;
9266     suppress_error = 0;
9267     r = guestfs_command (g, arguments);
9268     if (r == NULL)
9269       return -1;
9270     if (strcmp (r, expected) != 0) {
9271       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9272       return -1;
9273     }
9274     free (r);
9275   }
9276   return 0;
9277 }
9278
9279 static int test_command_7_skip (void)
9280 {
9281   const char *str;
9282
9283   str = getenv ("SKIP_TEST_COMMAND_7");
9284   if (str && strcmp (str, "1") == 0) return 1;
9285   str = getenv ("SKIP_TEST_COMMAND");
9286   if (str && strcmp (str, "1") == 0) return 1;
9287   return 0;
9288 }
9289
9290 static int test_command_7 (void)
9291 {
9292   if (test_command_7_skip ()) {
9293     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9294     return 0;
9295   }
9296
9297   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9298   {
9299     char device[] = "/dev/sda";
9300     device[5] = devchar;
9301     int r;
9302     suppress_error = 0;
9303     r = guestfs_blockdev_setrw (g, device);
9304     if (r == -1)
9305       return -1;
9306   }
9307   {
9308     int r;
9309     suppress_error = 0;
9310     r = guestfs_umount_all (g);
9311     if (r == -1)
9312       return -1;
9313   }
9314   {
9315     int r;
9316     suppress_error = 0;
9317     r = guestfs_lvm_remove_all (g);
9318     if (r == -1)
9319       return -1;
9320   }
9321   {
9322     char device[] = "/dev/sda";
9323     device[5] = devchar;
9324     char lines_0[] = ",";
9325     char *lines[] = {
9326       lines_0,
9327       NULL
9328     };
9329     int r;
9330     suppress_error = 0;
9331     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9332     if (r == -1)
9333       return -1;
9334   }
9335   {
9336     char fstype[] = "ext2";
9337     char device[] = "/dev/sda1";
9338     device[5] = devchar;
9339     int r;
9340     suppress_error = 0;
9341     r = guestfs_mkfs (g, fstype, device);
9342     if (r == -1)
9343       return -1;
9344   }
9345   {
9346     char device[] = "/dev/sda1";
9347     device[5] = devchar;
9348     char mountpoint[] = "/";
9349     int r;
9350     suppress_error = 0;
9351     r = guestfs_mount (g, device, mountpoint);
9352     if (r == -1)
9353       return -1;
9354   }
9355   /* TestOutput for command (7) */
9356   char expected[] = "\n";
9357   {
9358     char remotefilename[] = "/test-command";
9359     int r;
9360     suppress_error = 0;
9361     r = guestfs_upload (g, "test-command", remotefilename);
9362     if (r == -1)
9363       return -1;
9364   }
9365   {
9366     char path[] = "/test-command";
9367     int r;
9368     suppress_error = 0;
9369     r = guestfs_chmod (g, 493, path);
9370     if (r == -1)
9371       return -1;
9372   }
9373   {
9374     char arguments_0[] = "/test-command";
9375     char arguments_1[] = "8";
9376     char *arguments[] = {
9377       arguments_0,
9378       arguments_1,
9379       NULL
9380     };
9381     char *r;
9382     suppress_error = 0;
9383     r = guestfs_command (g, arguments);
9384     if (r == NULL)
9385       return -1;
9386     if (strcmp (r, expected) != 0) {
9387       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9388       return -1;
9389     }
9390     free (r);
9391   }
9392   return 0;
9393 }
9394
9395 static int test_command_8_skip (void)
9396 {
9397   const char *str;
9398
9399   str = getenv ("SKIP_TEST_COMMAND_8");
9400   if (str && strcmp (str, "1") == 0) return 1;
9401   str = getenv ("SKIP_TEST_COMMAND");
9402   if (str && strcmp (str, "1") == 0) return 1;
9403   return 0;
9404 }
9405
9406 static int test_command_8 (void)
9407 {
9408   if (test_command_8_skip ()) {
9409     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9410     return 0;
9411   }
9412
9413   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9414   {
9415     char device[] = "/dev/sda";
9416     device[5] = devchar;
9417     int r;
9418     suppress_error = 0;
9419     r = guestfs_blockdev_setrw (g, device);
9420     if (r == -1)
9421       return -1;
9422   }
9423   {
9424     int r;
9425     suppress_error = 0;
9426     r = guestfs_umount_all (g);
9427     if (r == -1)
9428       return -1;
9429   }
9430   {
9431     int r;
9432     suppress_error = 0;
9433     r = guestfs_lvm_remove_all (g);
9434     if (r == -1)
9435       return -1;
9436   }
9437   {
9438     char device[] = "/dev/sda";
9439     device[5] = devchar;
9440     char lines_0[] = ",";
9441     char *lines[] = {
9442       lines_0,
9443       NULL
9444     };
9445     int r;
9446     suppress_error = 0;
9447     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9448     if (r == -1)
9449       return -1;
9450   }
9451   {
9452     char fstype[] = "ext2";
9453     char device[] = "/dev/sda1";
9454     device[5] = devchar;
9455     int r;
9456     suppress_error = 0;
9457     r = guestfs_mkfs (g, fstype, device);
9458     if (r == -1)
9459       return -1;
9460   }
9461   {
9462     char device[] = "/dev/sda1";
9463     device[5] = devchar;
9464     char mountpoint[] = "/";
9465     int r;
9466     suppress_error = 0;
9467     r = guestfs_mount (g, device, mountpoint);
9468     if (r == -1)
9469       return -1;
9470   }
9471   /* TestOutput for command (8) */
9472   char expected[] = "\n\n";
9473   {
9474     char remotefilename[] = "/test-command";
9475     int r;
9476     suppress_error = 0;
9477     r = guestfs_upload (g, "test-command", remotefilename);
9478     if (r == -1)
9479       return -1;
9480   }
9481   {
9482     char path[] = "/test-command";
9483     int r;
9484     suppress_error = 0;
9485     r = guestfs_chmod (g, 493, path);
9486     if (r == -1)
9487       return -1;
9488   }
9489   {
9490     char arguments_0[] = "/test-command";
9491     char arguments_1[] = "9";
9492     char *arguments[] = {
9493       arguments_0,
9494       arguments_1,
9495       NULL
9496     };
9497     char *r;
9498     suppress_error = 0;
9499     r = guestfs_command (g, arguments);
9500     if (r == NULL)
9501       return -1;
9502     if (strcmp (r, expected) != 0) {
9503       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9504       return -1;
9505     }
9506     free (r);
9507   }
9508   return 0;
9509 }
9510
9511 static int test_command_9_skip (void)
9512 {
9513   const char *str;
9514
9515   str = getenv ("SKIP_TEST_COMMAND_9");
9516   if (str && strcmp (str, "1") == 0) return 1;
9517   str = getenv ("SKIP_TEST_COMMAND");
9518   if (str && strcmp (str, "1") == 0) return 1;
9519   return 0;
9520 }
9521
9522 static int test_command_9 (void)
9523 {
9524   if (test_command_9_skip ()) {
9525     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9526     return 0;
9527   }
9528
9529   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9530   {
9531     char device[] = "/dev/sda";
9532     device[5] = devchar;
9533     int r;
9534     suppress_error = 0;
9535     r = guestfs_blockdev_setrw (g, device);
9536     if (r == -1)
9537       return -1;
9538   }
9539   {
9540     int r;
9541     suppress_error = 0;
9542     r = guestfs_umount_all (g);
9543     if (r == -1)
9544       return -1;
9545   }
9546   {
9547     int r;
9548     suppress_error = 0;
9549     r = guestfs_lvm_remove_all (g);
9550     if (r == -1)
9551       return -1;
9552   }
9553   {
9554     char device[] = "/dev/sda";
9555     device[5] = devchar;
9556     char lines_0[] = ",";
9557     char *lines[] = {
9558       lines_0,
9559       NULL
9560     };
9561     int r;
9562     suppress_error = 0;
9563     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9564     if (r == -1)
9565       return -1;
9566   }
9567   {
9568     char fstype[] = "ext2";
9569     char device[] = "/dev/sda1";
9570     device[5] = devchar;
9571     int r;
9572     suppress_error = 0;
9573     r = guestfs_mkfs (g, fstype, device);
9574     if (r == -1)
9575       return -1;
9576   }
9577   {
9578     char device[] = "/dev/sda1";
9579     device[5] = devchar;
9580     char mountpoint[] = "/";
9581     int r;
9582     suppress_error = 0;
9583     r = guestfs_mount (g, device, mountpoint);
9584     if (r == -1)
9585       return -1;
9586   }
9587   /* TestOutput for command (9) */
9588   char expected[] = "Result10-1\nResult10-2\n";
9589   {
9590     char remotefilename[] = "/test-command";
9591     int r;
9592     suppress_error = 0;
9593     r = guestfs_upload (g, "test-command", remotefilename);
9594     if (r == -1)
9595       return -1;
9596   }
9597   {
9598     char path[] = "/test-command";
9599     int r;
9600     suppress_error = 0;
9601     r = guestfs_chmod (g, 493, path);
9602     if (r == -1)
9603       return -1;
9604   }
9605   {
9606     char arguments_0[] = "/test-command";
9607     char arguments_1[] = "10";
9608     char *arguments[] = {
9609       arguments_0,
9610       arguments_1,
9611       NULL
9612     };
9613     char *r;
9614     suppress_error = 0;
9615     r = guestfs_command (g, arguments);
9616     if (r == NULL)
9617       return -1;
9618     if (strcmp (r, expected) != 0) {
9619       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9620       return -1;
9621     }
9622     free (r);
9623   }
9624   return 0;
9625 }
9626
9627 static int test_command_10_skip (void)
9628 {
9629   const char *str;
9630
9631   str = getenv ("SKIP_TEST_COMMAND_10");
9632   if (str && strcmp (str, "1") == 0) return 1;
9633   str = getenv ("SKIP_TEST_COMMAND");
9634   if (str && strcmp (str, "1") == 0) return 1;
9635   return 0;
9636 }
9637
9638 static int test_command_10 (void)
9639 {
9640   if (test_command_10_skip ()) {
9641     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9642     return 0;
9643   }
9644
9645   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9646   {
9647     char device[] = "/dev/sda";
9648     device[5] = devchar;
9649     int r;
9650     suppress_error = 0;
9651     r = guestfs_blockdev_setrw (g, device);
9652     if (r == -1)
9653       return -1;
9654   }
9655   {
9656     int r;
9657     suppress_error = 0;
9658     r = guestfs_umount_all (g);
9659     if (r == -1)
9660       return -1;
9661   }
9662   {
9663     int r;
9664     suppress_error = 0;
9665     r = guestfs_lvm_remove_all (g);
9666     if (r == -1)
9667       return -1;
9668   }
9669   {
9670     char device[] = "/dev/sda";
9671     device[5] = devchar;
9672     char lines_0[] = ",";
9673     char *lines[] = {
9674       lines_0,
9675       NULL
9676     };
9677     int r;
9678     suppress_error = 0;
9679     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9680     if (r == -1)
9681       return -1;
9682   }
9683   {
9684     char fstype[] = "ext2";
9685     char device[] = "/dev/sda1";
9686     device[5] = devchar;
9687     int r;
9688     suppress_error = 0;
9689     r = guestfs_mkfs (g, fstype, device);
9690     if (r == -1)
9691       return -1;
9692   }
9693   {
9694     char device[] = "/dev/sda1";
9695     device[5] = devchar;
9696     char mountpoint[] = "/";
9697     int r;
9698     suppress_error = 0;
9699     r = guestfs_mount (g, device, mountpoint);
9700     if (r == -1)
9701       return -1;
9702   }
9703   /* TestOutput for command (10) */
9704   char expected[] = "Result11-1\nResult11-2";
9705   {
9706     char remotefilename[] = "/test-command";
9707     int r;
9708     suppress_error = 0;
9709     r = guestfs_upload (g, "test-command", remotefilename);
9710     if (r == -1)
9711       return -1;
9712   }
9713   {
9714     char path[] = "/test-command";
9715     int r;
9716     suppress_error = 0;
9717     r = guestfs_chmod (g, 493, path);
9718     if (r == -1)
9719       return -1;
9720   }
9721   {
9722     char arguments_0[] = "/test-command";
9723     char arguments_1[] = "11";
9724     char *arguments[] = {
9725       arguments_0,
9726       arguments_1,
9727       NULL
9728     };
9729     char *r;
9730     suppress_error = 0;
9731     r = guestfs_command (g, arguments);
9732     if (r == NULL)
9733       return -1;
9734     if (strcmp (r, expected) != 0) {
9735       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9736       return -1;
9737     }
9738     free (r);
9739   }
9740   return 0;
9741 }
9742
9743 static int test_command_11_skip (void)
9744 {
9745   const char *str;
9746
9747   str = getenv ("SKIP_TEST_COMMAND_11");
9748   if (str && strcmp (str, "1") == 0) return 1;
9749   str = getenv ("SKIP_TEST_COMMAND");
9750   if (str && strcmp (str, "1") == 0) return 1;
9751   return 0;
9752 }
9753
9754 static int test_command_11 (void)
9755 {
9756   if (test_command_11_skip ()) {
9757     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9758     return 0;
9759   }
9760
9761   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9762   {
9763     char device[] = "/dev/sda";
9764     device[5] = devchar;
9765     int r;
9766     suppress_error = 0;
9767     r = guestfs_blockdev_setrw (g, device);
9768     if (r == -1)
9769       return -1;
9770   }
9771   {
9772     int r;
9773     suppress_error = 0;
9774     r = guestfs_umount_all (g);
9775     if (r == -1)
9776       return -1;
9777   }
9778   {
9779     int r;
9780     suppress_error = 0;
9781     r = guestfs_lvm_remove_all (g);
9782     if (r == -1)
9783       return -1;
9784   }
9785   {
9786     char device[] = "/dev/sda";
9787     device[5] = devchar;
9788     char lines_0[] = ",";
9789     char *lines[] = {
9790       lines_0,
9791       NULL
9792     };
9793     int r;
9794     suppress_error = 0;
9795     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9796     if (r == -1)
9797       return -1;
9798   }
9799   {
9800     char fstype[] = "ext2";
9801     char device[] = "/dev/sda1";
9802     device[5] = devchar;
9803     int r;
9804     suppress_error = 0;
9805     r = guestfs_mkfs (g, fstype, device);
9806     if (r == -1)
9807       return -1;
9808   }
9809   {
9810     char device[] = "/dev/sda1";
9811     device[5] = devchar;
9812     char mountpoint[] = "/";
9813     int r;
9814     suppress_error = 0;
9815     r = guestfs_mount (g, device, mountpoint);
9816     if (r == -1)
9817       return -1;
9818   }
9819   /* TestLastFail for command (11) */
9820   {
9821     char remotefilename[] = "/test-command";
9822     int r;
9823     suppress_error = 0;
9824     r = guestfs_upload (g, "test-command", remotefilename);
9825     if (r == -1)
9826       return -1;
9827   }
9828   {
9829     char path[] = "/test-command";
9830     int r;
9831     suppress_error = 0;
9832     r = guestfs_chmod (g, 493, path);
9833     if (r == -1)
9834       return -1;
9835   }
9836   {
9837     char arguments_0[] = "/test-command";
9838     char *arguments[] = {
9839       arguments_0,
9840       NULL
9841     };
9842     char *r;
9843     suppress_error = 1;
9844     r = guestfs_command (g, arguments);
9845     if (r != NULL)
9846       return -1;
9847     free (r);
9848   }
9849   return 0;
9850 }
9851
9852 static int test_file_0_skip (void)
9853 {
9854   const char *str;
9855
9856   str = getenv ("SKIP_TEST_FILE_0");
9857   if (str && strcmp (str, "1") == 0) return 1;
9858   str = getenv ("SKIP_TEST_FILE");
9859   if (str && strcmp (str, "1") == 0) return 1;
9860   return 0;
9861 }
9862
9863 static int test_file_0 (void)
9864 {
9865   if (test_file_0_skip ()) {
9866     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9867     return 0;
9868   }
9869
9870   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9871   {
9872     char device[] = "/dev/sda";
9873     device[5] = devchar;
9874     int r;
9875     suppress_error = 0;
9876     r = guestfs_blockdev_setrw (g, device);
9877     if (r == -1)
9878       return -1;
9879   }
9880   {
9881     int r;
9882     suppress_error = 0;
9883     r = guestfs_umount_all (g);
9884     if (r == -1)
9885       return -1;
9886   }
9887   {
9888     int r;
9889     suppress_error = 0;
9890     r = guestfs_lvm_remove_all (g);
9891     if (r == -1)
9892       return -1;
9893   }
9894   {
9895     char device[] = "/dev/sda";
9896     device[5] = devchar;
9897     char lines_0[] = ",";
9898     char *lines[] = {
9899       lines_0,
9900       NULL
9901     };
9902     int r;
9903     suppress_error = 0;
9904     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9905     if (r == -1)
9906       return -1;
9907   }
9908   {
9909     char fstype[] = "ext2";
9910     char device[] = "/dev/sda1";
9911     device[5] = devchar;
9912     int r;
9913     suppress_error = 0;
9914     r = guestfs_mkfs (g, fstype, device);
9915     if (r == -1)
9916       return -1;
9917   }
9918   {
9919     char device[] = "/dev/sda1";
9920     device[5] = devchar;
9921     char mountpoint[] = "/";
9922     int r;
9923     suppress_error = 0;
9924     r = guestfs_mount (g, device, mountpoint);
9925     if (r == -1)
9926       return -1;
9927   }
9928   /* TestOutput for file (0) */
9929   char expected[] = "empty";
9930   {
9931     char path[] = "/new";
9932     int r;
9933     suppress_error = 0;
9934     r = guestfs_touch (g, path);
9935     if (r == -1)
9936       return -1;
9937   }
9938   {
9939     char path[] = "/new";
9940     char *r;
9941     suppress_error = 0;
9942     r = guestfs_file (g, path);
9943     if (r == NULL)
9944       return -1;
9945     if (strcmp (r, expected) != 0) {
9946       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9947       return -1;
9948     }
9949     free (r);
9950   }
9951   return 0;
9952 }
9953
9954 static int test_file_1_skip (void)
9955 {
9956   const char *str;
9957
9958   str = getenv ("SKIP_TEST_FILE_1");
9959   if (str && strcmp (str, "1") == 0) return 1;
9960   str = getenv ("SKIP_TEST_FILE");
9961   if (str && strcmp (str, "1") == 0) return 1;
9962   return 0;
9963 }
9964
9965 static int test_file_1 (void)
9966 {
9967   if (test_file_1_skip ()) {
9968     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9969     return 0;
9970   }
9971
9972   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9973   {
9974     char device[] = "/dev/sda";
9975     device[5] = devchar;
9976     int r;
9977     suppress_error = 0;
9978     r = guestfs_blockdev_setrw (g, device);
9979     if (r == -1)
9980       return -1;
9981   }
9982   {
9983     int r;
9984     suppress_error = 0;
9985     r = guestfs_umount_all (g);
9986     if (r == -1)
9987       return -1;
9988   }
9989   {
9990     int r;
9991     suppress_error = 0;
9992     r = guestfs_lvm_remove_all (g);
9993     if (r == -1)
9994       return -1;
9995   }
9996   {
9997     char device[] = "/dev/sda";
9998     device[5] = devchar;
9999     char lines_0[] = ",";
10000     char *lines[] = {
10001       lines_0,
10002       NULL
10003     };
10004     int r;
10005     suppress_error = 0;
10006     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10007     if (r == -1)
10008       return -1;
10009   }
10010   {
10011     char fstype[] = "ext2";
10012     char device[] = "/dev/sda1";
10013     device[5] = devchar;
10014     int r;
10015     suppress_error = 0;
10016     r = guestfs_mkfs (g, fstype, device);
10017     if (r == -1)
10018       return -1;
10019   }
10020   {
10021     char device[] = "/dev/sda1";
10022     device[5] = devchar;
10023     char mountpoint[] = "/";
10024     int r;
10025     suppress_error = 0;
10026     r = guestfs_mount (g, device, mountpoint);
10027     if (r == -1)
10028       return -1;
10029   }
10030   /* TestOutput for file (1) */
10031   char expected[] = "ASCII text";
10032   {
10033     char path[] = "/new";
10034     char content[] = "some content\n";
10035     int r;
10036     suppress_error = 0;
10037     r = guestfs_write_file (g, path, content, 0);
10038     if (r == -1)
10039       return -1;
10040   }
10041   {
10042     char path[] = "/new";
10043     char *r;
10044     suppress_error = 0;
10045     r = guestfs_file (g, path);
10046     if (r == NULL)
10047       return -1;
10048     if (strcmp (r, expected) != 0) {
10049       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10050       return -1;
10051     }
10052     free (r);
10053   }
10054   return 0;
10055 }
10056
10057 static int test_file_2_skip (void)
10058 {
10059   const char *str;
10060
10061   str = getenv ("SKIP_TEST_FILE_2");
10062   if (str && strcmp (str, "1") == 0) return 1;
10063   str = getenv ("SKIP_TEST_FILE");
10064   if (str && strcmp (str, "1") == 0) return 1;
10065   return 0;
10066 }
10067
10068 static int test_file_2 (void)
10069 {
10070   if (test_file_2_skip ()) {
10071     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10072     return 0;
10073   }
10074
10075   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10076   {
10077     char device[] = "/dev/sda";
10078     device[5] = devchar;
10079     int r;
10080     suppress_error = 0;
10081     r = guestfs_blockdev_setrw (g, device);
10082     if (r == -1)
10083       return -1;
10084   }
10085   {
10086     int r;
10087     suppress_error = 0;
10088     r = guestfs_umount_all (g);
10089     if (r == -1)
10090       return -1;
10091   }
10092   {
10093     int r;
10094     suppress_error = 0;
10095     r = guestfs_lvm_remove_all (g);
10096     if (r == -1)
10097       return -1;
10098   }
10099   {
10100     char device[] = "/dev/sda";
10101     device[5] = devchar;
10102     char lines_0[] = ",";
10103     char *lines[] = {
10104       lines_0,
10105       NULL
10106     };
10107     int r;
10108     suppress_error = 0;
10109     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10110     if (r == -1)
10111       return -1;
10112   }
10113   {
10114     char fstype[] = "ext2";
10115     char device[] = "/dev/sda1";
10116     device[5] = devchar;
10117     int r;
10118     suppress_error = 0;
10119     r = guestfs_mkfs (g, fstype, device);
10120     if (r == -1)
10121       return -1;
10122   }
10123   {
10124     char device[] = "/dev/sda1";
10125     device[5] = devchar;
10126     char mountpoint[] = "/";
10127     int r;
10128     suppress_error = 0;
10129     r = guestfs_mount (g, device, mountpoint);
10130     if (r == -1)
10131       return -1;
10132   }
10133   /* TestLastFail for file (2) */
10134   {
10135     char path[] = "/nofile";
10136     char *r;
10137     suppress_error = 1;
10138     r = guestfs_file (g, path);
10139     if (r != NULL)
10140       return -1;
10141     free (r);
10142   }
10143   return 0;
10144 }
10145
10146 static int test_umount_all_0_skip (void)
10147 {
10148   const char *str;
10149
10150   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10151   if (str && strcmp (str, "1") == 0) return 1;
10152   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10153   if (str && strcmp (str, "1") == 0) return 1;
10154   return 0;
10155 }
10156
10157 static int test_umount_all_0 (void)
10158 {
10159   if (test_umount_all_0_skip ()) {
10160     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10161     return 0;
10162   }
10163
10164   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10165   {
10166     char device[] = "/dev/sda";
10167     device[5] = devchar;
10168     int r;
10169     suppress_error = 0;
10170     r = guestfs_blockdev_setrw (g, device);
10171     if (r == -1)
10172       return -1;
10173   }
10174   {
10175     int r;
10176     suppress_error = 0;
10177     r = guestfs_umount_all (g);
10178     if (r == -1)
10179       return -1;
10180   }
10181   {
10182     int r;
10183     suppress_error = 0;
10184     r = guestfs_lvm_remove_all (g);
10185     if (r == -1)
10186       return -1;
10187   }
10188   {
10189     char device[] = "/dev/sda";
10190     device[5] = devchar;
10191     char lines_0[] = ",";
10192     char *lines[] = {
10193       lines_0,
10194       NULL
10195     };
10196     int r;
10197     suppress_error = 0;
10198     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10199     if (r == -1)
10200       return -1;
10201   }
10202   {
10203     char fstype[] = "ext2";
10204     char device[] = "/dev/sda1";
10205     device[5] = devchar;
10206     int r;
10207     suppress_error = 0;
10208     r = guestfs_mkfs (g, fstype, device);
10209     if (r == -1)
10210       return -1;
10211   }
10212   {
10213     char device[] = "/dev/sda1";
10214     device[5] = devchar;
10215     char mountpoint[] = "/";
10216     int r;
10217     suppress_error = 0;
10218     r = guestfs_mount (g, device, mountpoint);
10219     if (r == -1)
10220       return -1;
10221   }
10222   /* TestOutputList for umount_all (0) */
10223   {
10224     int r;
10225     suppress_error = 0;
10226     r = guestfs_umount_all (g);
10227     if (r == -1)
10228       return -1;
10229   }
10230   {
10231     char **r;
10232     int i;
10233     suppress_error = 0;
10234     r = guestfs_mounts (g);
10235     if (r == NULL)
10236       return -1;
10237     if (r[0] != NULL) {
10238       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10239       print_strings (r);
10240       return -1;
10241     }
10242     for (i = 0; r[i] != NULL; ++i)
10243       free (r[i]);
10244     free (r);
10245   }
10246   return 0;
10247 }
10248
10249 static int test_umount_all_1_skip (void)
10250 {
10251   const char *str;
10252
10253   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10254   if (str && strcmp (str, "1") == 0) return 1;
10255   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10256   if (str && strcmp (str, "1") == 0) return 1;
10257   return 0;
10258 }
10259
10260 static int test_umount_all_1 (void)
10261 {
10262   if (test_umount_all_1_skip ()) {
10263     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10264     return 0;
10265   }
10266
10267   /* InitNone|InitEmpty for test_umount_all_1 */
10268   {
10269     char device[] = "/dev/sda";
10270     device[5] = devchar;
10271     int r;
10272     suppress_error = 0;
10273     r = guestfs_blockdev_setrw (g, device);
10274     if (r == -1)
10275       return -1;
10276   }
10277   {
10278     int r;
10279     suppress_error = 0;
10280     r = guestfs_umount_all (g);
10281     if (r == -1)
10282       return -1;
10283   }
10284   {
10285     int r;
10286     suppress_error = 0;
10287     r = guestfs_lvm_remove_all (g);
10288     if (r == -1)
10289       return -1;
10290   }
10291   /* TestOutputList for umount_all (1) */
10292   {
10293     char device[] = "/dev/sda";
10294     device[5] = devchar;
10295     char lines_0[] = ",10";
10296     char lines_1[] = ",20";
10297     char lines_2[] = ",";
10298     char *lines[] = {
10299       lines_0,
10300       lines_1,
10301       lines_2,
10302       NULL
10303     };
10304     int r;
10305     suppress_error = 0;
10306     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10307     if (r == -1)
10308       return -1;
10309   }
10310   {
10311     char fstype[] = "ext2";
10312     char device[] = "/dev/sda1";
10313     device[5] = devchar;
10314     int r;
10315     suppress_error = 0;
10316     r = guestfs_mkfs (g, fstype, device);
10317     if (r == -1)
10318       return -1;
10319   }
10320   {
10321     char fstype[] = "ext2";
10322     char device[] = "/dev/sda2";
10323     device[5] = devchar;
10324     int r;
10325     suppress_error = 0;
10326     r = guestfs_mkfs (g, fstype, device);
10327     if (r == -1)
10328       return -1;
10329   }
10330   {
10331     char fstype[] = "ext2";
10332     char device[] = "/dev/sda3";
10333     device[5] = devchar;
10334     int r;
10335     suppress_error = 0;
10336     r = guestfs_mkfs (g, fstype, device);
10337     if (r == -1)
10338       return -1;
10339   }
10340   {
10341     char device[] = "/dev/sda1";
10342     device[5] = devchar;
10343     char mountpoint[] = "/";
10344     int r;
10345     suppress_error = 0;
10346     r = guestfs_mount (g, device, mountpoint);
10347     if (r == -1)
10348       return -1;
10349   }
10350   {
10351     char path[] = "/mp1";
10352     int r;
10353     suppress_error = 0;
10354     r = guestfs_mkdir (g, path);
10355     if (r == -1)
10356       return -1;
10357   }
10358   {
10359     char device[] = "/dev/sda2";
10360     device[5] = devchar;
10361     char mountpoint[] = "/mp1";
10362     int r;
10363     suppress_error = 0;
10364     r = guestfs_mount (g, device, mountpoint);
10365     if (r == -1)
10366       return -1;
10367   }
10368   {
10369     char path[] = "/mp1/mp2";
10370     int r;
10371     suppress_error = 0;
10372     r = guestfs_mkdir (g, path);
10373     if (r == -1)
10374       return -1;
10375   }
10376   {
10377     char device[] = "/dev/sda3";
10378     device[5] = devchar;
10379     char mountpoint[] = "/mp1/mp2";
10380     int r;
10381     suppress_error = 0;
10382     r = guestfs_mount (g, device, mountpoint);
10383     if (r == -1)
10384       return -1;
10385   }
10386   {
10387     char path[] = "/mp1/mp2/mp3";
10388     int r;
10389     suppress_error = 0;
10390     r = guestfs_mkdir (g, path);
10391     if (r == -1)
10392       return -1;
10393   }
10394   {
10395     int r;
10396     suppress_error = 0;
10397     r = guestfs_umount_all (g);
10398     if (r == -1)
10399       return -1;
10400   }
10401   {
10402     char **r;
10403     int i;
10404     suppress_error = 0;
10405     r = guestfs_mounts (g);
10406     if (r == NULL)
10407       return -1;
10408     if (r[0] != NULL) {
10409       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10410       print_strings (r);
10411       return -1;
10412     }
10413     for (i = 0; r[i] != NULL; ++i)
10414       free (r[i]);
10415     free (r);
10416   }
10417   return 0;
10418 }
10419
10420 static int test_mounts_0_skip (void)
10421 {
10422   const char *str;
10423
10424   str = getenv ("SKIP_TEST_MOUNTS_0");
10425   if (str && strcmp (str, "1") == 0) return 1;
10426   str = getenv ("SKIP_TEST_MOUNTS");
10427   if (str && strcmp (str, "1") == 0) return 1;
10428   return 0;
10429 }
10430
10431 static int test_mounts_0 (void)
10432 {
10433   if (test_mounts_0_skip ()) {
10434     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10435     return 0;
10436   }
10437
10438   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10439   {
10440     char device[] = "/dev/sda";
10441     device[5] = devchar;
10442     int r;
10443     suppress_error = 0;
10444     r = guestfs_blockdev_setrw (g, device);
10445     if (r == -1)
10446       return -1;
10447   }
10448   {
10449     int r;
10450     suppress_error = 0;
10451     r = guestfs_umount_all (g);
10452     if (r == -1)
10453       return -1;
10454   }
10455   {
10456     int r;
10457     suppress_error = 0;
10458     r = guestfs_lvm_remove_all (g);
10459     if (r == -1)
10460       return -1;
10461   }
10462   {
10463     char device[] = "/dev/sda";
10464     device[5] = devchar;
10465     char lines_0[] = ",";
10466     char *lines[] = {
10467       lines_0,
10468       NULL
10469     };
10470     int r;
10471     suppress_error = 0;
10472     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10473     if (r == -1)
10474       return -1;
10475   }
10476   {
10477     char fstype[] = "ext2";
10478     char device[] = "/dev/sda1";
10479     device[5] = devchar;
10480     int r;
10481     suppress_error = 0;
10482     r = guestfs_mkfs (g, fstype, device);
10483     if (r == -1)
10484       return -1;
10485   }
10486   {
10487     char device[] = "/dev/sda1";
10488     device[5] = devchar;
10489     char mountpoint[] = "/";
10490     int r;
10491     suppress_error = 0;
10492     r = guestfs_mount (g, device, mountpoint);
10493     if (r == -1)
10494       return -1;
10495   }
10496   /* TestOutputList for mounts (0) */
10497   {
10498     char **r;
10499     int i;
10500     suppress_error = 0;
10501     r = guestfs_mounts (g);
10502     if (r == NULL)
10503       return -1;
10504     if (!r[0]) {
10505       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10506       print_strings (r);
10507       return -1;
10508     }
10509     {
10510       char expected[] = "/dev/sda1";
10511       expected[5] = devchar;
10512       if (strcmp (r[0], expected) != 0) {
10513         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10514         return -1;
10515       }
10516     }
10517     if (r[1] != NULL) {
10518       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10519       print_strings (r);
10520       return -1;
10521     }
10522     for (i = 0; r[i] != NULL; ++i)
10523       free (r[i]);
10524     free (r);
10525   }
10526   return 0;
10527 }
10528
10529 static int test_umount_0_skip (void)
10530 {
10531   const char *str;
10532
10533   str = getenv ("SKIP_TEST_UMOUNT_0");
10534   if (str && strcmp (str, "1") == 0) return 1;
10535   str = getenv ("SKIP_TEST_UMOUNT");
10536   if (str && strcmp (str, "1") == 0) return 1;
10537   return 0;
10538 }
10539
10540 static int test_umount_0 (void)
10541 {
10542   if (test_umount_0_skip ()) {
10543     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10544     return 0;
10545   }
10546
10547   /* InitNone|InitEmpty for test_umount_0 */
10548   {
10549     char device[] = "/dev/sda";
10550     device[5] = devchar;
10551     int r;
10552     suppress_error = 0;
10553     r = guestfs_blockdev_setrw (g, device);
10554     if (r == -1)
10555       return -1;
10556   }
10557   {
10558     int r;
10559     suppress_error = 0;
10560     r = guestfs_umount_all (g);
10561     if (r == -1)
10562       return -1;
10563   }
10564   {
10565     int r;
10566     suppress_error = 0;
10567     r = guestfs_lvm_remove_all (g);
10568     if (r == -1)
10569       return -1;
10570   }
10571   /* TestOutputList for umount (0) */
10572   {
10573     char device[] = "/dev/sda";
10574     device[5] = devchar;
10575     char lines_0[] = ",";
10576     char *lines[] = {
10577       lines_0,
10578       NULL
10579     };
10580     int r;
10581     suppress_error = 0;
10582     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10583     if (r == -1)
10584       return -1;
10585   }
10586   {
10587     char fstype[] = "ext2";
10588     char device[] = "/dev/sda1";
10589     device[5] = devchar;
10590     int r;
10591     suppress_error = 0;
10592     r = guestfs_mkfs (g, fstype, device);
10593     if (r == -1)
10594       return -1;
10595   }
10596   {
10597     char device[] = "/dev/sda1";
10598     device[5] = devchar;
10599     char mountpoint[] = "/";
10600     int r;
10601     suppress_error = 0;
10602     r = guestfs_mount (g, device, mountpoint);
10603     if (r == -1)
10604       return -1;
10605   }
10606   {
10607     char **r;
10608     int i;
10609     suppress_error = 0;
10610     r = guestfs_mounts (g);
10611     if (r == NULL)
10612       return -1;
10613     if (!r[0]) {
10614       fprintf (stderr, "test_umount_0: short list returned from command\n");
10615       print_strings (r);
10616       return -1;
10617     }
10618     {
10619       char expected[] = "/dev/sda1";
10620       expected[5] = devchar;
10621       if (strcmp (r[0], expected) != 0) {
10622         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10623         return -1;
10624       }
10625     }
10626     if (r[1] != NULL) {
10627       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10628       print_strings (r);
10629       return -1;
10630     }
10631     for (i = 0; r[i] != NULL; ++i)
10632       free (r[i]);
10633     free (r);
10634   }
10635   return 0;
10636 }
10637
10638 static int test_umount_1_skip (void)
10639 {
10640   const char *str;
10641
10642   str = getenv ("SKIP_TEST_UMOUNT_1");
10643   if (str && strcmp (str, "1") == 0) return 1;
10644   str = getenv ("SKIP_TEST_UMOUNT");
10645   if (str && strcmp (str, "1") == 0) return 1;
10646   return 0;
10647 }
10648
10649 static int test_umount_1 (void)
10650 {
10651   if (test_umount_1_skip ()) {
10652     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10653     return 0;
10654   }
10655
10656   /* InitNone|InitEmpty for test_umount_1 */
10657   {
10658     char device[] = "/dev/sda";
10659     device[5] = devchar;
10660     int r;
10661     suppress_error = 0;
10662     r = guestfs_blockdev_setrw (g, device);
10663     if (r == -1)
10664       return -1;
10665   }
10666   {
10667     int r;
10668     suppress_error = 0;
10669     r = guestfs_umount_all (g);
10670     if (r == -1)
10671       return -1;
10672   }
10673   {
10674     int r;
10675     suppress_error = 0;
10676     r = guestfs_lvm_remove_all (g);
10677     if (r == -1)
10678       return -1;
10679   }
10680   /* TestOutputList for umount (1) */
10681   {
10682     char device[] = "/dev/sda";
10683     device[5] = devchar;
10684     char lines_0[] = ",";
10685     char *lines[] = {
10686       lines_0,
10687       NULL
10688     };
10689     int r;
10690     suppress_error = 0;
10691     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10692     if (r == -1)
10693       return -1;
10694   }
10695   {
10696     char fstype[] = "ext2";
10697     char device[] = "/dev/sda1";
10698     device[5] = devchar;
10699     int r;
10700     suppress_error = 0;
10701     r = guestfs_mkfs (g, fstype, device);
10702     if (r == -1)
10703       return -1;
10704   }
10705   {
10706     char device[] = "/dev/sda1";
10707     device[5] = devchar;
10708     char mountpoint[] = "/";
10709     int r;
10710     suppress_error = 0;
10711     r = guestfs_mount (g, device, mountpoint);
10712     if (r == -1)
10713       return -1;
10714   }
10715   {
10716     char pathordevice[] = "/";
10717     int r;
10718     suppress_error = 0;
10719     r = guestfs_umount (g, pathordevice);
10720     if (r == -1)
10721       return -1;
10722   }
10723   {
10724     char **r;
10725     int i;
10726     suppress_error = 0;
10727     r = guestfs_mounts (g);
10728     if (r == NULL)
10729       return -1;
10730     if (r[0] != NULL) {
10731       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10732       print_strings (r);
10733       return -1;
10734     }
10735     for (i = 0; r[i] != NULL; ++i)
10736       free (r[i]);
10737     free (r);
10738   }
10739   return 0;
10740 }
10741
10742 static int test_write_file_0_skip (void)
10743 {
10744   const char *str;
10745
10746   str = getenv ("SKIP_TEST_WRITE_FILE_0");
10747   if (str && strcmp (str, "1") == 0) return 1;
10748   str = getenv ("SKIP_TEST_WRITE_FILE");
10749   if (str && strcmp (str, "1") == 0) return 1;
10750   return 0;
10751 }
10752
10753 static int test_write_file_0 (void)
10754 {
10755   if (test_write_file_0_skip ()) {
10756     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10757     return 0;
10758   }
10759
10760   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10761   {
10762     char device[] = "/dev/sda";
10763     device[5] = devchar;
10764     int r;
10765     suppress_error = 0;
10766     r = guestfs_blockdev_setrw (g, device);
10767     if (r == -1)
10768       return -1;
10769   }
10770   {
10771     int r;
10772     suppress_error = 0;
10773     r = guestfs_umount_all (g);
10774     if (r == -1)
10775       return -1;
10776   }
10777   {
10778     int r;
10779     suppress_error = 0;
10780     r = guestfs_lvm_remove_all (g);
10781     if (r == -1)
10782       return -1;
10783   }
10784   {
10785     char device[] = "/dev/sda";
10786     device[5] = devchar;
10787     char lines_0[] = ",";
10788     char *lines[] = {
10789       lines_0,
10790       NULL
10791     };
10792     int r;
10793     suppress_error = 0;
10794     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10795     if (r == -1)
10796       return -1;
10797   }
10798   {
10799     char fstype[] = "ext2";
10800     char device[] = "/dev/sda1";
10801     device[5] = devchar;
10802     int r;
10803     suppress_error = 0;
10804     r = guestfs_mkfs (g, fstype, device);
10805     if (r == -1)
10806       return -1;
10807   }
10808   {
10809     char device[] = "/dev/sda1";
10810     device[5] = devchar;
10811     char mountpoint[] = "/";
10812     int r;
10813     suppress_error = 0;
10814     r = guestfs_mount (g, device, mountpoint);
10815     if (r == -1)
10816       return -1;
10817   }
10818   /* TestOutput for write_file (0) */
10819   char expected[] = "new file contents";
10820   {
10821     char path[] = "/new";
10822     char content[] = "new file contents";
10823     int r;
10824     suppress_error = 0;
10825     r = guestfs_write_file (g, path, content, 0);
10826     if (r == -1)
10827       return -1;
10828   }
10829   {
10830     char path[] = "/new";
10831     char *r;
10832     suppress_error = 0;
10833     r = guestfs_cat (g, path);
10834     if (r == NULL)
10835       return -1;
10836     if (strcmp (r, expected) != 0) {
10837       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10838       return -1;
10839     }
10840     free (r);
10841   }
10842   return 0;
10843 }
10844
10845 static int test_write_file_1_skip (void)
10846 {
10847   const char *str;
10848
10849   str = getenv ("SKIP_TEST_WRITE_FILE_1");
10850   if (str && strcmp (str, "1") == 0) return 1;
10851   str = getenv ("SKIP_TEST_WRITE_FILE");
10852   if (str && strcmp (str, "1") == 0) return 1;
10853   return 0;
10854 }
10855
10856 static int test_write_file_1 (void)
10857 {
10858   if (test_write_file_1_skip ()) {
10859     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10860     return 0;
10861   }
10862
10863   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10864   {
10865     char device[] = "/dev/sda";
10866     device[5] = devchar;
10867     int r;
10868     suppress_error = 0;
10869     r = guestfs_blockdev_setrw (g, device);
10870     if (r == -1)
10871       return -1;
10872   }
10873   {
10874     int r;
10875     suppress_error = 0;
10876     r = guestfs_umount_all (g);
10877     if (r == -1)
10878       return -1;
10879   }
10880   {
10881     int r;
10882     suppress_error = 0;
10883     r = guestfs_lvm_remove_all (g);
10884     if (r == -1)
10885       return -1;
10886   }
10887   {
10888     char device[] = "/dev/sda";
10889     device[5] = devchar;
10890     char lines_0[] = ",";
10891     char *lines[] = {
10892       lines_0,
10893       NULL
10894     };
10895     int r;
10896     suppress_error = 0;
10897     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10898     if (r == -1)
10899       return -1;
10900   }
10901   {
10902     char fstype[] = "ext2";
10903     char device[] = "/dev/sda1";
10904     device[5] = devchar;
10905     int r;
10906     suppress_error = 0;
10907     r = guestfs_mkfs (g, fstype, device);
10908     if (r == -1)
10909       return -1;
10910   }
10911   {
10912     char device[] = "/dev/sda1";
10913     device[5] = devchar;
10914     char mountpoint[] = "/";
10915     int r;
10916     suppress_error = 0;
10917     r = guestfs_mount (g, device, mountpoint);
10918     if (r == -1)
10919       return -1;
10920   }
10921   /* TestOutput for write_file (1) */
10922   char expected[] = "\nnew file contents\n";
10923   {
10924     char path[] = "/new";
10925     char content[] = "\nnew file contents\n";
10926     int r;
10927     suppress_error = 0;
10928     r = guestfs_write_file (g, path, content, 0);
10929     if (r == -1)
10930       return -1;
10931   }
10932   {
10933     char path[] = "/new";
10934     char *r;
10935     suppress_error = 0;
10936     r = guestfs_cat (g, path);
10937     if (r == NULL)
10938       return -1;
10939     if (strcmp (r, expected) != 0) {
10940       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10941       return -1;
10942     }
10943     free (r);
10944   }
10945   return 0;
10946 }
10947
10948 static int test_write_file_2_skip (void)
10949 {
10950   const char *str;
10951
10952   str = getenv ("SKIP_TEST_WRITE_FILE_2");
10953   if (str && strcmp (str, "1") == 0) return 1;
10954   str = getenv ("SKIP_TEST_WRITE_FILE");
10955   if (str && strcmp (str, "1") == 0) return 1;
10956   return 0;
10957 }
10958
10959 static int test_write_file_2 (void)
10960 {
10961   if (test_write_file_2_skip ()) {
10962     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10963     return 0;
10964   }
10965
10966   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10967   {
10968     char device[] = "/dev/sda";
10969     device[5] = devchar;
10970     int r;
10971     suppress_error = 0;
10972     r = guestfs_blockdev_setrw (g, device);
10973     if (r == -1)
10974       return -1;
10975   }
10976   {
10977     int r;
10978     suppress_error = 0;
10979     r = guestfs_umount_all (g);
10980     if (r == -1)
10981       return -1;
10982   }
10983   {
10984     int r;
10985     suppress_error = 0;
10986     r = guestfs_lvm_remove_all (g);
10987     if (r == -1)
10988       return -1;
10989   }
10990   {
10991     char device[] = "/dev/sda";
10992     device[5] = devchar;
10993     char lines_0[] = ",";
10994     char *lines[] = {
10995       lines_0,
10996       NULL
10997     };
10998     int r;
10999     suppress_error = 0;
11000     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11001     if (r == -1)
11002       return -1;
11003   }
11004   {
11005     char fstype[] = "ext2";
11006     char device[] = "/dev/sda1";
11007     device[5] = devchar;
11008     int r;
11009     suppress_error = 0;
11010     r = guestfs_mkfs (g, fstype, device);
11011     if (r == -1)
11012       return -1;
11013   }
11014   {
11015     char device[] = "/dev/sda1";
11016     device[5] = devchar;
11017     char mountpoint[] = "/";
11018     int r;
11019     suppress_error = 0;
11020     r = guestfs_mount (g, device, mountpoint);
11021     if (r == -1)
11022       return -1;
11023   }
11024   /* TestOutput for write_file (2) */
11025   char expected[] = "\n\n";
11026   {
11027     char path[] = "/new";
11028     char content[] = "\n\n";
11029     int r;
11030     suppress_error = 0;
11031     r = guestfs_write_file (g, path, content, 0);
11032     if (r == -1)
11033       return -1;
11034   }
11035   {
11036     char path[] = "/new";
11037     char *r;
11038     suppress_error = 0;
11039     r = guestfs_cat (g, path);
11040     if (r == NULL)
11041       return -1;
11042     if (strcmp (r, expected) != 0) {
11043       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11044       return -1;
11045     }
11046     free (r);
11047   }
11048   return 0;
11049 }
11050
11051 static int test_write_file_3_skip (void)
11052 {
11053   const char *str;
11054
11055   str = getenv ("SKIP_TEST_WRITE_FILE_3");
11056   if (str && strcmp (str, "1") == 0) return 1;
11057   str = getenv ("SKIP_TEST_WRITE_FILE");
11058   if (str && strcmp (str, "1") == 0) return 1;
11059   return 0;
11060 }
11061
11062 static int test_write_file_3 (void)
11063 {
11064   if (test_write_file_3_skip ()) {
11065     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11066     return 0;
11067   }
11068
11069   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11070   {
11071     char device[] = "/dev/sda";
11072     device[5] = devchar;
11073     int r;
11074     suppress_error = 0;
11075     r = guestfs_blockdev_setrw (g, device);
11076     if (r == -1)
11077       return -1;
11078   }
11079   {
11080     int r;
11081     suppress_error = 0;
11082     r = guestfs_umount_all (g);
11083     if (r == -1)
11084       return -1;
11085   }
11086   {
11087     int r;
11088     suppress_error = 0;
11089     r = guestfs_lvm_remove_all (g);
11090     if (r == -1)
11091       return -1;
11092   }
11093   {
11094     char device[] = "/dev/sda";
11095     device[5] = devchar;
11096     char lines_0[] = ",";
11097     char *lines[] = {
11098       lines_0,
11099       NULL
11100     };
11101     int r;
11102     suppress_error = 0;
11103     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11104     if (r == -1)
11105       return -1;
11106   }
11107   {
11108     char fstype[] = "ext2";
11109     char device[] = "/dev/sda1";
11110     device[5] = devchar;
11111     int r;
11112     suppress_error = 0;
11113     r = guestfs_mkfs (g, fstype, device);
11114     if (r == -1)
11115       return -1;
11116   }
11117   {
11118     char device[] = "/dev/sda1";
11119     device[5] = devchar;
11120     char mountpoint[] = "/";
11121     int r;
11122     suppress_error = 0;
11123     r = guestfs_mount (g, device, mountpoint);
11124     if (r == -1)
11125       return -1;
11126   }
11127   /* TestOutput for write_file (3) */
11128   char expected[] = "";
11129   {
11130     char path[] = "/new";
11131     char content[] = "";
11132     int r;
11133     suppress_error = 0;
11134     r = guestfs_write_file (g, path, content, 0);
11135     if (r == -1)
11136       return -1;
11137   }
11138   {
11139     char path[] = "/new";
11140     char *r;
11141     suppress_error = 0;
11142     r = guestfs_cat (g, path);
11143     if (r == NULL)
11144       return -1;
11145     if (strcmp (r, expected) != 0) {
11146       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11147       return -1;
11148     }
11149     free (r);
11150   }
11151   return 0;
11152 }
11153
11154 static int test_write_file_4_skip (void)
11155 {
11156   const char *str;
11157
11158   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11159   if (str && strcmp (str, "1") == 0) return 1;
11160   str = getenv ("SKIP_TEST_WRITE_FILE");
11161   if (str && strcmp (str, "1") == 0) return 1;
11162   return 0;
11163 }
11164
11165 static int test_write_file_4 (void)
11166 {
11167   if (test_write_file_4_skip ()) {
11168     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11169     return 0;
11170   }
11171
11172   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11173   {
11174     char device[] = "/dev/sda";
11175     device[5] = devchar;
11176     int r;
11177     suppress_error = 0;
11178     r = guestfs_blockdev_setrw (g, device);
11179     if (r == -1)
11180       return -1;
11181   }
11182   {
11183     int r;
11184     suppress_error = 0;
11185     r = guestfs_umount_all (g);
11186     if (r == -1)
11187       return -1;
11188   }
11189   {
11190     int r;
11191     suppress_error = 0;
11192     r = guestfs_lvm_remove_all (g);
11193     if (r == -1)
11194       return -1;
11195   }
11196   {
11197     char device[] = "/dev/sda";
11198     device[5] = devchar;
11199     char lines_0[] = ",";
11200     char *lines[] = {
11201       lines_0,
11202       NULL
11203     };
11204     int r;
11205     suppress_error = 0;
11206     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11207     if (r == -1)
11208       return -1;
11209   }
11210   {
11211     char fstype[] = "ext2";
11212     char device[] = "/dev/sda1";
11213     device[5] = devchar;
11214     int r;
11215     suppress_error = 0;
11216     r = guestfs_mkfs (g, fstype, device);
11217     if (r == -1)
11218       return -1;
11219   }
11220   {
11221     char device[] = "/dev/sda1";
11222     device[5] = devchar;
11223     char mountpoint[] = "/";
11224     int r;
11225     suppress_error = 0;
11226     r = guestfs_mount (g, device, mountpoint);
11227     if (r == -1)
11228       return -1;
11229   }
11230   /* TestOutput for write_file (4) */
11231   char expected[] = "\n\n\n";
11232   {
11233     char path[] = "/new";
11234     char content[] = "\n\n\n";
11235     int r;
11236     suppress_error = 0;
11237     r = guestfs_write_file (g, path, content, 0);
11238     if (r == -1)
11239       return -1;
11240   }
11241   {
11242     char path[] = "/new";
11243     char *r;
11244     suppress_error = 0;
11245     r = guestfs_cat (g, path);
11246     if (r == NULL)
11247       return -1;
11248     if (strcmp (r, expected) != 0) {
11249       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11250       return -1;
11251     }
11252     free (r);
11253   }
11254   return 0;
11255 }
11256
11257 static int test_write_file_5_skip (void)
11258 {
11259   const char *str;
11260
11261   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11262   if (str && strcmp (str, "1") == 0) return 1;
11263   str = getenv ("SKIP_TEST_WRITE_FILE");
11264   if (str && strcmp (str, "1") == 0) return 1;
11265   return 0;
11266 }
11267
11268 static int test_write_file_5 (void)
11269 {
11270   if (test_write_file_5_skip ()) {
11271     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11272     return 0;
11273   }
11274
11275   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11276   {
11277     char device[] = "/dev/sda";
11278     device[5] = devchar;
11279     int r;
11280     suppress_error = 0;
11281     r = guestfs_blockdev_setrw (g, device);
11282     if (r == -1)
11283       return -1;
11284   }
11285   {
11286     int r;
11287     suppress_error = 0;
11288     r = guestfs_umount_all (g);
11289     if (r == -1)
11290       return -1;
11291   }
11292   {
11293     int r;
11294     suppress_error = 0;
11295     r = guestfs_lvm_remove_all (g);
11296     if (r == -1)
11297       return -1;
11298   }
11299   {
11300     char device[] = "/dev/sda";
11301     device[5] = devchar;
11302     char lines_0[] = ",";
11303     char *lines[] = {
11304       lines_0,
11305       NULL
11306     };
11307     int r;
11308     suppress_error = 0;
11309     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11310     if (r == -1)
11311       return -1;
11312   }
11313   {
11314     char fstype[] = "ext2";
11315     char device[] = "/dev/sda1";
11316     device[5] = devchar;
11317     int r;
11318     suppress_error = 0;
11319     r = guestfs_mkfs (g, fstype, device);
11320     if (r == -1)
11321       return -1;
11322   }
11323   {
11324     char device[] = "/dev/sda1";
11325     device[5] = devchar;
11326     char mountpoint[] = "/";
11327     int r;
11328     suppress_error = 0;
11329     r = guestfs_mount (g, device, mountpoint);
11330     if (r == -1)
11331       return -1;
11332   }
11333   /* TestOutput for write_file (5) */
11334   char expected[] = "\n";
11335   {
11336     char path[] = "/new";
11337     char content[] = "\n";
11338     int r;
11339     suppress_error = 0;
11340     r = guestfs_write_file (g, path, content, 0);
11341     if (r == -1)
11342       return -1;
11343   }
11344   {
11345     char path[] = "/new";
11346     char *r;
11347     suppress_error = 0;
11348     r = guestfs_cat (g, path);
11349     if (r == NULL)
11350       return -1;
11351     if (strcmp (r, expected) != 0) {
11352       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11353       return -1;
11354     }
11355     free (r);
11356   }
11357   return 0;
11358 }
11359
11360 static int test_mkfs_0_skip (void)
11361 {
11362   const char *str;
11363
11364   str = getenv ("SKIP_TEST_MKFS_0");
11365   if (str && strcmp (str, "1") == 0) return 1;
11366   str = getenv ("SKIP_TEST_MKFS");
11367   if (str && strcmp (str, "1") == 0) return 1;
11368   return 0;
11369 }
11370
11371 static int test_mkfs_0 (void)
11372 {
11373   if (test_mkfs_0_skip ()) {
11374     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11375     return 0;
11376   }
11377
11378   /* InitNone|InitEmpty for test_mkfs_0 */
11379   {
11380     char device[] = "/dev/sda";
11381     device[5] = devchar;
11382     int r;
11383     suppress_error = 0;
11384     r = guestfs_blockdev_setrw (g, device);
11385     if (r == -1)
11386       return -1;
11387   }
11388   {
11389     int r;
11390     suppress_error = 0;
11391     r = guestfs_umount_all (g);
11392     if (r == -1)
11393       return -1;
11394   }
11395   {
11396     int r;
11397     suppress_error = 0;
11398     r = guestfs_lvm_remove_all (g);
11399     if (r == -1)
11400       return -1;
11401   }
11402   /* TestOutput for mkfs (0) */
11403   char expected[] = "new file contents";
11404   {
11405     char device[] = "/dev/sda";
11406     device[5] = devchar;
11407     char lines_0[] = ",";
11408     char *lines[] = {
11409       lines_0,
11410       NULL
11411     };
11412     int r;
11413     suppress_error = 0;
11414     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11415     if (r == -1)
11416       return -1;
11417   }
11418   {
11419     char fstype[] = "ext2";
11420     char device[] = "/dev/sda1";
11421     device[5] = devchar;
11422     int r;
11423     suppress_error = 0;
11424     r = guestfs_mkfs (g, fstype, device);
11425     if (r == -1)
11426       return -1;
11427   }
11428   {
11429     char device[] = "/dev/sda1";
11430     device[5] = devchar;
11431     char mountpoint[] = "/";
11432     int r;
11433     suppress_error = 0;
11434     r = guestfs_mount (g, device, mountpoint);
11435     if (r == -1)
11436       return -1;
11437   }
11438   {
11439     char path[] = "/new";
11440     char content[] = "new file contents";
11441     int r;
11442     suppress_error = 0;
11443     r = guestfs_write_file (g, path, content, 0);
11444     if (r == -1)
11445       return -1;
11446   }
11447   {
11448     char path[] = "/new";
11449     char *r;
11450     suppress_error = 0;
11451     r = guestfs_cat (g, path);
11452     if (r == NULL)
11453       return -1;
11454     if (strcmp (r, expected) != 0) {
11455       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11456       return -1;
11457     }
11458     free (r);
11459   }
11460   return 0;
11461 }
11462
11463 static int test_lvcreate_0_skip (void)
11464 {
11465   const char *str;
11466
11467   str = getenv ("SKIP_TEST_LVCREATE_0");
11468   if (str && strcmp (str, "1") == 0) return 1;
11469   str = getenv ("SKIP_TEST_LVCREATE");
11470   if (str && strcmp (str, "1") == 0) return 1;
11471   return 0;
11472 }
11473
11474 static int test_lvcreate_0 (void)
11475 {
11476   if (test_lvcreate_0_skip ()) {
11477     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11478     return 0;
11479   }
11480
11481   /* InitNone|InitEmpty for test_lvcreate_0 */
11482   {
11483     char device[] = "/dev/sda";
11484     device[5] = devchar;
11485     int r;
11486     suppress_error = 0;
11487     r = guestfs_blockdev_setrw (g, device);
11488     if (r == -1)
11489       return -1;
11490   }
11491   {
11492     int r;
11493     suppress_error = 0;
11494     r = guestfs_umount_all (g);
11495     if (r == -1)
11496       return -1;
11497   }
11498   {
11499     int r;
11500     suppress_error = 0;
11501     r = guestfs_lvm_remove_all (g);
11502     if (r == -1)
11503       return -1;
11504   }
11505   /* TestOutputList for lvcreate (0) */
11506   {
11507     char device[] = "/dev/sda";
11508     device[5] = devchar;
11509     char lines_0[] = ",10";
11510     char lines_1[] = ",20";
11511     char lines_2[] = ",";
11512     char *lines[] = {
11513       lines_0,
11514       lines_1,
11515       lines_2,
11516       NULL
11517     };
11518     int r;
11519     suppress_error = 0;
11520     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11521     if (r == -1)
11522       return -1;
11523   }
11524   {
11525     char device[] = "/dev/sda1";
11526     device[5] = devchar;
11527     int r;
11528     suppress_error = 0;
11529     r = guestfs_pvcreate (g, device);
11530     if (r == -1)
11531       return -1;
11532   }
11533   {
11534     char device[] = "/dev/sda2";
11535     device[5] = devchar;
11536     int r;
11537     suppress_error = 0;
11538     r = guestfs_pvcreate (g, device);
11539     if (r == -1)
11540       return -1;
11541   }
11542   {
11543     char device[] = "/dev/sda3";
11544     device[5] = devchar;
11545     int r;
11546     suppress_error = 0;
11547     r = guestfs_pvcreate (g, device);
11548     if (r == -1)
11549       return -1;
11550   }
11551   {
11552     char volgroup[] = "VG1";
11553     char physvols_0[] = "/dev/sda1";
11554     physvols_0[5] = devchar;
11555     char physvols_1[] = "/dev/sda2";
11556     physvols_1[5] = devchar;
11557     char *physvols[] = {
11558       physvols_0,
11559       physvols_1,
11560       NULL
11561     };
11562     int r;
11563     suppress_error = 0;
11564     r = guestfs_vgcreate (g, volgroup, physvols);
11565     if (r == -1)
11566       return -1;
11567   }
11568   {
11569     char volgroup[] = "VG2";
11570     char physvols_0[] = "/dev/sda3";
11571     physvols_0[5] = devchar;
11572     char *physvols[] = {
11573       physvols_0,
11574       NULL
11575     };
11576     int r;
11577     suppress_error = 0;
11578     r = guestfs_vgcreate (g, volgroup, physvols);
11579     if (r == -1)
11580       return -1;
11581   }
11582   {
11583     char logvol[] = "LV1";
11584     char volgroup[] = "VG1";
11585     int r;
11586     suppress_error = 0;
11587     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11588     if (r == -1)
11589       return -1;
11590   }
11591   {
11592     char logvol[] = "LV2";
11593     char volgroup[] = "VG1";
11594     int r;
11595     suppress_error = 0;
11596     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11597     if (r == -1)
11598       return -1;
11599   }
11600   {
11601     char logvol[] = "LV3";
11602     char volgroup[] = "VG2";
11603     int r;
11604     suppress_error = 0;
11605     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11606     if (r == -1)
11607       return -1;
11608   }
11609   {
11610     char logvol[] = "LV4";
11611     char volgroup[] = "VG2";
11612     int r;
11613     suppress_error = 0;
11614     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11615     if (r == -1)
11616       return -1;
11617   }
11618   {
11619     char logvol[] = "LV5";
11620     char volgroup[] = "VG2";
11621     int r;
11622     suppress_error = 0;
11623     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11624     if (r == -1)
11625       return -1;
11626   }
11627   {
11628     char **r;
11629     int i;
11630     suppress_error = 0;
11631     r = guestfs_lvs (g);
11632     if (r == NULL)
11633       return -1;
11634     if (!r[0]) {
11635       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11636       print_strings (r);
11637       return -1;
11638     }
11639     {
11640       char expected[] = "/dev/VG1/LV1";
11641       if (strcmp (r[0], expected) != 0) {
11642         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11643         return -1;
11644       }
11645     }
11646     if (!r[1]) {
11647       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11648       print_strings (r);
11649       return -1;
11650     }
11651     {
11652       char expected[] = "/dev/VG1/LV2";
11653       if (strcmp (r[1], expected) != 0) {
11654         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11655         return -1;
11656       }
11657     }
11658     if (!r[2]) {
11659       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11660       print_strings (r);
11661       return -1;
11662     }
11663     {
11664       char expected[] = "/dev/VG2/LV3";
11665       if (strcmp (r[2], expected) != 0) {
11666         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11667         return -1;
11668       }
11669     }
11670     if (!r[3]) {
11671       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11672       print_strings (r);
11673       return -1;
11674     }
11675     {
11676       char expected[] = "/dev/VG2/LV4";
11677       if (strcmp (r[3], expected) != 0) {
11678         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11679         return -1;
11680       }
11681     }
11682     if (!r[4]) {
11683       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11684       print_strings (r);
11685       return -1;
11686     }
11687     {
11688       char expected[] = "/dev/VG2/LV5";
11689       if (strcmp (r[4], expected) != 0) {
11690         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11691         return -1;
11692       }
11693     }
11694     if (r[5] != NULL) {
11695       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11696       print_strings (r);
11697       return -1;
11698     }
11699     for (i = 0; r[i] != NULL; ++i)
11700       free (r[i]);
11701     free (r);
11702   }
11703   return 0;
11704 }
11705
11706 static int test_vgcreate_0_skip (void)
11707 {
11708   const char *str;
11709
11710   str = getenv ("SKIP_TEST_VGCREATE_0");
11711   if (str && strcmp (str, "1") == 0) return 1;
11712   str = getenv ("SKIP_TEST_VGCREATE");
11713   if (str && strcmp (str, "1") == 0) return 1;
11714   return 0;
11715 }
11716
11717 static int test_vgcreate_0 (void)
11718 {
11719   if (test_vgcreate_0_skip ()) {
11720     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11721     return 0;
11722   }
11723
11724   /* InitNone|InitEmpty for test_vgcreate_0 */
11725   {
11726     char device[] = "/dev/sda";
11727     device[5] = devchar;
11728     int r;
11729     suppress_error = 0;
11730     r = guestfs_blockdev_setrw (g, device);
11731     if (r == -1)
11732       return -1;
11733   }
11734   {
11735     int r;
11736     suppress_error = 0;
11737     r = guestfs_umount_all (g);
11738     if (r == -1)
11739       return -1;
11740   }
11741   {
11742     int r;
11743     suppress_error = 0;
11744     r = guestfs_lvm_remove_all (g);
11745     if (r == -1)
11746       return -1;
11747   }
11748   /* TestOutputList for vgcreate (0) */
11749   {
11750     char device[] = "/dev/sda";
11751     device[5] = devchar;
11752     char lines_0[] = ",10";
11753     char lines_1[] = ",20";
11754     char lines_2[] = ",";
11755     char *lines[] = {
11756       lines_0,
11757       lines_1,
11758       lines_2,
11759       NULL
11760     };
11761     int r;
11762     suppress_error = 0;
11763     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11764     if (r == -1)
11765       return -1;
11766   }
11767   {
11768     char device[] = "/dev/sda1";
11769     device[5] = devchar;
11770     int r;
11771     suppress_error = 0;
11772     r = guestfs_pvcreate (g, device);
11773     if (r == -1)
11774       return -1;
11775   }
11776   {
11777     char device[] = "/dev/sda2";
11778     device[5] = devchar;
11779     int r;
11780     suppress_error = 0;
11781     r = guestfs_pvcreate (g, device);
11782     if (r == -1)
11783       return -1;
11784   }
11785   {
11786     char device[] = "/dev/sda3";
11787     device[5] = devchar;
11788     int r;
11789     suppress_error = 0;
11790     r = guestfs_pvcreate (g, device);
11791     if (r == -1)
11792       return -1;
11793   }
11794   {
11795     char volgroup[] = "VG1";
11796     char physvols_0[] = "/dev/sda1";
11797     physvols_0[5] = devchar;
11798     char physvols_1[] = "/dev/sda2";
11799     physvols_1[5] = devchar;
11800     char *physvols[] = {
11801       physvols_0,
11802       physvols_1,
11803       NULL
11804     };
11805     int r;
11806     suppress_error = 0;
11807     r = guestfs_vgcreate (g, volgroup, physvols);
11808     if (r == -1)
11809       return -1;
11810   }
11811   {
11812     char volgroup[] = "VG2";
11813     char physvols_0[] = "/dev/sda3";
11814     physvols_0[5] = devchar;
11815     char *physvols[] = {
11816       physvols_0,
11817       NULL
11818     };
11819     int r;
11820     suppress_error = 0;
11821     r = guestfs_vgcreate (g, volgroup, physvols);
11822     if (r == -1)
11823       return -1;
11824   }
11825   {
11826     char **r;
11827     int i;
11828     suppress_error = 0;
11829     r = guestfs_vgs (g);
11830     if (r == NULL)
11831       return -1;
11832     if (!r[0]) {
11833       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11834       print_strings (r);
11835       return -1;
11836     }
11837     {
11838       char expected[] = "VG1";
11839       if (strcmp (r[0], expected) != 0) {
11840         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11841         return -1;
11842       }
11843     }
11844     if (!r[1]) {
11845       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11846       print_strings (r);
11847       return -1;
11848     }
11849     {
11850       char expected[] = "VG2";
11851       if (strcmp (r[1], expected) != 0) {
11852         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11853         return -1;
11854       }
11855     }
11856     if (r[2] != NULL) {
11857       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11858       print_strings (r);
11859       return -1;
11860     }
11861     for (i = 0; r[i] != NULL; ++i)
11862       free (r[i]);
11863     free (r);
11864   }
11865   return 0;
11866 }
11867
11868 static int test_pvcreate_0_skip (void)
11869 {
11870   const char *str;
11871
11872   str = getenv ("SKIP_TEST_PVCREATE_0");
11873   if (str && strcmp (str, "1") == 0) return 1;
11874   str = getenv ("SKIP_TEST_PVCREATE");
11875   if (str && strcmp (str, "1") == 0) return 1;
11876   return 0;
11877 }
11878
11879 static int test_pvcreate_0 (void)
11880 {
11881   if (test_pvcreate_0_skip ()) {
11882     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11883     return 0;
11884   }
11885
11886   /* InitNone|InitEmpty for test_pvcreate_0 */
11887   {
11888     char device[] = "/dev/sda";
11889     device[5] = devchar;
11890     int r;
11891     suppress_error = 0;
11892     r = guestfs_blockdev_setrw (g, device);
11893     if (r == -1)
11894       return -1;
11895   }
11896   {
11897     int r;
11898     suppress_error = 0;
11899     r = guestfs_umount_all (g);
11900     if (r == -1)
11901       return -1;
11902   }
11903   {
11904     int r;
11905     suppress_error = 0;
11906     r = guestfs_lvm_remove_all (g);
11907     if (r == -1)
11908       return -1;
11909   }
11910   /* TestOutputList for pvcreate (0) */
11911   {
11912     char device[] = "/dev/sda";
11913     device[5] = devchar;
11914     char lines_0[] = ",10";
11915     char lines_1[] = ",20";
11916     char lines_2[] = ",";
11917     char *lines[] = {
11918       lines_0,
11919       lines_1,
11920       lines_2,
11921       NULL
11922     };
11923     int r;
11924     suppress_error = 0;
11925     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11926     if (r == -1)
11927       return -1;
11928   }
11929   {
11930     char device[] = "/dev/sda1";
11931     device[5] = devchar;
11932     int r;
11933     suppress_error = 0;
11934     r = guestfs_pvcreate (g, device);
11935     if (r == -1)
11936       return -1;
11937   }
11938   {
11939     char device[] = "/dev/sda2";
11940     device[5] = devchar;
11941     int r;
11942     suppress_error = 0;
11943     r = guestfs_pvcreate (g, device);
11944     if (r == -1)
11945       return -1;
11946   }
11947   {
11948     char device[] = "/dev/sda3";
11949     device[5] = devchar;
11950     int r;
11951     suppress_error = 0;
11952     r = guestfs_pvcreate (g, device);
11953     if (r == -1)
11954       return -1;
11955   }
11956   {
11957     char **r;
11958     int i;
11959     suppress_error = 0;
11960     r = guestfs_pvs (g);
11961     if (r == NULL)
11962       return -1;
11963     if (!r[0]) {
11964       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11965       print_strings (r);
11966       return -1;
11967     }
11968     {
11969       char expected[] = "/dev/sda1";
11970       expected[5] = devchar;
11971       if (strcmp (r[0], expected) != 0) {
11972         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11973         return -1;
11974       }
11975     }
11976     if (!r[1]) {
11977       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11978       print_strings (r);
11979       return -1;
11980     }
11981     {
11982       char expected[] = "/dev/sda2";
11983       expected[5] = devchar;
11984       if (strcmp (r[1], expected) != 0) {
11985         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11986         return -1;
11987       }
11988     }
11989     if (!r[2]) {
11990       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11991       print_strings (r);
11992       return -1;
11993     }
11994     {
11995       char expected[] = "/dev/sda3";
11996       expected[5] = devchar;
11997       if (strcmp (r[2], expected) != 0) {
11998         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11999         return -1;
12000       }
12001     }
12002     if (r[3] != NULL) {
12003       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12004       print_strings (r);
12005       return -1;
12006     }
12007     for (i = 0; r[i] != NULL; ++i)
12008       free (r[i]);
12009     free (r);
12010   }
12011   return 0;
12012 }
12013
12014 static int test_is_dir_0_skip (void)
12015 {
12016   const char *str;
12017
12018   str = getenv ("SKIP_TEST_IS_DIR_0");
12019   if (str && strcmp (str, "1") == 0) return 1;
12020   str = getenv ("SKIP_TEST_IS_DIR");
12021   if (str && strcmp (str, "1") == 0) return 1;
12022   return 0;
12023 }
12024
12025 static int test_is_dir_0 (void)
12026 {
12027   if (test_is_dir_0_skip ()) {
12028     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12029     return 0;
12030   }
12031
12032   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12033   {
12034     char device[] = "/dev/sda";
12035     device[5] = devchar;
12036     int r;
12037     suppress_error = 0;
12038     r = guestfs_blockdev_setrw (g, device);
12039     if (r == -1)
12040       return -1;
12041   }
12042   {
12043     int r;
12044     suppress_error = 0;
12045     r = guestfs_umount_all (g);
12046     if (r == -1)
12047       return -1;
12048   }
12049   {
12050     int r;
12051     suppress_error = 0;
12052     r = guestfs_lvm_remove_all (g);
12053     if (r == -1)
12054       return -1;
12055   }
12056   {
12057     char device[] = "/dev/sda";
12058     device[5] = devchar;
12059     char lines_0[] = ",";
12060     char *lines[] = {
12061       lines_0,
12062       NULL
12063     };
12064     int r;
12065     suppress_error = 0;
12066     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12067     if (r == -1)
12068       return -1;
12069   }
12070   {
12071     char fstype[] = "ext2";
12072     char device[] = "/dev/sda1";
12073     device[5] = devchar;
12074     int r;
12075     suppress_error = 0;
12076     r = guestfs_mkfs (g, fstype, device);
12077     if (r == -1)
12078       return -1;
12079   }
12080   {
12081     char device[] = "/dev/sda1";
12082     device[5] = devchar;
12083     char mountpoint[] = "/";
12084     int r;
12085     suppress_error = 0;
12086     r = guestfs_mount (g, device, mountpoint);
12087     if (r == -1)
12088       return -1;
12089   }
12090   /* TestOutputFalse for is_dir (0) */
12091   {
12092     char path[] = "/new";
12093     int r;
12094     suppress_error = 0;
12095     r = guestfs_touch (g, path);
12096     if (r == -1)
12097       return -1;
12098   }
12099   {
12100     char path[] = "/new";
12101     int r;
12102     suppress_error = 0;
12103     r = guestfs_is_dir (g, path);
12104     if (r == -1)
12105       return -1;
12106     if (r) {
12107       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12108       return -1;
12109     }
12110   }
12111   return 0;
12112 }
12113
12114 static int test_is_dir_1_skip (void)
12115 {
12116   const char *str;
12117
12118   str = getenv ("SKIP_TEST_IS_DIR_1");
12119   if (str && strcmp (str, "1") == 0) return 1;
12120   str = getenv ("SKIP_TEST_IS_DIR");
12121   if (str && strcmp (str, "1") == 0) return 1;
12122   return 0;
12123 }
12124
12125 static int test_is_dir_1 (void)
12126 {
12127   if (test_is_dir_1_skip ()) {
12128     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12129     return 0;
12130   }
12131
12132   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12133   {
12134     char device[] = "/dev/sda";
12135     device[5] = devchar;
12136     int r;
12137     suppress_error = 0;
12138     r = guestfs_blockdev_setrw (g, device);
12139     if (r == -1)
12140       return -1;
12141   }
12142   {
12143     int r;
12144     suppress_error = 0;
12145     r = guestfs_umount_all (g);
12146     if (r == -1)
12147       return -1;
12148   }
12149   {
12150     int r;
12151     suppress_error = 0;
12152     r = guestfs_lvm_remove_all (g);
12153     if (r == -1)
12154       return -1;
12155   }
12156   {
12157     char device[] = "/dev/sda";
12158     device[5] = devchar;
12159     char lines_0[] = ",";
12160     char *lines[] = {
12161       lines_0,
12162       NULL
12163     };
12164     int r;
12165     suppress_error = 0;
12166     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12167     if (r == -1)
12168       return -1;
12169   }
12170   {
12171     char fstype[] = "ext2";
12172     char device[] = "/dev/sda1";
12173     device[5] = devchar;
12174     int r;
12175     suppress_error = 0;
12176     r = guestfs_mkfs (g, fstype, device);
12177     if (r == -1)
12178       return -1;
12179   }
12180   {
12181     char device[] = "/dev/sda1";
12182     device[5] = devchar;
12183     char mountpoint[] = "/";
12184     int r;
12185     suppress_error = 0;
12186     r = guestfs_mount (g, device, mountpoint);
12187     if (r == -1)
12188       return -1;
12189   }
12190   /* TestOutputTrue for is_dir (1) */
12191   {
12192     char path[] = "/new";
12193     int r;
12194     suppress_error = 0;
12195     r = guestfs_mkdir (g, path);
12196     if (r == -1)
12197       return -1;
12198   }
12199   {
12200     char path[] = "/new";
12201     int r;
12202     suppress_error = 0;
12203     r = guestfs_is_dir (g, path);
12204     if (r == -1)
12205       return -1;
12206     if (!r) {
12207       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12208       return -1;
12209     }
12210   }
12211   return 0;
12212 }
12213
12214 static int test_is_file_0_skip (void)
12215 {
12216   const char *str;
12217
12218   str = getenv ("SKIP_TEST_IS_FILE_0");
12219   if (str && strcmp (str, "1") == 0) return 1;
12220   str = getenv ("SKIP_TEST_IS_FILE");
12221   if (str && strcmp (str, "1") == 0) return 1;
12222   return 0;
12223 }
12224
12225 static int test_is_file_0 (void)
12226 {
12227   if (test_is_file_0_skip ()) {
12228     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12229     return 0;
12230   }
12231
12232   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12233   {
12234     char device[] = "/dev/sda";
12235     device[5] = devchar;
12236     int r;
12237     suppress_error = 0;
12238     r = guestfs_blockdev_setrw (g, device);
12239     if (r == -1)
12240       return -1;
12241   }
12242   {
12243     int r;
12244     suppress_error = 0;
12245     r = guestfs_umount_all (g);
12246     if (r == -1)
12247       return -1;
12248   }
12249   {
12250     int r;
12251     suppress_error = 0;
12252     r = guestfs_lvm_remove_all (g);
12253     if (r == -1)
12254       return -1;
12255   }
12256   {
12257     char device[] = "/dev/sda";
12258     device[5] = devchar;
12259     char lines_0[] = ",";
12260     char *lines[] = {
12261       lines_0,
12262       NULL
12263     };
12264     int r;
12265     suppress_error = 0;
12266     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12267     if (r == -1)
12268       return -1;
12269   }
12270   {
12271     char fstype[] = "ext2";
12272     char device[] = "/dev/sda1";
12273     device[5] = devchar;
12274     int r;
12275     suppress_error = 0;
12276     r = guestfs_mkfs (g, fstype, device);
12277     if (r == -1)
12278       return -1;
12279   }
12280   {
12281     char device[] = "/dev/sda1";
12282     device[5] = devchar;
12283     char mountpoint[] = "/";
12284     int r;
12285     suppress_error = 0;
12286     r = guestfs_mount (g, device, mountpoint);
12287     if (r == -1)
12288       return -1;
12289   }
12290   /* TestOutputTrue for is_file (0) */
12291   {
12292     char path[] = "/new";
12293     int r;
12294     suppress_error = 0;
12295     r = guestfs_touch (g, path);
12296     if (r == -1)
12297       return -1;
12298   }
12299   {
12300     char path[] = "/new";
12301     int r;
12302     suppress_error = 0;
12303     r = guestfs_is_file (g, path);
12304     if (r == -1)
12305       return -1;
12306     if (!r) {
12307       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12308       return -1;
12309     }
12310   }
12311   return 0;
12312 }
12313
12314 static int test_is_file_1_skip (void)
12315 {
12316   const char *str;
12317
12318   str = getenv ("SKIP_TEST_IS_FILE_1");
12319   if (str && strcmp (str, "1") == 0) return 1;
12320   str = getenv ("SKIP_TEST_IS_FILE");
12321   if (str && strcmp (str, "1") == 0) return 1;
12322   return 0;
12323 }
12324
12325 static int test_is_file_1 (void)
12326 {
12327   if (test_is_file_1_skip ()) {
12328     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12329     return 0;
12330   }
12331
12332   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12333   {
12334     char device[] = "/dev/sda";
12335     device[5] = devchar;
12336     int r;
12337     suppress_error = 0;
12338     r = guestfs_blockdev_setrw (g, device);
12339     if (r == -1)
12340       return -1;
12341   }
12342   {
12343     int r;
12344     suppress_error = 0;
12345     r = guestfs_umount_all (g);
12346     if (r == -1)
12347       return -1;
12348   }
12349   {
12350     int r;
12351     suppress_error = 0;
12352     r = guestfs_lvm_remove_all (g);
12353     if (r == -1)
12354       return -1;
12355   }
12356   {
12357     char device[] = "/dev/sda";
12358     device[5] = devchar;
12359     char lines_0[] = ",";
12360     char *lines[] = {
12361       lines_0,
12362       NULL
12363     };
12364     int r;
12365     suppress_error = 0;
12366     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12367     if (r == -1)
12368       return -1;
12369   }
12370   {
12371     char fstype[] = "ext2";
12372     char device[] = "/dev/sda1";
12373     device[5] = devchar;
12374     int r;
12375     suppress_error = 0;
12376     r = guestfs_mkfs (g, fstype, device);
12377     if (r == -1)
12378       return -1;
12379   }
12380   {
12381     char device[] = "/dev/sda1";
12382     device[5] = devchar;
12383     char mountpoint[] = "/";
12384     int r;
12385     suppress_error = 0;
12386     r = guestfs_mount (g, device, mountpoint);
12387     if (r == -1)
12388       return -1;
12389   }
12390   /* TestOutputFalse for is_file (1) */
12391   {
12392     char path[] = "/new";
12393     int r;
12394     suppress_error = 0;
12395     r = guestfs_mkdir (g, path);
12396     if (r == -1)
12397       return -1;
12398   }
12399   {
12400     char path[] = "/new";
12401     int r;
12402     suppress_error = 0;
12403     r = guestfs_is_file (g, path);
12404     if (r == -1)
12405       return -1;
12406     if (r) {
12407       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12408       return -1;
12409     }
12410   }
12411   return 0;
12412 }
12413
12414 static int test_exists_0_skip (void)
12415 {
12416   const char *str;
12417
12418   str = getenv ("SKIP_TEST_EXISTS_0");
12419   if (str && strcmp (str, "1") == 0) return 1;
12420   str = getenv ("SKIP_TEST_EXISTS");
12421   if (str && strcmp (str, "1") == 0) return 1;
12422   return 0;
12423 }
12424
12425 static int test_exists_0 (void)
12426 {
12427   if (test_exists_0_skip ()) {
12428     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12429     return 0;
12430   }
12431
12432   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12433   {
12434     char device[] = "/dev/sda";
12435     device[5] = devchar;
12436     int r;
12437     suppress_error = 0;
12438     r = guestfs_blockdev_setrw (g, device);
12439     if (r == -1)
12440       return -1;
12441   }
12442   {
12443     int r;
12444     suppress_error = 0;
12445     r = guestfs_umount_all (g);
12446     if (r == -1)
12447       return -1;
12448   }
12449   {
12450     int r;
12451     suppress_error = 0;
12452     r = guestfs_lvm_remove_all (g);
12453     if (r == -1)
12454       return -1;
12455   }
12456   {
12457     char device[] = "/dev/sda";
12458     device[5] = devchar;
12459     char lines_0[] = ",";
12460     char *lines[] = {
12461       lines_0,
12462       NULL
12463     };
12464     int r;
12465     suppress_error = 0;
12466     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12467     if (r == -1)
12468       return -1;
12469   }
12470   {
12471     char fstype[] = "ext2";
12472     char device[] = "/dev/sda1";
12473     device[5] = devchar;
12474     int r;
12475     suppress_error = 0;
12476     r = guestfs_mkfs (g, fstype, device);
12477     if (r == -1)
12478       return -1;
12479   }
12480   {
12481     char device[] = "/dev/sda1";
12482     device[5] = devchar;
12483     char mountpoint[] = "/";
12484     int r;
12485     suppress_error = 0;
12486     r = guestfs_mount (g, device, mountpoint);
12487     if (r == -1)
12488       return -1;
12489   }
12490   /* TestOutputTrue for exists (0) */
12491   {
12492     char path[] = "/new";
12493     int r;
12494     suppress_error = 0;
12495     r = guestfs_touch (g, path);
12496     if (r == -1)
12497       return -1;
12498   }
12499   {
12500     char path[] = "/new";
12501     int r;
12502     suppress_error = 0;
12503     r = guestfs_exists (g, path);
12504     if (r == -1)
12505       return -1;
12506     if (!r) {
12507       fprintf (stderr, "test_exists_0: expected true, got false\n");
12508       return -1;
12509     }
12510   }
12511   return 0;
12512 }
12513
12514 static int test_exists_1_skip (void)
12515 {
12516   const char *str;
12517
12518   str = getenv ("SKIP_TEST_EXISTS_1");
12519   if (str && strcmp (str, "1") == 0) return 1;
12520   str = getenv ("SKIP_TEST_EXISTS");
12521   if (str && strcmp (str, "1") == 0) return 1;
12522   return 0;
12523 }
12524
12525 static int test_exists_1 (void)
12526 {
12527   if (test_exists_1_skip ()) {
12528     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12529     return 0;
12530   }
12531
12532   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12533   {
12534     char device[] = "/dev/sda";
12535     device[5] = devchar;
12536     int r;
12537     suppress_error = 0;
12538     r = guestfs_blockdev_setrw (g, device);
12539     if (r == -1)
12540       return -1;
12541   }
12542   {
12543     int r;
12544     suppress_error = 0;
12545     r = guestfs_umount_all (g);
12546     if (r == -1)
12547       return -1;
12548   }
12549   {
12550     int r;
12551     suppress_error = 0;
12552     r = guestfs_lvm_remove_all (g);
12553     if (r == -1)
12554       return -1;
12555   }
12556   {
12557     char device[] = "/dev/sda";
12558     device[5] = devchar;
12559     char lines_0[] = ",";
12560     char *lines[] = {
12561       lines_0,
12562       NULL
12563     };
12564     int r;
12565     suppress_error = 0;
12566     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12567     if (r == -1)
12568       return -1;
12569   }
12570   {
12571     char fstype[] = "ext2";
12572     char device[] = "/dev/sda1";
12573     device[5] = devchar;
12574     int r;
12575     suppress_error = 0;
12576     r = guestfs_mkfs (g, fstype, device);
12577     if (r == -1)
12578       return -1;
12579   }
12580   {
12581     char device[] = "/dev/sda1";
12582     device[5] = devchar;
12583     char mountpoint[] = "/";
12584     int r;
12585     suppress_error = 0;
12586     r = guestfs_mount (g, device, mountpoint);
12587     if (r == -1)
12588       return -1;
12589   }
12590   /* TestOutputTrue for exists (1) */
12591   {
12592     char path[] = "/new";
12593     int r;
12594     suppress_error = 0;
12595     r = guestfs_mkdir (g, path);
12596     if (r == -1)
12597       return -1;
12598   }
12599   {
12600     char path[] = "/new";
12601     int r;
12602     suppress_error = 0;
12603     r = guestfs_exists (g, path);
12604     if (r == -1)
12605       return -1;
12606     if (!r) {
12607       fprintf (stderr, "test_exists_1: expected true, got false\n");
12608       return -1;
12609     }
12610   }
12611   return 0;
12612 }
12613
12614 static int test_mkdir_p_0_skip (void)
12615 {
12616   const char *str;
12617
12618   str = getenv ("SKIP_TEST_MKDIR_P_0");
12619   if (str && strcmp (str, "1") == 0) return 1;
12620   str = getenv ("SKIP_TEST_MKDIR_P");
12621   if (str && strcmp (str, "1") == 0) return 1;
12622   return 0;
12623 }
12624
12625 static int test_mkdir_p_0 (void)
12626 {
12627   if (test_mkdir_p_0_skip ()) {
12628     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12629     return 0;
12630   }
12631
12632   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12633   {
12634     char device[] = "/dev/sda";
12635     device[5] = devchar;
12636     int r;
12637     suppress_error = 0;
12638     r = guestfs_blockdev_setrw (g, device);
12639     if (r == -1)
12640       return -1;
12641   }
12642   {
12643     int r;
12644     suppress_error = 0;
12645     r = guestfs_umount_all (g);
12646     if (r == -1)
12647       return -1;
12648   }
12649   {
12650     int r;
12651     suppress_error = 0;
12652     r = guestfs_lvm_remove_all (g);
12653     if (r == -1)
12654       return -1;
12655   }
12656   {
12657     char device[] = "/dev/sda";
12658     device[5] = devchar;
12659     char lines_0[] = ",";
12660     char *lines[] = {
12661       lines_0,
12662       NULL
12663     };
12664     int r;
12665     suppress_error = 0;
12666     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12667     if (r == -1)
12668       return -1;
12669   }
12670   {
12671     char fstype[] = "ext2";
12672     char device[] = "/dev/sda1";
12673     device[5] = devchar;
12674     int r;
12675     suppress_error = 0;
12676     r = guestfs_mkfs (g, fstype, device);
12677     if (r == -1)
12678       return -1;
12679   }
12680   {
12681     char device[] = "/dev/sda1";
12682     device[5] = devchar;
12683     char mountpoint[] = "/";
12684     int r;
12685     suppress_error = 0;
12686     r = guestfs_mount (g, device, mountpoint);
12687     if (r == -1)
12688       return -1;
12689   }
12690   /* TestOutputTrue for mkdir_p (0) */
12691   {
12692     char path[] = "/new/foo/bar";
12693     int r;
12694     suppress_error = 0;
12695     r = guestfs_mkdir_p (g, path);
12696     if (r == -1)
12697       return -1;
12698   }
12699   {
12700     char path[] = "/new/foo/bar";
12701     int r;
12702     suppress_error = 0;
12703     r = guestfs_is_dir (g, path);
12704     if (r == -1)
12705       return -1;
12706     if (!r) {
12707       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12708       return -1;
12709     }
12710   }
12711   return 0;
12712 }
12713
12714 static int test_mkdir_p_1_skip (void)
12715 {
12716   const char *str;
12717
12718   str = getenv ("SKIP_TEST_MKDIR_P_1");
12719   if (str && strcmp (str, "1") == 0) return 1;
12720   str = getenv ("SKIP_TEST_MKDIR_P");
12721   if (str && strcmp (str, "1") == 0) return 1;
12722   return 0;
12723 }
12724
12725 static int test_mkdir_p_1 (void)
12726 {
12727   if (test_mkdir_p_1_skip ()) {
12728     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12729     return 0;
12730   }
12731
12732   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12733   {
12734     char device[] = "/dev/sda";
12735     device[5] = devchar;
12736     int r;
12737     suppress_error = 0;
12738     r = guestfs_blockdev_setrw (g, device);
12739     if (r == -1)
12740       return -1;
12741   }
12742   {
12743     int r;
12744     suppress_error = 0;
12745     r = guestfs_umount_all (g);
12746     if (r == -1)
12747       return -1;
12748   }
12749   {
12750     int r;
12751     suppress_error = 0;
12752     r = guestfs_lvm_remove_all (g);
12753     if (r == -1)
12754       return -1;
12755   }
12756   {
12757     char device[] = "/dev/sda";
12758     device[5] = devchar;
12759     char lines_0[] = ",";
12760     char *lines[] = {
12761       lines_0,
12762       NULL
12763     };
12764     int r;
12765     suppress_error = 0;
12766     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12767     if (r == -1)
12768       return -1;
12769   }
12770   {
12771     char fstype[] = "ext2";
12772     char device[] = "/dev/sda1";
12773     device[5] = devchar;
12774     int r;
12775     suppress_error = 0;
12776     r = guestfs_mkfs (g, fstype, device);
12777     if (r == -1)
12778       return -1;
12779   }
12780   {
12781     char device[] = "/dev/sda1";
12782     device[5] = devchar;
12783     char mountpoint[] = "/";
12784     int r;
12785     suppress_error = 0;
12786     r = guestfs_mount (g, device, mountpoint);
12787     if (r == -1)
12788       return -1;
12789   }
12790   /* TestOutputTrue for mkdir_p (1) */
12791   {
12792     char path[] = "/new/foo/bar";
12793     int r;
12794     suppress_error = 0;
12795     r = guestfs_mkdir_p (g, path);
12796     if (r == -1)
12797       return -1;
12798   }
12799   {
12800     char path[] = "/new/foo";
12801     int r;
12802     suppress_error = 0;
12803     r = guestfs_is_dir (g, path);
12804     if (r == -1)
12805       return -1;
12806     if (!r) {
12807       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12808       return -1;
12809     }
12810   }
12811   return 0;
12812 }
12813
12814 static int test_mkdir_p_2_skip (void)
12815 {
12816   const char *str;
12817
12818   str = getenv ("SKIP_TEST_MKDIR_P_2");
12819   if (str && strcmp (str, "1") == 0) return 1;
12820   str = getenv ("SKIP_TEST_MKDIR_P");
12821   if (str && strcmp (str, "1") == 0) return 1;
12822   return 0;
12823 }
12824
12825 static int test_mkdir_p_2 (void)
12826 {
12827   if (test_mkdir_p_2_skip ()) {
12828     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12829     return 0;
12830   }
12831
12832   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12833   {
12834     char device[] = "/dev/sda";
12835     device[5] = devchar;
12836     int r;
12837     suppress_error = 0;
12838     r = guestfs_blockdev_setrw (g, device);
12839     if (r == -1)
12840       return -1;
12841   }
12842   {
12843     int r;
12844     suppress_error = 0;
12845     r = guestfs_umount_all (g);
12846     if (r == -1)
12847       return -1;
12848   }
12849   {
12850     int r;
12851     suppress_error = 0;
12852     r = guestfs_lvm_remove_all (g);
12853     if (r == -1)
12854       return -1;
12855   }
12856   {
12857     char device[] = "/dev/sda";
12858     device[5] = devchar;
12859     char lines_0[] = ",";
12860     char *lines[] = {
12861       lines_0,
12862       NULL
12863     };
12864     int r;
12865     suppress_error = 0;
12866     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12867     if (r == -1)
12868       return -1;
12869   }
12870   {
12871     char fstype[] = "ext2";
12872     char device[] = "/dev/sda1";
12873     device[5] = devchar;
12874     int r;
12875     suppress_error = 0;
12876     r = guestfs_mkfs (g, fstype, device);
12877     if (r == -1)
12878       return -1;
12879   }
12880   {
12881     char device[] = "/dev/sda1";
12882     device[5] = devchar;
12883     char mountpoint[] = "/";
12884     int r;
12885     suppress_error = 0;
12886     r = guestfs_mount (g, device, mountpoint);
12887     if (r == -1)
12888       return -1;
12889   }
12890   /* TestOutputTrue for mkdir_p (2) */
12891   {
12892     char path[] = "/new/foo/bar";
12893     int r;
12894     suppress_error = 0;
12895     r = guestfs_mkdir_p (g, path);
12896     if (r == -1)
12897       return -1;
12898   }
12899   {
12900     char path[] = "/new";
12901     int r;
12902     suppress_error = 0;
12903     r = guestfs_is_dir (g, path);
12904     if (r == -1)
12905       return -1;
12906     if (!r) {
12907       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12908       return -1;
12909     }
12910   }
12911   return 0;
12912 }
12913
12914 static int test_mkdir_p_3_skip (void)
12915 {
12916   const char *str;
12917
12918   str = getenv ("SKIP_TEST_MKDIR_P_3");
12919   if (str && strcmp (str, "1") == 0) return 1;
12920   str = getenv ("SKIP_TEST_MKDIR_P");
12921   if (str && strcmp (str, "1") == 0) return 1;
12922   return 0;
12923 }
12924
12925 static int test_mkdir_p_3 (void)
12926 {
12927   if (test_mkdir_p_3_skip ()) {
12928     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12929     return 0;
12930   }
12931
12932   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12933   {
12934     char device[] = "/dev/sda";
12935     device[5] = devchar;
12936     int r;
12937     suppress_error = 0;
12938     r = guestfs_blockdev_setrw (g, device);
12939     if (r == -1)
12940       return -1;
12941   }
12942   {
12943     int r;
12944     suppress_error = 0;
12945     r = guestfs_umount_all (g);
12946     if (r == -1)
12947       return -1;
12948   }
12949   {
12950     int r;
12951     suppress_error = 0;
12952     r = guestfs_lvm_remove_all (g);
12953     if (r == -1)
12954       return -1;
12955   }
12956   {
12957     char device[] = "/dev/sda";
12958     device[5] = devchar;
12959     char lines_0[] = ",";
12960     char *lines[] = {
12961       lines_0,
12962       NULL
12963     };
12964     int r;
12965     suppress_error = 0;
12966     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12967     if (r == -1)
12968       return -1;
12969   }
12970   {
12971     char fstype[] = "ext2";
12972     char device[] = "/dev/sda1";
12973     device[5] = devchar;
12974     int r;
12975     suppress_error = 0;
12976     r = guestfs_mkfs (g, fstype, device);
12977     if (r == -1)
12978       return -1;
12979   }
12980   {
12981     char device[] = "/dev/sda1";
12982     device[5] = devchar;
12983     char mountpoint[] = "/";
12984     int r;
12985     suppress_error = 0;
12986     r = guestfs_mount (g, device, mountpoint);
12987     if (r == -1)
12988       return -1;
12989   }
12990   /* TestRun for mkdir_p (3) */
12991   {
12992     char path[] = "/new";
12993     int r;
12994     suppress_error = 0;
12995     r = guestfs_mkdir (g, path);
12996     if (r == -1)
12997       return -1;
12998   }
12999   {
13000     char path[] = "/new";
13001     int r;
13002     suppress_error = 0;
13003     r = guestfs_mkdir_p (g, path);
13004     if (r == -1)
13005       return -1;
13006   }
13007   return 0;
13008 }
13009
13010 static int test_mkdir_p_4_skip (void)
13011 {
13012   const char *str;
13013
13014   str = getenv ("SKIP_TEST_MKDIR_P_4");
13015   if (str && strcmp (str, "1") == 0) return 1;
13016   str = getenv ("SKIP_TEST_MKDIR_P");
13017   if (str && strcmp (str, "1") == 0) return 1;
13018   return 0;
13019 }
13020
13021 static int test_mkdir_p_4 (void)
13022 {
13023   if (test_mkdir_p_4_skip ()) {
13024     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13025     return 0;
13026   }
13027
13028   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13029   {
13030     char device[] = "/dev/sda";
13031     device[5] = devchar;
13032     int r;
13033     suppress_error = 0;
13034     r = guestfs_blockdev_setrw (g, device);
13035     if (r == -1)
13036       return -1;
13037   }
13038   {
13039     int r;
13040     suppress_error = 0;
13041     r = guestfs_umount_all (g);
13042     if (r == -1)
13043       return -1;
13044   }
13045   {
13046     int r;
13047     suppress_error = 0;
13048     r = guestfs_lvm_remove_all (g);
13049     if (r == -1)
13050       return -1;
13051   }
13052   {
13053     char device[] = "/dev/sda";
13054     device[5] = devchar;
13055     char lines_0[] = ",";
13056     char *lines[] = {
13057       lines_0,
13058       NULL
13059     };
13060     int r;
13061     suppress_error = 0;
13062     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13063     if (r == -1)
13064       return -1;
13065   }
13066   {
13067     char fstype[] = "ext2";
13068     char device[] = "/dev/sda1";
13069     device[5] = devchar;
13070     int r;
13071     suppress_error = 0;
13072     r = guestfs_mkfs (g, fstype, device);
13073     if (r == -1)
13074       return -1;
13075   }
13076   {
13077     char device[] = "/dev/sda1";
13078     device[5] = devchar;
13079     char mountpoint[] = "/";
13080     int r;
13081     suppress_error = 0;
13082     r = guestfs_mount (g, device, mountpoint);
13083     if (r == -1)
13084       return -1;
13085   }
13086   /* TestLastFail for mkdir_p (4) */
13087   {
13088     char path[] = "/new";
13089     int r;
13090     suppress_error = 0;
13091     r = guestfs_touch (g, path);
13092     if (r == -1)
13093       return -1;
13094   }
13095   {
13096     char path[] = "/new";
13097     int r;
13098     suppress_error = 1;
13099     r = guestfs_mkdir_p (g, path);
13100     if (r != -1)
13101       return -1;
13102   }
13103   return 0;
13104 }
13105
13106 static int test_mkdir_0_skip (void)
13107 {
13108   const char *str;
13109
13110   str = getenv ("SKIP_TEST_MKDIR_0");
13111   if (str && strcmp (str, "1") == 0) return 1;
13112   str = getenv ("SKIP_TEST_MKDIR");
13113   if (str && strcmp (str, "1") == 0) return 1;
13114   return 0;
13115 }
13116
13117 static int test_mkdir_0 (void)
13118 {
13119   if (test_mkdir_0_skip ()) {
13120     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13121     return 0;
13122   }
13123
13124   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13125   {
13126     char device[] = "/dev/sda";
13127     device[5] = devchar;
13128     int r;
13129     suppress_error = 0;
13130     r = guestfs_blockdev_setrw (g, device);
13131     if (r == -1)
13132       return -1;
13133   }
13134   {
13135     int r;
13136     suppress_error = 0;
13137     r = guestfs_umount_all (g);
13138     if (r == -1)
13139       return -1;
13140   }
13141   {
13142     int r;
13143     suppress_error = 0;
13144     r = guestfs_lvm_remove_all (g);
13145     if (r == -1)
13146       return -1;
13147   }
13148   {
13149     char device[] = "/dev/sda";
13150     device[5] = devchar;
13151     char lines_0[] = ",";
13152     char *lines[] = {
13153       lines_0,
13154       NULL
13155     };
13156     int r;
13157     suppress_error = 0;
13158     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13159     if (r == -1)
13160       return -1;
13161   }
13162   {
13163     char fstype[] = "ext2";
13164     char device[] = "/dev/sda1";
13165     device[5] = devchar;
13166     int r;
13167     suppress_error = 0;
13168     r = guestfs_mkfs (g, fstype, device);
13169     if (r == -1)
13170       return -1;
13171   }
13172   {
13173     char device[] = "/dev/sda1";
13174     device[5] = devchar;
13175     char mountpoint[] = "/";
13176     int r;
13177     suppress_error = 0;
13178     r = guestfs_mount (g, device, mountpoint);
13179     if (r == -1)
13180       return -1;
13181   }
13182   /* TestOutputTrue for mkdir (0) */
13183   {
13184     char path[] = "/new";
13185     int r;
13186     suppress_error = 0;
13187     r = guestfs_mkdir (g, path);
13188     if (r == -1)
13189       return -1;
13190   }
13191   {
13192     char path[] = "/new";
13193     int r;
13194     suppress_error = 0;
13195     r = guestfs_is_dir (g, path);
13196     if (r == -1)
13197       return -1;
13198     if (!r) {
13199       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13200       return -1;
13201     }
13202   }
13203   return 0;
13204 }
13205
13206 static int test_mkdir_1_skip (void)
13207 {
13208   const char *str;
13209
13210   str = getenv ("SKIP_TEST_MKDIR_1");
13211   if (str && strcmp (str, "1") == 0) return 1;
13212   str = getenv ("SKIP_TEST_MKDIR");
13213   if (str && strcmp (str, "1") == 0) return 1;
13214   return 0;
13215 }
13216
13217 static int test_mkdir_1 (void)
13218 {
13219   if (test_mkdir_1_skip ()) {
13220     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13221     return 0;
13222   }
13223
13224   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13225   {
13226     char device[] = "/dev/sda";
13227     device[5] = devchar;
13228     int r;
13229     suppress_error = 0;
13230     r = guestfs_blockdev_setrw (g, device);
13231     if (r == -1)
13232       return -1;
13233   }
13234   {
13235     int r;
13236     suppress_error = 0;
13237     r = guestfs_umount_all (g);
13238     if (r == -1)
13239       return -1;
13240   }
13241   {
13242     int r;
13243     suppress_error = 0;
13244     r = guestfs_lvm_remove_all (g);
13245     if (r == -1)
13246       return -1;
13247   }
13248   {
13249     char device[] = "/dev/sda";
13250     device[5] = devchar;
13251     char lines_0[] = ",";
13252     char *lines[] = {
13253       lines_0,
13254       NULL
13255     };
13256     int r;
13257     suppress_error = 0;
13258     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13259     if (r == -1)
13260       return -1;
13261   }
13262   {
13263     char fstype[] = "ext2";
13264     char device[] = "/dev/sda1";
13265     device[5] = devchar;
13266     int r;
13267     suppress_error = 0;
13268     r = guestfs_mkfs (g, fstype, device);
13269     if (r == -1)
13270       return -1;
13271   }
13272   {
13273     char device[] = "/dev/sda1";
13274     device[5] = devchar;
13275     char mountpoint[] = "/";
13276     int r;
13277     suppress_error = 0;
13278     r = guestfs_mount (g, device, mountpoint);
13279     if (r == -1)
13280       return -1;
13281   }
13282   /* TestLastFail for mkdir (1) */
13283   {
13284     char path[] = "/new/foo/bar";
13285     int r;
13286     suppress_error = 1;
13287     r = guestfs_mkdir (g, path);
13288     if (r != -1)
13289       return -1;
13290   }
13291   return 0;
13292 }
13293
13294 static int test_rm_rf_0_skip (void)
13295 {
13296   const char *str;
13297
13298   str = getenv ("SKIP_TEST_RM_RF_0");
13299   if (str && strcmp (str, "1") == 0) return 1;
13300   str = getenv ("SKIP_TEST_RM_RF");
13301   if (str && strcmp (str, "1") == 0) return 1;
13302   return 0;
13303 }
13304
13305 static int test_rm_rf_0 (void)
13306 {
13307   if (test_rm_rf_0_skip ()) {
13308     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13309     return 0;
13310   }
13311
13312   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13313   {
13314     char device[] = "/dev/sda";
13315     device[5] = devchar;
13316     int r;
13317     suppress_error = 0;
13318     r = guestfs_blockdev_setrw (g, device);
13319     if (r == -1)
13320       return -1;
13321   }
13322   {
13323     int r;
13324     suppress_error = 0;
13325     r = guestfs_umount_all (g);
13326     if (r == -1)
13327       return -1;
13328   }
13329   {
13330     int r;
13331     suppress_error = 0;
13332     r = guestfs_lvm_remove_all (g);
13333     if (r == -1)
13334       return -1;
13335   }
13336   {
13337     char device[] = "/dev/sda";
13338     device[5] = devchar;
13339     char lines_0[] = ",";
13340     char *lines[] = {
13341       lines_0,
13342       NULL
13343     };
13344     int r;
13345     suppress_error = 0;
13346     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13347     if (r == -1)
13348       return -1;
13349   }
13350   {
13351     char fstype[] = "ext2";
13352     char device[] = "/dev/sda1";
13353     device[5] = devchar;
13354     int r;
13355     suppress_error = 0;
13356     r = guestfs_mkfs (g, fstype, device);
13357     if (r == -1)
13358       return -1;
13359   }
13360   {
13361     char device[] = "/dev/sda1";
13362     device[5] = devchar;
13363     char mountpoint[] = "/";
13364     int r;
13365     suppress_error = 0;
13366     r = guestfs_mount (g, device, mountpoint);
13367     if (r == -1)
13368       return -1;
13369   }
13370   /* TestOutputFalse for rm_rf (0) */
13371   {
13372     char path[] = "/new";
13373     int r;
13374     suppress_error = 0;
13375     r = guestfs_mkdir (g, path);
13376     if (r == -1)
13377       return -1;
13378   }
13379   {
13380     char path[] = "/new/foo";
13381     int r;
13382     suppress_error = 0;
13383     r = guestfs_mkdir (g, path);
13384     if (r == -1)
13385       return -1;
13386   }
13387   {
13388     char path[] = "/new/foo/bar";
13389     int r;
13390     suppress_error = 0;
13391     r = guestfs_touch (g, path);
13392     if (r == -1)
13393       return -1;
13394   }
13395   {
13396     char path[] = "/new";
13397     int r;
13398     suppress_error = 0;
13399     r = guestfs_rm_rf (g, path);
13400     if (r == -1)
13401       return -1;
13402   }
13403   {
13404     char path[] = "/new";
13405     int r;
13406     suppress_error = 0;
13407     r = guestfs_exists (g, path);
13408     if (r == -1)
13409       return -1;
13410     if (r) {
13411       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13412       return -1;
13413     }
13414   }
13415   return 0;
13416 }
13417
13418 static int test_rmdir_0_skip (void)
13419 {
13420   const char *str;
13421
13422   str = getenv ("SKIP_TEST_RMDIR_0");
13423   if (str && strcmp (str, "1") == 0) return 1;
13424   str = getenv ("SKIP_TEST_RMDIR");
13425   if (str && strcmp (str, "1") == 0) return 1;
13426   return 0;
13427 }
13428
13429 static int test_rmdir_0 (void)
13430 {
13431   if (test_rmdir_0_skip ()) {
13432     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13433     return 0;
13434   }
13435
13436   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13437   {
13438     char device[] = "/dev/sda";
13439     device[5] = devchar;
13440     int r;
13441     suppress_error = 0;
13442     r = guestfs_blockdev_setrw (g, device);
13443     if (r == -1)
13444       return -1;
13445   }
13446   {
13447     int r;
13448     suppress_error = 0;
13449     r = guestfs_umount_all (g);
13450     if (r == -1)
13451       return -1;
13452   }
13453   {
13454     int r;
13455     suppress_error = 0;
13456     r = guestfs_lvm_remove_all (g);
13457     if (r == -1)
13458       return -1;
13459   }
13460   {
13461     char device[] = "/dev/sda";
13462     device[5] = devchar;
13463     char lines_0[] = ",";
13464     char *lines[] = {
13465       lines_0,
13466       NULL
13467     };
13468     int r;
13469     suppress_error = 0;
13470     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13471     if (r == -1)
13472       return -1;
13473   }
13474   {
13475     char fstype[] = "ext2";
13476     char device[] = "/dev/sda1";
13477     device[5] = devchar;
13478     int r;
13479     suppress_error = 0;
13480     r = guestfs_mkfs (g, fstype, device);
13481     if (r == -1)
13482       return -1;
13483   }
13484   {
13485     char device[] = "/dev/sda1";
13486     device[5] = devchar;
13487     char mountpoint[] = "/";
13488     int r;
13489     suppress_error = 0;
13490     r = guestfs_mount (g, device, mountpoint);
13491     if (r == -1)
13492       return -1;
13493   }
13494   /* TestRun for rmdir (0) */
13495   {
13496     char path[] = "/new";
13497     int r;
13498     suppress_error = 0;
13499     r = guestfs_mkdir (g, path);
13500     if (r == -1)
13501       return -1;
13502   }
13503   {
13504     char path[] = "/new";
13505     int r;
13506     suppress_error = 0;
13507     r = guestfs_rmdir (g, path);
13508     if (r == -1)
13509       return -1;
13510   }
13511   return 0;
13512 }
13513
13514 static int test_rmdir_1_skip (void)
13515 {
13516   const char *str;
13517
13518   str = getenv ("SKIP_TEST_RMDIR_1");
13519   if (str && strcmp (str, "1") == 0) return 1;
13520   str = getenv ("SKIP_TEST_RMDIR");
13521   if (str && strcmp (str, "1") == 0) return 1;
13522   return 0;
13523 }
13524
13525 static int test_rmdir_1 (void)
13526 {
13527   if (test_rmdir_1_skip ()) {
13528     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13529     return 0;
13530   }
13531
13532   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13533   {
13534     char device[] = "/dev/sda";
13535     device[5] = devchar;
13536     int r;
13537     suppress_error = 0;
13538     r = guestfs_blockdev_setrw (g, device);
13539     if (r == -1)
13540       return -1;
13541   }
13542   {
13543     int r;
13544     suppress_error = 0;
13545     r = guestfs_umount_all (g);
13546     if (r == -1)
13547       return -1;
13548   }
13549   {
13550     int r;
13551     suppress_error = 0;
13552     r = guestfs_lvm_remove_all (g);
13553     if (r == -1)
13554       return -1;
13555   }
13556   {
13557     char device[] = "/dev/sda";
13558     device[5] = devchar;
13559     char lines_0[] = ",";
13560     char *lines[] = {
13561       lines_0,
13562       NULL
13563     };
13564     int r;
13565     suppress_error = 0;
13566     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13567     if (r == -1)
13568       return -1;
13569   }
13570   {
13571     char fstype[] = "ext2";
13572     char device[] = "/dev/sda1";
13573     device[5] = devchar;
13574     int r;
13575     suppress_error = 0;
13576     r = guestfs_mkfs (g, fstype, device);
13577     if (r == -1)
13578       return -1;
13579   }
13580   {
13581     char device[] = "/dev/sda1";
13582     device[5] = devchar;
13583     char mountpoint[] = "/";
13584     int r;
13585     suppress_error = 0;
13586     r = guestfs_mount (g, device, mountpoint);
13587     if (r == -1)
13588       return -1;
13589   }
13590   /* TestLastFail for rmdir (1) */
13591   {
13592     char path[] = "/new";
13593     int r;
13594     suppress_error = 1;
13595     r = guestfs_rmdir (g, path);
13596     if (r != -1)
13597       return -1;
13598   }
13599   return 0;
13600 }
13601
13602 static int test_rmdir_2_skip (void)
13603 {
13604   const char *str;
13605
13606   str = getenv ("SKIP_TEST_RMDIR_2");
13607   if (str && strcmp (str, "1") == 0) return 1;
13608   str = getenv ("SKIP_TEST_RMDIR");
13609   if (str && strcmp (str, "1") == 0) return 1;
13610   return 0;
13611 }
13612
13613 static int test_rmdir_2 (void)
13614 {
13615   if (test_rmdir_2_skip ()) {
13616     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13617     return 0;
13618   }
13619
13620   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13621   {
13622     char device[] = "/dev/sda";
13623     device[5] = devchar;
13624     int r;
13625     suppress_error = 0;
13626     r = guestfs_blockdev_setrw (g, device);
13627     if (r == -1)
13628       return -1;
13629   }
13630   {
13631     int r;
13632     suppress_error = 0;
13633     r = guestfs_umount_all (g);
13634     if (r == -1)
13635       return -1;
13636   }
13637   {
13638     int r;
13639     suppress_error = 0;
13640     r = guestfs_lvm_remove_all (g);
13641     if (r == -1)
13642       return -1;
13643   }
13644   {
13645     char device[] = "/dev/sda";
13646     device[5] = devchar;
13647     char lines_0[] = ",";
13648     char *lines[] = {
13649       lines_0,
13650       NULL
13651     };
13652     int r;
13653     suppress_error = 0;
13654     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13655     if (r == -1)
13656       return -1;
13657   }
13658   {
13659     char fstype[] = "ext2";
13660     char device[] = "/dev/sda1";
13661     device[5] = devchar;
13662     int r;
13663     suppress_error = 0;
13664     r = guestfs_mkfs (g, fstype, device);
13665     if (r == -1)
13666       return -1;
13667   }
13668   {
13669     char device[] = "/dev/sda1";
13670     device[5] = devchar;
13671     char mountpoint[] = "/";
13672     int r;
13673     suppress_error = 0;
13674     r = guestfs_mount (g, device, mountpoint);
13675     if (r == -1)
13676       return -1;
13677   }
13678   /* TestLastFail for rmdir (2) */
13679   {
13680     char path[] = "/new";
13681     int r;
13682     suppress_error = 0;
13683     r = guestfs_touch (g, path);
13684     if (r == -1)
13685       return -1;
13686   }
13687   {
13688     char path[] = "/new";
13689     int r;
13690     suppress_error = 1;
13691     r = guestfs_rmdir (g, path);
13692     if (r != -1)
13693       return -1;
13694   }
13695   return 0;
13696 }
13697
13698 static int test_rm_0_skip (void)
13699 {
13700   const char *str;
13701
13702   str = getenv ("SKIP_TEST_RM_0");
13703   if (str && strcmp (str, "1") == 0) return 1;
13704   str = getenv ("SKIP_TEST_RM");
13705   if (str && strcmp (str, "1") == 0) return 1;
13706   return 0;
13707 }
13708
13709 static int test_rm_0 (void)
13710 {
13711   if (test_rm_0_skip ()) {
13712     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13713     return 0;
13714   }
13715
13716   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13717   {
13718     char device[] = "/dev/sda";
13719     device[5] = devchar;
13720     int r;
13721     suppress_error = 0;
13722     r = guestfs_blockdev_setrw (g, device);
13723     if (r == -1)
13724       return -1;
13725   }
13726   {
13727     int r;
13728     suppress_error = 0;
13729     r = guestfs_umount_all (g);
13730     if (r == -1)
13731       return -1;
13732   }
13733   {
13734     int r;
13735     suppress_error = 0;
13736     r = guestfs_lvm_remove_all (g);
13737     if (r == -1)
13738       return -1;
13739   }
13740   {
13741     char device[] = "/dev/sda";
13742     device[5] = devchar;
13743     char lines_0[] = ",";
13744     char *lines[] = {
13745       lines_0,
13746       NULL
13747     };
13748     int r;
13749     suppress_error = 0;
13750     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13751     if (r == -1)
13752       return -1;
13753   }
13754   {
13755     char fstype[] = "ext2";
13756     char device[] = "/dev/sda1";
13757     device[5] = devchar;
13758     int r;
13759     suppress_error = 0;
13760     r = guestfs_mkfs (g, fstype, device);
13761     if (r == -1)
13762       return -1;
13763   }
13764   {
13765     char device[] = "/dev/sda1";
13766     device[5] = devchar;
13767     char mountpoint[] = "/";
13768     int r;
13769     suppress_error = 0;
13770     r = guestfs_mount (g, device, mountpoint);
13771     if (r == -1)
13772       return -1;
13773   }
13774   /* TestRun for rm (0) */
13775   {
13776     char path[] = "/new";
13777     int r;
13778     suppress_error = 0;
13779     r = guestfs_touch (g, path);
13780     if (r == -1)
13781       return -1;
13782   }
13783   {
13784     char path[] = "/new";
13785     int r;
13786     suppress_error = 0;
13787     r = guestfs_rm (g, path);
13788     if (r == -1)
13789       return -1;
13790   }
13791   return 0;
13792 }
13793
13794 static int test_rm_1_skip (void)
13795 {
13796   const char *str;
13797
13798   str = getenv ("SKIP_TEST_RM_1");
13799   if (str && strcmp (str, "1") == 0) return 1;
13800   str = getenv ("SKIP_TEST_RM");
13801   if (str && strcmp (str, "1") == 0) return 1;
13802   return 0;
13803 }
13804
13805 static int test_rm_1 (void)
13806 {
13807   if (test_rm_1_skip ()) {
13808     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13809     return 0;
13810   }
13811
13812   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13813   {
13814     char device[] = "/dev/sda";
13815     device[5] = devchar;
13816     int r;
13817     suppress_error = 0;
13818     r = guestfs_blockdev_setrw (g, device);
13819     if (r == -1)
13820       return -1;
13821   }
13822   {
13823     int r;
13824     suppress_error = 0;
13825     r = guestfs_umount_all (g);
13826     if (r == -1)
13827       return -1;
13828   }
13829   {
13830     int r;
13831     suppress_error = 0;
13832     r = guestfs_lvm_remove_all (g);
13833     if (r == -1)
13834       return -1;
13835   }
13836   {
13837     char device[] = "/dev/sda";
13838     device[5] = devchar;
13839     char lines_0[] = ",";
13840     char *lines[] = {
13841       lines_0,
13842       NULL
13843     };
13844     int r;
13845     suppress_error = 0;
13846     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13847     if (r == -1)
13848       return -1;
13849   }
13850   {
13851     char fstype[] = "ext2";
13852     char device[] = "/dev/sda1";
13853     device[5] = devchar;
13854     int r;
13855     suppress_error = 0;
13856     r = guestfs_mkfs (g, fstype, device);
13857     if (r == -1)
13858       return -1;
13859   }
13860   {
13861     char device[] = "/dev/sda1";
13862     device[5] = devchar;
13863     char mountpoint[] = "/";
13864     int r;
13865     suppress_error = 0;
13866     r = guestfs_mount (g, device, mountpoint);
13867     if (r == -1)
13868       return -1;
13869   }
13870   /* TestLastFail for rm (1) */
13871   {
13872     char path[] = "/new";
13873     int r;
13874     suppress_error = 1;
13875     r = guestfs_rm (g, path);
13876     if (r != -1)
13877       return -1;
13878   }
13879   return 0;
13880 }
13881
13882 static int test_rm_2_skip (void)
13883 {
13884   const char *str;
13885
13886   str = getenv ("SKIP_TEST_RM_2");
13887   if (str && strcmp (str, "1") == 0) return 1;
13888   str = getenv ("SKIP_TEST_RM");
13889   if (str && strcmp (str, "1") == 0) return 1;
13890   return 0;
13891 }
13892
13893 static int test_rm_2 (void)
13894 {
13895   if (test_rm_2_skip ()) {
13896     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13897     return 0;
13898   }
13899
13900   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13901   {
13902     char device[] = "/dev/sda";
13903     device[5] = devchar;
13904     int r;
13905     suppress_error = 0;
13906     r = guestfs_blockdev_setrw (g, device);
13907     if (r == -1)
13908       return -1;
13909   }
13910   {
13911     int r;
13912     suppress_error = 0;
13913     r = guestfs_umount_all (g);
13914     if (r == -1)
13915       return -1;
13916   }
13917   {
13918     int r;
13919     suppress_error = 0;
13920     r = guestfs_lvm_remove_all (g);
13921     if (r == -1)
13922       return -1;
13923   }
13924   {
13925     char device[] = "/dev/sda";
13926     device[5] = devchar;
13927     char lines_0[] = ",";
13928     char *lines[] = {
13929       lines_0,
13930       NULL
13931     };
13932     int r;
13933     suppress_error = 0;
13934     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13935     if (r == -1)
13936       return -1;
13937   }
13938   {
13939     char fstype[] = "ext2";
13940     char device[] = "/dev/sda1";
13941     device[5] = devchar;
13942     int r;
13943     suppress_error = 0;
13944     r = guestfs_mkfs (g, fstype, device);
13945     if (r == -1)
13946       return -1;
13947   }
13948   {
13949     char device[] = "/dev/sda1";
13950     device[5] = devchar;
13951     char mountpoint[] = "/";
13952     int r;
13953     suppress_error = 0;
13954     r = guestfs_mount (g, device, mountpoint);
13955     if (r == -1)
13956       return -1;
13957   }
13958   /* TestLastFail for rm (2) */
13959   {
13960     char path[] = "/new";
13961     int r;
13962     suppress_error = 0;
13963     r = guestfs_mkdir (g, path);
13964     if (r == -1)
13965       return -1;
13966   }
13967   {
13968     char path[] = "/new";
13969     int r;
13970     suppress_error = 1;
13971     r = guestfs_rm (g, path);
13972     if (r != -1)
13973       return -1;
13974   }
13975   return 0;
13976 }
13977
13978 static int test_read_lines_0_skip (void)
13979 {
13980   const char *str;
13981
13982   str = getenv ("SKIP_TEST_READ_LINES_0");
13983   if (str && strcmp (str, "1") == 0) return 1;
13984   str = getenv ("SKIP_TEST_READ_LINES");
13985   if (str && strcmp (str, "1") == 0) return 1;
13986   return 0;
13987 }
13988
13989 static int test_read_lines_0 (void)
13990 {
13991   if (test_read_lines_0_skip ()) {
13992     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13993     return 0;
13994   }
13995
13996   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13997   {
13998     char device[] = "/dev/sda";
13999     device[5] = devchar;
14000     int r;
14001     suppress_error = 0;
14002     r = guestfs_blockdev_setrw (g, device);
14003     if (r == -1)
14004       return -1;
14005   }
14006   {
14007     int r;
14008     suppress_error = 0;
14009     r = guestfs_umount_all (g);
14010     if (r == -1)
14011       return -1;
14012   }
14013   {
14014     int r;
14015     suppress_error = 0;
14016     r = guestfs_lvm_remove_all (g);
14017     if (r == -1)
14018       return -1;
14019   }
14020   {
14021     char device[] = "/dev/sda";
14022     device[5] = devchar;
14023     char lines_0[] = ",";
14024     char *lines[] = {
14025       lines_0,
14026       NULL
14027     };
14028     int r;
14029     suppress_error = 0;
14030     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14031     if (r == -1)
14032       return -1;
14033   }
14034   {
14035     char fstype[] = "ext2";
14036     char device[] = "/dev/sda1";
14037     device[5] = devchar;
14038     int r;
14039     suppress_error = 0;
14040     r = guestfs_mkfs (g, fstype, device);
14041     if (r == -1)
14042       return -1;
14043   }
14044   {
14045     char device[] = "/dev/sda1";
14046     device[5] = devchar;
14047     char mountpoint[] = "/";
14048     int r;
14049     suppress_error = 0;
14050     r = guestfs_mount (g, device, mountpoint);
14051     if (r == -1)
14052       return -1;
14053   }
14054   /* TestOutputList for read_lines (0) */
14055   {
14056     char path[] = "/new";
14057     char content[] = "line1\r\nline2\nline3";
14058     int r;
14059     suppress_error = 0;
14060     r = guestfs_write_file (g, path, content, 0);
14061     if (r == -1)
14062       return -1;
14063   }
14064   {
14065     char path[] = "/new";
14066     char **r;
14067     int i;
14068     suppress_error = 0;
14069     r = guestfs_read_lines (g, path);
14070     if (r == NULL)
14071       return -1;
14072     if (!r[0]) {
14073       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14074       print_strings (r);
14075       return -1;
14076     }
14077     {
14078       char expected[] = "line1";
14079       if (strcmp (r[0], expected) != 0) {
14080         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14081         return -1;
14082       }
14083     }
14084     if (!r[1]) {
14085       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14086       print_strings (r);
14087       return -1;
14088     }
14089     {
14090       char expected[] = "line2";
14091       if (strcmp (r[1], expected) != 0) {
14092         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14093         return -1;
14094       }
14095     }
14096     if (!r[2]) {
14097       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14098       print_strings (r);
14099       return -1;
14100     }
14101     {
14102       char expected[] = "line3";
14103       if (strcmp (r[2], expected) != 0) {
14104         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14105         return -1;
14106       }
14107     }
14108     if (r[3] != NULL) {
14109       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14110       print_strings (r);
14111       return -1;
14112     }
14113     for (i = 0; r[i] != NULL; ++i)
14114       free (r[i]);
14115     free (r);
14116   }
14117   return 0;
14118 }
14119
14120 static int test_read_lines_1_skip (void)
14121 {
14122   const char *str;
14123
14124   str = getenv ("SKIP_TEST_READ_LINES_1");
14125   if (str && strcmp (str, "1") == 0) return 1;
14126   str = getenv ("SKIP_TEST_READ_LINES");
14127   if (str && strcmp (str, "1") == 0) return 1;
14128   return 0;
14129 }
14130
14131 static int test_read_lines_1 (void)
14132 {
14133   if (test_read_lines_1_skip ()) {
14134     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14135     return 0;
14136   }
14137
14138   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14139   {
14140     char device[] = "/dev/sda";
14141     device[5] = devchar;
14142     int r;
14143     suppress_error = 0;
14144     r = guestfs_blockdev_setrw (g, device);
14145     if (r == -1)
14146       return -1;
14147   }
14148   {
14149     int r;
14150     suppress_error = 0;
14151     r = guestfs_umount_all (g);
14152     if (r == -1)
14153       return -1;
14154   }
14155   {
14156     int r;
14157     suppress_error = 0;
14158     r = guestfs_lvm_remove_all (g);
14159     if (r == -1)
14160       return -1;
14161   }
14162   {
14163     char device[] = "/dev/sda";
14164     device[5] = devchar;
14165     char lines_0[] = ",";
14166     char *lines[] = {
14167       lines_0,
14168       NULL
14169     };
14170     int r;
14171     suppress_error = 0;
14172     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14173     if (r == -1)
14174       return -1;
14175   }
14176   {
14177     char fstype[] = "ext2";
14178     char device[] = "/dev/sda1";
14179     device[5] = devchar;
14180     int r;
14181     suppress_error = 0;
14182     r = guestfs_mkfs (g, fstype, device);
14183     if (r == -1)
14184       return -1;
14185   }
14186   {
14187     char device[] = "/dev/sda1";
14188     device[5] = devchar;
14189     char mountpoint[] = "/";
14190     int r;
14191     suppress_error = 0;
14192     r = guestfs_mount (g, device, mountpoint);
14193     if (r == -1)
14194       return -1;
14195   }
14196   /* TestOutputList for read_lines (1) */
14197   {
14198     char path[] = "/new";
14199     char content[] = "";
14200     int r;
14201     suppress_error = 0;
14202     r = guestfs_write_file (g, path, content, 0);
14203     if (r == -1)
14204       return -1;
14205   }
14206   {
14207     char path[] = "/new";
14208     char **r;
14209     int i;
14210     suppress_error = 0;
14211     r = guestfs_read_lines (g, path);
14212     if (r == NULL)
14213       return -1;
14214     if (r[0] != NULL) {
14215       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14216       print_strings (r);
14217       return -1;
14218     }
14219     for (i = 0; r[i] != NULL; ++i)
14220       free (r[i]);
14221     free (r);
14222   }
14223   return 0;
14224 }
14225
14226 static int test_lvs_0_skip (void)
14227 {
14228   const char *str;
14229
14230   str = getenv ("SKIP_TEST_LVS_0");
14231   if (str && strcmp (str, "1") == 0) return 1;
14232   str = getenv ("SKIP_TEST_LVS");
14233   if (str && strcmp (str, "1") == 0) return 1;
14234   return 0;
14235 }
14236
14237 static int test_lvs_0 (void)
14238 {
14239   if (test_lvs_0_skip ()) {
14240     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14241     return 0;
14242   }
14243
14244   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14245   {
14246     char device[] = "/dev/sda";
14247     device[5] = devchar;
14248     int r;
14249     suppress_error = 0;
14250     r = guestfs_blockdev_setrw (g, device);
14251     if (r == -1)
14252       return -1;
14253   }
14254   {
14255     int r;
14256     suppress_error = 0;
14257     r = guestfs_umount_all (g);
14258     if (r == -1)
14259       return -1;
14260   }
14261   {
14262     int r;
14263     suppress_error = 0;
14264     r = guestfs_lvm_remove_all (g);
14265     if (r == -1)
14266       return -1;
14267   }
14268   {
14269     char device[] = "/dev/sda";
14270     device[5] = devchar;
14271     char lines_0[] = ",";
14272     char *lines[] = {
14273       lines_0,
14274       NULL
14275     };
14276     int r;
14277     suppress_error = 0;
14278     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14279     if (r == -1)
14280       return -1;
14281   }
14282   {
14283     char device[] = "/dev/sda1";
14284     device[5] = devchar;
14285     int r;
14286     suppress_error = 0;
14287     r = guestfs_pvcreate (g, device);
14288     if (r == -1)
14289       return -1;
14290   }
14291   {
14292     char volgroup[] = "VG";
14293     char physvols_0[] = "/dev/sda1";
14294     physvols_0[5] = devchar;
14295     char *physvols[] = {
14296       physvols_0,
14297       NULL
14298     };
14299     int r;
14300     suppress_error = 0;
14301     r = guestfs_vgcreate (g, volgroup, physvols);
14302     if (r == -1)
14303       return -1;
14304   }
14305   {
14306     char logvol[] = "LV";
14307     char volgroup[] = "VG";
14308     int r;
14309     suppress_error = 0;
14310     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14311     if (r == -1)
14312       return -1;
14313   }
14314   {
14315     char fstype[] = "ext2";
14316     char device[] = "/dev/VG/LV";
14317     int r;
14318     suppress_error = 0;
14319     r = guestfs_mkfs (g, fstype, device);
14320     if (r == -1)
14321       return -1;
14322   }
14323   {
14324     char device[] = "/dev/VG/LV";
14325     char mountpoint[] = "/";
14326     int r;
14327     suppress_error = 0;
14328     r = guestfs_mount (g, device, mountpoint);
14329     if (r == -1)
14330       return -1;
14331   }
14332   /* TestOutputList for lvs (0) */
14333   {
14334     char **r;
14335     int i;
14336     suppress_error = 0;
14337     r = guestfs_lvs (g);
14338     if (r == NULL)
14339       return -1;
14340     if (!r[0]) {
14341       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14342       print_strings (r);
14343       return -1;
14344     }
14345     {
14346       char expected[] = "/dev/VG/LV";
14347       if (strcmp (r[0], expected) != 0) {
14348         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14349         return -1;
14350       }
14351     }
14352     if (r[1] != NULL) {
14353       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14354       print_strings (r);
14355       return -1;
14356     }
14357     for (i = 0; r[i] != NULL; ++i)
14358       free (r[i]);
14359     free (r);
14360   }
14361   return 0;
14362 }
14363
14364 static int test_lvs_1_skip (void)
14365 {
14366   const char *str;
14367
14368   str = getenv ("SKIP_TEST_LVS_1");
14369   if (str && strcmp (str, "1") == 0) return 1;
14370   str = getenv ("SKIP_TEST_LVS");
14371   if (str && strcmp (str, "1") == 0) return 1;
14372   return 0;
14373 }
14374
14375 static int test_lvs_1 (void)
14376 {
14377   if (test_lvs_1_skip ()) {
14378     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14379     return 0;
14380   }
14381
14382   /* InitNone|InitEmpty for test_lvs_1 */
14383   {
14384     char device[] = "/dev/sda";
14385     device[5] = devchar;
14386     int r;
14387     suppress_error = 0;
14388     r = guestfs_blockdev_setrw (g, device);
14389     if (r == -1)
14390       return -1;
14391   }
14392   {
14393     int r;
14394     suppress_error = 0;
14395     r = guestfs_umount_all (g);
14396     if (r == -1)
14397       return -1;
14398   }
14399   {
14400     int r;
14401     suppress_error = 0;
14402     r = guestfs_lvm_remove_all (g);
14403     if (r == -1)
14404       return -1;
14405   }
14406   /* TestOutputList for lvs (1) */
14407   {
14408     char device[] = "/dev/sda";
14409     device[5] = devchar;
14410     char lines_0[] = ",10";
14411     char lines_1[] = ",20";
14412     char lines_2[] = ",";
14413     char *lines[] = {
14414       lines_0,
14415       lines_1,
14416       lines_2,
14417       NULL
14418     };
14419     int r;
14420     suppress_error = 0;
14421     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14422     if (r == -1)
14423       return -1;
14424   }
14425   {
14426     char device[] = "/dev/sda1";
14427     device[5] = devchar;
14428     int r;
14429     suppress_error = 0;
14430     r = guestfs_pvcreate (g, device);
14431     if (r == -1)
14432       return -1;
14433   }
14434   {
14435     char device[] = "/dev/sda2";
14436     device[5] = devchar;
14437     int r;
14438     suppress_error = 0;
14439     r = guestfs_pvcreate (g, device);
14440     if (r == -1)
14441       return -1;
14442   }
14443   {
14444     char device[] = "/dev/sda3";
14445     device[5] = devchar;
14446     int r;
14447     suppress_error = 0;
14448     r = guestfs_pvcreate (g, device);
14449     if (r == -1)
14450       return -1;
14451   }
14452   {
14453     char volgroup[] = "VG1";
14454     char physvols_0[] = "/dev/sda1";
14455     physvols_0[5] = devchar;
14456     char physvols_1[] = "/dev/sda2";
14457     physvols_1[5] = devchar;
14458     char *physvols[] = {
14459       physvols_0,
14460       physvols_1,
14461       NULL
14462     };
14463     int r;
14464     suppress_error = 0;
14465     r = guestfs_vgcreate (g, volgroup, physvols);
14466     if (r == -1)
14467       return -1;
14468   }
14469   {
14470     char volgroup[] = "VG2";
14471     char physvols_0[] = "/dev/sda3";
14472     physvols_0[5] = devchar;
14473     char *physvols[] = {
14474       physvols_0,
14475       NULL
14476     };
14477     int r;
14478     suppress_error = 0;
14479     r = guestfs_vgcreate (g, volgroup, physvols);
14480     if (r == -1)
14481       return -1;
14482   }
14483   {
14484     char logvol[] = "LV1";
14485     char volgroup[] = "VG1";
14486     int r;
14487     suppress_error = 0;
14488     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14489     if (r == -1)
14490       return -1;
14491   }
14492   {
14493     char logvol[] = "LV2";
14494     char volgroup[] = "VG1";
14495     int r;
14496     suppress_error = 0;
14497     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14498     if (r == -1)
14499       return -1;
14500   }
14501   {
14502     char logvol[] = "LV3";
14503     char volgroup[] = "VG2";
14504     int r;
14505     suppress_error = 0;
14506     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14507     if (r == -1)
14508       return -1;
14509   }
14510   {
14511     char **r;
14512     int i;
14513     suppress_error = 0;
14514     r = guestfs_lvs (g);
14515     if (r == NULL)
14516       return -1;
14517     if (!r[0]) {
14518       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14519       print_strings (r);
14520       return -1;
14521     }
14522     {
14523       char expected[] = "/dev/VG1/LV1";
14524       if (strcmp (r[0], expected) != 0) {
14525         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14526         return -1;
14527       }
14528     }
14529     if (!r[1]) {
14530       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14531       print_strings (r);
14532       return -1;
14533     }
14534     {
14535       char expected[] = "/dev/VG1/LV2";
14536       if (strcmp (r[1], expected) != 0) {
14537         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14538         return -1;
14539       }
14540     }
14541     if (!r[2]) {
14542       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14543       print_strings (r);
14544       return -1;
14545     }
14546     {
14547       char expected[] = "/dev/VG2/LV3";
14548       if (strcmp (r[2], expected) != 0) {
14549         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14550         return -1;
14551       }
14552     }
14553     if (r[3] != NULL) {
14554       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14555       print_strings (r);
14556       return -1;
14557     }
14558     for (i = 0; r[i] != NULL; ++i)
14559       free (r[i]);
14560     free (r);
14561   }
14562   return 0;
14563 }
14564
14565 static int test_vgs_0_skip (void)
14566 {
14567   const char *str;
14568
14569   str = getenv ("SKIP_TEST_VGS_0");
14570   if (str && strcmp (str, "1") == 0) return 1;
14571   str = getenv ("SKIP_TEST_VGS");
14572   if (str && strcmp (str, "1") == 0) return 1;
14573   return 0;
14574 }
14575
14576 static int test_vgs_0 (void)
14577 {
14578   if (test_vgs_0_skip ()) {
14579     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14580     return 0;
14581   }
14582
14583   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14584   {
14585     char device[] = "/dev/sda";
14586     device[5] = devchar;
14587     int r;
14588     suppress_error = 0;
14589     r = guestfs_blockdev_setrw (g, device);
14590     if (r == -1)
14591       return -1;
14592   }
14593   {
14594     int r;
14595     suppress_error = 0;
14596     r = guestfs_umount_all (g);
14597     if (r == -1)
14598       return -1;
14599   }
14600   {
14601     int r;
14602     suppress_error = 0;
14603     r = guestfs_lvm_remove_all (g);
14604     if (r == -1)
14605       return -1;
14606   }
14607   {
14608     char device[] = "/dev/sda";
14609     device[5] = devchar;
14610     char lines_0[] = ",";
14611     char *lines[] = {
14612       lines_0,
14613       NULL
14614     };
14615     int r;
14616     suppress_error = 0;
14617     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14618     if (r == -1)
14619       return -1;
14620   }
14621   {
14622     char device[] = "/dev/sda1";
14623     device[5] = devchar;
14624     int r;
14625     suppress_error = 0;
14626     r = guestfs_pvcreate (g, device);
14627     if (r == -1)
14628       return -1;
14629   }
14630   {
14631     char volgroup[] = "VG";
14632     char physvols_0[] = "/dev/sda1";
14633     physvols_0[5] = devchar;
14634     char *physvols[] = {
14635       physvols_0,
14636       NULL
14637     };
14638     int r;
14639     suppress_error = 0;
14640     r = guestfs_vgcreate (g, volgroup, physvols);
14641     if (r == -1)
14642       return -1;
14643   }
14644   {
14645     char logvol[] = "LV";
14646     char volgroup[] = "VG";
14647     int r;
14648     suppress_error = 0;
14649     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14650     if (r == -1)
14651       return -1;
14652   }
14653   {
14654     char fstype[] = "ext2";
14655     char device[] = "/dev/VG/LV";
14656     int r;
14657     suppress_error = 0;
14658     r = guestfs_mkfs (g, fstype, device);
14659     if (r == -1)
14660       return -1;
14661   }
14662   {
14663     char device[] = "/dev/VG/LV";
14664     char mountpoint[] = "/";
14665     int r;
14666     suppress_error = 0;
14667     r = guestfs_mount (g, device, mountpoint);
14668     if (r == -1)
14669       return -1;
14670   }
14671   /* TestOutputList for vgs (0) */
14672   {
14673     char **r;
14674     int i;
14675     suppress_error = 0;
14676     r = guestfs_vgs (g);
14677     if (r == NULL)
14678       return -1;
14679     if (!r[0]) {
14680       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14681       print_strings (r);
14682       return -1;
14683     }
14684     {
14685       char expected[] = "VG";
14686       if (strcmp (r[0], expected) != 0) {
14687         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14688         return -1;
14689       }
14690     }
14691     if (r[1] != NULL) {
14692       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14693       print_strings (r);
14694       return -1;
14695     }
14696     for (i = 0; r[i] != NULL; ++i)
14697       free (r[i]);
14698     free (r);
14699   }
14700   return 0;
14701 }
14702
14703 static int test_vgs_1_skip (void)
14704 {
14705   const char *str;
14706
14707   str = getenv ("SKIP_TEST_VGS_1");
14708   if (str && strcmp (str, "1") == 0) return 1;
14709   str = getenv ("SKIP_TEST_VGS");
14710   if (str && strcmp (str, "1") == 0) return 1;
14711   return 0;
14712 }
14713
14714 static int test_vgs_1 (void)
14715 {
14716   if (test_vgs_1_skip ()) {
14717     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14718     return 0;
14719   }
14720
14721   /* InitNone|InitEmpty for test_vgs_1 */
14722   {
14723     char device[] = "/dev/sda";
14724     device[5] = devchar;
14725     int r;
14726     suppress_error = 0;
14727     r = guestfs_blockdev_setrw (g, device);
14728     if (r == -1)
14729       return -1;
14730   }
14731   {
14732     int r;
14733     suppress_error = 0;
14734     r = guestfs_umount_all (g);
14735     if (r == -1)
14736       return -1;
14737   }
14738   {
14739     int r;
14740     suppress_error = 0;
14741     r = guestfs_lvm_remove_all (g);
14742     if (r == -1)
14743       return -1;
14744   }
14745   /* TestOutputList for vgs (1) */
14746   {
14747     char device[] = "/dev/sda";
14748     device[5] = devchar;
14749     char lines_0[] = ",10";
14750     char lines_1[] = ",20";
14751     char lines_2[] = ",";
14752     char *lines[] = {
14753       lines_0,
14754       lines_1,
14755       lines_2,
14756       NULL
14757     };
14758     int r;
14759     suppress_error = 0;
14760     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14761     if (r == -1)
14762       return -1;
14763   }
14764   {
14765     char device[] = "/dev/sda1";
14766     device[5] = devchar;
14767     int r;
14768     suppress_error = 0;
14769     r = guestfs_pvcreate (g, device);
14770     if (r == -1)
14771       return -1;
14772   }
14773   {
14774     char device[] = "/dev/sda2";
14775     device[5] = devchar;
14776     int r;
14777     suppress_error = 0;
14778     r = guestfs_pvcreate (g, device);
14779     if (r == -1)
14780       return -1;
14781   }
14782   {
14783     char device[] = "/dev/sda3";
14784     device[5] = devchar;
14785     int r;
14786     suppress_error = 0;
14787     r = guestfs_pvcreate (g, device);
14788     if (r == -1)
14789       return -1;
14790   }
14791   {
14792     char volgroup[] = "VG1";
14793     char physvols_0[] = "/dev/sda1";
14794     physvols_0[5] = devchar;
14795     char physvols_1[] = "/dev/sda2";
14796     physvols_1[5] = devchar;
14797     char *physvols[] = {
14798       physvols_0,
14799       physvols_1,
14800       NULL
14801     };
14802     int r;
14803     suppress_error = 0;
14804     r = guestfs_vgcreate (g, volgroup, physvols);
14805     if (r == -1)
14806       return -1;
14807   }
14808   {
14809     char volgroup[] = "VG2";
14810     char physvols_0[] = "/dev/sda3";
14811     physvols_0[5] = devchar;
14812     char *physvols[] = {
14813       physvols_0,
14814       NULL
14815     };
14816     int r;
14817     suppress_error = 0;
14818     r = guestfs_vgcreate (g, volgroup, physvols);
14819     if (r == -1)
14820       return -1;
14821   }
14822   {
14823     char **r;
14824     int i;
14825     suppress_error = 0;
14826     r = guestfs_vgs (g);
14827     if (r == NULL)
14828       return -1;
14829     if (!r[0]) {
14830       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14831       print_strings (r);
14832       return -1;
14833     }
14834     {
14835       char expected[] = "VG1";
14836       if (strcmp (r[0], expected) != 0) {
14837         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14838         return -1;
14839       }
14840     }
14841     if (!r[1]) {
14842       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14843       print_strings (r);
14844       return -1;
14845     }
14846     {
14847       char expected[] = "VG2";
14848       if (strcmp (r[1], expected) != 0) {
14849         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14850         return -1;
14851       }
14852     }
14853     if (r[2] != NULL) {
14854       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14855       print_strings (r);
14856       return -1;
14857     }
14858     for (i = 0; r[i] != NULL; ++i)
14859       free (r[i]);
14860     free (r);
14861   }
14862   return 0;
14863 }
14864
14865 static int test_pvs_0_skip (void)
14866 {
14867   const char *str;
14868
14869   str = getenv ("SKIP_TEST_PVS_0");
14870   if (str && strcmp (str, "1") == 0) return 1;
14871   str = getenv ("SKIP_TEST_PVS");
14872   if (str && strcmp (str, "1") == 0) return 1;
14873   return 0;
14874 }
14875
14876 static int test_pvs_0 (void)
14877 {
14878   if (test_pvs_0_skip ()) {
14879     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14880     return 0;
14881   }
14882
14883   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14884   {
14885     char device[] = "/dev/sda";
14886     device[5] = devchar;
14887     int r;
14888     suppress_error = 0;
14889     r = guestfs_blockdev_setrw (g, device);
14890     if (r == -1)
14891       return -1;
14892   }
14893   {
14894     int r;
14895     suppress_error = 0;
14896     r = guestfs_umount_all (g);
14897     if (r == -1)
14898       return -1;
14899   }
14900   {
14901     int r;
14902     suppress_error = 0;
14903     r = guestfs_lvm_remove_all (g);
14904     if (r == -1)
14905       return -1;
14906   }
14907   {
14908     char device[] = "/dev/sda";
14909     device[5] = devchar;
14910     char lines_0[] = ",";
14911     char *lines[] = {
14912       lines_0,
14913       NULL
14914     };
14915     int r;
14916     suppress_error = 0;
14917     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14918     if (r == -1)
14919       return -1;
14920   }
14921   {
14922     char device[] = "/dev/sda1";
14923     device[5] = devchar;
14924     int r;
14925     suppress_error = 0;
14926     r = guestfs_pvcreate (g, device);
14927     if (r == -1)
14928       return -1;
14929   }
14930   {
14931     char volgroup[] = "VG";
14932     char physvols_0[] = "/dev/sda1";
14933     physvols_0[5] = devchar;
14934     char *physvols[] = {
14935       physvols_0,
14936       NULL
14937     };
14938     int r;
14939     suppress_error = 0;
14940     r = guestfs_vgcreate (g, volgroup, physvols);
14941     if (r == -1)
14942       return -1;
14943   }
14944   {
14945     char logvol[] = "LV";
14946     char volgroup[] = "VG";
14947     int r;
14948     suppress_error = 0;
14949     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14950     if (r == -1)
14951       return -1;
14952   }
14953   {
14954     char fstype[] = "ext2";
14955     char device[] = "/dev/VG/LV";
14956     int r;
14957     suppress_error = 0;
14958     r = guestfs_mkfs (g, fstype, device);
14959     if (r == -1)
14960       return -1;
14961   }
14962   {
14963     char device[] = "/dev/VG/LV";
14964     char mountpoint[] = "/";
14965     int r;
14966     suppress_error = 0;
14967     r = guestfs_mount (g, device, mountpoint);
14968     if (r == -1)
14969       return -1;
14970   }
14971   /* TestOutputList for pvs (0) */
14972   {
14973     char **r;
14974     int i;
14975     suppress_error = 0;
14976     r = guestfs_pvs (g);
14977     if (r == NULL)
14978       return -1;
14979     if (!r[0]) {
14980       fprintf (stderr, "test_pvs_0: short list returned from command\n");
14981       print_strings (r);
14982       return -1;
14983     }
14984     {
14985       char expected[] = "/dev/sda1";
14986       expected[5] = devchar;
14987       if (strcmp (r[0], expected) != 0) {
14988         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14989         return -1;
14990       }
14991     }
14992     if (r[1] != NULL) {
14993       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14994       print_strings (r);
14995       return -1;
14996     }
14997     for (i = 0; r[i] != NULL; ++i)
14998       free (r[i]);
14999     free (r);
15000   }
15001   return 0;
15002 }
15003
15004 static int test_pvs_1_skip (void)
15005 {
15006   const char *str;
15007
15008   str = getenv ("SKIP_TEST_PVS_1");
15009   if (str && strcmp (str, "1") == 0) return 1;
15010   str = getenv ("SKIP_TEST_PVS");
15011   if (str && strcmp (str, "1") == 0) return 1;
15012   return 0;
15013 }
15014
15015 static int test_pvs_1 (void)
15016 {
15017   if (test_pvs_1_skip ()) {
15018     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15019     return 0;
15020   }
15021
15022   /* InitNone|InitEmpty for test_pvs_1 */
15023   {
15024     char device[] = "/dev/sda";
15025     device[5] = devchar;
15026     int r;
15027     suppress_error = 0;
15028     r = guestfs_blockdev_setrw (g, device);
15029     if (r == -1)
15030       return -1;
15031   }
15032   {
15033     int r;
15034     suppress_error = 0;
15035     r = guestfs_umount_all (g);
15036     if (r == -1)
15037       return -1;
15038   }
15039   {
15040     int r;
15041     suppress_error = 0;
15042     r = guestfs_lvm_remove_all (g);
15043     if (r == -1)
15044       return -1;
15045   }
15046   /* TestOutputList for pvs (1) */
15047   {
15048     char device[] = "/dev/sda";
15049     device[5] = devchar;
15050     char lines_0[] = ",10";
15051     char lines_1[] = ",20";
15052     char lines_2[] = ",";
15053     char *lines[] = {
15054       lines_0,
15055       lines_1,
15056       lines_2,
15057       NULL
15058     };
15059     int r;
15060     suppress_error = 0;
15061     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15062     if (r == -1)
15063       return -1;
15064   }
15065   {
15066     char device[] = "/dev/sda1";
15067     device[5] = devchar;
15068     int r;
15069     suppress_error = 0;
15070     r = guestfs_pvcreate (g, device);
15071     if (r == -1)
15072       return -1;
15073   }
15074   {
15075     char device[] = "/dev/sda2";
15076     device[5] = devchar;
15077     int r;
15078     suppress_error = 0;
15079     r = guestfs_pvcreate (g, device);
15080     if (r == -1)
15081       return -1;
15082   }
15083   {
15084     char device[] = "/dev/sda3";
15085     device[5] = devchar;
15086     int r;
15087     suppress_error = 0;
15088     r = guestfs_pvcreate (g, device);
15089     if (r == -1)
15090       return -1;
15091   }
15092   {
15093     char **r;
15094     int i;
15095     suppress_error = 0;
15096     r = guestfs_pvs (g);
15097     if (r == NULL)
15098       return -1;
15099     if (!r[0]) {
15100       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15101       print_strings (r);
15102       return -1;
15103     }
15104     {
15105       char expected[] = "/dev/sda1";
15106       expected[5] = devchar;
15107       if (strcmp (r[0], expected) != 0) {
15108         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15109         return -1;
15110       }
15111     }
15112     if (!r[1]) {
15113       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15114       print_strings (r);
15115       return -1;
15116     }
15117     {
15118       char expected[] = "/dev/sda2";
15119       expected[5] = devchar;
15120       if (strcmp (r[1], expected) != 0) {
15121         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15122         return -1;
15123       }
15124     }
15125     if (!r[2]) {
15126       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15127       print_strings (r);
15128       return -1;
15129     }
15130     {
15131       char expected[] = "/dev/sda3";
15132       expected[5] = devchar;
15133       if (strcmp (r[2], expected) != 0) {
15134         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15135         return -1;
15136       }
15137     }
15138     if (r[3] != NULL) {
15139       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15140       print_strings (r);
15141       return -1;
15142     }
15143     for (i = 0; r[i] != NULL; ++i)
15144       free (r[i]);
15145     free (r);
15146   }
15147   return 0;
15148 }
15149
15150 static int test_list_partitions_0_skip (void)
15151 {
15152   const char *str;
15153
15154   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15155   if (str && strcmp (str, "1") == 0) return 1;
15156   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15157   if (str && strcmp (str, "1") == 0) return 1;
15158   return 0;
15159 }
15160
15161 static int test_list_partitions_0 (void)
15162 {
15163   if (test_list_partitions_0_skip ()) {
15164     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15165     return 0;
15166   }
15167
15168   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15169   {
15170     char device[] = "/dev/sda";
15171     device[5] = devchar;
15172     int r;
15173     suppress_error = 0;
15174     r = guestfs_blockdev_setrw (g, device);
15175     if (r == -1)
15176       return -1;
15177   }
15178   {
15179     int r;
15180     suppress_error = 0;
15181     r = guestfs_umount_all (g);
15182     if (r == -1)
15183       return -1;
15184   }
15185   {
15186     int r;
15187     suppress_error = 0;
15188     r = guestfs_lvm_remove_all (g);
15189     if (r == -1)
15190       return -1;
15191   }
15192   {
15193     char device[] = "/dev/sda";
15194     device[5] = devchar;
15195     char lines_0[] = ",";
15196     char *lines[] = {
15197       lines_0,
15198       NULL
15199     };
15200     int r;
15201     suppress_error = 0;
15202     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15203     if (r == -1)
15204       return -1;
15205   }
15206   {
15207     char fstype[] = "ext2";
15208     char device[] = "/dev/sda1";
15209     device[5] = devchar;
15210     int r;
15211     suppress_error = 0;
15212     r = guestfs_mkfs (g, fstype, device);
15213     if (r == -1)
15214       return -1;
15215   }
15216   {
15217     char device[] = "/dev/sda1";
15218     device[5] = devchar;
15219     char mountpoint[] = "/";
15220     int r;
15221     suppress_error = 0;
15222     r = guestfs_mount (g, device, mountpoint);
15223     if (r == -1)
15224       return -1;
15225   }
15226   /* TestOutputList for list_partitions (0) */
15227   {
15228     char **r;
15229     int i;
15230     suppress_error = 0;
15231     r = guestfs_list_partitions (g);
15232     if (r == NULL)
15233       return -1;
15234     if (!r[0]) {
15235       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15236       print_strings (r);
15237       return -1;
15238     }
15239     {
15240       char expected[] = "/dev/sda1";
15241       expected[5] = devchar;
15242       if (strcmp (r[0], expected) != 0) {
15243         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15244         return -1;
15245       }
15246     }
15247     if (r[1] != NULL) {
15248       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15249       print_strings (r);
15250       return -1;
15251     }
15252     for (i = 0; r[i] != NULL; ++i)
15253       free (r[i]);
15254     free (r);
15255   }
15256   return 0;
15257 }
15258
15259 static int test_list_partitions_1_skip (void)
15260 {
15261   const char *str;
15262
15263   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15264   if (str && strcmp (str, "1") == 0) return 1;
15265   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15266   if (str && strcmp (str, "1") == 0) return 1;
15267   return 0;
15268 }
15269
15270 static int test_list_partitions_1 (void)
15271 {
15272   if (test_list_partitions_1_skip ()) {
15273     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15274     return 0;
15275   }
15276
15277   /* InitNone|InitEmpty for test_list_partitions_1 */
15278   {
15279     char device[] = "/dev/sda";
15280     device[5] = devchar;
15281     int r;
15282     suppress_error = 0;
15283     r = guestfs_blockdev_setrw (g, device);
15284     if (r == -1)
15285       return -1;
15286   }
15287   {
15288     int r;
15289     suppress_error = 0;
15290     r = guestfs_umount_all (g);
15291     if (r == -1)
15292       return -1;
15293   }
15294   {
15295     int r;
15296     suppress_error = 0;
15297     r = guestfs_lvm_remove_all (g);
15298     if (r == -1)
15299       return -1;
15300   }
15301   /* TestOutputList for list_partitions (1) */
15302   {
15303     char device[] = "/dev/sda";
15304     device[5] = devchar;
15305     char lines_0[] = ",10";
15306     char lines_1[] = ",20";
15307     char lines_2[] = ",";
15308     char *lines[] = {
15309       lines_0,
15310       lines_1,
15311       lines_2,
15312       NULL
15313     };
15314     int r;
15315     suppress_error = 0;
15316     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15317     if (r == -1)
15318       return -1;
15319   }
15320   {
15321     char **r;
15322     int i;
15323     suppress_error = 0;
15324     r = guestfs_list_partitions (g);
15325     if (r == NULL)
15326       return -1;
15327     if (!r[0]) {
15328       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15329       print_strings (r);
15330       return -1;
15331     }
15332     {
15333       char expected[] = "/dev/sda1";
15334       expected[5] = devchar;
15335       if (strcmp (r[0], expected) != 0) {
15336         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15337         return -1;
15338       }
15339     }
15340     if (!r[1]) {
15341       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15342       print_strings (r);
15343       return -1;
15344     }
15345     {
15346       char expected[] = "/dev/sda2";
15347       expected[5] = devchar;
15348       if (strcmp (r[1], expected) != 0) {
15349         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15350         return -1;
15351       }
15352     }
15353     if (!r[2]) {
15354       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15355       print_strings (r);
15356       return -1;
15357     }
15358     {
15359       char expected[] = "/dev/sda3";
15360       expected[5] = devchar;
15361       if (strcmp (r[2], expected) != 0) {
15362         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15363         return -1;
15364       }
15365     }
15366     if (r[3] != NULL) {
15367       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15368       print_strings (r);
15369       return -1;
15370     }
15371     for (i = 0; r[i] != NULL; ++i)
15372       free (r[i]);
15373     free (r);
15374   }
15375   return 0;
15376 }
15377
15378 static int test_list_devices_0_skip (void)
15379 {
15380   const char *str;
15381
15382   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15383   if (str && strcmp (str, "1") == 0) return 1;
15384   str = getenv ("SKIP_TEST_LIST_DEVICES");
15385   if (str && strcmp (str, "1") == 0) return 1;
15386   return 0;
15387 }
15388
15389 static int test_list_devices_0 (void)
15390 {
15391   if (test_list_devices_0_skip ()) {
15392     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15393     return 0;
15394   }
15395
15396   /* InitNone|InitEmpty for test_list_devices_0 */
15397   {
15398     char device[] = "/dev/sda";
15399     device[5] = devchar;
15400     int r;
15401     suppress_error = 0;
15402     r = guestfs_blockdev_setrw (g, device);
15403     if (r == -1)
15404       return -1;
15405   }
15406   {
15407     int r;
15408     suppress_error = 0;
15409     r = guestfs_umount_all (g);
15410     if (r == -1)
15411       return -1;
15412   }
15413   {
15414     int r;
15415     suppress_error = 0;
15416     r = guestfs_lvm_remove_all (g);
15417     if (r == -1)
15418       return -1;
15419   }
15420   /* TestOutputList for list_devices (0) */
15421   {
15422     char **r;
15423     int i;
15424     suppress_error = 0;
15425     r = guestfs_list_devices (g);
15426     if (r == NULL)
15427       return -1;
15428     if (!r[0]) {
15429       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15430       print_strings (r);
15431       return -1;
15432     }
15433     {
15434       char expected[] = "/dev/sda";
15435       expected[5] = devchar;
15436       if (strcmp (r[0], expected) != 0) {
15437         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15438         return -1;
15439       }
15440     }
15441     if (!r[1]) {
15442       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15443       print_strings (r);
15444       return -1;
15445     }
15446     {
15447       char expected[] = "/dev/sdb";
15448       expected[5] = devchar;
15449       if (strcmp (r[1], expected) != 0) {
15450         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15451         return -1;
15452       }
15453     }
15454     if (!r[2]) {
15455       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15456       print_strings (r);
15457       return -1;
15458     }
15459     {
15460       char expected[] = "/dev/sdc";
15461       expected[5] = devchar;
15462       if (strcmp (r[2], expected) != 0) {
15463         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15464         return -1;
15465       }
15466     }
15467     if (!r[3]) {
15468       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15469       print_strings (r);
15470       return -1;
15471     }
15472     {
15473       char expected[] = "/dev/sdd";
15474       expected[5] = devchar;
15475       if (strcmp (r[3], expected) != 0) {
15476         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15477         return -1;
15478       }
15479     }
15480     if (r[4] != NULL) {
15481       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15482       print_strings (r);
15483       return -1;
15484     }
15485     for (i = 0; r[i] != NULL; ++i)
15486       free (r[i]);
15487     free (r);
15488   }
15489   return 0;
15490 }
15491
15492 static int test_ls_0_skip (void)
15493 {
15494   const char *str;
15495
15496   str = getenv ("SKIP_TEST_LS_0");
15497   if (str && strcmp (str, "1") == 0) return 1;
15498   str = getenv ("SKIP_TEST_LS");
15499   if (str && strcmp (str, "1") == 0) return 1;
15500   return 0;
15501 }
15502
15503 static int test_ls_0 (void)
15504 {
15505   if (test_ls_0_skip ()) {
15506     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15507     return 0;
15508   }
15509
15510   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15511   {
15512     char device[] = "/dev/sda";
15513     device[5] = devchar;
15514     int r;
15515     suppress_error = 0;
15516     r = guestfs_blockdev_setrw (g, device);
15517     if (r == -1)
15518       return -1;
15519   }
15520   {
15521     int r;
15522     suppress_error = 0;
15523     r = guestfs_umount_all (g);
15524     if (r == -1)
15525       return -1;
15526   }
15527   {
15528     int r;
15529     suppress_error = 0;
15530     r = guestfs_lvm_remove_all (g);
15531     if (r == -1)
15532       return -1;
15533   }
15534   {
15535     char device[] = "/dev/sda";
15536     device[5] = devchar;
15537     char lines_0[] = ",";
15538     char *lines[] = {
15539       lines_0,
15540       NULL
15541     };
15542     int r;
15543     suppress_error = 0;
15544     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15545     if (r == -1)
15546       return -1;
15547   }
15548   {
15549     char fstype[] = "ext2";
15550     char device[] = "/dev/sda1";
15551     device[5] = devchar;
15552     int r;
15553     suppress_error = 0;
15554     r = guestfs_mkfs (g, fstype, device);
15555     if (r == -1)
15556       return -1;
15557   }
15558   {
15559     char device[] = "/dev/sda1";
15560     device[5] = devchar;
15561     char mountpoint[] = "/";
15562     int r;
15563     suppress_error = 0;
15564     r = guestfs_mount (g, device, mountpoint);
15565     if (r == -1)
15566       return -1;
15567   }
15568   /* TestOutputList for ls (0) */
15569   {
15570     char path[] = "/new";
15571     int r;
15572     suppress_error = 0;
15573     r = guestfs_touch (g, path);
15574     if (r == -1)
15575       return -1;
15576   }
15577   {
15578     char path[] = "/newer";
15579     int r;
15580     suppress_error = 0;
15581     r = guestfs_touch (g, path);
15582     if (r == -1)
15583       return -1;
15584   }
15585   {
15586     char path[] = "/newest";
15587     int r;
15588     suppress_error = 0;
15589     r = guestfs_touch (g, path);
15590     if (r == -1)
15591       return -1;
15592   }
15593   {
15594     char directory[] = "/";
15595     char **r;
15596     int i;
15597     suppress_error = 0;
15598     r = guestfs_ls (g, directory);
15599     if (r == NULL)
15600       return -1;
15601     if (!r[0]) {
15602       fprintf (stderr, "test_ls_0: short list returned from command\n");
15603       print_strings (r);
15604       return -1;
15605     }
15606     {
15607       char expected[] = "lost+found";
15608       if (strcmp (r[0], expected) != 0) {
15609         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15610         return -1;
15611       }
15612     }
15613     if (!r[1]) {
15614       fprintf (stderr, "test_ls_0: short list returned from command\n");
15615       print_strings (r);
15616       return -1;
15617     }
15618     {
15619       char expected[] = "new";
15620       if (strcmp (r[1], expected) != 0) {
15621         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15622         return -1;
15623       }
15624     }
15625     if (!r[2]) {
15626       fprintf (stderr, "test_ls_0: short list returned from command\n");
15627       print_strings (r);
15628       return -1;
15629     }
15630     {
15631       char expected[] = "newer";
15632       if (strcmp (r[2], expected) != 0) {
15633         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15634         return -1;
15635       }
15636     }
15637     if (!r[3]) {
15638       fprintf (stderr, "test_ls_0: short list returned from command\n");
15639       print_strings (r);
15640       return -1;
15641     }
15642     {
15643       char expected[] = "newest";
15644       if (strcmp (r[3], expected) != 0) {
15645         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15646         return -1;
15647       }
15648     }
15649     if (r[4] != NULL) {
15650       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15651       print_strings (r);
15652       return -1;
15653     }
15654     for (i = 0; r[i] != NULL; ++i)
15655       free (r[i]);
15656     free (r);
15657   }
15658   return 0;
15659 }
15660
15661 static int test_cat_0_skip (void)
15662 {
15663   const char *str;
15664
15665   str = getenv ("SKIP_TEST_CAT_0");
15666   if (str && strcmp (str, "1") == 0) return 1;
15667   str = getenv ("SKIP_TEST_CAT");
15668   if (str && strcmp (str, "1") == 0) return 1;
15669   return 0;
15670 }
15671
15672 static int test_cat_0 (void)
15673 {
15674   if (test_cat_0_skip ()) {
15675     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15676     return 0;
15677   }
15678
15679   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15680   {
15681     char device[] = "/dev/sda";
15682     device[5] = devchar;
15683     int r;
15684     suppress_error = 0;
15685     r = guestfs_blockdev_setrw (g, device);
15686     if (r == -1)
15687       return -1;
15688   }
15689   {
15690     int r;
15691     suppress_error = 0;
15692     r = guestfs_umount_all (g);
15693     if (r == -1)
15694       return -1;
15695   }
15696   {
15697     int r;
15698     suppress_error = 0;
15699     r = guestfs_lvm_remove_all (g);
15700     if (r == -1)
15701       return -1;
15702   }
15703   {
15704     char device[] = "/dev/sda";
15705     device[5] = devchar;
15706     char lines_0[] = ",";
15707     char *lines[] = {
15708       lines_0,
15709       NULL
15710     };
15711     int r;
15712     suppress_error = 0;
15713     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15714     if (r == -1)
15715       return -1;
15716   }
15717   {
15718     char fstype[] = "ext2";
15719     char device[] = "/dev/sda1";
15720     device[5] = devchar;
15721     int r;
15722     suppress_error = 0;
15723     r = guestfs_mkfs (g, fstype, device);
15724     if (r == -1)
15725       return -1;
15726   }
15727   {
15728     char device[] = "/dev/sda1";
15729     device[5] = devchar;
15730     char mountpoint[] = "/";
15731     int r;
15732     suppress_error = 0;
15733     r = guestfs_mount (g, device, mountpoint);
15734     if (r == -1)
15735       return -1;
15736   }
15737   /* TestOutput for cat (0) */
15738   char expected[] = "new file contents";
15739   {
15740     char path[] = "/new";
15741     char content[] = "new file contents";
15742     int r;
15743     suppress_error = 0;
15744     r = guestfs_write_file (g, path, content, 0);
15745     if (r == -1)
15746       return -1;
15747   }
15748   {
15749     char path[] = "/new";
15750     char *r;
15751     suppress_error = 0;
15752     r = guestfs_cat (g, path);
15753     if (r == NULL)
15754       return -1;
15755     if (strcmp (r, expected) != 0) {
15756       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15757       return -1;
15758     }
15759     free (r);
15760   }
15761   return 0;
15762 }
15763
15764 static int test_touch_0_skip (void)
15765 {
15766   const char *str;
15767
15768   str = getenv ("SKIP_TEST_TOUCH_0");
15769   if (str && strcmp (str, "1") == 0) return 1;
15770   str = getenv ("SKIP_TEST_TOUCH");
15771   if (str && strcmp (str, "1") == 0) return 1;
15772   return 0;
15773 }
15774
15775 static int test_touch_0 (void)
15776 {
15777   if (test_touch_0_skip ()) {
15778     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15779     return 0;
15780   }
15781
15782   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15783   {
15784     char device[] = "/dev/sda";
15785     device[5] = devchar;
15786     int r;
15787     suppress_error = 0;
15788     r = guestfs_blockdev_setrw (g, device);
15789     if (r == -1)
15790       return -1;
15791   }
15792   {
15793     int r;
15794     suppress_error = 0;
15795     r = guestfs_umount_all (g);
15796     if (r == -1)
15797       return -1;
15798   }
15799   {
15800     int r;
15801     suppress_error = 0;
15802     r = guestfs_lvm_remove_all (g);
15803     if (r == -1)
15804       return -1;
15805   }
15806   {
15807     char device[] = "/dev/sda";
15808     device[5] = devchar;
15809     char lines_0[] = ",";
15810     char *lines[] = {
15811       lines_0,
15812       NULL
15813     };
15814     int r;
15815     suppress_error = 0;
15816     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15817     if (r == -1)
15818       return -1;
15819   }
15820   {
15821     char fstype[] = "ext2";
15822     char device[] = "/dev/sda1";
15823     device[5] = devchar;
15824     int r;
15825     suppress_error = 0;
15826     r = guestfs_mkfs (g, fstype, device);
15827     if (r == -1)
15828       return -1;
15829   }
15830   {
15831     char device[] = "/dev/sda1";
15832     device[5] = devchar;
15833     char mountpoint[] = "/";
15834     int r;
15835     suppress_error = 0;
15836     r = guestfs_mount (g, device, mountpoint);
15837     if (r == -1)
15838       return -1;
15839   }
15840   /* TestOutputTrue for touch (0) */
15841   {
15842     char path[] = "/new";
15843     int r;
15844     suppress_error = 0;
15845     r = guestfs_touch (g, path);
15846     if (r == -1)
15847       return -1;
15848   }
15849   {
15850     char path[] = "/new";
15851     int r;
15852     suppress_error = 0;
15853     r = guestfs_exists (g, path);
15854     if (r == -1)
15855       return -1;
15856     if (!r) {
15857       fprintf (stderr, "test_touch_0: expected true, got false\n");
15858       return -1;
15859     }
15860   }
15861   return 0;
15862 }
15863
15864 static int test_sync_0_skip (void)
15865 {
15866   const char *str;
15867
15868   str = getenv ("SKIP_TEST_SYNC_0");
15869   if (str && strcmp (str, "1") == 0) return 1;
15870   str = getenv ("SKIP_TEST_SYNC");
15871   if (str && strcmp (str, "1") == 0) return 1;
15872   return 0;
15873 }
15874
15875 static int test_sync_0 (void)
15876 {
15877   if (test_sync_0_skip ()) {
15878     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15879     return 0;
15880   }
15881
15882   /* InitNone|InitEmpty for test_sync_0 */
15883   {
15884     char device[] = "/dev/sda";
15885     device[5] = devchar;
15886     int r;
15887     suppress_error = 0;
15888     r = guestfs_blockdev_setrw (g, device);
15889     if (r == -1)
15890       return -1;
15891   }
15892   {
15893     int r;
15894     suppress_error = 0;
15895     r = guestfs_umount_all (g);
15896     if (r == -1)
15897       return -1;
15898   }
15899   {
15900     int r;
15901     suppress_error = 0;
15902     r = guestfs_lvm_remove_all (g);
15903     if (r == -1)
15904       return -1;
15905   }
15906   /* TestRun for sync (0) */
15907   {
15908     int r;
15909     suppress_error = 0;
15910     r = guestfs_sync (g);
15911     if (r == -1)
15912       return -1;
15913   }
15914   return 0;
15915 }
15916
15917 static int test_mount_0_skip (void)
15918 {
15919   const char *str;
15920
15921   str = getenv ("SKIP_TEST_MOUNT_0");
15922   if (str && strcmp (str, "1") == 0) return 1;
15923   str = getenv ("SKIP_TEST_MOUNT");
15924   if (str && strcmp (str, "1") == 0) return 1;
15925   return 0;
15926 }
15927
15928 static int test_mount_0 (void)
15929 {
15930   if (test_mount_0_skip ()) {
15931     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15932     return 0;
15933   }
15934
15935   /* InitNone|InitEmpty for test_mount_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   /* TestOutput for mount (0) */
15960   char expected[] = "new file contents";
15961   {
15962     char device[] = "/dev/sda";
15963     device[5] = devchar;
15964     char lines_0[] = ",";
15965     char *lines[] = {
15966       lines_0,
15967       NULL
15968     };
15969     int r;
15970     suppress_error = 0;
15971     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15972     if (r == -1)
15973       return -1;
15974   }
15975   {
15976     char fstype[] = "ext2";
15977     char device[] = "/dev/sda1";
15978     device[5] = devchar;
15979     int r;
15980     suppress_error = 0;
15981     r = guestfs_mkfs (g, fstype, device);
15982     if (r == -1)
15983       return -1;
15984   }
15985   {
15986     char device[] = "/dev/sda1";
15987     device[5] = devchar;
15988     char mountpoint[] = "/";
15989     int r;
15990     suppress_error = 0;
15991     r = guestfs_mount (g, device, mountpoint);
15992     if (r == -1)
15993       return -1;
15994   }
15995   {
15996     char path[] = "/new";
15997     char content[] = "new file contents";
15998     int r;
15999     suppress_error = 0;
16000     r = guestfs_write_file (g, path, content, 0);
16001     if (r == -1)
16002       return -1;
16003   }
16004   {
16005     char path[] = "/new";
16006     char *r;
16007     suppress_error = 0;
16008     r = guestfs_cat (g, path);
16009     if (r == NULL)
16010       return -1;
16011     if (strcmp (r, expected) != 0) {
16012       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16013       return -1;
16014     }
16015     free (r);
16016   }
16017   return 0;
16018 }
16019
16020 int main (int argc, char *argv[])
16021 {
16022   char c = 0;
16023   int failed = 0;
16024   const char *filename;
16025   int fd, i;
16026   int nr_tests, test_num = 0;
16027   char **devs;
16028
16029   no_test_warnings ();
16030
16031   g = guestfs_create ();
16032   if (g == NULL) {
16033     printf ("guestfs_create FAILED\n");
16034     exit (1);
16035   }
16036
16037   guestfs_set_error_handler (g, print_error, NULL);
16038
16039   guestfs_set_path (g, "../appliance");
16040
16041   filename = "test1.img";
16042   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16043   if (fd == -1) {
16044     perror (filename);
16045     exit (1);
16046   }
16047   if (lseek (fd, 524288000, SEEK_SET) == -1) {
16048     perror ("lseek");
16049     close (fd);
16050     unlink (filename);
16051     exit (1);
16052   }
16053   if (write (fd, &c, 1) == -1) {
16054     perror ("write");
16055     close (fd);
16056     unlink (filename);
16057     exit (1);
16058   }
16059   if (close (fd) == -1) {
16060     perror (filename);
16061     unlink (filename);
16062     exit (1);
16063   }
16064   if (guestfs_add_drive (g, filename) == -1) {
16065     printf ("guestfs_add_drive %s FAILED\n", filename);
16066     exit (1);
16067   }
16068
16069   filename = "test2.img";
16070   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16071   if (fd == -1) {
16072     perror (filename);
16073     exit (1);
16074   }
16075   if (lseek (fd, 52428800, SEEK_SET) == -1) {
16076     perror ("lseek");
16077     close (fd);
16078     unlink (filename);
16079     exit (1);
16080   }
16081   if (write (fd, &c, 1) == -1) {
16082     perror ("write");
16083     close (fd);
16084     unlink (filename);
16085     exit (1);
16086   }
16087   if (close (fd) == -1) {
16088     perror (filename);
16089     unlink (filename);
16090     exit (1);
16091   }
16092   if (guestfs_add_drive (g, filename) == -1) {
16093     printf ("guestfs_add_drive %s FAILED\n", filename);
16094     exit (1);
16095   }
16096
16097   filename = "test3.img";
16098   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16099   if (fd == -1) {
16100     perror (filename);
16101     exit (1);
16102   }
16103   if (lseek (fd, 10485760, SEEK_SET) == -1) {
16104     perror ("lseek");
16105     close (fd);
16106     unlink (filename);
16107     exit (1);
16108   }
16109   if (write (fd, &c, 1) == -1) {
16110     perror ("write");
16111     close (fd);
16112     unlink (filename);
16113     exit (1);
16114   }
16115   if (close (fd) == -1) {
16116     perror (filename);
16117     unlink (filename);
16118     exit (1);
16119   }
16120   if (guestfs_add_drive (g, filename) == -1) {
16121     printf ("guestfs_add_drive %s FAILED\n", filename);
16122     exit (1);
16123   }
16124
16125   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16126     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16127     exit (1);
16128   }
16129
16130   if (guestfs_launch (g) == -1) {
16131     printf ("guestfs_launch FAILED\n");
16132     exit (1);
16133   }
16134   if (guestfs_wait_ready (g) == -1) {
16135     printf ("guestfs_wait_ready FAILED\n");
16136     exit (1);
16137   }
16138
16139   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
16140    * names.  This changed between RHEL 5 and RHEL 6 so we have to
16141    * support both.
16142    */
16143   devs = guestfs_list_devices (g);
16144   if (devs == NULL || devs[0] == NULL) {
16145     printf ("guestfs_list_devices FAILED\n");
16146     exit (1);
16147   }
16148   if (strncmp (devs[0], "/dev/sd", 7) == 0)
16149     devchar = 's';
16150   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
16151     devchar = 'h';
16152   else {
16153     printf ("guestfs_list_devices returned unexpected string '%s'\n",
16154             devs[0]);
16155     exit (1);
16156   }
16157   for (i = 0; devs[i] != NULL; ++i)
16158     free (devs[i]);
16159   free (devs);
16160
16161   nr_tests = 143;
16162
16163   test_num++;
16164   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16165   if (test_find_0 () == -1) {
16166     printf ("test_find_0 FAILED\n");
16167     failed++;
16168   }
16169   test_num++;
16170   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16171   if (test_find_1 () == -1) {
16172     printf ("test_find_1 FAILED\n");
16173     failed++;
16174   }
16175   test_num++;
16176   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16177   if (test_find_2 () == -1) {
16178     printf ("test_find_2 FAILED\n");
16179     failed++;
16180   }
16181   test_num++;
16182   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16183   if (test_lvresize_0 () == -1) {
16184     printf ("test_lvresize_0 FAILED\n");
16185     failed++;
16186   }
16187   test_num++;
16188   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16189   if (test_zerofree_0 () == -1) {
16190     printf ("test_zerofree_0 FAILED\n");
16191     failed++;
16192   }
16193   test_num++;
16194   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16195   if (test_hexdump_0 () == -1) {
16196     printf ("test_hexdump_0 FAILED\n");
16197     failed++;
16198   }
16199   test_num++;
16200   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16201   if (test_strings_e_0 () == -1) {
16202     printf ("test_strings_e_0 FAILED\n");
16203     failed++;
16204   }
16205   test_num++;
16206   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16207   if (test_strings_e_1 () == -1) {
16208     printf ("test_strings_e_1 FAILED\n");
16209     failed++;
16210   }
16211   test_num++;
16212   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16213   if (test_strings_0 () == -1) {
16214     printf ("test_strings_0 FAILED\n");
16215     failed++;
16216   }
16217   test_num++;
16218   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16219   if (test_strings_1 () == -1) {
16220     printf ("test_strings_1 FAILED\n");
16221     failed++;
16222   }
16223   test_num++;
16224   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16225   if (test_equal_0 () == -1) {
16226     printf ("test_equal_0 FAILED\n");
16227     failed++;
16228   }
16229   test_num++;
16230   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16231   if (test_equal_1 () == -1) {
16232     printf ("test_equal_1 FAILED\n");
16233     failed++;
16234   }
16235   test_num++;
16236   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16237   if (test_equal_2 () == -1) {
16238     printf ("test_equal_2 FAILED\n");
16239     failed++;
16240   }
16241   test_num++;
16242   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16243   if (test_ping_daemon_0 () == -1) {
16244     printf ("test_ping_daemon_0 FAILED\n");
16245     failed++;
16246   }
16247   test_num++;
16248   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16249   if (test_dmesg_0 () == -1) {
16250     printf ("test_dmesg_0 FAILED\n");
16251     failed++;
16252   }
16253   test_num++;
16254   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16255   if (test_drop_caches_0 () == -1) {
16256     printf ("test_drop_caches_0 FAILED\n");
16257     failed++;
16258   }
16259   test_num++;
16260   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16261   if (test_mv_0 () == -1) {
16262     printf ("test_mv_0 FAILED\n");
16263     failed++;
16264   }
16265   test_num++;
16266   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16267   if (test_mv_1 () == -1) {
16268     printf ("test_mv_1 FAILED\n");
16269     failed++;
16270   }
16271   test_num++;
16272   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16273   if (test_cp_a_0 () == -1) {
16274     printf ("test_cp_a_0 FAILED\n");
16275     failed++;
16276   }
16277   test_num++;
16278   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16279   if (test_cp_0 () == -1) {
16280     printf ("test_cp_0 FAILED\n");
16281     failed++;
16282   }
16283   test_num++;
16284   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16285   if (test_cp_1 () == -1) {
16286     printf ("test_cp_1 FAILED\n");
16287     failed++;
16288   }
16289   test_num++;
16290   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16291   if (test_cp_2 () == -1) {
16292     printf ("test_cp_2 FAILED\n");
16293     failed++;
16294   }
16295   test_num++;
16296   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16297   if (test_grub_install_0 () == -1) {
16298     printf ("test_grub_install_0 FAILED\n");
16299     failed++;
16300   }
16301   test_num++;
16302   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16303   if (test_zero_0 () == -1) {
16304     printf ("test_zero_0 FAILED\n");
16305     failed++;
16306   }
16307   test_num++;
16308   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16309   if (test_fsck_0 () == -1) {
16310     printf ("test_fsck_0 FAILED\n");
16311     failed++;
16312   }
16313   test_num++;
16314   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16315   if (test_fsck_1 () == -1) {
16316     printf ("test_fsck_1 FAILED\n");
16317     failed++;
16318   }
16319   test_num++;
16320   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16321   if (test_set_e2uuid_0 () == -1) {
16322     printf ("test_set_e2uuid_0 FAILED\n");
16323     failed++;
16324   }
16325   test_num++;
16326   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16327   if (test_set_e2uuid_1 () == -1) {
16328     printf ("test_set_e2uuid_1 FAILED\n");
16329     failed++;
16330   }
16331   test_num++;
16332   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16333   if (test_set_e2uuid_2 () == -1) {
16334     printf ("test_set_e2uuid_2 FAILED\n");
16335     failed++;
16336   }
16337   test_num++;
16338   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16339   if (test_set_e2uuid_3 () == -1) {
16340     printf ("test_set_e2uuid_3 FAILED\n");
16341     failed++;
16342   }
16343   test_num++;
16344   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16345   if (test_set_e2label_0 () == -1) {
16346     printf ("test_set_e2label_0 FAILED\n");
16347     failed++;
16348   }
16349   test_num++;
16350   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16351   if (test_pvremove_0 () == -1) {
16352     printf ("test_pvremove_0 FAILED\n");
16353     failed++;
16354   }
16355   test_num++;
16356   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16357   if (test_pvremove_1 () == -1) {
16358     printf ("test_pvremove_1 FAILED\n");
16359     failed++;
16360   }
16361   test_num++;
16362   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16363   if (test_pvremove_2 () == -1) {
16364     printf ("test_pvremove_2 FAILED\n");
16365     failed++;
16366   }
16367   test_num++;
16368   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16369   if (test_vgremove_0 () == -1) {
16370     printf ("test_vgremove_0 FAILED\n");
16371     failed++;
16372   }
16373   test_num++;
16374   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16375   if (test_vgremove_1 () == -1) {
16376     printf ("test_vgremove_1 FAILED\n");
16377     failed++;
16378   }
16379   test_num++;
16380   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16381   if (test_lvremove_0 () == -1) {
16382     printf ("test_lvremove_0 FAILED\n");
16383     failed++;
16384   }
16385   test_num++;
16386   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16387   if (test_lvremove_1 () == -1) {
16388     printf ("test_lvremove_1 FAILED\n");
16389     failed++;
16390   }
16391   test_num++;
16392   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16393   if (test_lvremove_2 () == -1) {
16394     printf ("test_lvremove_2 FAILED\n");
16395     failed++;
16396   }
16397   test_num++;
16398   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16399   if (test_mount_ro_0 () == -1) {
16400     printf ("test_mount_ro_0 FAILED\n");
16401     failed++;
16402   }
16403   test_num++;
16404   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16405   if (test_mount_ro_1 () == -1) {
16406     printf ("test_mount_ro_1 FAILED\n");
16407     failed++;
16408   }
16409   test_num++;
16410   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16411   if (test_tgz_in_0 () == -1) {
16412     printf ("test_tgz_in_0 FAILED\n");
16413     failed++;
16414   }
16415   test_num++;
16416   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16417   if (test_tar_in_0 () == -1) {
16418     printf ("test_tar_in_0 FAILED\n");
16419     failed++;
16420   }
16421   test_num++;
16422   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16423   if (test_checksum_0 () == -1) {
16424     printf ("test_checksum_0 FAILED\n");
16425     failed++;
16426   }
16427   test_num++;
16428   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16429   if (test_checksum_1 () == -1) {
16430     printf ("test_checksum_1 FAILED\n");
16431     failed++;
16432   }
16433   test_num++;
16434   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16435   if (test_checksum_2 () == -1) {
16436     printf ("test_checksum_2 FAILED\n");
16437     failed++;
16438   }
16439   test_num++;
16440   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16441   if (test_checksum_3 () == -1) {
16442     printf ("test_checksum_3 FAILED\n");
16443     failed++;
16444   }
16445   test_num++;
16446   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16447   if (test_checksum_4 () == -1) {
16448     printf ("test_checksum_4 FAILED\n");
16449     failed++;
16450   }
16451   test_num++;
16452   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16453   if (test_checksum_5 () == -1) {
16454     printf ("test_checksum_5 FAILED\n");
16455     failed++;
16456   }
16457   test_num++;
16458   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16459   if (test_checksum_6 () == -1) {
16460     printf ("test_checksum_6 FAILED\n");
16461     failed++;
16462   }
16463   test_num++;
16464   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16465   if (test_checksum_7 () == -1) {
16466     printf ("test_checksum_7 FAILED\n");
16467     failed++;
16468   }
16469   test_num++;
16470   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16471   if (test_checksum_8 () == -1) {
16472     printf ("test_checksum_8 FAILED\n");
16473     failed++;
16474   }
16475   test_num++;
16476   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16477   if (test_download_0 () == -1) {
16478     printf ("test_download_0 FAILED\n");
16479     failed++;
16480   }
16481   test_num++;
16482   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16483   if (test_upload_0 () == -1) {
16484     printf ("test_upload_0 FAILED\n");
16485     failed++;
16486   }
16487   test_num++;
16488   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16489   if (test_blockdev_rereadpt_0 () == -1) {
16490     printf ("test_blockdev_rereadpt_0 FAILED\n");
16491     failed++;
16492   }
16493   test_num++;
16494   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16495   if (test_blockdev_flushbufs_0 () == -1) {
16496     printf ("test_blockdev_flushbufs_0 FAILED\n");
16497     failed++;
16498   }
16499   test_num++;
16500   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16501   if (test_blockdev_getsize64_0 () == -1) {
16502     printf ("test_blockdev_getsize64_0 FAILED\n");
16503     failed++;
16504   }
16505   test_num++;
16506   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16507   if (test_blockdev_getsz_0 () == -1) {
16508     printf ("test_blockdev_getsz_0 FAILED\n");
16509     failed++;
16510   }
16511   test_num++;
16512   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16513   if (test_blockdev_getbsz_0 () == -1) {
16514     printf ("test_blockdev_getbsz_0 FAILED\n");
16515     failed++;
16516   }
16517   test_num++;
16518   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16519   if (test_blockdev_getss_0 () == -1) {
16520     printf ("test_blockdev_getss_0 FAILED\n");
16521     failed++;
16522   }
16523   test_num++;
16524   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16525   if (test_blockdev_getro_0 () == -1) {
16526     printf ("test_blockdev_getro_0 FAILED\n");
16527     failed++;
16528   }
16529   test_num++;
16530   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16531   if (test_blockdev_setrw_0 () == -1) {
16532     printf ("test_blockdev_setrw_0 FAILED\n");
16533     failed++;
16534   }
16535   test_num++;
16536   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16537   if (test_blockdev_setro_0 () == -1) {
16538     printf ("test_blockdev_setro_0 FAILED\n");
16539     failed++;
16540   }
16541   test_num++;
16542   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16543   if (test_statvfs_0 () == -1) {
16544     printf ("test_statvfs_0 FAILED\n");
16545     failed++;
16546   }
16547   test_num++;
16548   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16549   if (test_lstat_0 () == -1) {
16550     printf ("test_lstat_0 FAILED\n");
16551     failed++;
16552   }
16553   test_num++;
16554   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16555   if (test_stat_0 () == -1) {
16556     printf ("test_stat_0 FAILED\n");
16557     failed++;
16558   }
16559   test_num++;
16560   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16561   if (test_command_lines_0 () == -1) {
16562     printf ("test_command_lines_0 FAILED\n");
16563     failed++;
16564   }
16565   test_num++;
16566   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16567   if (test_command_lines_1 () == -1) {
16568     printf ("test_command_lines_1 FAILED\n");
16569     failed++;
16570   }
16571   test_num++;
16572   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16573   if (test_command_lines_2 () == -1) {
16574     printf ("test_command_lines_2 FAILED\n");
16575     failed++;
16576   }
16577   test_num++;
16578   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16579   if (test_command_lines_3 () == -1) {
16580     printf ("test_command_lines_3 FAILED\n");
16581     failed++;
16582   }
16583   test_num++;
16584   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16585   if (test_command_lines_4 () == -1) {
16586     printf ("test_command_lines_4 FAILED\n");
16587     failed++;
16588   }
16589   test_num++;
16590   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16591   if (test_command_lines_5 () == -1) {
16592     printf ("test_command_lines_5 FAILED\n");
16593     failed++;
16594   }
16595   test_num++;
16596   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16597   if (test_command_lines_6 () == -1) {
16598     printf ("test_command_lines_6 FAILED\n");
16599     failed++;
16600   }
16601   test_num++;
16602   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16603   if (test_command_lines_7 () == -1) {
16604     printf ("test_command_lines_7 FAILED\n");
16605     failed++;
16606   }
16607   test_num++;
16608   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16609   if (test_command_lines_8 () == -1) {
16610     printf ("test_command_lines_8 FAILED\n");
16611     failed++;
16612   }
16613   test_num++;
16614   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16615   if (test_command_lines_9 () == -1) {
16616     printf ("test_command_lines_9 FAILED\n");
16617     failed++;
16618   }
16619   test_num++;
16620   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16621   if (test_command_lines_10 () == -1) {
16622     printf ("test_command_lines_10 FAILED\n");
16623     failed++;
16624   }
16625   test_num++;
16626   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16627   if (test_command_0 () == -1) {
16628     printf ("test_command_0 FAILED\n");
16629     failed++;
16630   }
16631   test_num++;
16632   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16633   if (test_command_1 () == -1) {
16634     printf ("test_command_1 FAILED\n");
16635     failed++;
16636   }
16637   test_num++;
16638   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16639   if (test_command_2 () == -1) {
16640     printf ("test_command_2 FAILED\n");
16641     failed++;
16642   }
16643   test_num++;
16644   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16645   if (test_command_3 () == -1) {
16646     printf ("test_command_3 FAILED\n");
16647     failed++;
16648   }
16649   test_num++;
16650   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16651   if (test_command_4 () == -1) {
16652     printf ("test_command_4 FAILED\n");
16653     failed++;
16654   }
16655   test_num++;
16656   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16657   if (test_command_5 () == -1) {
16658     printf ("test_command_5 FAILED\n");
16659     failed++;
16660   }
16661   test_num++;
16662   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16663   if (test_command_6 () == -1) {
16664     printf ("test_command_6 FAILED\n");
16665     failed++;
16666   }
16667   test_num++;
16668   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16669   if (test_command_7 () == -1) {
16670     printf ("test_command_7 FAILED\n");
16671     failed++;
16672   }
16673   test_num++;
16674   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16675   if (test_command_8 () == -1) {
16676     printf ("test_command_8 FAILED\n");
16677     failed++;
16678   }
16679   test_num++;
16680   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16681   if (test_command_9 () == -1) {
16682     printf ("test_command_9 FAILED\n");
16683     failed++;
16684   }
16685   test_num++;
16686   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16687   if (test_command_10 () == -1) {
16688     printf ("test_command_10 FAILED\n");
16689     failed++;
16690   }
16691   test_num++;
16692   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16693   if (test_command_11 () == -1) {
16694     printf ("test_command_11 FAILED\n");
16695     failed++;
16696   }
16697   test_num++;
16698   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16699   if (test_file_0 () == -1) {
16700     printf ("test_file_0 FAILED\n");
16701     failed++;
16702   }
16703   test_num++;
16704   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16705   if (test_file_1 () == -1) {
16706     printf ("test_file_1 FAILED\n");
16707     failed++;
16708   }
16709   test_num++;
16710   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16711   if (test_file_2 () == -1) {
16712     printf ("test_file_2 FAILED\n");
16713     failed++;
16714   }
16715   test_num++;
16716   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16717   if (test_umount_all_0 () == -1) {
16718     printf ("test_umount_all_0 FAILED\n");
16719     failed++;
16720   }
16721   test_num++;
16722   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16723   if (test_umount_all_1 () == -1) {
16724     printf ("test_umount_all_1 FAILED\n");
16725     failed++;
16726   }
16727   test_num++;
16728   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16729   if (test_mounts_0 () == -1) {
16730     printf ("test_mounts_0 FAILED\n");
16731     failed++;
16732   }
16733   test_num++;
16734   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16735   if (test_umount_0 () == -1) {
16736     printf ("test_umount_0 FAILED\n");
16737     failed++;
16738   }
16739   test_num++;
16740   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16741   if (test_umount_1 () == -1) {
16742     printf ("test_umount_1 FAILED\n");
16743     failed++;
16744   }
16745   test_num++;
16746   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16747   if (test_write_file_0 () == -1) {
16748     printf ("test_write_file_0 FAILED\n");
16749     failed++;
16750   }
16751   test_num++;
16752   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16753   if (test_write_file_1 () == -1) {
16754     printf ("test_write_file_1 FAILED\n");
16755     failed++;
16756   }
16757   test_num++;
16758   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16759   if (test_write_file_2 () == -1) {
16760     printf ("test_write_file_2 FAILED\n");
16761     failed++;
16762   }
16763   test_num++;
16764   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16765   if (test_write_file_3 () == -1) {
16766     printf ("test_write_file_3 FAILED\n");
16767     failed++;
16768   }
16769   test_num++;
16770   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16771   if (test_write_file_4 () == -1) {
16772     printf ("test_write_file_4 FAILED\n");
16773     failed++;
16774   }
16775   test_num++;
16776   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16777   if (test_write_file_5 () == -1) {
16778     printf ("test_write_file_5 FAILED\n");
16779     failed++;
16780   }
16781   test_num++;
16782   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16783   if (test_mkfs_0 () == -1) {
16784     printf ("test_mkfs_0 FAILED\n");
16785     failed++;
16786   }
16787   test_num++;
16788   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16789   if (test_lvcreate_0 () == -1) {
16790     printf ("test_lvcreate_0 FAILED\n");
16791     failed++;
16792   }
16793   test_num++;
16794   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16795   if (test_vgcreate_0 () == -1) {
16796     printf ("test_vgcreate_0 FAILED\n");
16797     failed++;
16798   }
16799   test_num++;
16800   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16801   if (test_pvcreate_0 () == -1) {
16802     printf ("test_pvcreate_0 FAILED\n");
16803     failed++;
16804   }
16805   test_num++;
16806   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16807   if (test_is_dir_0 () == -1) {
16808     printf ("test_is_dir_0 FAILED\n");
16809     failed++;
16810   }
16811   test_num++;
16812   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16813   if (test_is_dir_1 () == -1) {
16814     printf ("test_is_dir_1 FAILED\n");
16815     failed++;
16816   }
16817   test_num++;
16818   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16819   if (test_is_file_0 () == -1) {
16820     printf ("test_is_file_0 FAILED\n");
16821     failed++;
16822   }
16823   test_num++;
16824   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16825   if (test_is_file_1 () == -1) {
16826     printf ("test_is_file_1 FAILED\n");
16827     failed++;
16828   }
16829   test_num++;
16830   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16831   if (test_exists_0 () == -1) {
16832     printf ("test_exists_0 FAILED\n");
16833     failed++;
16834   }
16835   test_num++;
16836   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16837   if (test_exists_1 () == -1) {
16838     printf ("test_exists_1 FAILED\n");
16839     failed++;
16840   }
16841   test_num++;
16842   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16843   if (test_mkdir_p_0 () == -1) {
16844     printf ("test_mkdir_p_0 FAILED\n");
16845     failed++;
16846   }
16847   test_num++;
16848   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16849   if (test_mkdir_p_1 () == -1) {
16850     printf ("test_mkdir_p_1 FAILED\n");
16851     failed++;
16852   }
16853   test_num++;
16854   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16855   if (test_mkdir_p_2 () == -1) {
16856     printf ("test_mkdir_p_2 FAILED\n");
16857     failed++;
16858   }
16859   test_num++;
16860   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16861   if (test_mkdir_p_3 () == -1) {
16862     printf ("test_mkdir_p_3 FAILED\n");
16863     failed++;
16864   }
16865   test_num++;
16866   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16867   if (test_mkdir_p_4 () == -1) {
16868     printf ("test_mkdir_p_4 FAILED\n");
16869     failed++;
16870   }
16871   test_num++;
16872   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16873   if (test_mkdir_0 () == -1) {
16874     printf ("test_mkdir_0 FAILED\n");
16875     failed++;
16876   }
16877   test_num++;
16878   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16879   if (test_mkdir_1 () == -1) {
16880     printf ("test_mkdir_1 FAILED\n");
16881     failed++;
16882   }
16883   test_num++;
16884   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16885   if (test_rm_rf_0 () == -1) {
16886     printf ("test_rm_rf_0 FAILED\n");
16887     failed++;
16888   }
16889   test_num++;
16890   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16891   if (test_rmdir_0 () == -1) {
16892     printf ("test_rmdir_0 FAILED\n");
16893     failed++;
16894   }
16895   test_num++;
16896   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16897   if (test_rmdir_1 () == -1) {
16898     printf ("test_rmdir_1 FAILED\n");
16899     failed++;
16900   }
16901   test_num++;
16902   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16903   if (test_rmdir_2 () == -1) {
16904     printf ("test_rmdir_2 FAILED\n");
16905     failed++;
16906   }
16907   test_num++;
16908   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16909   if (test_rm_0 () == -1) {
16910     printf ("test_rm_0 FAILED\n");
16911     failed++;
16912   }
16913   test_num++;
16914   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16915   if (test_rm_1 () == -1) {
16916     printf ("test_rm_1 FAILED\n");
16917     failed++;
16918   }
16919   test_num++;
16920   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16921   if (test_rm_2 () == -1) {
16922     printf ("test_rm_2 FAILED\n");
16923     failed++;
16924   }
16925   test_num++;
16926   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16927   if (test_read_lines_0 () == -1) {
16928     printf ("test_read_lines_0 FAILED\n");
16929     failed++;
16930   }
16931   test_num++;
16932   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16933   if (test_read_lines_1 () == -1) {
16934     printf ("test_read_lines_1 FAILED\n");
16935     failed++;
16936   }
16937   test_num++;
16938   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16939   if (test_lvs_0 () == -1) {
16940     printf ("test_lvs_0 FAILED\n");
16941     failed++;
16942   }
16943   test_num++;
16944   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16945   if (test_lvs_1 () == -1) {
16946     printf ("test_lvs_1 FAILED\n");
16947     failed++;
16948   }
16949   test_num++;
16950   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16951   if (test_vgs_0 () == -1) {
16952     printf ("test_vgs_0 FAILED\n");
16953     failed++;
16954   }
16955   test_num++;
16956   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16957   if (test_vgs_1 () == -1) {
16958     printf ("test_vgs_1 FAILED\n");
16959     failed++;
16960   }
16961   test_num++;
16962   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16963   if (test_pvs_0 () == -1) {
16964     printf ("test_pvs_0 FAILED\n");
16965     failed++;
16966   }
16967   test_num++;
16968   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16969   if (test_pvs_1 () == -1) {
16970     printf ("test_pvs_1 FAILED\n");
16971     failed++;
16972   }
16973   test_num++;
16974   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16975   if (test_list_partitions_0 () == -1) {
16976     printf ("test_list_partitions_0 FAILED\n");
16977     failed++;
16978   }
16979   test_num++;
16980   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16981   if (test_list_partitions_1 () == -1) {
16982     printf ("test_list_partitions_1 FAILED\n");
16983     failed++;
16984   }
16985   test_num++;
16986   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16987   if (test_list_devices_0 () == -1) {
16988     printf ("test_list_devices_0 FAILED\n");
16989     failed++;
16990   }
16991   test_num++;
16992   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16993   if (test_ls_0 () == -1) {
16994     printf ("test_ls_0 FAILED\n");
16995     failed++;
16996   }
16997   test_num++;
16998   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16999   if (test_cat_0 () == -1) {
17000     printf ("test_cat_0 FAILED\n");
17001     failed++;
17002   }
17003   test_num++;
17004   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17005   if (test_touch_0 () == -1) {
17006     printf ("test_touch_0 FAILED\n");
17007     failed++;
17008   }
17009   test_num++;
17010   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17011   if (test_sync_0 () == -1) {
17012     printf ("test_sync_0 FAILED\n");
17013     failed++;
17014   }
17015   test_num++;
17016   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17017   if (test_mount_0 () == -1) {
17018     printf ("test_mount_0 FAILED\n");
17019     failed++;
17020   }
17021
17022   guestfs_close (g);
17023   unlink ("test1.img");
17024   unlink ("test2.img");
17025   unlink ("test3.img");
17026
17027   if (failed > 0) {
17028     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
17029     exit (1);
17030   }
17031
17032   exit (0);
17033 }