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_config\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 155 }
 156
 157 static int test_find_0_skip (void)
 158 {
 159   const char *str;
 160
 161   str = getenv ("SKIP_TEST_FIND_0");
 162   if (str && strcmp (str, "1") == 0) return 1;
 163   str = getenv ("SKIP_TEST_FIND");
 164   if (str && strcmp (str, "1") == 0) return 1;
 165   return 0;
 166 }
 167
 168 static int test_find_0 (void)
 169 {
 170   if (test_find_0_skip ()) {
 171     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
 172     return 0;
 173   }
 174
 175   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 176   {
 177     char device[] = "/dev/sda";
 178     device[5] = devchar;
 179     int r;
 180     suppress_error = 0;
 181     r = guestfs_blockdev_setrw (g, device);
 182     if (r == -1)
 183       return -1;
 184   }
 185   {
 186     int r;
 187     suppress_error = 0;
 188     r = guestfs_umount_all (g);
 189     if (r == -1)
 190       return -1;
 191   }
 192   {
 193     int r;
 194     suppress_error = 0;
 195     r = guestfs_lvm_remove_all (g);
 196     if (r == -1)
 197       return -1;
 198   }
 199   {
 200     char device[] = "/dev/sda";
 201     device[5] = devchar;
 202     char lines_0[] = ",";
 203     char *lines[] = {
 204       lines_0,
 205       NULL
 206     };
 207     int r;
 208     suppress_error = 0;
 209     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 210     if (r == -1)
 211       return -1;
 212   }
 213   {
 214     char fstype[] = "ext2";
 215     char device[] = "/dev/sda1";
 216     device[5] = devchar;
 217     int r;
 218     suppress_error = 0;
 219     r = guestfs_mkfs (g, fstype, device);
 220     if (r == -1)
 221       return -1;
 222   }
 223   {
 224     char device[] = "/dev/sda1";
 225     device[5] = devchar;
 226     char mountpoint[] = "/";
 227     int r;
 228     suppress_error = 0;
 229     r = guestfs_mount (g, device, mountpoint);
 230     if (r == -1)
 231       return -1;
 232   }
 233   /* TestOutputList for find (0) */
 234   {
 235     char directory[] = "/";
 236     char **r;
 237     int i;
 238     suppress_error = 0;
 239     r = guestfs_find (g, directory);
 240     if (r == NULL)
 241       return -1;
 242     if (!r[0]) {
 243       fprintf (stderr, "test_find_0: short list returned from command\n");
 244       print_strings (r);
 245       return -1;
 246     }
 247     {
 248       char expected[] = "lost+found";
 249       if (strcmp (r[0], expected) != 0) {
 250         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 251         return -1;
 252       }
 253     }
 254     if (r[1] != NULL) {
 255       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 256       print_strings (r);
 257       return -1;
 258     }
 259     for (i = 0; r[i] != NULL; ++i)
 260       free (r[i]);
 261     free (r);
 262   }
 263   return 0;
 264 }
 265
 266 static int test_find_1_skip (void)
 267 {
 268   const char *str;
 269
 270   str = getenv ("SKIP_TEST_FIND_1");
 271   if (str && strcmp (str, "1") == 0) return 1;
 272   str = getenv ("SKIP_TEST_FIND");
 273   if (str && strcmp (str, "1") == 0) return 1;
 274   return 0;
 275 }
 276
 277 static int test_find_1 (void)
 278 {
 279   if (test_find_1_skip ()) {
 280     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
 281     return 0;
 282   }
 283
 284   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
 285   {
 286     char device[] = "/dev/sda";
 287     device[5] = devchar;
 288     int r;
 289     suppress_error = 0;
 290     r = guestfs_blockdev_setrw (g, device);
 291     if (r == -1)
 292       return -1;
 293   }
 294   {
 295     int r;
 296     suppress_error = 0;
 297     r = guestfs_umount_all (g);
 298     if (r == -1)
 299       return -1;
 300   }
 301   {
 302     int r;
 303     suppress_error = 0;
 304     r = guestfs_lvm_remove_all (g);
 305     if (r == -1)
 306       return -1;
 307   }
 308   {
 309     char device[] = "/dev/sda";
 310     device[5] = devchar;
 311     char lines_0[] = ",";
 312     char *lines[] = {
 313       lines_0,
 314       NULL
 315     };
 316     int r;
 317     suppress_error = 0;
 318     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 319     if (r == -1)
 320       return -1;
 321   }
 322   {
 323     char fstype[] = "ext2";
 324     char device[] = "/dev/sda1";
 325     device[5] = devchar;
 326     int r;
 327     suppress_error = 0;
 328     r = guestfs_mkfs (g, fstype, device);
 329     if (r == -1)
 330       return -1;
 331   }
 332   {
 333     char device[] = "/dev/sda1";
 334     device[5] = devchar;
 335     char mountpoint[] = "/";
 336     int r;
 337     suppress_error = 0;
 338     r = guestfs_mount (g, device, mountpoint);
 339     if (r == -1)
 340       return -1;
 341   }
 342   /* TestOutputList for find (1) */
 343   {
 344     char path[] = "/a";
 345     int r;
 346     suppress_error = 0;
 347     r = guestfs_touch (g, path);
 348     if (r == -1)
 349       return -1;
 350   }
 351   {
 352     char path[] = "/b";
 353     int r;
 354     suppress_error = 0;
 355     r = guestfs_mkdir (g, path);
 356     if (r == -1)
 357       return -1;
 358   }
 359   {
 360     char path[] = "/b/c";
 361     int r;
 362     suppress_error = 0;
 363     r = guestfs_touch (g, path);
 364     if (r == -1)
 365       return -1;
 366   }
 367   {
 368     char directory[] = "/";
 369     char **r;
 370     int i;
 371     suppress_error = 0;
 372     r = guestfs_find (g, directory);
 373     if (r == NULL)
 374       return -1;
 375     if (!r[0]) {
 376       fprintf (stderr, "test_find_1: short list returned from command\n");
 377       print_strings (r);
 378       return -1;
 379     }
 380     {
 381       char expected[] = "a";
 382       if (strcmp (r[0], expected) != 0) {
 383         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 384         return -1;
 385       }
 386     }
 387     if (!r[1]) {
 388       fprintf (stderr, "test_find_1: short list returned from command\n");
 389       print_strings (r);
 390       return -1;
 391     }
 392     {
 393       char expected[] = "b";
 394       if (strcmp (r[1], expected) != 0) {
 395         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 396         return -1;
 397       }
 398     }
 399     if (!r[2]) {
 400       fprintf (stderr, "test_find_1: short list returned from command\n");
 401       print_strings (r);
 402       return -1;
 403     }
 404     {
 405       char expected[] = "b/c";
 406       if (strcmp (r[2], expected) != 0) {
 407         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 408         return -1;
 409       }
 410     }
 411     if (!r[3]) {
 412       fprintf (stderr, "test_find_1: short list returned from command\n");
 413       print_strings (r);
 414       return -1;
 415     }
 416     {
 417       char expected[] = "lost+found";
 418       if (strcmp (r[3], expected) != 0) {
 419         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 420         return -1;
 421       }
 422     }
 423     if (r[4] != NULL) {
 424       fprintf (stderr, "test_find_1: extra elements returned from command\n");
 425       print_strings (r);
 426       return -1;
 427     }
 428     for (i = 0; r[i] != NULL; ++i)
 429       free (r[i]);
 430     free (r);
 431   }
 432   return 0;
 433 }
 434
 435 static int test_find_2_skip (void)
 436 {
 437   const char *str;
 438
 439   str = getenv ("SKIP_TEST_FIND_2");
 440   if (str && strcmp (str, "1") == 0) return 1;
 441   str = getenv ("SKIP_TEST_FIND");
 442   if (str && strcmp (str, "1") == 0) return 1;
 443   return 0;
 444 }
 445
 446 static int test_find_2 (void)
 447 {
 448   if (test_find_2_skip ()) {
 449     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
 450     return 0;
 451   }
 452
 453   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
 454   {
 455     char device[] = "/dev/sda";
 456     device[5] = devchar;
 457     int r;
 458     suppress_error = 0;
 459     r = guestfs_blockdev_setrw (g, device);
 460     if (r == -1)
 461       return -1;
 462   }
 463   {
 464     int r;
 465     suppress_error = 0;
 466     r = guestfs_umount_all (g);
 467     if (r == -1)
 468       return -1;
 469   }
 470   {
 471     int r;
 472     suppress_error = 0;
 473     r = guestfs_lvm_remove_all (g);
 474     if (r == -1)
 475       return -1;
 476   }
 477   {
 478     char device[] = "/dev/sda";
 479     device[5] = devchar;
 480     char lines_0[] = ",";
 481     char *lines[] = {
 482       lines_0,
 483       NULL
 484     };
 485     int r;
 486     suppress_error = 0;
 487     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 488     if (r == -1)
 489       return -1;
 490   }
 491   {
 492     char fstype[] = "ext2";
 493     char device[] = "/dev/sda1";
 494     device[5] = devchar;
 495     int r;
 496     suppress_error = 0;
 497     r = guestfs_mkfs (g, fstype, device);
 498     if (r == -1)
 499       return -1;
 500   }
 501   {
 502     char device[] = "/dev/sda1";
 503     device[5] = devchar;
 504     char mountpoint[] = "/";
 505     int r;
 506     suppress_error = 0;
 507     r = guestfs_mount (g, device, mountpoint);
 508     if (r == -1)
 509       return -1;
 510   }
 511   /* TestOutputList for find (2) */
 512   {
 513     char path[] = "/a/b/c";
 514     int r;
 515     suppress_error = 0;
 516     r = guestfs_mkdir_p (g, path);
 517     if (r == -1)
 518       return -1;
 519   }
 520   {
 521     char path[] = "/a/b/c/d";
 522     int r;
 523     suppress_error = 0;
 524     r = guestfs_touch (g, path);
 525     if (r == -1)
 526       return -1;
 527   }
 528   {
 529     char directory[] = "/a/b/";
 530     char **r;
 531     int i;
 532     suppress_error = 0;
 533     r = guestfs_find (g, directory);
 534     if (r == NULL)
 535       return -1;
 536     if (!r[0]) {
 537       fprintf (stderr, "test_find_2: short list returned from command\n");
 538       print_strings (r);
 539       return -1;
 540     }
 541     {
 542       char expected[] = "c";
 543       if (strcmp (r[0], expected) != 0) {
 544         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 545         return -1;
 546       }
 547     }
 548     if (!r[1]) {
 549       fprintf (stderr, "test_find_2: short list returned from command\n");
 550       print_strings (r);
 551       return -1;
 552     }
 553     {
 554       char expected[] = "c/d";
 555       if (strcmp (r[1], expected) != 0) {
 556         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 557         return -1;
 558       }
 559     }
 560     if (r[2] != NULL) {
 561       fprintf (stderr, "test_find_2: extra elements returned from command\n");
 562       print_strings (r);
 563       return -1;
 564     }
 565     for (i = 0; r[i] != NULL; ++i)
 566       free (r[i]);
 567     free (r);
 568   }
 569   return 0;
 570 }
 571
 572 static int test_lvresize_0_skip (void)
 573 {
 574   const char *str;
 575
 576   str = getenv ("SKIP_TEST_LVRESIZE_0");
 577   if (str && strcmp (str, "1") == 0) return 1;
 578   str = getenv ("SKIP_TEST_LVRESIZE");
 579   if (str && strcmp (str, "1") == 0) return 1;
 580   return 0;
 581 }
 582
 583 static int test_lvresize_0 (void)
 584 {
 585   if (test_lvresize_0_skip ()) {
 586     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
 587     return 0;
 588   }
 589
 590   /* InitNone|InitEmpty for test_lvresize_0 */
 591   {
 592     char device[] = "/dev/sda";
 593     device[5] = devchar;
 594     int r;
 595     suppress_error = 0;
 596     r = guestfs_blockdev_setrw (g, device);
 597     if (r == -1)
 598       return -1;
 599   }
 600   {
 601     int r;
 602     suppress_error = 0;
 603     r = guestfs_umount_all (g);
 604     if (r == -1)
 605       return -1;
 606   }
 607   {
 608     int r;
 609     suppress_error = 0;
 610     r = guestfs_lvm_remove_all (g);
 611     if (r == -1)
 612       return -1;
 613   }
 614   /* TestOutput for lvresize (0) */
 615   char expected[] = "test content";
 616   {
 617     char device[] = "/dev/sda";
 618     device[5] = devchar;
 619     char lines_0[] = ",";
 620     char *lines[] = {
 621       lines_0,
 622       NULL
 623     };
 624     int r;
 625     suppress_error = 0;
 626     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 627     if (r == -1)
 628       return -1;
 629   }
 630   {
 631     char device[] = "/dev/sda1";
 632     device[5] = devchar;
 633     int r;
 634     suppress_error = 0;
 635     r = guestfs_pvcreate (g, device);
 636     if (r == -1)
 637       return -1;
 638   }
 639   {
 640     char volgroup[] = "VG";
 641     char physvols_0[] = "/dev/sda1";
 642     physvols_0[5] = devchar;
 643     char *physvols[] = {
 644       physvols_0,
 645       NULL
 646     };
 647     int r;
 648     suppress_error = 0;
 649     r = guestfs_vgcreate (g, volgroup, physvols);
 650     if (r == -1)
 651       return -1;
 652   }
 653   {
 654     char logvol[] = "LV";
 655     char volgroup[] = "VG";
 656     int r;
 657     suppress_error = 0;
 658     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 659     if (r == -1)
 660       return -1;
 661   }
 662   {
 663     char fstype[] = "ext2";
 664     char device[] = "/dev/VG/LV";
 665     int r;
 666     suppress_error = 0;
 667     r = guestfs_mkfs (g, fstype, device);
 668     if (r == -1)
 669       return -1;
 670   }
 671   {
 672     char device[] = "/dev/VG/LV";
 673     char mountpoint[] = "/";
 674     int r;
 675     suppress_error = 0;
 676     r = guestfs_mount (g, device, mountpoint);
 677     if (r == -1)
 678       return -1;
 679   }
 680   {
 681     char path[] = "/new";
 682     char content[] = "test content";
 683     int r;
 684     suppress_error = 0;
 685     r = guestfs_write_file (g, path, content, 0);
 686     if (r == -1)
 687       return -1;
 688   }
 689   {
 690     char pathordevice[] = "/";
 691     int r;
 692     suppress_error = 0;
 693     r = guestfs_umount (g, pathordevice);
 694     if (r == -1)
 695       return -1;
 696   }
 697   {
 698     char device[] = "/dev/VG/LV";
 699     int r;
 700     suppress_error = 0;
 701     r = guestfs_lvresize (g, device, 20);
 702     if (r == -1)
 703       return -1;
 704   }
 705   {
 706     char device[] = "/dev/VG/LV";
 707     int r;
 708     suppress_error = 0;
 709     r = guestfs_e2fsck_f (g, device);
 710     if (r == -1)
 711       return -1;
 712   }
 713   {
 714     char device[] = "/dev/VG/LV";
 715     int r;
 716     suppress_error = 0;
 717     r = guestfs_resize2fs (g, device);
 718     if (r == -1)
 719       return -1;
 720   }
 721   {
 722     char device[] = "/dev/VG/LV";
 723     char mountpoint[] = "/";
 724     int r;
 725     suppress_error = 0;
 726     r = guestfs_mount (g, device, mountpoint);
 727     if (r == -1)
 728       return -1;
 729   }
 730   {
 731     char path[] = "/new";
 732     char *r;
 733     suppress_error = 0;
 734     r = guestfs_cat (g, path);
 735     if (r == NULL)
 736       return -1;
 737     if (strcmp (r, expected) != 0) {
 738       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 739       return -1;
 740     }
 741     free (r);
 742   }
 743   return 0;
 744 }
 745
 746 static int test_zerofree_0_skip (void)
 747 {
 748   const char *str;
 749
 750   str = getenv ("SKIP_TEST_ZEROFREE_0");
 751   if (str && strcmp (str, "1") == 0) return 1;
 752   str = getenv ("SKIP_TEST_ZEROFREE");
 753   if (str && strcmp (str, "1") == 0) return 1;
 754   return 0;
 755 }
 756
 757 static int test_zerofree_0 (void)
 758 {
 759   if (test_zerofree_0_skip ()) {
 760     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
 761     return 0;
 762   }
 763
 764   /* InitNone|InitEmpty for test_zerofree_0 */
 765   {
 766     char device[] = "/dev/sda";
 767     device[5] = devchar;
 768     int r;
 769     suppress_error = 0;
 770     r = guestfs_blockdev_setrw (g, device);
 771     if (r == -1)
 772       return -1;
 773   }
 774   {
 775     int r;
 776     suppress_error = 0;
 777     r = guestfs_umount_all (g);
 778     if (r == -1)
 779       return -1;
 780   }
 781   {
 782     int r;
 783     suppress_error = 0;
 784     r = guestfs_lvm_remove_all (g);
 785     if (r == -1)
 786       return -1;
 787   }
 788   /* TestOutput for zerofree (0) */
 789   char expected[] = "test file";
 790   {
 791     char device[] = "/dev/sda";
 792     device[5] = devchar;
 793     char lines_0[] = ",";
 794     char *lines[] = {
 795       lines_0,
 796       NULL
 797     };
 798     int r;
 799     suppress_error = 0;
 800     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 801     if (r == -1)
 802       return -1;
 803   }
 804   {
 805     char fstype[] = "ext3";
 806     char device[] = "/dev/sda1";
 807     device[5] = devchar;
 808     int r;
 809     suppress_error = 0;
 810     r = guestfs_mkfs (g, fstype, device);
 811     if (r == -1)
 812       return -1;
 813   }
 814   {
 815     char device[] = "/dev/sda1";
 816     device[5] = devchar;
 817     char mountpoint[] = "/";
 818     int r;
 819     suppress_error = 0;
 820     r = guestfs_mount (g, device, mountpoint);
 821     if (r == -1)
 822       return -1;
 823   }
 824   {
 825     char path[] = "/new";
 826     char content[] = "test file";
 827     int r;
 828     suppress_error = 0;
 829     r = guestfs_write_file (g, path, content, 0);
 830     if (r == -1)
 831       return -1;
 832   }
 833   {
 834     char pathordevice[] = "/dev/sda1";
 835     pathordevice[5] = devchar;
 836     int r;
 837     suppress_error = 0;
 838     r = guestfs_umount (g, pathordevice);
 839     if (r == -1)
 840       return -1;
 841   }
 842   {
 843     char device[] = "/dev/sda1";
 844     device[5] = devchar;
 845     int r;
 846     suppress_error = 0;
 847     r = guestfs_zerofree (g, device);
 848     if (r == -1)
 849       return -1;
 850   }
 851   {
 852     char device[] = "/dev/sda1";
 853     device[5] = devchar;
 854     char mountpoint[] = "/";
 855     int r;
 856     suppress_error = 0;
 857     r = guestfs_mount (g, device, mountpoint);
 858     if (r == -1)
 859       return -1;
 860   }
 861   {
 862     char path[] = "/new";
 863     char *r;
 864     suppress_error = 0;
 865     r = guestfs_cat (g, path);
 866     if (r == NULL)
 867       return -1;
 868     if (strcmp (r, expected) != 0) {
 869       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
 870       return -1;
 871     }
 872     free (r);
 873   }
 874   return 0;
 875 }
 876
 877 static int test_hexdump_0_skip (void)
 878 {
 879   const char *str;
 880
 881   str = getenv ("SKIP_TEST_HEXDUMP_0");
 882   if (str && strcmp (str, "1") == 0) return 1;
 883   str = getenv ("SKIP_TEST_HEXDUMP");
 884   if (str && strcmp (str, "1") == 0) return 1;
 885   return 0;
 886 }
 887
 888 static int test_hexdump_0 (void)
 889 {
 890   if (test_hexdump_0_skip ()) {
 891     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
 892     return 0;
 893   }
 894
 895   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
 896   {
 897     char device[] = "/dev/sda";
 898     device[5] = devchar;
 899     int r;
 900     suppress_error = 0;
 901     r = guestfs_blockdev_setrw (g, device);
 902     if (r == -1)
 903       return -1;
 904   }
 905   {
 906     int r;
 907     suppress_error = 0;
 908     r = guestfs_umount_all (g);
 909     if (r == -1)
 910       return -1;
 911   }
 912   {
 913     int r;
 914     suppress_error = 0;
 915     r = guestfs_lvm_remove_all (g);
 916     if (r == -1)
 917       return -1;
 918   }
 919   {
 920     char device[] = "/dev/sda";
 921     device[5] = devchar;
 922     char lines_0[] = ",";
 923     char *lines[] = {
 924       lines_0,
 925       NULL
 926     };
 927     int r;
 928     suppress_error = 0;
 929     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 930     if (r == -1)
 931       return -1;
 932   }
 933   {
 934     char fstype[] = "ext2";
 935     char device[] = "/dev/sda1";
 936     device[5] = devchar;
 937     int r;
 938     suppress_error = 0;
 939     r = guestfs_mkfs (g, fstype, device);
 940     if (r == -1)
 941       return -1;
 942   }
 943   {
 944     char device[] = "/dev/sda1";
 945     device[5] = devchar;
 946     char mountpoint[] = "/";
 947     int r;
 948     suppress_error = 0;
 949     r = guestfs_mount (g, device, mountpoint);
 950     if (r == -1)
 951       return -1;
 952   }
 953   /* TestOutput for hexdump (0) */
 954   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
 955   {
 956     char path[] = "/new";
 957     char content[] = "hello\nworld\n";
 958     int r;
 959     suppress_error = 0;
 960     r = guestfs_write_file (g, path, content, 12);
 961     if (r == -1)
 962       return -1;
 963   }
 964   {
 965     char path[] = "/new";
 966     char *r;
 967     suppress_error = 0;
 968     r = guestfs_hexdump (g, path);
 969     if (r == NULL)
 970       return -1;
 971     if (strcmp (r, expected) != 0) {
 972       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
 973       return -1;
 974     }
 975     free (r);
 976   }
 977   return 0;
 978 }
 979
 980 static int test_strings_e_0_skip (void)
 981 {
 982   const char *str;
 983
 984   str = getenv ("SKIP_TEST_STRINGS_E_0");
 985   if (str && strcmp (str, "1") == 0) return 1;
 986   str = getenv ("SKIP_TEST_STRINGS_E");
 987   if (str && strcmp (str, "1") == 0) return 1;
 988   return 0;
 989 }
 990
 991 static int test_strings_e_0 (void)
 992 {
 993   if (test_strings_e_0_skip ()) {
 994     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
 995     return 0;
 996   }
 997
 998   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
 999   {
1000     char device[] = "/dev/sda";
1001     device[5] = devchar;
1002     int r;
1003     suppress_error = 0;
1004     r = guestfs_blockdev_setrw (g, device);
1005     if (r == -1)
1006       return -1;
1007   }
1008   {
1009     int r;
1010     suppress_error = 0;
1011     r = guestfs_umount_all (g);
1012     if (r == -1)
1013       return -1;
1014   }
1015   {
1016     int r;
1017     suppress_error = 0;
1018     r = guestfs_lvm_remove_all (g);
1019     if (r == -1)
1020       return -1;
1021   }
1022   {
1023     char device[] = "/dev/sda";
1024     device[5] = devchar;
1025     char lines_0[] = ",";
1026     char *lines[] = {
1027       lines_0,
1028       NULL
1029     };
1030     int r;
1031     suppress_error = 0;
1032     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1033     if (r == -1)
1034       return -1;
1035   }
1036   {
1037     char fstype[] = "ext2";
1038     char device[] = "/dev/sda1";
1039     device[5] = devchar;
1040     int r;
1041     suppress_error = 0;
1042     r = guestfs_mkfs (g, fstype, device);
1043     if (r == -1)
1044       return -1;
1045   }
1046   {
1047     char device[] = "/dev/sda1";
1048     device[5] = devchar;
1049     char mountpoint[] = "/";
1050     int r;
1051     suppress_error = 0;
1052     r = guestfs_mount (g, device, mountpoint);
1053     if (r == -1)
1054       return -1;
1055   }
1056   /* TestOutputList for strings_e (0) */
1057   {
1058     char path[] = "/new";
1059     char content[] = "hello\nworld\n";
1060     int r;
1061     suppress_error = 0;
1062     r = guestfs_write_file (g, path, content, 0);
1063     if (r == -1)
1064       return -1;
1065   }
1066   {
1067     char encoding[] = "b";
1068     char path[] = "/new";
1069     char **r;
1070     int i;
1071     suppress_error = 0;
1072     r = guestfs_strings_e (g, encoding, path);
1073     if (r == NULL)
1074       return -1;
1075     if (r[0] != NULL) {
1076       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1077       print_strings (r);
1078       return -1;
1079     }
1080     for (i = 0; r[i] != NULL; ++i)
1081       free (r[i]);
1082     free (r);
1083   }
1084   return 0;
1085 }
1086
1087 static int test_strings_e_1_skip (void)
1088 {
1089   const char *str;
1090
1091   str = getenv ("SKIP_TEST_STRINGS_E_1");
1092   if (str && strcmp (str, "1") == 0) return 1;
1093   str = getenv ("SKIP_TEST_STRINGS_E");
1094   if (str && strcmp (str, "1") == 0) return 1;
1095   return 0;
1096 }
1097
1098 static int test_strings_e_1 (void)
1099 {
1100   if (test_strings_e_1_skip ()) {
1101     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1102     return 0;
1103   }
1104
1105   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1106   return 0;
1107 }
1108
1109 static int test_strings_0_skip (void)
1110 {
1111   const char *str;
1112
1113   str = getenv ("SKIP_TEST_STRINGS_0");
1114   if (str && strcmp (str, "1") == 0) return 1;
1115   str = getenv ("SKIP_TEST_STRINGS");
1116   if (str && strcmp (str, "1") == 0) return 1;
1117   return 0;
1118 }
1119
1120 static int test_strings_0 (void)
1121 {
1122   if (test_strings_0_skip ()) {
1123     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1124     return 0;
1125   }
1126
1127   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1128   {
1129     char device[] = "/dev/sda";
1130     device[5] = devchar;
1131     int r;
1132     suppress_error = 0;
1133     r = guestfs_blockdev_setrw (g, device);
1134     if (r == -1)
1135       return -1;
1136   }
1137   {
1138     int r;
1139     suppress_error = 0;
1140     r = guestfs_umount_all (g);
1141     if (r == -1)
1142       return -1;
1143   }
1144   {
1145     int r;
1146     suppress_error = 0;
1147     r = guestfs_lvm_remove_all (g);
1148     if (r == -1)
1149       return -1;
1150   }
1151   {
1152     char device[] = "/dev/sda";
1153     device[5] = devchar;
1154     char lines_0[] = ",";
1155     char *lines[] = {
1156       lines_0,
1157       NULL
1158     };
1159     int r;
1160     suppress_error = 0;
1161     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1162     if (r == -1)
1163       return -1;
1164   }
1165   {
1166     char fstype[] = "ext2";
1167     char device[] = "/dev/sda1";
1168     device[5] = devchar;
1169     int r;
1170     suppress_error = 0;
1171     r = guestfs_mkfs (g, fstype, device);
1172     if (r == -1)
1173       return -1;
1174   }
1175   {
1176     char device[] = "/dev/sda1";
1177     device[5] = devchar;
1178     char mountpoint[] = "/";
1179     int r;
1180     suppress_error = 0;
1181     r = guestfs_mount (g, device, mountpoint);
1182     if (r == -1)
1183       return -1;
1184   }
1185   /* TestOutputList for strings (0) */
1186   {
1187     char path[] = "/new";
1188     char content[] = "hello\nworld\n";
1189     int r;
1190     suppress_error = 0;
1191     r = guestfs_write_file (g, path, content, 0);
1192     if (r == -1)
1193       return -1;
1194   }
1195   {
1196     char path[] = "/new";
1197     char **r;
1198     int i;
1199     suppress_error = 0;
1200     r = guestfs_strings (g, path);
1201     if (r == NULL)
1202       return -1;
1203     if (!r[0]) {
1204       fprintf (stderr, "test_strings_0: short list returned from command\n");
1205       print_strings (r);
1206       return -1;
1207     }
1208     {
1209       char expected[] = "hello";
1210       if (strcmp (r[0], expected) != 0) {
1211         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1212         return -1;
1213       }
1214     }
1215     if (!r[1]) {
1216       fprintf (stderr, "test_strings_0: short list returned from command\n");
1217       print_strings (r);
1218       return -1;
1219     }
1220     {
1221       char expected[] = "world";
1222       if (strcmp (r[1], expected) != 0) {
1223         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1224         return -1;
1225       }
1226     }
1227     if (r[2] != NULL) {
1228       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1229       print_strings (r);
1230       return -1;
1231     }
1232     for (i = 0; r[i] != NULL; ++i)
1233       free (r[i]);
1234     free (r);
1235   }
1236   return 0;
1237 }
1238
1239 static int test_strings_1_skip (void)
1240 {
1241   const char *str;
1242
1243   str = getenv ("SKIP_TEST_STRINGS_1");
1244   if (str && strcmp (str, "1") == 0) return 1;
1245   str = getenv ("SKIP_TEST_STRINGS");
1246   if (str && strcmp (str, "1") == 0) return 1;
1247   return 0;
1248 }
1249
1250 static int test_strings_1 (void)
1251 {
1252   if (test_strings_1_skip ()) {
1253     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1254     return 0;
1255   }
1256
1257   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1258   {
1259     char device[] = "/dev/sda";
1260     device[5] = devchar;
1261     int r;
1262     suppress_error = 0;
1263     r = guestfs_blockdev_setrw (g, device);
1264     if (r == -1)
1265       return -1;
1266   }
1267   {
1268     int r;
1269     suppress_error = 0;
1270     r = guestfs_umount_all (g);
1271     if (r == -1)
1272       return -1;
1273   }
1274   {
1275     int r;
1276     suppress_error = 0;
1277     r = guestfs_lvm_remove_all (g);
1278     if (r == -1)
1279       return -1;
1280   }
1281   {
1282     char device[] = "/dev/sda";
1283     device[5] = devchar;
1284     char lines_0[] = ",";
1285     char *lines[] = {
1286       lines_0,
1287       NULL
1288     };
1289     int r;
1290     suppress_error = 0;
1291     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1292     if (r == -1)
1293       return -1;
1294   }
1295   {
1296     char fstype[] = "ext2";
1297     char device[] = "/dev/sda1";
1298     device[5] = devchar;
1299     int r;
1300     suppress_error = 0;
1301     r = guestfs_mkfs (g, fstype, device);
1302     if (r == -1)
1303       return -1;
1304   }
1305   {
1306     char device[] = "/dev/sda1";
1307     device[5] = devchar;
1308     char mountpoint[] = "/";
1309     int r;
1310     suppress_error = 0;
1311     r = guestfs_mount (g, device, mountpoint);
1312     if (r == -1)
1313       return -1;
1314   }
1315   /* TestOutputList for strings (1) */
1316   {
1317     char path[] = "/new";
1318     int r;
1319     suppress_error = 0;
1320     r = guestfs_touch (g, path);
1321     if (r == -1)
1322       return -1;
1323   }
1324   {
1325     char path[] = "/new";
1326     char **r;
1327     int i;
1328     suppress_error = 0;
1329     r = guestfs_strings (g, path);
1330     if (r == NULL)
1331       return -1;
1332     if (r[0] != NULL) {
1333       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1334       print_strings (r);
1335       return -1;
1336     }
1337     for (i = 0; r[i] != NULL; ++i)
1338       free (r[i]);
1339     free (r);
1340   }
1341   return 0;
1342 }
1343
1344 static int test_equal_0_skip (void)
1345 {
1346   const char *str;
1347
1348   str = getenv ("SKIP_TEST_EQUAL_0");
1349   if (str && strcmp (str, "1") == 0) return 1;
1350   str = getenv ("SKIP_TEST_EQUAL");
1351   if (str && strcmp (str, "1") == 0) return 1;
1352   return 0;
1353 }
1354
1355 static int test_equal_0 (void)
1356 {
1357   if (test_equal_0_skip ()) {
1358     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1359     return 0;
1360   }
1361
1362   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1363   {
1364     char device[] = "/dev/sda";
1365     device[5] = devchar;
1366     int r;
1367     suppress_error = 0;
1368     r = guestfs_blockdev_setrw (g, device);
1369     if (r == -1)
1370       return -1;
1371   }
1372   {
1373     int r;
1374     suppress_error = 0;
1375     r = guestfs_umount_all (g);
1376     if (r == -1)
1377       return -1;
1378   }
1379   {
1380     int r;
1381     suppress_error = 0;
1382     r = guestfs_lvm_remove_all (g);
1383     if (r == -1)
1384       return -1;
1385   }
1386   {
1387     char device[] = "/dev/sda";
1388     device[5] = devchar;
1389     char lines_0[] = ",";
1390     char *lines[] = {
1391       lines_0,
1392       NULL
1393     };
1394     int r;
1395     suppress_error = 0;
1396     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1397     if (r == -1)
1398       return -1;
1399   }
1400   {
1401     char fstype[] = "ext2";
1402     char device[] = "/dev/sda1";
1403     device[5] = devchar;
1404     int r;
1405     suppress_error = 0;
1406     r = guestfs_mkfs (g, fstype, device);
1407     if (r == -1)
1408       return -1;
1409   }
1410   {
1411     char device[] = "/dev/sda1";
1412     device[5] = devchar;
1413     char mountpoint[] = "/";
1414     int r;
1415     suppress_error = 0;
1416     r = guestfs_mount (g, device, mountpoint);
1417     if (r == -1)
1418       return -1;
1419   }
1420   /* TestOutputTrue for equal (0) */
1421   {
1422     char path[] = "/file1";
1423     char content[] = "contents of a file";
1424     int r;
1425     suppress_error = 0;
1426     r = guestfs_write_file (g, path, content, 0);
1427     if (r == -1)
1428       return -1;
1429   }
1430   {
1431     char src[] = "/file1";
1432     char dest[] = "/file2";
1433     int r;
1434     suppress_error = 0;
1435     r = guestfs_cp (g, src, dest);
1436     if (r == -1)
1437       return -1;
1438   }
1439   {
1440     char file1[] = "/file1";
1441     char file2[] = "/file2";
1442     int r;
1443     suppress_error = 0;
1444     r = guestfs_equal (g, file1, file2);
1445     if (r == -1)
1446       return -1;
1447     if (!r) {
1448       fprintf (stderr, "test_equal_0: expected true, got false\n");
1449       return -1;
1450     }
1451   }
1452   return 0;
1453 }
1454
1455 static int test_equal_1_skip (void)
1456 {
1457   const char *str;
1458
1459   str = getenv ("SKIP_TEST_EQUAL_1");
1460   if (str && strcmp (str, "1") == 0) return 1;
1461   str = getenv ("SKIP_TEST_EQUAL");
1462   if (str && strcmp (str, "1") == 0) return 1;
1463   return 0;
1464 }
1465
1466 static int test_equal_1 (void)
1467 {
1468   if (test_equal_1_skip ()) {
1469     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1470     return 0;
1471   }
1472
1473   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1474   {
1475     char device[] = "/dev/sda";
1476     device[5] = devchar;
1477     int r;
1478     suppress_error = 0;
1479     r = guestfs_blockdev_setrw (g, device);
1480     if (r == -1)
1481       return -1;
1482   }
1483   {
1484     int r;
1485     suppress_error = 0;
1486     r = guestfs_umount_all (g);
1487     if (r == -1)
1488       return -1;
1489   }
1490   {
1491     int r;
1492     suppress_error = 0;
1493     r = guestfs_lvm_remove_all (g);
1494     if (r == -1)
1495       return -1;
1496   }
1497   {
1498     char device[] = "/dev/sda";
1499     device[5] = devchar;
1500     char lines_0[] = ",";
1501     char *lines[] = {
1502       lines_0,
1503       NULL
1504     };
1505     int r;
1506     suppress_error = 0;
1507     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1508     if (r == -1)
1509       return -1;
1510   }
1511   {
1512     char fstype[] = "ext2";
1513     char device[] = "/dev/sda1";
1514     device[5] = devchar;
1515     int r;
1516     suppress_error = 0;
1517     r = guestfs_mkfs (g, fstype, device);
1518     if (r == -1)
1519       return -1;
1520   }
1521   {
1522     char device[] = "/dev/sda1";
1523     device[5] = devchar;
1524     char mountpoint[] = "/";
1525     int r;
1526     suppress_error = 0;
1527     r = guestfs_mount (g, device, mountpoint);
1528     if (r == -1)
1529       return -1;
1530   }
1531   /* TestOutputFalse for equal (1) */
1532   {
1533     char path[] = "/file1";
1534     char content[] = "contents of a file";
1535     int r;
1536     suppress_error = 0;
1537     r = guestfs_write_file (g, path, content, 0);
1538     if (r == -1)
1539       return -1;
1540   }
1541   {
1542     char path[] = "/file2";
1543     char content[] = "contents of another file";
1544     int r;
1545     suppress_error = 0;
1546     r = guestfs_write_file (g, path, content, 0);
1547     if (r == -1)
1548       return -1;
1549   }
1550   {
1551     char file1[] = "/file1";
1552     char file2[] = "/file2";
1553     int r;
1554     suppress_error = 0;
1555     r = guestfs_equal (g, file1, file2);
1556     if (r == -1)
1557       return -1;
1558     if (r) {
1559       fprintf (stderr, "test_equal_1: expected false, got true\n");
1560       return -1;
1561     }
1562   }
1563   return 0;
1564 }
1565
1566 static int test_equal_2_skip (void)
1567 {
1568   const char *str;
1569
1570   str = getenv ("SKIP_TEST_EQUAL_2");
1571   if (str && strcmp (str, "1") == 0) return 1;
1572   str = getenv ("SKIP_TEST_EQUAL");
1573   if (str && strcmp (str, "1") == 0) return 1;
1574   return 0;
1575 }
1576
1577 static int test_equal_2 (void)
1578 {
1579   if (test_equal_2_skip ()) {
1580     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1581     return 0;
1582   }
1583
1584   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1585   {
1586     char device[] = "/dev/sda";
1587     device[5] = devchar;
1588     int r;
1589     suppress_error = 0;
1590     r = guestfs_blockdev_setrw (g, device);
1591     if (r == -1)
1592       return -1;
1593   }
1594   {
1595     int r;
1596     suppress_error = 0;
1597     r = guestfs_umount_all (g);
1598     if (r == -1)
1599       return -1;
1600   }
1601   {
1602     int r;
1603     suppress_error = 0;
1604     r = guestfs_lvm_remove_all (g);
1605     if (r == -1)
1606       return -1;
1607   }
1608   {
1609     char device[] = "/dev/sda";
1610     device[5] = devchar;
1611     char lines_0[] = ",";
1612     char *lines[] = {
1613       lines_0,
1614       NULL
1615     };
1616     int r;
1617     suppress_error = 0;
1618     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1619     if (r == -1)
1620       return -1;
1621   }
1622   {
1623     char fstype[] = "ext2";
1624     char device[] = "/dev/sda1";
1625     device[5] = devchar;
1626     int r;
1627     suppress_error = 0;
1628     r = guestfs_mkfs (g, fstype, device);
1629     if (r == -1)
1630       return -1;
1631   }
1632   {
1633     char device[] = "/dev/sda1";
1634     device[5] = devchar;
1635     char mountpoint[] = "/";
1636     int r;
1637     suppress_error = 0;
1638     r = guestfs_mount (g, device, mountpoint);
1639     if (r == -1)
1640       return -1;
1641   }
1642   /* TestLastFail for equal (2) */
1643   {
1644     char file1[] = "/file1";
1645     char file2[] = "/file2";
1646     int r;
1647     suppress_error = 1;
1648     r = guestfs_equal (g, file1, file2);
1649     if (r != -1)
1650       return -1;
1651   }
1652   return 0;
1653 }
1654
1655 static int test_ping_daemon_0_skip (void)
1656 {
1657   const char *str;
1658
1659   str = getenv ("SKIP_TEST_PING_DAEMON_0");
1660   if (str && strcmp (str, "1") == 0) return 1;
1661   str = getenv ("SKIP_TEST_PING_DAEMON");
1662   if (str && strcmp (str, "1") == 0) return 1;
1663   return 0;
1664 }
1665
1666 static int test_ping_daemon_0 (void)
1667 {
1668   if (test_ping_daemon_0_skip ()) {
1669     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1670     return 0;
1671   }
1672
1673   /* InitNone|InitEmpty for test_ping_daemon_0 */
1674   {
1675     char device[] = "/dev/sda";
1676     device[5] = devchar;
1677     int r;
1678     suppress_error = 0;
1679     r = guestfs_blockdev_setrw (g, device);
1680     if (r == -1)
1681       return -1;
1682   }
1683   {
1684     int r;
1685     suppress_error = 0;
1686     r = guestfs_umount_all (g);
1687     if (r == -1)
1688       return -1;
1689   }
1690   {
1691     int r;
1692     suppress_error = 0;
1693     r = guestfs_lvm_remove_all (g);
1694     if (r == -1)
1695       return -1;
1696   }
1697   /* TestRun for ping_daemon (0) */
1698   {
1699     int r;
1700     suppress_error = 0;
1701     r = guestfs_ping_daemon (g);
1702     if (r == -1)
1703       return -1;
1704   }
1705   return 0;
1706 }
1707
1708 static int test_dmesg_0_skip (void)
1709 {
1710   const char *str;
1711
1712   str = getenv ("SKIP_TEST_DMESG_0");
1713   if (str && strcmp (str, "1") == 0) return 1;
1714   str = getenv ("SKIP_TEST_DMESG");
1715   if (str && strcmp (str, "1") == 0) return 1;
1716   return 0;
1717 }
1718
1719 static int test_dmesg_0 (void)
1720 {
1721   if (test_dmesg_0_skip ()) {
1722     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1723     return 0;
1724   }
1725
1726   /* InitNone|InitEmpty for test_dmesg_0 */
1727   {
1728     char device[] = "/dev/sda";
1729     device[5] = devchar;
1730     int r;
1731     suppress_error = 0;
1732     r = guestfs_blockdev_setrw (g, device);
1733     if (r == -1)
1734       return -1;
1735   }
1736   {
1737     int r;
1738     suppress_error = 0;
1739     r = guestfs_umount_all (g);
1740     if (r == -1)
1741       return -1;
1742   }
1743   {
1744     int r;
1745     suppress_error = 0;
1746     r = guestfs_lvm_remove_all (g);
1747     if (r == -1)
1748       return -1;
1749   }
1750   /* TestRun for dmesg (0) */
1751   {
1752     char *r;
1753     suppress_error = 0;
1754     r = guestfs_dmesg (g);
1755     if (r == NULL)
1756       return -1;
1757     free (r);
1758   }
1759   return 0;
1760 }
1761
1762 static int test_drop_caches_0_skip (void)
1763 {
1764   const char *str;
1765
1766   str = getenv ("SKIP_TEST_DROP_CACHES_0");
1767   if (str && strcmp (str, "1") == 0) return 1;
1768   str = getenv ("SKIP_TEST_DROP_CACHES");
1769   if (str && strcmp (str, "1") == 0) return 1;
1770   return 0;
1771 }
1772
1773 static int test_drop_caches_0 (void)
1774 {
1775   if (test_drop_caches_0_skip ()) {
1776     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1777     return 0;
1778   }
1779
1780   /* InitNone|InitEmpty for test_drop_caches_0 */
1781   {
1782     char device[] = "/dev/sda";
1783     device[5] = devchar;
1784     int r;
1785     suppress_error = 0;
1786     r = guestfs_blockdev_setrw (g, device);
1787     if (r == -1)
1788       return -1;
1789   }
1790   {
1791     int r;
1792     suppress_error = 0;
1793     r = guestfs_umount_all (g);
1794     if (r == -1)
1795       return -1;
1796   }
1797   {
1798     int r;
1799     suppress_error = 0;
1800     r = guestfs_lvm_remove_all (g);
1801     if (r == -1)
1802       return -1;
1803   }
1804   /* TestRun for drop_caches (0) */
1805   {
1806     int r;
1807     suppress_error = 0;
1808     r = guestfs_drop_caches (g, 3);
1809     if (r == -1)
1810       return -1;
1811   }
1812   return 0;
1813 }
1814
1815 static int test_mv_0_skip (void)
1816 {
1817   const char *str;
1818
1819   str = getenv ("SKIP_TEST_MV_0");
1820   if (str && strcmp (str, "1") == 0) return 1;
1821   str = getenv ("SKIP_TEST_MV");
1822   if (str && strcmp (str, "1") == 0) return 1;
1823   return 0;
1824 }
1825
1826 static int test_mv_0 (void)
1827 {
1828   if (test_mv_0_skip ()) {
1829     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
1830     return 0;
1831   }
1832
1833   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1834   {
1835     char device[] = "/dev/sda";
1836     device[5] = devchar;
1837     int r;
1838     suppress_error = 0;
1839     r = guestfs_blockdev_setrw (g, device);
1840     if (r == -1)
1841       return -1;
1842   }
1843   {
1844     int r;
1845     suppress_error = 0;
1846     r = guestfs_umount_all (g);
1847     if (r == -1)
1848       return -1;
1849   }
1850   {
1851     int r;
1852     suppress_error = 0;
1853     r = guestfs_lvm_remove_all (g);
1854     if (r == -1)
1855       return -1;
1856   }
1857   {
1858     char device[] = "/dev/sda";
1859     device[5] = devchar;
1860     char lines_0[] = ",";
1861     char *lines[] = {
1862       lines_0,
1863       NULL
1864     };
1865     int r;
1866     suppress_error = 0;
1867     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1868     if (r == -1)
1869       return -1;
1870   }
1871   {
1872     char fstype[] = "ext2";
1873     char device[] = "/dev/sda1";
1874     device[5] = devchar;
1875     int r;
1876     suppress_error = 0;
1877     r = guestfs_mkfs (g, fstype, device);
1878     if (r == -1)
1879       return -1;
1880   }
1881   {
1882     char device[] = "/dev/sda1";
1883     device[5] = devchar;
1884     char mountpoint[] = "/";
1885     int r;
1886     suppress_error = 0;
1887     r = guestfs_mount (g, device, mountpoint);
1888     if (r == -1)
1889       return -1;
1890   }
1891   /* TestOutput for mv (0) */
1892   char expected[] = "file content";
1893   {
1894     char path[] = "/old";
1895     char content[] = "file content";
1896     int r;
1897     suppress_error = 0;
1898     r = guestfs_write_file (g, path, content, 0);
1899     if (r == -1)
1900       return -1;
1901   }
1902   {
1903     char src[] = "/old";
1904     char dest[] = "/new";
1905     int r;
1906     suppress_error = 0;
1907     r = guestfs_mv (g, src, dest);
1908     if (r == -1)
1909       return -1;
1910   }
1911   {
1912     char path[] = "/new";
1913     char *r;
1914     suppress_error = 0;
1915     r = guestfs_cat (g, path);
1916     if (r == NULL)
1917       return -1;
1918     if (strcmp (r, expected) != 0) {
1919       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1920       return -1;
1921     }
1922     free (r);
1923   }
1924   return 0;
1925 }
1926
1927 static int test_mv_1_skip (void)
1928 {
1929   const char *str;
1930
1931   str = getenv ("SKIP_TEST_MV_1");
1932   if (str && strcmp (str, "1") == 0) return 1;
1933   str = getenv ("SKIP_TEST_MV");
1934   if (str && strcmp (str, "1") == 0) return 1;
1935   return 0;
1936 }
1937
1938 static int test_mv_1 (void)
1939 {
1940   if (test_mv_1_skip ()) {
1941     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
1942     return 0;
1943   }
1944
1945   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1946   {
1947     char device[] = "/dev/sda";
1948     device[5] = devchar;
1949     int r;
1950     suppress_error = 0;
1951     r = guestfs_blockdev_setrw (g, device);
1952     if (r == -1)
1953       return -1;
1954   }
1955   {
1956     int r;
1957     suppress_error = 0;
1958     r = guestfs_umount_all (g);
1959     if (r == -1)
1960       return -1;
1961   }
1962   {
1963     int r;
1964     suppress_error = 0;
1965     r = guestfs_lvm_remove_all (g);
1966     if (r == -1)
1967       return -1;
1968   }
1969   {
1970     char device[] = "/dev/sda";
1971     device[5] = devchar;
1972     char lines_0[] = ",";
1973     char *lines[] = {
1974       lines_0,
1975       NULL
1976     };
1977     int r;
1978     suppress_error = 0;
1979     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1980     if (r == -1)
1981       return -1;
1982   }
1983   {
1984     char fstype[] = "ext2";
1985     char device[] = "/dev/sda1";
1986     device[5] = devchar;
1987     int r;
1988     suppress_error = 0;
1989     r = guestfs_mkfs (g, fstype, device);
1990     if (r == -1)
1991       return -1;
1992   }
1993   {
1994     char device[] = "/dev/sda1";
1995     device[5] = devchar;
1996     char mountpoint[] = "/";
1997     int r;
1998     suppress_error = 0;
1999     r = guestfs_mount (g, device, mountpoint);
2000     if (r == -1)
2001       return -1;
2002   }
2003   /* TestOutputFalse for mv (1) */
2004   {
2005     char path[] = "/old";
2006     char content[] = "file content";
2007     int r;
2008     suppress_error = 0;
2009     r = guestfs_write_file (g, path, content, 0);
2010     if (r == -1)
2011       return -1;
2012   }
2013   {
2014     char src[] = "/old";
2015     char dest[] = "/new";
2016     int r;
2017     suppress_error = 0;
2018     r = guestfs_mv (g, src, dest);
2019     if (r == -1)
2020       return -1;
2021   }
2022   {
2023     char path[] = "/old";
2024     int r;
2025     suppress_error = 0;
2026     r = guestfs_is_file (g, path);
2027     if (r == -1)
2028       return -1;
2029     if (r) {
2030       fprintf (stderr, "test_mv_1: expected false, got true\n");
2031       return -1;
2032     }
2033   }
2034   return 0;
2035 }
2036
2037 static int test_cp_a_0_skip (void)
2038 {
2039   const char *str;
2040
2041   str = getenv ("SKIP_TEST_CP_A_0");
2042   if (str && strcmp (str, "1") == 0) return 1;
2043   str = getenv ("SKIP_TEST_CP_A");
2044   if (str && strcmp (str, "1") == 0) return 1;
2045   return 0;
2046 }
2047
2048 static int test_cp_a_0 (void)
2049 {
2050   if (test_cp_a_0_skip ()) {
2051     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2052     return 0;
2053   }
2054
2055   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2056   {
2057     char device[] = "/dev/sda";
2058     device[5] = devchar;
2059     int r;
2060     suppress_error = 0;
2061     r = guestfs_blockdev_setrw (g, device);
2062     if (r == -1)
2063       return -1;
2064   }
2065   {
2066     int r;
2067     suppress_error = 0;
2068     r = guestfs_umount_all (g);
2069     if (r == -1)
2070       return -1;
2071   }
2072   {
2073     int r;
2074     suppress_error = 0;
2075     r = guestfs_lvm_remove_all (g);
2076     if (r == -1)
2077       return -1;
2078   }
2079   {
2080     char device[] = "/dev/sda";
2081     device[5] = devchar;
2082     char lines_0[] = ",";
2083     char *lines[] = {
2084       lines_0,
2085       NULL
2086     };
2087     int r;
2088     suppress_error = 0;
2089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2090     if (r == -1)
2091       return -1;
2092   }
2093   {
2094     char fstype[] = "ext2";
2095     char device[] = "/dev/sda1";
2096     device[5] = devchar;
2097     int r;
2098     suppress_error = 0;
2099     r = guestfs_mkfs (g, fstype, device);
2100     if (r == -1)
2101       return -1;
2102   }
2103   {
2104     char device[] = "/dev/sda1";
2105     device[5] = devchar;
2106     char mountpoint[] = "/";
2107     int r;
2108     suppress_error = 0;
2109     r = guestfs_mount (g, device, mountpoint);
2110     if (r == -1)
2111       return -1;
2112   }
2113   /* TestOutput for cp_a (0) */
2114   char expected[] = "file content";
2115   {
2116     char path[] = "/olddir";
2117     int r;
2118     suppress_error = 0;
2119     r = guestfs_mkdir (g, path);
2120     if (r == -1)
2121       return -1;
2122   }
2123   {
2124     char path[] = "/newdir";
2125     int r;
2126     suppress_error = 0;
2127     r = guestfs_mkdir (g, path);
2128     if (r == -1)
2129       return -1;
2130   }
2131   {
2132     char path[] = "/olddir/file";
2133     char content[] = "file content";
2134     int r;
2135     suppress_error = 0;
2136     r = guestfs_write_file (g, path, content, 0);
2137     if (r == -1)
2138       return -1;
2139   }
2140   {
2141     char src[] = "/olddir";
2142     char dest[] = "/newdir";
2143     int r;
2144     suppress_error = 0;
2145     r = guestfs_cp_a (g, src, dest);
2146     if (r == -1)
2147       return -1;
2148   }
2149   {
2150     char path[] = "/newdir/olddir/file";
2151     char *r;
2152     suppress_error = 0;
2153     r = guestfs_cat (g, path);
2154     if (r == NULL)
2155       return -1;
2156     if (strcmp (r, expected) != 0) {
2157       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2158       return -1;
2159     }
2160     free (r);
2161   }
2162   return 0;
2163 }
2164
2165 static int test_cp_0_skip (void)
2166 {
2167   const char *str;
2168
2169   str = getenv ("SKIP_TEST_CP_0");
2170   if (str && strcmp (str, "1") == 0) return 1;
2171   str = getenv ("SKIP_TEST_CP");
2172   if (str && strcmp (str, "1") == 0) return 1;
2173   return 0;
2174 }
2175
2176 static int test_cp_0 (void)
2177 {
2178   if (test_cp_0_skip ()) {
2179     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2180     return 0;
2181   }
2182
2183   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2184   {
2185     char device[] = "/dev/sda";
2186     device[5] = devchar;
2187     int r;
2188     suppress_error = 0;
2189     r = guestfs_blockdev_setrw (g, device);
2190     if (r == -1)
2191       return -1;
2192   }
2193   {
2194     int r;
2195     suppress_error = 0;
2196     r = guestfs_umount_all (g);
2197     if (r == -1)
2198       return -1;
2199   }
2200   {
2201     int r;
2202     suppress_error = 0;
2203     r = guestfs_lvm_remove_all (g);
2204     if (r == -1)
2205       return -1;
2206   }
2207   {
2208     char device[] = "/dev/sda";
2209     device[5] = devchar;
2210     char lines_0[] = ",";
2211     char *lines[] = {
2212       lines_0,
2213       NULL
2214     };
2215     int r;
2216     suppress_error = 0;
2217     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2218     if (r == -1)
2219       return -1;
2220   }
2221   {
2222     char fstype[] = "ext2";
2223     char device[] = "/dev/sda1";
2224     device[5] = devchar;
2225     int r;
2226     suppress_error = 0;
2227     r = guestfs_mkfs (g, fstype, device);
2228     if (r == -1)
2229       return -1;
2230   }
2231   {
2232     char device[] = "/dev/sda1";
2233     device[5] = devchar;
2234     char mountpoint[] = "/";
2235     int r;
2236     suppress_error = 0;
2237     r = guestfs_mount (g, device, mountpoint);
2238     if (r == -1)
2239       return -1;
2240   }
2241   /* TestOutput for cp (0) */
2242   char expected[] = "file content";
2243   {
2244     char path[] = "/old";
2245     char content[] = "file content";
2246     int r;
2247     suppress_error = 0;
2248     r = guestfs_write_file (g, path, content, 0);
2249     if (r == -1)
2250       return -1;
2251   }
2252   {
2253     char src[] = "/old";
2254     char dest[] = "/new";
2255     int r;
2256     suppress_error = 0;
2257     r = guestfs_cp (g, src, dest);
2258     if (r == -1)
2259       return -1;
2260   }
2261   {
2262     char path[] = "/new";
2263     char *r;
2264     suppress_error = 0;
2265     r = guestfs_cat (g, path);
2266     if (r == NULL)
2267       return -1;
2268     if (strcmp (r, expected) != 0) {
2269       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2270       return -1;
2271     }
2272     free (r);
2273   }
2274   return 0;
2275 }
2276
2277 static int test_cp_1_skip (void)
2278 {
2279   const char *str;
2280
2281   str = getenv ("SKIP_TEST_CP_1");
2282   if (str && strcmp (str, "1") == 0) return 1;
2283   str = getenv ("SKIP_TEST_CP");
2284   if (str && strcmp (str, "1") == 0) return 1;
2285   return 0;
2286 }
2287
2288 static int test_cp_1 (void)
2289 {
2290   if (test_cp_1_skip ()) {
2291     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2292     return 0;
2293   }
2294
2295   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2296   {
2297     char device[] = "/dev/sda";
2298     device[5] = devchar;
2299     int r;
2300     suppress_error = 0;
2301     r = guestfs_blockdev_setrw (g, device);
2302     if (r == -1)
2303       return -1;
2304   }
2305   {
2306     int r;
2307     suppress_error = 0;
2308     r = guestfs_umount_all (g);
2309     if (r == -1)
2310       return -1;
2311   }
2312   {
2313     int r;
2314     suppress_error = 0;
2315     r = guestfs_lvm_remove_all (g);
2316     if (r == -1)
2317       return -1;
2318   }
2319   {
2320     char device[] = "/dev/sda";
2321     device[5] = devchar;
2322     char lines_0[] = ",";
2323     char *lines[] = {
2324       lines_0,
2325       NULL
2326     };
2327     int r;
2328     suppress_error = 0;
2329     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2330     if (r == -1)
2331       return -1;
2332   }
2333   {
2334     char fstype[] = "ext2";
2335     char device[] = "/dev/sda1";
2336     device[5] = devchar;
2337     int r;
2338     suppress_error = 0;
2339     r = guestfs_mkfs (g, fstype, device);
2340     if (r == -1)
2341       return -1;
2342   }
2343   {
2344     char device[] = "/dev/sda1";
2345     device[5] = devchar;
2346     char mountpoint[] = "/";
2347     int r;
2348     suppress_error = 0;
2349     r = guestfs_mount (g, device, mountpoint);
2350     if (r == -1)
2351       return -1;
2352   }
2353   /* TestOutputTrue for cp (1) */
2354   {
2355     char path[] = "/old";
2356     char content[] = "file content";
2357     int r;
2358     suppress_error = 0;
2359     r = guestfs_write_file (g, path, content, 0);
2360     if (r == -1)
2361       return -1;
2362   }
2363   {
2364     char src[] = "/old";
2365     char dest[] = "/new";
2366     int r;
2367     suppress_error = 0;
2368     r = guestfs_cp (g, src, dest);
2369     if (r == -1)
2370       return -1;
2371   }
2372   {
2373     char path[] = "/old";
2374     int r;
2375     suppress_error = 0;
2376     r = guestfs_is_file (g, path);
2377     if (r == -1)
2378       return -1;
2379     if (!r) {
2380       fprintf (stderr, "test_cp_1: expected true, got false\n");
2381       return -1;
2382     }
2383   }
2384   return 0;
2385 }
2386
2387 static int test_cp_2_skip (void)
2388 {
2389   const char *str;
2390
2391   str = getenv ("SKIP_TEST_CP_2");
2392   if (str && strcmp (str, "1") == 0) return 1;
2393   str = getenv ("SKIP_TEST_CP");
2394   if (str && strcmp (str, "1") == 0) return 1;
2395   return 0;
2396 }
2397
2398 static int test_cp_2 (void)
2399 {
2400   if (test_cp_2_skip ()) {
2401     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2402     return 0;
2403   }
2404
2405   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2406   {
2407     char device[] = "/dev/sda";
2408     device[5] = devchar;
2409     int r;
2410     suppress_error = 0;
2411     r = guestfs_blockdev_setrw (g, device);
2412     if (r == -1)
2413       return -1;
2414   }
2415   {
2416     int r;
2417     suppress_error = 0;
2418     r = guestfs_umount_all (g);
2419     if (r == -1)
2420       return -1;
2421   }
2422   {
2423     int r;
2424     suppress_error = 0;
2425     r = guestfs_lvm_remove_all (g);
2426     if (r == -1)
2427       return -1;
2428   }
2429   {
2430     char device[] = "/dev/sda";
2431     device[5] = devchar;
2432     char lines_0[] = ",";
2433     char *lines[] = {
2434       lines_0,
2435       NULL
2436     };
2437     int r;
2438     suppress_error = 0;
2439     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2440     if (r == -1)
2441       return -1;
2442   }
2443   {
2444     char fstype[] = "ext2";
2445     char device[] = "/dev/sda1";
2446     device[5] = devchar;
2447     int r;
2448     suppress_error = 0;
2449     r = guestfs_mkfs (g, fstype, device);
2450     if (r == -1)
2451       return -1;
2452   }
2453   {
2454     char device[] = "/dev/sda1";
2455     device[5] = devchar;
2456     char mountpoint[] = "/";
2457     int r;
2458     suppress_error = 0;
2459     r = guestfs_mount (g, device, mountpoint);
2460     if (r == -1)
2461       return -1;
2462   }
2463   /* TestOutput for cp (2) */
2464   char expected[] = "file content";
2465   {
2466     char path[] = "/old";
2467     char content[] = "file content";
2468     int r;
2469     suppress_error = 0;
2470     r = guestfs_write_file (g, path, content, 0);
2471     if (r == -1)
2472       return -1;
2473   }
2474   {
2475     char path[] = "/dir";
2476     int r;
2477     suppress_error = 0;
2478     r = guestfs_mkdir (g, path);
2479     if (r == -1)
2480       return -1;
2481   }
2482   {
2483     char src[] = "/old";
2484     char dest[] = "/dir/new";
2485     int r;
2486     suppress_error = 0;
2487     r = guestfs_cp (g, src, dest);
2488     if (r == -1)
2489       return -1;
2490   }
2491   {
2492     char path[] = "/dir/new";
2493     char *r;
2494     suppress_error = 0;
2495     r = guestfs_cat (g, path);
2496     if (r == NULL)
2497       return -1;
2498     if (strcmp (r, expected) != 0) {
2499       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2500       return -1;
2501     }
2502     free (r);
2503   }
2504   return 0;
2505 }
2506
2507 static int test_grub_install_0_skip (void)
2508 {
2509   const char *str;
2510
2511   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2512   if (str && strcmp (str, "1") == 0) return 1;
2513   str = getenv ("SKIP_TEST_GRUB_INSTALL");
2514   if (str && strcmp (str, "1") == 0) return 1;
2515   return 0;
2516 }
2517
2518 static int test_grub_install_0 (void)
2519 {
2520   if (test_grub_install_0_skip ()) {
2521     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2522     return 0;
2523   }
2524
2525   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2526   {
2527     char device[] = "/dev/sda";
2528     device[5] = devchar;
2529     int r;
2530     suppress_error = 0;
2531     r = guestfs_blockdev_setrw (g, device);
2532     if (r == -1)
2533       return -1;
2534   }
2535   {
2536     int r;
2537     suppress_error = 0;
2538     r = guestfs_umount_all (g);
2539     if (r == -1)
2540       return -1;
2541   }
2542   {
2543     int r;
2544     suppress_error = 0;
2545     r = guestfs_lvm_remove_all (g);
2546     if (r == -1)
2547       return -1;
2548   }
2549   {
2550     char device[] = "/dev/sda";
2551     device[5] = devchar;
2552     char lines_0[] = ",";
2553     char *lines[] = {
2554       lines_0,
2555       NULL
2556     };
2557     int r;
2558     suppress_error = 0;
2559     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2560     if (r == -1)
2561       return -1;
2562   }
2563   {
2564     char fstype[] = "ext2";
2565     char device[] = "/dev/sda1";
2566     device[5] = devchar;
2567     int r;
2568     suppress_error = 0;
2569     r = guestfs_mkfs (g, fstype, device);
2570     if (r == -1)
2571       return -1;
2572   }
2573   {
2574     char device[] = "/dev/sda1";
2575     device[5] = devchar;
2576     char mountpoint[] = "/";
2577     int r;
2578     suppress_error = 0;
2579     r = guestfs_mount (g, device, mountpoint);
2580     if (r == -1)
2581       return -1;
2582   }
2583   /* TestOutputTrue for grub_install (0) */
2584   {
2585     char root[] = "/";
2586     char device[] = "/dev/sda1";
2587     device[5] = devchar;
2588     int r;
2589     suppress_error = 0;
2590     r = guestfs_grub_install (g, root, device);
2591     if (r == -1)
2592       return -1;
2593   }
2594   {
2595     char path[] = "/boot";
2596     int r;
2597     suppress_error = 0;
2598     r = guestfs_is_dir (g, path);
2599     if (r == -1)
2600       return -1;
2601     if (!r) {
2602       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2603       return -1;
2604     }
2605   }
2606   return 0;
2607 }
2608
2609 static int test_zero_0_skip (void)
2610 {
2611   const char *str;
2612
2613   str = getenv ("SKIP_TEST_ZERO_0");
2614   if (str && strcmp (str, "1") == 0) return 1;
2615   str = getenv ("SKIP_TEST_ZERO");
2616   if (str && strcmp (str, "1") == 0) return 1;
2617   return 0;
2618 }
2619
2620 static int test_zero_0 (void)
2621 {
2622   if (test_zero_0_skip ()) {
2623     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2624     return 0;
2625   }
2626
2627   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2628   {
2629     char device[] = "/dev/sda";
2630     device[5] = devchar;
2631     int r;
2632     suppress_error = 0;
2633     r = guestfs_blockdev_setrw (g, device);
2634     if (r == -1)
2635       return -1;
2636   }
2637   {
2638     int r;
2639     suppress_error = 0;
2640     r = guestfs_umount_all (g);
2641     if (r == -1)
2642       return -1;
2643   }
2644   {
2645     int r;
2646     suppress_error = 0;
2647     r = guestfs_lvm_remove_all (g);
2648     if (r == -1)
2649       return -1;
2650   }
2651   {
2652     char device[] = "/dev/sda";
2653     device[5] = devchar;
2654     char lines_0[] = ",";
2655     char *lines[] = {
2656       lines_0,
2657       NULL
2658     };
2659     int r;
2660     suppress_error = 0;
2661     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2662     if (r == -1)
2663       return -1;
2664   }
2665   {
2666     char fstype[] = "ext2";
2667     char device[] = "/dev/sda1";
2668     device[5] = devchar;
2669     int r;
2670     suppress_error = 0;
2671     r = guestfs_mkfs (g, fstype, device);
2672     if (r == -1)
2673       return -1;
2674   }
2675   {
2676     char device[] = "/dev/sda1";
2677     device[5] = devchar;
2678     char mountpoint[] = "/";
2679     int r;
2680     suppress_error = 0;
2681     r = guestfs_mount (g, device, mountpoint);
2682     if (r == -1)
2683       return -1;
2684   }
2685   /* TestOutput for zero (0) */
2686   char expected[] = "data";
2687   {
2688     char pathordevice[] = "/dev/sda1";
2689     pathordevice[5] = devchar;
2690     int r;
2691     suppress_error = 0;
2692     r = guestfs_umount (g, pathordevice);
2693     if (r == -1)
2694       return -1;
2695   }
2696   {
2697     char device[] = "/dev/sda1";
2698     device[5] = devchar;
2699     int r;
2700     suppress_error = 0;
2701     r = guestfs_zero (g, device);
2702     if (r == -1)
2703       return -1;
2704   }
2705   {
2706     char path[] = "/dev/sda1";
2707     path[5] = devchar;
2708     char *r;
2709     suppress_error = 0;
2710     r = guestfs_file (g, path);
2711     if (r == NULL)
2712       return -1;
2713     if (strcmp (r, expected) != 0) {
2714       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2715       return -1;
2716     }
2717     free (r);
2718   }
2719   return 0;
2720 }
2721
2722 static int test_fsck_0_skip (void)
2723 {
2724   const char *str;
2725
2726   str = getenv ("SKIP_TEST_FSCK_0");
2727   if (str && strcmp (str, "1") == 0) return 1;
2728   str = getenv ("SKIP_TEST_FSCK");
2729   if (str && strcmp (str, "1") == 0) return 1;
2730   return 0;
2731 }
2732
2733 static int test_fsck_0 (void)
2734 {
2735   if (test_fsck_0_skip ()) {
2736     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2737     return 0;
2738   }
2739
2740   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2741   {
2742     char device[] = "/dev/sda";
2743     device[5] = devchar;
2744     int r;
2745     suppress_error = 0;
2746     r = guestfs_blockdev_setrw (g, device);
2747     if (r == -1)
2748       return -1;
2749   }
2750   {
2751     int r;
2752     suppress_error = 0;
2753     r = guestfs_umount_all (g);
2754     if (r == -1)
2755       return -1;
2756   }
2757   {
2758     int r;
2759     suppress_error = 0;
2760     r = guestfs_lvm_remove_all (g);
2761     if (r == -1)
2762       return -1;
2763   }
2764   {
2765     char device[] = "/dev/sda";
2766     device[5] = devchar;
2767     char lines_0[] = ",";
2768     char *lines[] = {
2769       lines_0,
2770       NULL
2771     };
2772     int r;
2773     suppress_error = 0;
2774     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2775     if (r == -1)
2776       return -1;
2777   }
2778   {
2779     char fstype[] = "ext2";
2780     char device[] = "/dev/sda1";
2781     device[5] = devchar;
2782     int r;
2783     suppress_error = 0;
2784     r = guestfs_mkfs (g, fstype, device);
2785     if (r == -1)
2786       return -1;
2787   }
2788   {
2789     char device[] = "/dev/sda1";
2790     device[5] = devchar;
2791     char mountpoint[] = "/";
2792     int r;
2793     suppress_error = 0;
2794     r = guestfs_mount (g, device, mountpoint);
2795     if (r == -1)
2796       return -1;
2797   }
2798   /* TestOutputInt for fsck (0) */
2799   {
2800     char pathordevice[] = "/dev/sda1";
2801     pathordevice[5] = devchar;
2802     int r;
2803     suppress_error = 0;
2804     r = guestfs_umount (g, pathordevice);
2805     if (r == -1)
2806       return -1;
2807   }
2808   {
2809     char fstype[] = "ext2";
2810     char device[] = "/dev/sda1";
2811     device[5] = devchar;
2812     int r;
2813     suppress_error = 0;
2814     r = guestfs_fsck (g, fstype, device);
2815     if (r == -1)
2816       return -1;
2817     if (r != 0) {
2818       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
2819       return -1;
2820     }
2821   }
2822   return 0;
2823 }
2824
2825 static int test_fsck_1_skip (void)
2826 {
2827   const char *str;
2828
2829   str = getenv ("SKIP_TEST_FSCK_1");
2830   if (str && strcmp (str, "1") == 0) return 1;
2831   str = getenv ("SKIP_TEST_FSCK");
2832   if (str && strcmp (str, "1") == 0) return 1;
2833   return 0;
2834 }
2835
2836 static int test_fsck_1 (void)
2837 {
2838   if (test_fsck_1_skip ()) {
2839     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
2840     return 0;
2841   }
2842
2843   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2844   {
2845     char device[] = "/dev/sda";
2846     device[5] = devchar;
2847     int r;
2848     suppress_error = 0;
2849     r = guestfs_blockdev_setrw (g, device);
2850     if (r == -1)
2851       return -1;
2852   }
2853   {
2854     int r;
2855     suppress_error = 0;
2856     r = guestfs_umount_all (g);
2857     if (r == -1)
2858       return -1;
2859   }
2860   {
2861     int r;
2862     suppress_error = 0;
2863     r = guestfs_lvm_remove_all (g);
2864     if (r == -1)
2865       return -1;
2866   }
2867   {
2868     char device[] = "/dev/sda";
2869     device[5] = devchar;
2870     char lines_0[] = ",";
2871     char *lines[] = {
2872       lines_0,
2873       NULL
2874     };
2875     int r;
2876     suppress_error = 0;
2877     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2878     if (r == -1)
2879       return -1;
2880   }
2881   {
2882     char fstype[] = "ext2";
2883     char device[] = "/dev/sda1";
2884     device[5] = devchar;
2885     int r;
2886     suppress_error = 0;
2887     r = guestfs_mkfs (g, fstype, device);
2888     if (r == -1)
2889       return -1;
2890   }
2891   {
2892     char device[] = "/dev/sda1";
2893     device[5] = devchar;
2894     char mountpoint[] = "/";
2895     int r;
2896     suppress_error = 0;
2897     r = guestfs_mount (g, device, mountpoint);
2898     if (r == -1)
2899       return -1;
2900   }
2901   /* TestOutputInt for fsck (1) */
2902   {
2903     char pathordevice[] = "/dev/sda1";
2904     pathordevice[5] = devchar;
2905     int r;
2906     suppress_error = 0;
2907     r = guestfs_umount (g, pathordevice);
2908     if (r == -1)
2909       return -1;
2910   }
2911   {
2912     char device[] = "/dev/sda1";
2913     device[5] = devchar;
2914     int r;
2915     suppress_error = 0;
2916     r = guestfs_zero (g, device);
2917     if (r == -1)
2918       return -1;
2919   }
2920   {
2921     char fstype[] = "ext2";
2922     char device[] = "/dev/sda1";
2923     device[5] = devchar;
2924     int r;
2925     suppress_error = 0;
2926     r = guestfs_fsck (g, fstype, device);
2927     if (r == -1)
2928       return -1;
2929     if (r != 8) {
2930       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
2931       return -1;
2932     }
2933   }
2934   return 0;
2935 }
2936
2937 static int test_set_e2uuid_0_skip (void)
2938 {
2939   const char *str;
2940
2941   str = getenv ("SKIP_TEST_SET_E2UUID_0");
2942   if (str && strcmp (str, "1") == 0) return 1;
2943   str = getenv ("SKIP_TEST_SET_E2UUID");
2944   if (str && strcmp (str, "1") == 0) return 1;
2945   return 0;
2946 }
2947
2948 static int test_set_e2uuid_0 (void)
2949 {
2950   if (test_set_e2uuid_0_skip ()) {
2951     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
2952     return 0;
2953   }
2954
2955   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2956   {
2957     char device[] = "/dev/sda";
2958     device[5] = devchar;
2959     int r;
2960     suppress_error = 0;
2961     r = guestfs_blockdev_setrw (g, device);
2962     if (r == -1)
2963       return -1;
2964   }
2965   {
2966     int r;
2967     suppress_error = 0;
2968     r = guestfs_umount_all (g);
2969     if (r == -1)
2970       return -1;
2971   }
2972   {
2973     int r;
2974     suppress_error = 0;
2975     r = guestfs_lvm_remove_all (g);
2976     if (r == -1)
2977       return -1;
2978   }
2979   {
2980     char device[] = "/dev/sda";
2981     device[5] = devchar;
2982     char lines_0[] = ",";
2983     char *lines[] = {
2984       lines_0,
2985       NULL
2986     };
2987     int r;
2988     suppress_error = 0;
2989     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2990     if (r == -1)
2991       return -1;
2992   }
2993   {
2994     char fstype[] = "ext2";
2995     char device[] = "/dev/sda1";
2996     device[5] = devchar;
2997     int r;
2998     suppress_error = 0;
2999     r = guestfs_mkfs (g, fstype, device);
3000     if (r == -1)
3001       return -1;
3002   }
3003   {
3004     char device[] = "/dev/sda1";
3005     device[5] = devchar;
3006     char mountpoint[] = "/";
3007     int r;
3008     suppress_error = 0;
3009     r = guestfs_mount (g, device, mountpoint);
3010     if (r == -1)
3011       return -1;
3012   }
3013   /* TestOutput for set_e2uuid (0) */
3014   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3015   {
3016     char device[] = "/dev/sda1";
3017     device[5] = devchar;
3018     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3019     int r;
3020     suppress_error = 0;
3021     r = guestfs_set_e2uuid (g, device, uuid);
3022     if (r == -1)
3023       return -1;
3024   }
3025   {
3026     char device[] = "/dev/sda1";
3027     device[5] = devchar;
3028     char *r;
3029     suppress_error = 0;
3030     r = guestfs_get_e2uuid (g, device);
3031     if (r == NULL)
3032       return -1;
3033     if (strcmp (r, expected) != 0) {
3034       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3035       return -1;
3036     }
3037     free (r);
3038   }
3039   return 0;
3040 }
3041
3042 static int test_set_e2uuid_1_skip (void)
3043 {
3044   const char *str;
3045
3046   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3047   if (str && strcmp (str, "1") == 0) return 1;
3048   str = getenv ("SKIP_TEST_SET_E2UUID");
3049   if (str && strcmp (str, "1") == 0) return 1;
3050   return 0;
3051 }
3052
3053 static int test_set_e2uuid_1 (void)
3054 {
3055   if (test_set_e2uuid_1_skip ()) {
3056     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3057     return 0;
3058   }
3059
3060   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3061   {
3062     char device[] = "/dev/sda";
3063     device[5] = devchar;
3064     int r;
3065     suppress_error = 0;
3066     r = guestfs_blockdev_setrw (g, device);
3067     if (r == -1)
3068       return -1;
3069   }
3070   {
3071     int r;
3072     suppress_error = 0;
3073     r = guestfs_umount_all (g);
3074     if (r == -1)
3075       return -1;
3076   }
3077   {
3078     int r;
3079     suppress_error = 0;
3080     r = guestfs_lvm_remove_all (g);
3081     if (r == -1)
3082       return -1;
3083   }
3084   {
3085     char device[] = "/dev/sda";
3086     device[5] = devchar;
3087     char lines_0[] = ",";
3088     char *lines[] = {
3089       lines_0,
3090       NULL
3091     };
3092     int r;
3093     suppress_error = 0;
3094     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3095     if (r == -1)
3096       return -1;
3097   }
3098   {
3099     char fstype[] = "ext2";
3100     char device[] = "/dev/sda1";
3101     device[5] = devchar;
3102     int r;
3103     suppress_error = 0;
3104     r = guestfs_mkfs (g, fstype, device);
3105     if (r == -1)
3106       return -1;
3107   }
3108   {
3109     char device[] = "/dev/sda1";
3110     device[5] = devchar;
3111     char mountpoint[] = "/";
3112     int r;
3113     suppress_error = 0;
3114     r = guestfs_mount (g, device, mountpoint);
3115     if (r == -1)
3116       return -1;
3117   }
3118   /* TestOutput for set_e2uuid (1) */
3119   char expected[] = "";
3120   {
3121     char device[] = "/dev/sda1";
3122     device[5] = devchar;
3123     char uuid[] = "clear";
3124     int r;
3125     suppress_error = 0;
3126     r = guestfs_set_e2uuid (g, device, uuid);
3127     if (r == -1)
3128       return -1;
3129   }
3130   {
3131     char device[] = "/dev/sda1";
3132     device[5] = devchar;
3133     char *r;
3134     suppress_error = 0;
3135     r = guestfs_get_e2uuid (g, device);
3136     if (r == NULL)
3137       return -1;
3138     if (strcmp (r, expected) != 0) {
3139       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3140       return -1;
3141     }
3142     free (r);
3143   }
3144   return 0;
3145 }
3146
3147 static int test_set_e2uuid_2_skip (void)
3148 {
3149   const char *str;
3150
3151   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3152   if (str && strcmp (str, "1") == 0) return 1;
3153   str = getenv ("SKIP_TEST_SET_E2UUID");
3154   if (str && strcmp (str, "1") == 0) return 1;
3155   return 0;
3156 }
3157
3158 static int test_set_e2uuid_2 (void)
3159 {
3160   if (test_set_e2uuid_2_skip ()) {
3161     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3162     return 0;
3163   }
3164
3165   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3166   {
3167     char device[] = "/dev/sda";
3168     device[5] = devchar;
3169     int r;
3170     suppress_error = 0;
3171     r = guestfs_blockdev_setrw (g, device);
3172     if (r == -1)
3173       return -1;
3174   }
3175   {
3176     int r;
3177     suppress_error = 0;
3178     r = guestfs_umount_all (g);
3179     if (r == -1)
3180       return -1;
3181   }
3182   {
3183     int r;
3184     suppress_error = 0;
3185     r = guestfs_lvm_remove_all (g);
3186     if (r == -1)
3187       return -1;
3188   }
3189   {
3190     char device[] = "/dev/sda";
3191     device[5] = devchar;
3192     char lines_0[] = ",";
3193     char *lines[] = {
3194       lines_0,
3195       NULL
3196     };
3197     int r;
3198     suppress_error = 0;
3199     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3200     if (r == -1)
3201       return -1;
3202   }
3203   {
3204     char fstype[] = "ext2";
3205     char device[] = "/dev/sda1";
3206     device[5] = devchar;
3207     int r;
3208     suppress_error = 0;
3209     r = guestfs_mkfs (g, fstype, device);
3210     if (r == -1)
3211       return -1;
3212   }
3213   {
3214     char device[] = "/dev/sda1";
3215     device[5] = devchar;
3216     char mountpoint[] = "/";
3217     int r;
3218     suppress_error = 0;
3219     r = guestfs_mount (g, device, mountpoint);
3220     if (r == -1)
3221       return -1;
3222   }
3223   /* TestRun for set_e2uuid (2) */
3224   {
3225     char device[] = "/dev/sda1";
3226     device[5] = devchar;
3227     char uuid[] = "random";
3228     int r;
3229     suppress_error = 0;
3230     r = guestfs_set_e2uuid (g, device, uuid);
3231     if (r == -1)
3232       return -1;
3233   }
3234   return 0;
3235 }
3236
3237 static int test_set_e2uuid_3_skip (void)
3238 {
3239   const char *str;
3240
3241   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3242   if (str && strcmp (str, "1") == 0) return 1;
3243   str = getenv ("SKIP_TEST_SET_E2UUID");
3244   if (str && strcmp (str, "1") == 0) return 1;
3245   return 0;
3246 }
3247
3248 static int test_set_e2uuid_3 (void)
3249 {
3250   if (test_set_e2uuid_3_skip ()) {
3251     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3252     return 0;
3253   }
3254
3255   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3256   {
3257     char device[] = "/dev/sda";
3258     device[5] = devchar;
3259     int r;
3260     suppress_error = 0;
3261     r = guestfs_blockdev_setrw (g, device);
3262     if (r == -1)
3263       return -1;
3264   }
3265   {
3266     int r;
3267     suppress_error = 0;
3268     r = guestfs_umount_all (g);
3269     if (r == -1)
3270       return -1;
3271   }
3272   {
3273     int r;
3274     suppress_error = 0;
3275     r = guestfs_lvm_remove_all (g);
3276     if (r == -1)
3277       return -1;
3278   }
3279   {
3280     char device[] = "/dev/sda";
3281     device[5] = devchar;
3282     char lines_0[] = ",";
3283     char *lines[] = {
3284       lines_0,
3285       NULL
3286     };
3287     int r;
3288     suppress_error = 0;
3289     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3290     if (r == -1)
3291       return -1;
3292   }
3293   {
3294     char fstype[] = "ext2";
3295     char device[] = "/dev/sda1";
3296     device[5] = devchar;
3297     int r;
3298     suppress_error = 0;
3299     r = guestfs_mkfs (g, fstype, device);
3300     if (r == -1)
3301       return -1;
3302   }
3303   {
3304     char device[] = "/dev/sda1";
3305     device[5] = devchar;
3306     char mountpoint[] = "/";
3307     int r;
3308     suppress_error = 0;
3309     r = guestfs_mount (g, device, mountpoint);
3310     if (r == -1)
3311       return -1;
3312   }
3313   /* TestRun for set_e2uuid (3) */
3314   {
3315     char device[] = "/dev/sda1";
3316     device[5] = devchar;
3317     char uuid[] = "time";
3318     int r;
3319     suppress_error = 0;
3320     r = guestfs_set_e2uuid (g, device, uuid);
3321     if (r == -1)
3322       return -1;
3323   }
3324   return 0;
3325 }
3326
3327 static int test_set_e2label_0_skip (void)
3328 {
3329   const char *str;
3330
3331   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3332   if (str && strcmp (str, "1") == 0) return 1;
3333   str = getenv ("SKIP_TEST_SET_E2LABEL");
3334   if (str && strcmp (str, "1") == 0) return 1;
3335   return 0;
3336 }
3337
3338 static int test_set_e2label_0 (void)
3339 {
3340   if (test_set_e2label_0_skip ()) {
3341     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3342     return 0;
3343   }
3344
3345   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3346   {
3347     char device[] = "/dev/sda";
3348     device[5] = devchar;
3349     int r;
3350     suppress_error = 0;
3351     r = guestfs_blockdev_setrw (g, device);
3352     if (r == -1)
3353       return -1;
3354   }
3355   {
3356     int r;
3357     suppress_error = 0;
3358     r = guestfs_umount_all (g);
3359     if (r == -1)
3360       return -1;
3361   }
3362   {
3363     int r;
3364     suppress_error = 0;
3365     r = guestfs_lvm_remove_all (g);
3366     if (r == -1)
3367       return -1;
3368   }
3369   {
3370     char device[] = "/dev/sda";
3371     device[5] = devchar;
3372     char lines_0[] = ",";
3373     char *lines[] = {
3374       lines_0,
3375       NULL
3376     };
3377     int r;
3378     suppress_error = 0;
3379     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3380     if (r == -1)
3381       return -1;
3382   }
3383   {
3384     char fstype[] = "ext2";
3385     char device[] = "/dev/sda1";
3386     device[5] = devchar;
3387     int r;
3388     suppress_error = 0;
3389     r = guestfs_mkfs (g, fstype, device);
3390     if (r == -1)
3391       return -1;
3392   }
3393   {
3394     char device[] = "/dev/sda1";
3395     device[5] = devchar;
3396     char mountpoint[] = "/";
3397     int r;
3398     suppress_error = 0;
3399     r = guestfs_mount (g, device, mountpoint);
3400     if (r == -1)
3401       return -1;
3402   }
3403   /* TestOutput for set_e2label (0) */
3404   char expected[] = "testlabel";
3405   {
3406     char device[] = "/dev/sda1";
3407     device[5] = devchar;
3408     char label[] = "testlabel";
3409     int r;
3410     suppress_error = 0;
3411     r = guestfs_set_e2label (g, device, label);
3412     if (r == -1)
3413       return -1;
3414   }
3415   {
3416     char device[] = "/dev/sda1";
3417     device[5] = devchar;
3418     char *r;
3419     suppress_error = 0;
3420     r = guestfs_get_e2label (g, device);
3421     if (r == NULL)
3422       return -1;
3423     if (strcmp (r, expected) != 0) {
3424       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3425       return -1;
3426     }
3427     free (r);
3428   }
3429   return 0;
3430 }
3431
3432 static int test_pvremove_0_skip (void)
3433 {
3434   const char *str;
3435
3436   str = getenv ("SKIP_TEST_PVREMOVE_0");
3437   if (str && strcmp (str, "1") == 0) return 1;
3438   str = getenv ("SKIP_TEST_PVREMOVE");
3439   if (str && strcmp (str, "1") == 0) return 1;
3440   return 0;
3441 }
3442
3443 static int test_pvremove_0 (void)
3444 {
3445   if (test_pvremove_0_skip ()) {
3446     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3447     return 0;
3448   }
3449
3450   /* InitNone|InitEmpty for test_pvremove_0 */
3451   {
3452     char device[] = "/dev/sda";
3453     device[5] = devchar;
3454     int r;
3455     suppress_error = 0;
3456     r = guestfs_blockdev_setrw (g, device);
3457     if (r == -1)
3458       return -1;
3459   }
3460   {
3461     int r;
3462     suppress_error = 0;
3463     r = guestfs_umount_all (g);
3464     if (r == -1)
3465       return -1;
3466   }
3467   {
3468     int r;
3469     suppress_error = 0;
3470     r = guestfs_lvm_remove_all (g);
3471     if (r == -1)
3472       return -1;
3473   }
3474   /* TestOutputList for pvremove (0) */
3475   {
3476     char device[] = "/dev/sda";
3477     device[5] = devchar;
3478     char lines_0[] = ",";
3479     char *lines[] = {
3480       lines_0,
3481       NULL
3482     };
3483     int r;
3484     suppress_error = 0;
3485     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3486     if (r == -1)
3487       return -1;
3488   }
3489   {
3490     char device[] = "/dev/sda1";
3491     device[5] = devchar;
3492     int r;
3493     suppress_error = 0;
3494     r = guestfs_pvcreate (g, device);
3495     if (r == -1)
3496       return -1;
3497   }
3498   {
3499     char volgroup[] = "VG";
3500     char physvols_0[] = "/dev/sda1";
3501     physvols_0[5] = devchar;
3502     char *physvols[] = {
3503       physvols_0,
3504       NULL
3505     };
3506     int r;
3507     suppress_error = 0;
3508     r = guestfs_vgcreate (g, volgroup, physvols);
3509     if (r == -1)
3510       return -1;
3511   }
3512   {
3513     char logvol[] = "LV1";
3514     char volgroup[] = "VG";
3515     int r;
3516     suppress_error = 0;
3517     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3518     if (r == -1)
3519       return -1;
3520   }
3521   {
3522     char logvol[] = "LV2";
3523     char volgroup[] = "VG";
3524     int r;
3525     suppress_error = 0;
3526     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3527     if (r == -1)
3528       return -1;
3529   }
3530   {
3531     char vgname[] = "VG";
3532     int r;
3533     suppress_error = 0;
3534     r = guestfs_vgremove (g, vgname);
3535     if (r == -1)
3536       return -1;
3537   }
3538   {
3539     char device[] = "/dev/sda1";
3540     device[5] = devchar;
3541     int r;
3542     suppress_error = 0;
3543     r = guestfs_pvremove (g, device);
3544     if (r == -1)
3545       return -1;
3546   }
3547   {
3548     char **r;
3549     int i;
3550     suppress_error = 0;
3551     r = guestfs_lvs (g);
3552     if (r == NULL)
3553       return -1;
3554     if (r[0] != NULL) {
3555       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3556       print_strings (r);
3557       return -1;
3558     }
3559     for (i = 0; r[i] != NULL; ++i)
3560       free (r[i]);
3561     free (r);
3562   }
3563   return 0;
3564 }
3565
3566 static int test_pvremove_1_skip (void)
3567 {
3568   const char *str;
3569
3570   str = getenv ("SKIP_TEST_PVREMOVE_1");
3571   if (str && strcmp (str, "1") == 0) return 1;
3572   str = getenv ("SKIP_TEST_PVREMOVE");
3573   if (str && strcmp (str, "1") == 0) return 1;
3574   return 0;
3575 }
3576
3577 static int test_pvremove_1 (void)
3578 {
3579   if (test_pvremove_1_skip ()) {
3580     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3581     return 0;
3582   }
3583
3584   /* InitNone|InitEmpty for test_pvremove_1 */
3585   {
3586     char device[] = "/dev/sda";
3587     device[5] = devchar;
3588     int r;
3589     suppress_error = 0;
3590     r = guestfs_blockdev_setrw (g, device);
3591     if (r == -1)
3592       return -1;
3593   }
3594   {
3595     int r;
3596     suppress_error = 0;
3597     r = guestfs_umount_all (g);
3598     if (r == -1)
3599       return -1;
3600   }
3601   {
3602     int r;
3603     suppress_error = 0;
3604     r = guestfs_lvm_remove_all (g);
3605     if (r == -1)
3606       return -1;
3607   }
3608   /* TestOutputList for pvremove (1) */
3609   {
3610     char device[] = "/dev/sda";
3611     device[5] = devchar;
3612     char lines_0[] = ",";
3613     char *lines[] = {
3614       lines_0,
3615       NULL
3616     };
3617     int r;
3618     suppress_error = 0;
3619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3620     if (r == -1)
3621       return -1;
3622   }
3623   {
3624     char device[] = "/dev/sda1";
3625     device[5] = devchar;
3626     int r;
3627     suppress_error = 0;
3628     r = guestfs_pvcreate (g, device);
3629     if (r == -1)
3630       return -1;
3631   }
3632   {
3633     char volgroup[] = "VG";
3634     char physvols_0[] = "/dev/sda1";
3635     physvols_0[5] = devchar;
3636     char *physvols[] = {
3637       physvols_0,
3638       NULL
3639     };
3640     int r;
3641     suppress_error = 0;
3642     r = guestfs_vgcreate (g, volgroup, physvols);
3643     if (r == -1)
3644       return -1;
3645   }
3646   {
3647     char logvol[] = "LV1";
3648     char volgroup[] = "VG";
3649     int r;
3650     suppress_error = 0;
3651     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3652     if (r == -1)
3653       return -1;
3654   }
3655   {
3656     char logvol[] = "LV2";
3657     char volgroup[] = "VG";
3658     int r;
3659     suppress_error = 0;
3660     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3661     if (r == -1)
3662       return -1;
3663   }
3664   {
3665     char vgname[] = "VG";
3666     int r;
3667     suppress_error = 0;
3668     r = guestfs_vgremove (g, vgname);
3669     if (r == -1)
3670       return -1;
3671   }
3672   {
3673     char device[] = "/dev/sda1";
3674     device[5] = devchar;
3675     int r;
3676     suppress_error = 0;
3677     r = guestfs_pvremove (g, device);
3678     if (r == -1)
3679       return -1;
3680   }
3681   {
3682     char **r;
3683     int i;
3684     suppress_error = 0;
3685     r = guestfs_vgs (g);
3686     if (r == NULL)
3687       return -1;
3688     if (r[0] != NULL) {
3689       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3690       print_strings (r);
3691       return -1;
3692     }
3693     for (i = 0; r[i] != NULL; ++i)
3694       free (r[i]);
3695     free (r);
3696   }
3697   return 0;
3698 }
3699
3700 static int test_pvremove_2_skip (void)
3701 {
3702   const char *str;
3703
3704   str = getenv ("SKIP_TEST_PVREMOVE_2");
3705   if (str && strcmp (str, "1") == 0) return 1;
3706   str = getenv ("SKIP_TEST_PVREMOVE");
3707   if (str && strcmp (str, "1") == 0) return 1;
3708   return 0;
3709 }
3710
3711 static int test_pvremove_2 (void)
3712 {
3713   if (test_pvremove_2_skip ()) {
3714     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3715     return 0;
3716   }
3717
3718   /* InitNone|InitEmpty for test_pvremove_2 */
3719   {
3720     char device[] = "/dev/sda";
3721     device[5] = devchar;
3722     int r;
3723     suppress_error = 0;
3724     r = guestfs_blockdev_setrw (g, device);
3725     if (r == -1)
3726       return -1;
3727   }
3728   {
3729     int r;
3730     suppress_error = 0;
3731     r = guestfs_umount_all (g);
3732     if (r == -1)
3733       return -1;
3734   }
3735   {
3736     int r;
3737     suppress_error = 0;
3738     r = guestfs_lvm_remove_all (g);
3739     if (r == -1)
3740       return -1;
3741   }
3742   /* TestOutputList for pvremove (2) */
3743   {
3744     char device[] = "/dev/sda";
3745     device[5] = devchar;
3746     char lines_0[] = ",";
3747     char *lines[] = {
3748       lines_0,
3749       NULL
3750     };
3751     int r;
3752     suppress_error = 0;
3753     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3754     if (r == -1)
3755       return -1;
3756   }
3757   {
3758     char device[] = "/dev/sda1";
3759     device[5] = devchar;
3760     int r;
3761     suppress_error = 0;
3762     r = guestfs_pvcreate (g, device);
3763     if (r == -1)
3764       return -1;
3765   }
3766   {
3767     char volgroup[] = "VG";
3768     char physvols_0[] = "/dev/sda1";
3769     physvols_0[5] = devchar;
3770     char *physvols[] = {
3771       physvols_0,
3772       NULL
3773     };
3774     int r;
3775     suppress_error = 0;
3776     r = guestfs_vgcreate (g, volgroup, physvols);
3777     if (r == -1)
3778       return -1;
3779   }
3780   {
3781     char logvol[] = "LV1";
3782     char volgroup[] = "VG";
3783     int r;
3784     suppress_error = 0;
3785     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3786     if (r == -1)
3787       return -1;
3788   }
3789   {
3790     char logvol[] = "LV2";
3791     char volgroup[] = "VG";
3792     int r;
3793     suppress_error = 0;
3794     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3795     if (r == -1)
3796       return -1;
3797   }
3798   {
3799     char vgname[] = "VG";
3800     int r;
3801     suppress_error = 0;
3802     r = guestfs_vgremove (g, vgname);
3803     if (r == -1)
3804       return -1;
3805   }
3806   {
3807     char device[] = "/dev/sda1";
3808     device[5] = devchar;
3809     int r;
3810     suppress_error = 0;
3811     r = guestfs_pvremove (g, device);
3812     if (r == -1)
3813       return -1;
3814   }
3815   {
3816     char **r;
3817     int i;
3818     suppress_error = 0;
3819     r = guestfs_pvs (g);
3820     if (r == NULL)
3821       return -1;
3822     if (r[0] != NULL) {
3823       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3824       print_strings (r);
3825       return -1;
3826     }
3827     for (i = 0; r[i] != NULL; ++i)
3828       free (r[i]);
3829     free (r);
3830   }
3831   return 0;
3832 }
3833
3834 static int test_vgremove_0_skip (void)
3835 {
3836   const char *str;
3837
3838   str = getenv ("SKIP_TEST_VGREMOVE_0");
3839   if (str && strcmp (str, "1") == 0) return 1;
3840   str = getenv ("SKIP_TEST_VGREMOVE");
3841   if (str && strcmp (str, "1") == 0) return 1;
3842   return 0;
3843 }
3844
3845 static int test_vgremove_0 (void)
3846 {
3847   if (test_vgremove_0_skip ()) {
3848     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
3849     return 0;
3850   }
3851
3852   /* InitNone|InitEmpty for test_vgremove_0 */
3853   {
3854     char device[] = "/dev/sda";
3855     device[5] = devchar;
3856     int r;
3857     suppress_error = 0;
3858     r = guestfs_blockdev_setrw (g, device);
3859     if (r == -1)
3860       return -1;
3861   }
3862   {
3863     int r;
3864     suppress_error = 0;
3865     r = guestfs_umount_all (g);
3866     if (r == -1)
3867       return -1;
3868   }
3869   {
3870     int r;
3871     suppress_error = 0;
3872     r = guestfs_lvm_remove_all (g);
3873     if (r == -1)
3874       return -1;
3875   }
3876   /* TestOutputList for vgremove (0) */
3877   {
3878     char device[] = "/dev/sda";
3879     device[5] = devchar;
3880     char lines_0[] = ",";
3881     char *lines[] = {
3882       lines_0,
3883       NULL
3884     };
3885     int r;
3886     suppress_error = 0;
3887     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3888     if (r == -1)
3889       return -1;
3890   }
3891   {
3892     char device[] = "/dev/sda1";
3893     device[5] = devchar;
3894     int r;
3895     suppress_error = 0;
3896     r = guestfs_pvcreate (g, device);
3897     if (r == -1)
3898       return -1;
3899   }
3900   {
3901     char volgroup[] = "VG";
3902     char physvols_0[] = "/dev/sda1";
3903     physvols_0[5] = devchar;
3904     char *physvols[] = {
3905       physvols_0,
3906       NULL
3907     };
3908     int r;
3909     suppress_error = 0;
3910     r = guestfs_vgcreate (g, volgroup, physvols);
3911     if (r == -1)
3912       return -1;
3913   }
3914   {
3915     char logvol[] = "LV1";
3916     char volgroup[] = "VG";
3917     int r;
3918     suppress_error = 0;
3919     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3920     if (r == -1)
3921       return -1;
3922   }
3923   {
3924     char logvol[] = "LV2";
3925     char volgroup[] = "VG";
3926     int r;
3927     suppress_error = 0;
3928     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3929     if (r == -1)
3930       return -1;
3931   }
3932   {
3933     char vgname[] = "VG";
3934     int r;
3935     suppress_error = 0;
3936     r = guestfs_vgremove (g, vgname);
3937     if (r == -1)
3938       return -1;
3939   }
3940   {
3941     char **r;
3942     int i;
3943     suppress_error = 0;
3944     r = guestfs_lvs (g);
3945     if (r == NULL)
3946       return -1;
3947     if (r[0] != NULL) {
3948       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3949       print_strings (r);
3950       return -1;
3951     }
3952     for (i = 0; r[i] != NULL; ++i)
3953       free (r[i]);
3954     free (r);
3955   }
3956   return 0;
3957 }
3958
3959 static int test_vgremove_1_skip (void)
3960 {
3961   const char *str;
3962
3963   str = getenv ("SKIP_TEST_VGREMOVE_1");
3964   if (str && strcmp (str, "1") == 0) return 1;
3965   str = getenv ("SKIP_TEST_VGREMOVE");
3966   if (str && strcmp (str, "1") == 0) return 1;
3967   return 0;
3968 }
3969
3970 static int test_vgremove_1 (void)
3971 {
3972   if (test_vgremove_1_skip ()) {
3973     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
3974     return 0;
3975   }
3976
3977   /* InitNone|InitEmpty for test_vgremove_1 */
3978   {
3979     char device[] = "/dev/sda";
3980     device[5] = devchar;
3981     int r;
3982     suppress_error = 0;
3983     r = guestfs_blockdev_setrw (g, device);
3984     if (r == -1)
3985       return -1;
3986   }
3987   {
3988     int r;
3989     suppress_error = 0;
3990     r = guestfs_umount_all (g);
3991     if (r == -1)
3992       return -1;
3993   }
3994   {
3995     int r;
3996     suppress_error = 0;
3997     r = guestfs_lvm_remove_all (g);
3998     if (r == -1)
3999       return -1;
4000   }
4001   /* TestOutputList for vgremove (1) */
4002   {
4003     char device[] = "/dev/sda";
4004     device[5] = devchar;
4005     char lines_0[] = ",";
4006     char *lines[] = {
4007       lines_0,
4008       NULL
4009     };
4010     int r;
4011     suppress_error = 0;
4012     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4013     if (r == -1)
4014       return -1;
4015   }
4016   {
4017     char device[] = "/dev/sda1";
4018     device[5] = devchar;
4019     int r;
4020     suppress_error = 0;
4021     r = guestfs_pvcreate (g, device);
4022     if (r == -1)
4023       return -1;
4024   }
4025   {
4026     char volgroup[] = "VG";
4027     char physvols_0[] = "/dev/sda1";
4028     physvols_0[5] = devchar;
4029     char *physvols[] = {
4030       physvols_0,
4031       NULL
4032     };
4033     int r;
4034     suppress_error = 0;
4035     r = guestfs_vgcreate (g, volgroup, physvols);
4036     if (r == -1)
4037       return -1;
4038   }
4039   {
4040     char logvol[] = "LV1";
4041     char volgroup[] = "VG";
4042     int r;
4043     suppress_error = 0;
4044     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4045     if (r == -1)
4046       return -1;
4047   }
4048   {
4049     char logvol[] = "LV2";
4050     char volgroup[] = "VG";
4051     int r;
4052     suppress_error = 0;
4053     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4054     if (r == -1)
4055       return -1;
4056   }
4057   {
4058     char vgname[] = "VG";
4059     int r;
4060     suppress_error = 0;
4061     r = guestfs_vgremove (g, vgname);
4062     if (r == -1)
4063       return -1;
4064   }
4065   {
4066     char **r;
4067     int i;
4068     suppress_error = 0;
4069     r = guestfs_vgs (g);
4070     if (r == NULL)
4071       return -1;
4072     if (r[0] != NULL) {
4073       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4074       print_strings (r);
4075       return -1;
4076     }
4077     for (i = 0; r[i] != NULL; ++i)
4078       free (r[i]);
4079     free (r);
4080   }
4081   return 0;
4082 }
4083
4084 static int test_lvremove_0_skip (void)
4085 {
4086   const char *str;
4087
4088   str = getenv ("SKIP_TEST_LVREMOVE_0");
4089   if (str && strcmp (str, "1") == 0) return 1;
4090   str = getenv ("SKIP_TEST_LVREMOVE");
4091   if (str && strcmp (str, "1") == 0) return 1;
4092   return 0;
4093 }
4094
4095 static int test_lvremove_0 (void)
4096 {
4097   if (test_lvremove_0_skip ()) {
4098     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4099     return 0;
4100   }
4101
4102   /* InitNone|InitEmpty for test_lvremove_0 */
4103   {
4104     char device[] = "/dev/sda";
4105     device[5] = devchar;
4106     int r;
4107     suppress_error = 0;
4108     r = guestfs_blockdev_setrw (g, device);
4109     if (r == -1)
4110       return -1;
4111   }
4112   {
4113     int r;
4114     suppress_error = 0;
4115     r = guestfs_umount_all (g);
4116     if (r == -1)
4117       return -1;
4118   }
4119   {
4120     int r;
4121     suppress_error = 0;
4122     r = guestfs_lvm_remove_all (g);
4123     if (r == -1)
4124       return -1;
4125   }
4126   /* TestOutputList for lvremove (0) */
4127   {
4128     char device[] = "/dev/sda";
4129     device[5] = devchar;
4130     char lines_0[] = ",";
4131     char *lines[] = {
4132       lines_0,
4133       NULL
4134     };
4135     int r;
4136     suppress_error = 0;
4137     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4138     if (r == -1)
4139       return -1;
4140   }
4141   {
4142     char device[] = "/dev/sda1";
4143     device[5] = devchar;
4144     int r;
4145     suppress_error = 0;
4146     r = guestfs_pvcreate (g, device);
4147     if (r == -1)
4148       return -1;
4149   }
4150   {
4151     char volgroup[] = "VG";
4152     char physvols_0[] = "/dev/sda1";
4153     physvols_0[5] = devchar;
4154     char *physvols[] = {
4155       physvols_0,
4156       NULL
4157     };
4158     int r;
4159     suppress_error = 0;
4160     r = guestfs_vgcreate (g, volgroup, physvols);
4161     if (r == -1)
4162       return -1;
4163   }
4164   {
4165     char logvol[] = "LV1";
4166     char volgroup[] = "VG";
4167     int r;
4168     suppress_error = 0;
4169     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4170     if (r == -1)
4171       return -1;
4172   }
4173   {
4174     char logvol[] = "LV2";
4175     char volgroup[] = "VG";
4176     int r;
4177     suppress_error = 0;
4178     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4179     if (r == -1)
4180       return -1;
4181   }
4182   {
4183     char device[] = "/dev/VG/LV1";
4184     int r;
4185     suppress_error = 0;
4186     r = guestfs_lvremove (g, device);
4187     if (r == -1)
4188       return -1;
4189   }
4190   {
4191     char **r;
4192     int i;
4193     suppress_error = 0;
4194     r = guestfs_lvs (g);
4195     if (r == NULL)
4196       return -1;
4197     if (!r[0]) {
4198       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4199       print_strings (r);
4200       return -1;
4201     }
4202     {
4203       char expected[] = "/dev/VG/LV2";
4204       if (strcmp (r[0], expected) != 0) {
4205         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4206         return -1;
4207       }
4208     }
4209     if (r[1] != NULL) {
4210       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4211       print_strings (r);
4212       return -1;
4213     }
4214     for (i = 0; r[i] != NULL; ++i)
4215       free (r[i]);
4216     free (r);
4217   }
4218   return 0;
4219 }
4220
4221 static int test_lvremove_1_skip (void)
4222 {
4223   const char *str;
4224
4225   str = getenv ("SKIP_TEST_LVREMOVE_1");
4226   if (str && strcmp (str, "1") == 0) return 1;
4227   str = getenv ("SKIP_TEST_LVREMOVE");
4228   if (str && strcmp (str, "1") == 0) return 1;
4229   return 0;
4230 }
4231
4232 static int test_lvremove_1 (void)
4233 {
4234   if (test_lvremove_1_skip ()) {
4235     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4236     return 0;
4237   }
4238
4239   /* InitNone|InitEmpty for test_lvremove_1 */
4240   {
4241     char device[] = "/dev/sda";
4242     device[5] = devchar;
4243     int r;
4244     suppress_error = 0;
4245     r = guestfs_blockdev_setrw (g, device);
4246     if (r == -1)
4247       return -1;
4248   }
4249   {
4250     int r;
4251     suppress_error = 0;
4252     r = guestfs_umount_all (g);
4253     if (r == -1)
4254       return -1;
4255   }
4256   {
4257     int r;
4258     suppress_error = 0;
4259     r = guestfs_lvm_remove_all (g);
4260     if (r == -1)
4261       return -1;
4262   }
4263   /* TestOutputList for lvremove (1) */
4264   {
4265     char device[] = "/dev/sda";
4266     device[5] = devchar;
4267     char lines_0[] = ",";
4268     char *lines[] = {
4269       lines_0,
4270       NULL
4271     };
4272     int r;
4273     suppress_error = 0;
4274     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4275     if (r == -1)
4276       return -1;
4277   }
4278   {
4279     char device[] = "/dev/sda1";
4280     device[5] = devchar;
4281     int r;
4282     suppress_error = 0;
4283     r = guestfs_pvcreate (g, device);
4284     if (r == -1)
4285       return -1;
4286   }
4287   {
4288     char volgroup[] = "VG";
4289     char physvols_0[] = "/dev/sda1";
4290     physvols_0[5] = devchar;
4291     char *physvols[] = {
4292       physvols_0,
4293       NULL
4294     };
4295     int r;
4296     suppress_error = 0;
4297     r = guestfs_vgcreate (g, volgroup, physvols);
4298     if (r == -1)
4299       return -1;
4300   }
4301   {
4302     char logvol[] = "LV1";
4303     char volgroup[] = "VG";
4304     int r;
4305     suppress_error = 0;
4306     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4307     if (r == -1)
4308       return -1;
4309   }
4310   {
4311     char logvol[] = "LV2";
4312     char volgroup[] = "VG";
4313     int r;
4314     suppress_error = 0;
4315     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4316     if (r == -1)
4317       return -1;
4318   }
4319   {
4320     char device[] = "/dev/VG";
4321     int r;
4322     suppress_error = 0;
4323     r = guestfs_lvremove (g, device);
4324     if (r == -1)
4325       return -1;
4326   }
4327   {
4328     char **r;
4329     int i;
4330     suppress_error = 0;
4331     r = guestfs_lvs (g);
4332     if (r == NULL)
4333       return -1;
4334     if (r[0] != NULL) {
4335       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4336       print_strings (r);
4337       return -1;
4338     }
4339     for (i = 0; r[i] != NULL; ++i)
4340       free (r[i]);
4341     free (r);
4342   }
4343   return 0;
4344 }
4345
4346 static int test_lvremove_2_skip (void)
4347 {
4348   const char *str;
4349
4350   str = getenv ("SKIP_TEST_LVREMOVE_2");
4351   if (str && strcmp (str, "1") == 0) return 1;
4352   str = getenv ("SKIP_TEST_LVREMOVE");
4353   if (str && strcmp (str, "1") == 0) return 1;
4354   return 0;
4355 }
4356
4357 static int test_lvremove_2 (void)
4358 {
4359   if (test_lvremove_2_skip ()) {
4360     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4361     return 0;
4362   }
4363
4364   /* InitNone|InitEmpty for test_lvremove_2 */
4365   {
4366     char device[] = "/dev/sda";
4367     device[5] = devchar;
4368     int r;
4369     suppress_error = 0;
4370     r = guestfs_blockdev_setrw (g, device);
4371     if (r == -1)
4372       return -1;
4373   }
4374   {
4375     int r;
4376     suppress_error = 0;
4377     r = guestfs_umount_all (g);
4378     if (r == -1)
4379       return -1;
4380   }
4381   {
4382     int r;
4383     suppress_error = 0;
4384     r = guestfs_lvm_remove_all (g);
4385     if (r == -1)
4386       return -1;
4387   }
4388   /* TestOutputList for lvremove (2) */
4389   {
4390     char device[] = "/dev/sda";
4391     device[5] = devchar;
4392     char lines_0[] = ",";
4393     char *lines[] = {
4394       lines_0,
4395       NULL
4396     };
4397     int r;
4398     suppress_error = 0;
4399     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4400     if (r == -1)
4401       return -1;
4402   }
4403   {
4404     char device[] = "/dev/sda1";
4405     device[5] = devchar;
4406     int r;
4407     suppress_error = 0;
4408     r = guestfs_pvcreate (g, device);
4409     if (r == -1)
4410       return -1;
4411   }
4412   {
4413     char volgroup[] = "VG";
4414     char physvols_0[] = "/dev/sda1";
4415     physvols_0[5] = devchar;
4416     char *physvols[] = {
4417       physvols_0,
4418       NULL
4419     };
4420     int r;
4421     suppress_error = 0;
4422     r = guestfs_vgcreate (g, volgroup, physvols);
4423     if (r == -1)
4424       return -1;
4425   }
4426   {
4427     char logvol[] = "LV1";
4428     char volgroup[] = "VG";
4429     int r;
4430     suppress_error = 0;
4431     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4432     if (r == -1)
4433       return -1;
4434   }
4435   {
4436     char logvol[] = "LV2";
4437     char volgroup[] = "VG";
4438     int r;
4439     suppress_error = 0;
4440     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4441     if (r == -1)
4442       return -1;
4443   }
4444   {
4445     char device[] = "/dev/VG";
4446     int r;
4447     suppress_error = 0;
4448     r = guestfs_lvremove (g, device);
4449     if (r == -1)
4450       return -1;
4451   }
4452   {
4453     char **r;
4454     int i;
4455     suppress_error = 0;
4456     r = guestfs_vgs (g);
4457     if (r == NULL)
4458       return -1;
4459     if (!r[0]) {
4460       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4461       print_strings (r);
4462       return -1;
4463     }
4464     {
4465       char expected[] = "VG";
4466       if (strcmp (r[0], expected) != 0) {
4467         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4468         return -1;
4469       }
4470     }
4471     if (r[1] != NULL) {
4472       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4473       print_strings (r);
4474       return -1;
4475     }
4476     for (i = 0; r[i] != NULL; ++i)
4477       free (r[i]);
4478     free (r);
4479   }
4480   return 0;
4481 }
4482
4483 static int test_mount_ro_0_skip (void)
4484 {
4485   const char *str;
4486
4487   str = getenv ("SKIP_TEST_MOUNT_RO_0");
4488   if (str && strcmp (str, "1") == 0) return 1;
4489   str = getenv ("SKIP_TEST_MOUNT_RO");
4490   if (str && strcmp (str, "1") == 0) return 1;
4491   return 0;
4492 }
4493
4494 static int test_mount_ro_0 (void)
4495 {
4496   if (test_mount_ro_0_skip ()) {
4497     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4498     return 0;
4499   }
4500
4501   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4502   {
4503     char device[] = "/dev/sda";
4504     device[5] = devchar;
4505     int r;
4506     suppress_error = 0;
4507     r = guestfs_blockdev_setrw (g, device);
4508     if (r == -1)
4509       return -1;
4510   }
4511   {
4512     int r;
4513     suppress_error = 0;
4514     r = guestfs_umount_all (g);
4515     if (r == -1)
4516       return -1;
4517   }
4518   {
4519     int r;
4520     suppress_error = 0;
4521     r = guestfs_lvm_remove_all (g);
4522     if (r == -1)
4523       return -1;
4524   }
4525   {
4526     char device[] = "/dev/sda";
4527     device[5] = devchar;
4528     char lines_0[] = ",";
4529     char *lines[] = {
4530       lines_0,
4531       NULL
4532     };
4533     int r;
4534     suppress_error = 0;
4535     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4536     if (r == -1)
4537       return -1;
4538   }
4539   {
4540     char fstype[] = "ext2";
4541     char device[] = "/dev/sda1";
4542     device[5] = devchar;
4543     int r;
4544     suppress_error = 0;
4545     r = guestfs_mkfs (g, fstype, device);
4546     if (r == -1)
4547       return -1;
4548   }
4549   {
4550     char device[] = "/dev/sda1";
4551     device[5] = devchar;
4552     char mountpoint[] = "/";
4553     int r;
4554     suppress_error = 0;
4555     r = guestfs_mount (g, device, mountpoint);
4556     if (r == -1)
4557       return -1;
4558   }
4559   /* TestLastFail for mount_ro (0) */
4560   {
4561     char pathordevice[] = "/";
4562     int r;
4563     suppress_error = 0;
4564     r = guestfs_umount (g, pathordevice);
4565     if (r == -1)
4566       return -1;
4567   }
4568   {
4569     char device[] = "/dev/sda1";
4570     device[5] = devchar;
4571     char mountpoint[] = "/";
4572     int r;
4573     suppress_error = 0;
4574     r = guestfs_mount_ro (g, device, mountpoint);
4575     if (r == -1)
4576       return -1;
4577   }
4578   {
4579     char path[] = "/new";
4580     int r;
4581     suppress_error = 1;
4582     r = guestfs_touch (g, path);
4583     if (r != -1)
4584       return -1;
4585   }
4586   return 0;
4587 }
4588
4589 static int test_mount_ro_1_skip (void)
4590 {
4591   const char *str;
4592
4593   str = getenv ("SKIP_TEST_MOUNT_RO_1");
4594   if (str && strcmp (str, "1") == 0) return 1;
4595   str = getenv ("SKIP_TEST_MOUNT_RO");
4596   if (str && strcmp (str, "1") == 0) return 1;
4597   return 0;
4598 }
4599
4600 static int test_mount_ro_1 (void)
4601 {
4602   if (test_mount_ro_1_skip ()) {
4603     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4604     return 0;
4605   }
4606
4607   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4608   {
4609     char device[] = "/dev/sda";
4610     device[5] = devchar;
4611     int r;
4612     suppress_error = 0;
4613     r = guestfs_blockdev_setrw (g, device);
4614     if (r == -1)
4615       return -1;
4616   }
4617   {
4618     int r;
4619     suppress_error = 0;
4620     r = guestfs_umount_all (g);
4621     if (r == -1)
4622       return -1;
4623   }
4624   {
4625     int r;
4626     suppress_error = 0;
4627     r = guestfs_lvm_remove_all (g);
4628     if (r == -1)
4629       return -1;
4630   }
4631   {
4632     char device[] = "/dev/sda";
4633     device[5] = devchar;
4634     char lines_0[] = ",";
4635     char *lines[] = {
4636       lines_0,
4637       NULL
4638     };
4639     int r;
4640     suppress_error = 0;
4641     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4642     if (r == -1)
4643       return -1;
4644   }
4645   {
4646     char fstype[] = "ext2";
4647     char device[] = "/dev/sda1";
4648     device[5] = devchar;
4649     int r;
4650     suppress_error = 0;
4651     r = guestfs_mkfs (g, fstype, device);
4652     if (r == -1)
4653       return -1;
4654   }
4655   {
4656     char device[] = "/dev/sda1";
4657     device[5] = devchar;
4658     char mountpoint[] = "/";
4659     int r;
4660     suppress_error = 0;
4661     r = guestfs_mount (g, device, mountpoint);
4662     if (r == -1)
4663       return -1;
4664   }
4665   /* TestOutput for mount_ro (1) */
4666   char expected[] = "data";
4667   {
4668     char path[] = "/new";
4669     char content[] = "data";
4670     int r;
4671     suppress_error = 0;
4672     r = guestfs_write_file (g, path, content, 0);
4673     if (r == -1)
4674       return -1;
4675   }
4676   {
4677     char pathordevice[] = "/";
4678     int r;
4679     suppress_error = 0;
4680     r = guestfs_umount (g, pathordevice);
4681     if (r == -1)
4682       return -1;
4683   }
4684   {
4685     char device[] = "/dev/sda1";
4686     device[5] = devchar;
4687     char mountpoint[] = "/";
4688     int r;
4689     suppress_error = 0;
4690     r = guestfs_mount_ro (g, device, mountpoint);
4691     if (r == -1)
4692       return -1;
4693   }
4694   {
4695     char path[] = "/new";
4696     char *r;
4697     suppress_error = 0;
4698     r = guestfs_cat (g, path);
4699     if (r == NULL)
4700       return -1;
4701     if (strcmp (r, expected) != 0) {
4702       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4703       return -1;
4704     }
4705     free (r);
4706   }
4707   return 0;
4708 }
4709
4710 static int test_tgz_in_0_skip (void)
4711 {
4712   const char *str;
4713
4714   str = getenv ("SKIP_TEST_TGZ_IN_0");
4715   if (str && strcmp (str, "1") == 0) return 1;
4716   str = getenv ("SKIP_TEST_TGZ_IN");
4717   if (str && strcmp (str, "1") == 0) return 1;
4718   return 0;
4719 }
4720
4721 static int test_tgz_in_0 (void)
4722 {
4723   if (test_tgz_in_0_skip ()) {
4724     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4725     return 0;
4726   }
4727
4728   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4729   {
4730     char device[] = "/dev/sda";
4731     device[5] = devchar;
4732     int r;
4733     suppress_error = 0;
4734     r = guestfs_blockdev_setrw (g, device);
4735     if (r == -1)
4736       return -1;
4737   }
4738   {
4739     int r;
4740     suppress_error = 0;
4741     r = guestfs_umount_all (g);
4742     if (r == -1)
4743       return -1;
4744   }
4745   {
4746     int r;
4747     suppress_error = 0;
4748     r = guestfs_lvm_remove_all (g);
4749     if (r == -1)
4750       return -1;
4751   }
4752   {
4753     char device[] = "/dev/sda";
4754     device[5] = devchar;
4755     char lines_0[] = ",";
4756     char *lines[] = {
4757       lines_0,
4758       NULL
4759     };
4760     int r;
4761     suppress_error = 0;
4762     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4763     if (r == -1)
4764       return -1;
4765   }
4766   {
4767     char fstype[] = "ext2";
4768     char device[] = "/dev/sda1";
4769     device[5] = devchar;
4770     int r;
4771     suppress_error = 0;
4772     r = guestfs_mkfs (g, fstype, device);
4773     if (r == -1)
4774       return -1;
4775   }
4776   {
4777     char device[] = "/dev/sda1";
4778     device[5] = devchar;
4779     char mountpoint[] = "/";
4780     int r;
4781     suppress_error = 0;
4782     r = guestfs_mount (g, device, mountpoint);
4783     if (r == -1)
4784       return -1;
4785   }
4786   /* TestOutput for tgz_in (0) */
4787   char expected[] = "hello\n";
4788   {
4789     char directory[] = "/";
4790     int r;
4791     suppress_error = 0;
4792     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
4793     if (r == -1)
4794       return -1;
4795   }
4796   {
4797     char path[] = "/hello";
4798     char *r;
4799     suppress_error = 0;
4800     r = guestfs_cat (g, path);
4801     if (r == NULL)
4802       return -1;
4803     if (strcmp (r, expected) != 0) {
4804       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4805       return -1;
4806     }
4807     free (r);
4808   }
4809   return 0;
4810 }
4811
4812 static int test_tar_in_0_skip (void)
4813 {
4814   const char *str;
4815
4816   str = getenv ("SKIP_TEST_TAR_IN_0");
4817   if (str && strcmp (str, "1") == 0) return 1;
4818   str = getenv ("SKIP_TEST_TAR_IN");
4819   if (str && strcmp (str, "1") == 0) return 1;
4820   return 0;
4821 }
4822
4823 static int test_tar_in_0 (void)
4824 {
4825   if (test_tar_in_0_skip ()) {
4826     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
4827     return 0;
4828   }
4829
4830   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4831   {
4832     char device[] = "/dev/sda";
4833     device[5] = devchar;
4834     int r;
4835     suppress_error = 0;
4836     r = guestfs_blockdev_setrw (g, device);
4837     if (r == -1)
4838       return -1;
4839   }
4840   {
4841     int r;
4842     suppress_error = 0;
4843     r = guestfs_umount_all (g);
4844     if (r == -1)
4845       return -1;
4846   }
4847   {
4848     int r;
4849     suppress_error = 0;
4850     r = guestfs_lvm_remove_all (g);
4851     if (r == -1)
4852       return -1;
4853   }
4854   {
4855     char device[] = "/dev/sda";
4856     device[5] = devchar;
4857     char lines_0[] = ",";
4858     char *lines[] = {
4859       lines_0,
4860       NULL
4861     };
4862     int r;
4863     suppress_error = 0;
4864     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4865     if (r == -1)
4866       return -1;
4867   }
4868   {
4869     char fstype[] = "ext2";
4870     char device[] = "/dev/sda1";
4871     device[5] = devchar;
4872     int r;
4873     suppress_error = 0;
4874     r = guestfs_mkfs (g, fstype, device);
4875     if (r == -1)
4876       return -1;
4877   }
4878   {
4879     char device[] = "/dev/sda1";
4880     device[5] = devchar;
4881     char mountpoint[] = "/";
4882     int r;
4883     suppress_error = 0;
4884     r = guestfs_mount (g, device, mountpoint);
4885     if (r == -1)
4886       return -1;
4887   }
4888   /* TestOutput for tar_in (0) */
4889   char expected[] = "hello\n";
4890   {
4891     char directory[] = "/";
4892     int r;
4893     suppress_error = 0;
4894     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
4895     if (r == -1)
4896       return -1;
4897   }
4898   {
4899     char path[] = "/hello";
4900     char *r;
4901     suppress_error = 0;
4902     r = guestfs_cat (g, path);
4903     if (r == NULL)
4904       return -1;
4905     if (strcmp (r, expected) != 0) {
4906       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4907       return -1;
4908     }
4909     free (r);
4910   }
4911   return 0;
4912 }
4913
4914 static int test_checksum_0_skip (void)
4915 {
4916   const char *str;
4917
4918   str = getenv ("SKIP_TEST_CHECKSUM_0");
4919   if (str && strcmp (str, "1") == 0) return 1;
4920   str = getenv ("SKIP_TEST_CHECKSUM");
4921   if (str && strcmp (str, "1") == 0) return 1;
4922   return 0;
4923 }
4924
4925 static int test_checksum_0 (void)
4926 {
4927   if (test_checksum_0_skip ()) {
4928     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
4929     return 0;
4930   }
4931
4932   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4933   {
4934     char device[] = "/dev/sda";
4935     device[5] = devchar;
4936     int r;
4937     suppress_error = 0;
4938     r = guestfs_blockdev_setrw (g, device);
4939     if (r == -1)
4940       return -1;
4941   }
4942   {
4943     int r;
4944     suppress_error = 0;
4945     r = guestfs_umount_all (g);
4946     if (r == -1)
4947       return -1;
4948   }
4949   {
4950     int r;
4951     suppress_error = 0;
4952     r = guestfs_lvm_remove_all (g);
4953     if (r == -1)
4954       return -1;
4955   }
4956   {
4957     char device[] = "/dev/sda";
4958     device[5] = devchar;
4959     char lines_0[] = ",";
4960     char *lines[] = {
4961       lines_0,
4962       NULL
4963     };
4964     int r;
4965     suppress_error = 0;
4966     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4967     if (r == -1)
4968       return -1;
4969   }
4970   {
4971     char fstype[] = "ext2";
4972     char device[] = "/dev/sda1";
4973     device[5] = devchar;
4974     int r;
4975     suppress_error = 0;
4976     r = guestfs_mkfs (g, fstype, device);
4977     if (r == -1)
4978       return -1;
4979   }
4980   {
4981     char device[] = "/dev/sda1";
4982     device[5] = devchar;
4983     char mountpoint[] = "/";
4984     int r;
4985     suppress_error = 0;
4986     r = guestfs_mount (g, device, mountpoint);
4987     if (r == -1)
4988       return -1;
4989   }
4990   /* TestOutput for checksum (0) */
4991   char expected[] = "935282863";
4992   {
4993     char path[] = "/new";
4994     char content[] = "test\n";
4995     int r;
4996     suppress_error = 0;
4997     r = guestfs_write_file (g, path, content, 0);
4998     if (r == -1)
4999       return -1;
5000   }
5001   {
5002     char csumtype[] = "crc";
5003     char path[] = "/new";
5004     char *r;
5005     suppress_error = 0;
5006     r = guestfs_checksum (g, csumtype, path);
5007     if (r == NULL)
5008       return -1;
5009     if (strcmp (r, expected) != 0) {
5010       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5011       return -1;
5012     }
5013     free (r);
5014   }
5015   return 0;
5016 }
5017
5018 static int test_checksum_1_skip (void)
5019 {
5020   const char *str;
5021
5022   str = getenv ("SKIP_TEST_CHECKSUM_1");
5023   if (str && strcmp (str, "1") == 0) return 1;
5024   str = getenv ("SKIP_TEST_CHECKSUM");
5025   if (str && strcmp (str, "1") == 0) return 1;
5026   return 0;
5027 }
5028
5029 static int test_checksum_1 (void)
5030 {
5031   if (test_checksum_1_skip ()) {
5032     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5033     return 0;
5034   }
5035
5036   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5037   {
5038     char device[] = "/dev/sda";
5039     device[5] = devchar;
5040     int r;
5041     suppress_error = 0;
5042     r = guestfs_blockdev_setrw (g, device);
5043     if (r == -1)
5044       return -1;
5045   }
5046   {
5047     int r;
5048     suppress_error = 0;
5049     r = guestfs_umount_all (g);
5050     if (r == -1)
5051       return -1;
5052   }
5053   {
5054     int r;
5055     suppress_error = 0;
5056     r = guestfs_lvm_remove_all (g);
5057     if (r == -1)
5058       return -1;
5059   }
5060   {
5061     char device[] = "/dev/sda";
5062     device[5] = devchar;
5063     char lines_0[] = ",";
5064     char *lines[] = {
5065       lines_0,
5066       NULL
5067     };
5068     int r;
5069     suppress_error = 0;
5070     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5071     if (r == -1)
5072       return -1;
5073   }
5074   {
5075     char fstype[] = "ext2";
5076     char device[] = "/dev/sda1";
5077     device[5] = devchar;
5078     int r;
5079     suppress_error = 0;
5080     r = guestfs_mkfs (g, fstype, device);
5081     if (r == -1)
5082       return -1;
5083   }
5084   {
5085     char device[] = "/dev/sda1";
5086     device[5] = devchar;
5087     char mountpoint[] = "/";
5088     int r;
5089     suppress_error = 0;
5090     r = guestfs_mount (g, device, mountpoint);
5091     if (r == -1)
5092       return -1;
5093   }
5094   /* TestLastFail for checksum (1) */
5095   {
5096     char csumtype[] = "crc";
5097     char path[] = "/new";
5098     char *r;
5099     suppress_error = 1;
5100     r = guestfs_checksum (g, csumtype, path);
5101     if (r != NULL)
5102       return -1;
5103     free (r);
5104   }
5105   return 0;
5106 }
5107
5108 static int test_checksum_2_skip (void)
5109 {
5110   const char *str;
5111
5112   str = getenv ("SKIP_TEST_CHECKSUM_2");
5113   if (str && strcmp (str, "1") == 0) return 1;
5114   str = getenv ("SKIP_TEST_CHECKSUM");
5115   if (str && strcmp (str, "1") == 0) return 1;
5116   return 0;
5117 }
5118
5119 static int test_checksum_2 (void)
5120 {
5121   if (test_checksum_2_skip ()) {
5122     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5123     return 0;
5124   }
5125
5126   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5127   {
5128     char device[] = "/dev/sda";
5129     device[5] = devchar;
5130     int r;
5131     suppress_error = 0;
5132     r = guestfs_blockdev_setrw (g, device);
5133     if (r == -1)
5134       return -1;
5135   }
5136   {
5137     int r;
5138     suppress_error = 0;
5139     r = guestfs_umount_all (g);
5140     if (r == -1)
5141       return -1;
5142   }
5143   {
5144     int r;
5145     suppress_error = 0;
5146     r = guestfs_lvm_remove_all (g);
5147     if (r == -1)
5148       return -1;
5149   }
5150   {
5151     char device[] = "/dev/sda";
5152     device[5] = devchar;
5153     char lines_0[] = ",";
5154     char *lines[] = {
5155       lines_0,
5156       NULL
5157     };
5158     int r;
5159     suppress_error = 0;
5160     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5161     if (r == -1)
5162       return -1;
5163   }
5164   {
5165     char fstype[] = "ext2";
5166     char device[] = "/dev/sda1";
5167     device[5] = devchar;
5168     int r;
5169     suppress_error = 0;
5170     r = guestfs_mkfs (g, fstype, device);
5171     if (r == -1)
5172       return -1;
5173   }
5174   {
5175     char device[] = "/dev/sda1";
5176     device[5] = devchar;
5177     char mountpoint[] = "/";
5178     int r;
5179     suppress_error = 0;
5180     r = guestfs_mount (g, device, mountpoint);
5181     if (r == -1)
5182       return -1;
5183   }
5184   /* TestOutput for checksum (2) */
5185   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5186   {
5187     char path[] = "/new";
5188     char content[] = "test\n";
5189     int r;
5190     suppress_error = 0;
5191     r = guestfs_write_file (g, path, content, 0);
5192     if (r == -1)
5193       return -1;
5194   }
5195   {
5196     char csumtype[] = "md5";
5197     char path[] = "/new";
5198     char *r;
5199     suppress_error = 0;
5200     r = guestfs_checksum (g, csumtype, path);
5201     if (r == NULL)
5202       return -1;
5203     if (strcmp (r, expected) != 0) {
5204       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5205       return -1;
5206     }
5207     free (r);
5208   }
5209   return 0;
5210 }
5211
5212 static int test_checksum_3_skip (void)
5213 {
5214   const char *str;
5215
5216   str = getenv ("SKIP_TEST_CHECKSUM_3");
5217   if (str && strcmp (str, "1") == 0) return 1;
5218   str = getenv ("SKIP_TEST_CHECKSUM");
5219   if (str && strcmp (str, "1") == 0) return 1;
5220   return 0;
5221 }
5222
5223 static int test_checksum_3 (void)
5224 {
5225   if (test_checksum_3_skip ()) {
5226     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5227     return 0;
5228   }
5229
5230   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5231   {
5232     char device[] = "/dev/sda";
5233     device[5] = devchar;
5234     int r;
5235     suppress_error = 0;
5236     r = guestfs_blockdev_setrw (g, device);
5237     if (r == -1)
5238       return -1;
5239   }
5240   {
5241     int r;
5242     suppress_error = 0;
5243     r = guestfs_umount_all (g);
5244     if (r == -1)
5245       return -1;
5246   }
5247   {
5248     int r;
5249     suppress_error = 0;
5250     r = guestfs_lvm_remove_all (g);
5251     if (r == -1)
5252       return -1;
5253   }
5254   {
5255     char device[] = "/dev/sda";
5256     device[5] = devchar;
5257     char lines_0[] = ",";
5258     char *lines[] = {
5259       lines_0,
5260       NULL
5261     };
5262     int r;
5263     suppress_error = 0;
5264     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5265     if (r == -1)
5266       return -1;
5267   }
5268   {
5269     char fstype[] = "ext2";
5270     char device[] = "/dev/sda1";
5271     device[5] = devchar;
5272     int r;
5273     suppress_error = 0;
5274     r = guestfs_mkfs (g, fstype, device);
5275     if (r == -1)
5276       return -1;
5277   }
5278   {
5279     char device[] = "/dev/sda1";
5280     device[5] = devchar;
5281     char mountpoint[] = "/";
5282     int r;
5283     suppress_error = 0;
5284     r = guestfs_mount (g, device, mountpoint);
5285     if (r == -1)
5286       return -1;
5287   }
5288   /* TestOutput for checksum (3) */
5289   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5290   {
5291     char path[] = "/new";
5292     char content[] = "test\n";
5293     int r;
5294     suppress_error = 0;
5295     r = guestfs_write_file (g, path, content, 0);
5296     if (r == -1)
5297       return -1;
5298   }
5299   {
5300     char csumtype[] = "sha1";
5301     char path[] = "/new";
5302     char *r;
5303     suppress_error = 0;
5304     r = guestfs_checksum (g, csumtype, path);
5305     if (r == NULL)
5306       return -1;
5307     if (strcmp (r, expected) != 0) {
5308       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5309       return -1;
5310     }
5311     free (r);
5312   }
5313   return 0;
5314 }
5315
5316 static int test_checksum_4_skip (void)
5317 {
5318   const char *str;
5319
5320   str = getenv ("SKIP_TEST_CHECKSUM_4");
5321   if (str && strcmp (str, "1") == 0) return 1;
5322   str = getenv ("SKIP_TEST_CHECKSUM");
5323   if (str && strcmp (str, "1") == 0) return 1;
5324   return 0;
5325 }
5326
5327 static int test_checksum_4 (void)
5328 {
5329   if (test_checksum_4_skip ()) {
5330     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5331     return 0;
5332   }
5333
5334   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5335   {
5336     char device[] = "/dev/sda";
5337     device[5] = devchar;
5338     int r;
5339     suppress_error = 0;
5340     r = guestfs_blockdev_setrw (g, device);
5341     if (r == -1)
5342       return -1;
5343   }
5344   {
5345     int r;
5346     suppress_error = 0;
5347     r = guestfs_umount_all (g);
5348     if (r == -1)
5349       return -1;
5350   }
5351   {
5352     int r;
5353     suppress_error = 0;
5354     r = guestfs_lvm_remove_all (g);
5355     if (r == -1)
5356       return -1;
5357   }
5358   {
5359     char device[] = "/dev/sda";
5360     device[5] = devchar;
5361     char lines_0[] = ",";
5362     char *lines[] = {
5363       lines_0,
5364       NULL
5365     };
5366     int r;
5367     suppress_error = 0;
5368     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5369     if (r == -1)
5370       return -1;
5371   }
5372   {
5373     char fstype[] = "ext2";
5374     char device[] = "/dev/sda1";
5375     device[5] = devchar;
5376     int r;
5377     suppress_error = 0;
5378     r = guestfs_mkfs (g, fstype, device);
5379     if (r == -1)
5380       return -1;
5381   }
5382   {
5383     char device[] = "/dev/sda1";
5384     device[5] = devchar;
5385     char mountpoint[] = "/";
5386     int r;
5387     suppress_error = 0;
5388     r = guestfs_mount (g, device, mountpoint);
5389     if (r == -1)
5390       return -1;
5391   }
5392   /* TestOutput for checksum (4) */
5393   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5394   {
5395     char path[] = "/new";
5396     char content[] = "test\n";
5397     int r;
5398     suppress_error = 0;
5399     r = guestfs_write_file (g, path, content, 0);
5400     if (r == -1)
5401       return -1;
5402   }
5403   {
5404     char csumtype[] = "sha224";
5405     char path[] = "/new";
5406     char *r;
5407     suppress_error = 0;
5408     r = guestfs_checksum (g, csumtype, path);
5409     if (r == NULL)
5410       return -1;
5411     if (strcmp (r, expected) != 0) {
5412       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5413       return -1;
5414     }
5415     free (r);
5416   }
5417   return 0;
5418 }
5419
5420 static int test_checksum_5_skip (void)
5421 {
5422   const char *str;
5423
5424   str = getenv ("SKIP_TEST_CHECKSUM_5");
5425   if (str && strcmp (str, "1") == 0) return 1;
5426   str = getenv ("SKIP_TEST_CHECKSUM");
5427   if (str && strcmp (str, "1") == 0) return 1;
5428   return 0;
5429 }
5430
5431 static int test_checksum_5 (void)
5432 {
5433   if (test_checksum_5_skip ()) {
5434     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5435     return 0;
5436   }
5437
5438   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5439   {
5440     char device[] = "/dev/sda";
5441     device[5] = devchar;
5442     int r;
5443     suppress_error = 0;
5444     r = guestfs_blockdev_setrw (g, device);
5445     if (r == -1)
5446       return -1;
5447   }
5448   {
5449     int r;
5450     suppress_error = 0;
5451     r = guestfs_umount_all (g);
5452     if (r == -1)
5453       return -1;
5454   }
5455   {
5456     int r;
5457     suppress_error = 0;
5458     r = guestfs_lvm_remove_all (g);
5459     if (r == -1)
5460       return -1;
5461   }
5462   {
5463     char device[] = "/dev/sda";
5464     device[5] = devchar;
5465     char lines_0[] = ",";
5466     char *lines[] = {
5467       lines_0,
5468       NULL
5469     };
5470     int r;
5471     suppress_error = 0;
5472     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5473     if (r == -1)
5474       return -1;
5475   }
5476   {
5477     char fstype[] = "ext2";
5478     char device[] = "/dev/sda1";
5479     device[5] = devchar;
5480     int r;
5481     suppress_error = 0;
5482     r = guestfs_mkfs (g, fstype, device);
5483     if (r == -1)
5484       return -1;
5485   }
5486   {
5487     char device[] = "/dev/sda1";
5488     device[5] = devchar;
5489     char mountpoint[] = "/";
5490     int r;
5491     suppress_error = 0;
5492     r = guestfs_mount (g, device, mountpoint);
5493     if (r == -1)
5494       return -1;
5495   }
5496   /* TestOutput for checksum (5) */
5497   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5498   {
5499     char path[] = "/new";
5500     char content[] = "test\n";
5501     int r;
5502     suppress_error = 0;
5503     r = guestfs_write_file (g, path, content, 0);
5504     if (r == -1)
5505       return -1;
5506   }
5507   {
5508     char csumtype[] = "sha256";
5509     char path[] = "/new";
5510     char *r;
5511     suppress_error = 0;
5512     r = guestfs_checksum (g, csumtype, path);
5513     if (r == NULL)
5514       return -1;
5515     if (strcmp (r, expected) != 0) {
5516       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5517       return -1;
5518     }
5519     free (r);
5520   }
5521   return 0;
5522 }
5523
5524 static int test_checksum_6_skip (void)
5525 {
5526   const char *str;
5527
5528   str = getenv ("SKIP_TEST_CHECKSUM_6");
5529   if (str && strcmp (str, "1") == 0) return 1;
5530   str = getenv ("SKIP_TEST_CHECKSUM");
5531   if (str && strcmp (str, "1") == 0) return 1;
5532   return 0;
5533 }
5534
5535 static int test_checksum_6 (void)
5536 {
5537   if (test_checksum_6_skip ()) {
5538     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5539     return 0;
5540   }
5541
5542   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5543   {
5544     char device[] = "/dev/sda";
5545     device[5] = devchar;
5546     int r;
5547     suppress_error = 0;
5548     r = guestfs_blockdev_setrw (g, device);
5549     if (r == -1)
5550       return -1;
5551   }
5552   {
5553     int r;
5554     suppress_error = 0;
5555     r = guestfs_umount_all (g);
5556     if (r == -1)
5557       return -1;
5558   }
5559   {
5560     int r;
5561     suppress_error = 0;
5562     r = guestfs_lvm_remove_all (g);
5563     if (r == -1)
5564       return -1;
5565   }
5566   {
5567     char device[] = "/dev/sda";
5568     device[5] = devchar;
5569     char lines_0[] = ",";
5570     char *lines[] = {
5571       lines_0,
5572       NULL
5573     };
5574     int r;
5575     suppress_error = 0;
5576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5577     if (r == -1)
5578       return -1;
5579   }
5580   {
5581     char fstype[] = "ext2";
5582     char device[] = "/dev/sda1";
5583     device[5] = devchar;
5584     int r;
5585     suppress_error = 0;
5586     r = guestfs_mkfs (g, fstype, device);
5587     if (r == -1)
5588       return -1;
5589   }
5590   {
5591     char device[] = "/dev/sda1";
5592     device[5] = devchar;
5593     char mountpoint[] = "/";
5594     int r;
5595     suppress_error = 0;
5596     r = guestfs_mount (g, device, mountpoint);
5597     if (r == -1)
5598       return -1;
5599   }
5600   /* TestOutput for checksum (6) */
5601   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5602   {
5603     char path[] = "/new";
5604     char content[] = "test\n";
5605     int r;
5606     suppress_error = 0;
5607     r = guestfs_write_file (g, path, content, 0);
5608     if (r == -1)
5609       return -1;
5610   }
5611   {
5612     char csumtype[] = "sha384";
5613     char path[] = "/new";
5614     char *r;
5615     suppress_error = 0;
5616     r = guestfs_checksum (g, csumtype, path);
5617     if (r == NULL)
5618       return -1;
5619     if (strcmp (r, expected) != 0) {
5620       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5621       return -1;
5622     }
5623     free (r);
5624   }
5625   return 0;
5626 }
5627
5628 static int test_checksum_7_skip (void)
5629 {
5630   const char *str;
5631
5632   str = getenv ("SKIP_TEST_CHECKSUM_7");
5633   if (str && strcmp (str, "1") == 0) return 1;
5634   str = getenv ("SKIP_TEST_CHECKSUM");
5635   if (str && strcmp (str, "1") == 0) return 1;
5636   return 0;
5637 }
5638
5639 static int test_checksum_7 (void)
5640 {
5641   if (test_checksum_7_skip ()) {
5642     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5643     return 0;
5644   }
5645
5646   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5647   {
5648     char device[] = "/dev/sda";
5649     device[5] = devchar;
5650     int r;
5651     suppress_error = 0;
5652     r = guestfs_blockdev_setrw (g, device);
5653     if (r == -1)
5654       return -1;
5655   }
5656   {
5657     int r;
5658     suppress_error = 0;
5659     r = guestfs_umount_all (g);
5660     if (r == -1)
5661       return -1;
5662   }
5663   {
5664     int r;
5665     suppress_error = 0;
5666     r = guestfs_lvm_remove_all (g);
5667     if (r == -1)
5668       return -1;
5669   }
5670   {
5671     char device[] = "/dev/sda";
5672     device[5] = devchar;
5673     char lines_0[] = ",";
5674     char *lines[] = {
5675       lines_0,
5676       NULL
5677     };
5678     int r;
5679     suppress_error = 0;
5680     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5681     if (r == -1)
5682       return -1;
5683   }
5684   {
5685     char fstype[] = "ext2";
5686     char device[] = "/dev/sda1";
5687     device[5] = devchar;
5688     int r;
5689     suppress_error = 0;
5690     r = guestfs_mkfs (g, fstype, device);
5691     if (r == -1)
5692       return -1;
5693   }
5694   {
5695     char device[] = "/dev/sda1";
5696     device[5] = devchar;
5697     char mountpoint[] = "/";
5698     int r;
5699     suppress_error = 0;
5700     r = guestfs_mount (g, device, mountpoint);
5701     if (r == -1)
5702       return -1;
5703   }
5704   /* TestOutput for checksum (7) */
5705   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5706   {
5707     char path[] = "/new";
5708     char content[] = "test\n";
5709     int r;
5710     suppress_error = 0;
5711     r = guestfs_write_file (g, path, content, 0);
5712     if (r == -1)
5713       return -1;
5714   }
5715   {
5716     char csumtype[] = "sha512";
5717     char path[] = "/new";
5718     char *r;
5719     suppress_error = 0;
5720     r = guestfs_checksum (g, csumtype, path);
5721     if (r == NULL)
5722       return -1;
5723     if (strcmp (r, expected) != 0) {
5724       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5725       return -1;
5726     }
5727     free (r);
5728   }
5729   return 0;
5730 }
5731
5732 static int test_download_0_skip (void)
5733 {
5734   const char *str;
5735
5736   str = getenv ("SKIP_TEST_DOWNLOAD_0");
5737   if (str && strcmp (str, "1") == 0) return 1;
5738   str = getenv ("SKIP_TEST_DOWNLOAD");
5739   if (str && strcmp (str, "1") == 0) return 1;
5740   return 0;
5741 }
5742
5743 static int test_download_0 (void)
5744 {
5745   if (test_download_0_skip ()) {
5746     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5747     return 0;
5748   }
5749
5750   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5751   {
5752     char device[] = "/dev/sda";
5753     device[5] = devchar;
5754     int r;
5755     suppress_error = 0;
5756     r = guestfs_blockdev_setrw (g, device);
5757     if (r == -1)
5758       return -1;
5759   }
5760   {
5761     int r;
5762     suppress_error = 0;
5763     r = guestfs_umount_all (g);
5764     if (r == -1)
5765       return -1;
5766   }
5767   {
5768     int r;
5769     suppress_error = 0;
5770     r = guestfs_lvm_remove_all (g);
5771     if (r == -1)
5772       return -1;
5773   }
5774   {
5775     char device[] = "/dev/sda";
5776     device[5] = devchar;
5777     char lines_0[] = ",";
5778     char *lines[] = {
5779       lines_0,
5780       NULL
5781     };
5782     int r;
5783     suppress_error = 0;
5784     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5785     if (r == -1)
5786       return -1;
5787   }
5788   {
5789     char fstype[] = "ext2";
5790     char device[] = "/dev/sda1";
5791     device[5] = devchar;
5792     int r;
5793     suppress_error = 0;
5794     r = guestfs_mkfs (g, fstype, device);
5795     if (r == -1)
5796       return -1;
5797   }
5798   {
5799     char device[] = "/dev/sda1";
5800     device[5] = devchar;
5801     char mountpoint[] = "/";
5802     int r;
5803     suppress_error = 0;
5804     r = guestfs_mount (g, device, mountpoint);
5805     if (r == -1)
5806       return -1;
5807   }
5808   /* TestOutput for download (0) */
5809   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5810   {
5811     char remotefilename[] = "/COPYING.LIB";
5812     int r;
5813     suppress_error = 0;
5814     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
5815     if (r == -1)
5816       return -1;
5817   }
5818   {
5819     char remotefilename[] = "/COPYING.LIB";
5820     int r;
5821     suppress_error = 0;
5822     r = guestfs_download (g, remotefilename, "testdownload.tmp");
5823     if (r == -1)
5824       return -1;
5825   }
5826   {
5827     char remotefilename[] = "/upload";
5828     int r;
5829     suppress_error = 0;
5830     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5831     if (r == -1)
5832       return -1;
5833   }
5834   {
5835     char csumtype[] = "md5";
5836     char path[] = "/upload";
5837     char *r;
5838     suppress_error = 0;
5839     r = guestfs_checksum (g, csumtype, path);
5840     if (r == NULL)
5841       return -1;
5842     if (strcmp (r, expected) != 0) {
5843       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5844       return -1;
5845     }
5846     free (r);
5847   }
5848   return 0;
5849 }
5850
5851 static int test_upload_0_skip (void)
5852 {
5853   const char *str;
5854
5855   str = getenv ("SKIP_TEST_UPLOAD_0");
5856   if (str && strcmp (str, "1") == 0) return 1;
5857   str = getenv ("SKIP_TEST_UPLOAD");
5858   if (str && strcmp (str, "1") == 0) return 1;
5859   return 0;
5860 }
5861
5862 static int test_upload_0 (void)
5863 {
5864   if (test_upload_0_skip ()) {
5865     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5866     return 0;
5867   }
5868
5869   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5870   {
5871     char device[] = "/dev/sda";
5872     device[5] = devchar;
5873     int r;
5874     suppress_error = 0;
5875     r = guestfs_blockdev_setrw (g, device);
5876     if (r == -1)
5877       return -1;
5878   }
5879   {
5880     int r;
5881     suppress_error = 0;
5882     r = guestfs_umount_all (g);
5883     if (r == -1)
5884       return -1;
5885   }
5886   {
5887     int r;
5888     suppress_error = 0;
5889     r = guestfs_lvm_remove_all (g);
5890     if (r == -1)
5891       return -1;
5892   }
5893   {
5894     char device[] = "/dev/sda";
5895     device[5] = devchar;
5896     char lines_0[] = ",";
5897     char *lines[] = {
5898       lines_0,
5899       NULL
5900     };
5901     int r;
5902     suppress_error = 0;
5903     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5904     if (r == -1)
5905       return -1;
5906   }
5907   {
5908     char fstype[] = "ext2";
5909     char device[] = "/dev/sda1";
5910     device[5] = devchar;
5911     int r;
5912     suppress_error = 0;
5913     r = guestfs_mkfs (g, fstype, device);
5914     if (r == -1)
5915       return -1;
5916   }
5917   {
5918     char device[] = "/dev/sda1";
5919     device[5] = devchar;
5920     char mountpoint[] = "/";
5921     int r;
5922     suppress_error = 0;
5923     r = guestfs_mount (g, device, mountpoint);
5924     if (r == -1)
5925       return -1;
5926   }
5927   /* TestOutput for upload (0) */
5928   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5929   {
5930     char remotefilename[] = "/COPYING.LIB";
5931     int r;
5932     suppress_error = 0;
5933     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
5934     if (r == -1)
5935       return -1;
5936   }
5937   {
5938     char csumtype[] = "md5";
5939     char path[] = "/COPYING.LIB";
5940     char *r;
5941     suppress_error = 0;
5942     r = guestfs_checksum (g, csumtype, path);
5943     if (r == NULL)
5944       return -1;
5945     if (strcmp (r, expected) != 0) {
5946       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
5947       return -1;
5948     }
5949     free (r);
5950   }
5951   return 0;
5952 }
5953
5954 static int test_blockdev_rereadpt_0_skip (void)
5955 {
5956   const char *str;
5957
5958   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
5959   if (str && strcmp (str, "1") == 0) return 1;
5960   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
5961   if (str && strcmp (str, "1") == 0) return 1;
5962   return 0;
5963 }
5964
5965 static int test_blockdev_rereadpt_0 (void)
5966 {
5967   if (test_blockdev_rereadpt_0_skip ()) {
5968     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
5969     return 0;
5970   }
5971
5972   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
5973   {
5974     char device[] = "/dev/sda";
5975     device[5] = devchar;
5976     int r;
5977     suppress_error = 0;
5978     r = guestfs_blockdev_setrw (g, device);
5979     if (r == -1)
5980       return -1;
5981   }
5982   {
5983     int r;
5984     suppress_error = 0;
5985     r = guestfs_umount_all (g);
5986     if (r == -1)
5987       return -1;
5988   }
5989   {
5990     int r;
5991     suppress_error = 0;
5992     r = guestfs_lvm_remove_all (g);
5993     if (r == -1)
5994       return -1;
5995   }
5996   /* TestRun for blockdev_rereadpt (0) */
5997   {
5998     char device[] = "/dev/sda";
5999     device[5] = devchar;
6000     int r;
6001     suppress_error = 0;
6002     r = guestfs_blockdev_rereadpt (g, device);
6003     if (r == -1)
6004       return -1;
6005   }
6006   return 0;
6007 }
6008
6009 static int test_blockdev_flushbufs_0_skip (void)
6010 {
6011   const char *str;
6012
6013   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6014   if (str && strcmp (str, "1") == 0) return 1;
6015   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6016   if (str && strcmp (str, "1") == 0) return 1;
6017   return 0;
6018 }
6019
6020 static int test_blockdev_flushbufs_0 (void)
6021 {
6022   if (test_blockdev_flushbufs_0_skip ()) {
6023     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6024     return 0;
6025   }
6026
6027   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6028   {
6029     char device[] = "/dev/sda";
6030     device[5] = devchar;
6031     int r;
6032     suppress_error = 0;
6033     r = guestfs_blockdev_setrw (g, device);
6034     if (r == -1)
6035       return -1;
6036   }
6037   {
6038     int r;
6039     suppress_error = 0;
6040     r = guestfs_umount_all (g);
6041     if (r == -1)
6042       return -1;
6043   }
6044   {
6045     int r;
6046     suppress_error = 0;
6047     r = guestfs_lvm_remove_all (g);
6048     if (r == -1)
6049       return -1;
6050   }
6051   /* TestRun for blockdev_flushbufs (0) */
6052   {
6053     char device[] = "/dev/sda";
6054     device[5] = devchar;
6055     int r;
6056     suppress_error = 0;
6057     r = guestfs_blockdev_flushbufs (g, device);
6058     if (r == -1)
6059       return -1;
6060   }
6061   return 0;
6062 }
6063
6064 static int test_blockdev_getsize64_0_skip (void)
6065 {
6066   const char *str;
6067
6068   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6069   if (str && strcmp (str, "1") == 0) return 1;
6070   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6071   if (str && strcmp (str, "1") == 0) return 1;
6072   return 0;
6073 }
6074
6075 static int test_blockdev_getsize64_0 (void)
6076 {
6077   if (test_blockdev_getsize64_0_skip ()) {
6078     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6079     return 0;
6080   }
6081
6082   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6083   {
6084     char device[] = "/dev/sda";
6085     device[5] = devchar;
6086     int r;
6087     suppress_error = 0;
6088     r = guestfs_blockdev_setrw (g, device);
6089     if (r == -1)
6090       return -1;
6091   }
6092   {
6093     int r;
6094     suppress_error = 0;
6095     r = guestfs_umount_all (g);
6096     if (r == -1)
6097       return -1;
6098   }
6099   {
6100     int r;
6101     suppress_error = 0;
6102     r = guestfs_lvm_remove_all (g);
6103     if (r == -1)
6104       return -1;
6105   }
6106   /* TestOutputInt for blockdev_getsize64 (0) */
6107   {
6108     char device[] = "/dev/sda";
6109     device[5] = devchar;
6110     int64_t r;
6111     suppress_error = 0;
6112     r = guestfs_blockdev_getsize64 (g, device);
6113     if (r == -1)
6114       return -1;
6115     if (r != 524288000) {
6116       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6117       return -1;
6118     }
6119   }
6120   return 0;
6121 }
6122
6123 static int test_blockdev_getsz_0_skip (void)
6124 {
6125   const char *str;
6126
6127   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6128   if (str && strcmp (str, "1") == 0) return 1;
6129   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6130   if (str && strcmp (str, "1") == 0) return 1;
6131   return 0;
6132 }
6133
6134 static int test_blockdev_getsz_0 (void)
6135 {
6136   if (test_blockdev_getsz_0_skip ()) {
6137     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6138     return 0;
6139   }
6140
6141   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6142   {
6143     char device[] = "/dev/sda";
6144     device[5] = devchar;
6145     int r;
6146     suppress_error = 0;
6147     r = guestfs_blockdev_setrw (g, device);
6148     if (r == -1)
6149       return -1;
6150   }
6151   {
6152     int r;
6153     suppress_error = 0;
6154     r = guestfs_umount_all (g);
6155     if (r == -1)
6156       return -1;
6157   }
6158   {
6159     int r;
6160     suppress_error = 0;
6161     r = guestfs_lvm_remove_all (g);
6162     if (r == -1)
6163       return -1;
6164   }
6165   /* TestOutputInt for blockdev_getsz (0) */
6166   {
6167     char device[] = "/dev/sda";
6168     device[5] = devchar;
6169     int64_t r;
6170     suppress_error = 0;
6171     r = guestfs_blockdev_getsz (g, device);
6172     if (r == -1)
6173       return -1;
6174     if (r != 1024000) {
6175       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6176       return -1;
6177     }
6178   }
6179   return 0;
6180 }
6181
6182 static int test_blockdev_getbsz_0_skip (void)
6183 {
6184   const char *str;
6185
6186   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6187   if (str && strcmp (str, "1") == 0) return 1;
6188   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6189   if (str && strcmp (str, "1") == 0) return 1;
6190   return 0;
6191 }
6192
6193 static int test_blockdev_getbsz_0 (void)
6194 {
6195   if (test_blockdev_getbsz_0_skip ()) {
6196     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6197     return 0;
6198   }
6199
6200   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6201   {
6202     char device[] = "/dev/sda";
6203     device[5] = devchar;
6204     int r;
6205     suppress_error = 0;
6206     r = guestfs_blockdev_setrw (g, device);
6207     if (r == -1)
6208       return -1;
6209   }
6210   {
6211     int r;
6212     suppress_error = 0;
6213     r = guestfs_umount_all (g);
6214     if (r == -1)
6215       return -1;
6216   }
6217   {
6218     int r;
6219     suppress_error = 0;
6220     r = guestfs_lvm_remove_all (g);
6221     if (r == -1)
6222       return -1;
6223   }
6224   /* TestOutputInt for blockdev_getbsz (0) */
6225   {
6226     char device[] = "/dev/sda";
6227     device[5] = devchar;
6228     int r;
6229     suppress_error = 0;
6230     r = guestfs_blockdev_getbsz (g, device);
6231     if (r == -1)
6232       return -1;
6233     if (r != 4096) {
6234       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6235       return -1;
6236     }
6237   }
6238   return 0;
6239 }
6240
6241 static int test_blockdev_getss_0_skip (void)
6242 {
6243   const char *str;
6244
6245   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6246   if (str && strcmp (str, "1") == 0) return 1;
6247   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6248   if (str && strcmp (str, "1") == 0) return 1;
6249   return 0;
6250 }
6251
6252 static int test_blockdev_getss_0 (void)
6253 {
6254   if (test_blockdev_getss_0_skip ()) {
6255     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6256     return 0;
6257   }
6258
6259   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6260   {
6261     char device[] = "/dev/sda";
6262     device[5] = devchar;
6263     int r;
6264     suppress_error = 0;
6265     r = guestfs_blockdev_setrw (g, device);
6266     if (r == -1)
6267       return -1;
6268   }
6269   {
6270     int r;
6271     suppress_error = 0;
6272     r = guestfs_umount_all (g);
6273     if (r == -1)
6274       return -1;
6275   }
6276   {
6277     int r;
6278     suppress_error = 0;
6279     r = guestfs_lvm_remove_all (g);
6280     if (r == -1)
6281       return -1;
6282   }
6283   /* TestOutputInt for blockdev_getss (0) */
6284   {
6285     char device[] = "/dev/sda";
6286     device[5] = devchar;
6287     int r;
6288     suppress_error = 0;
6289     r = guestfs_blockdev_getss (g, device);
6290     if (r == -1)
6291       return -1;
6292     if (r != 512) {
6293       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6294       return -1;
6295     }
6296   }
6297   return 0;
6298 }
6299
6300 static int test_blockdev_getro_0_skip (void)
6301 {
6302   const char *str;
6303
6304   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6305   if (str && strcmp (str, "1") == 0) return 1;
6306   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6307   if (str && strcmp (str, "1") == 0) return 1;
6308   return 0;
6309 }
6310
6311 static int test_blockdev_getro_0 (void)
6312 {
6313   if (test_blockdev_getro_0_skip ()) {
6314     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6315     return 0;
6316   }
6317
6318   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6319   {
6320     char device[] = "/dev/sda";
6321     device[5] = devchar;
6322     int r;
6323     suppress_error = 0;
6324     r = guestfs_blockdev_setrw (g, device);
6325     if (r == -1)
6326       return -1;
6327   }
6328   {
6329     int r;
6330     suppress_error = 0;
6331     r = guestfs_umount_all (g);
6332     if (r == -1)
6333       return -1;
6334   }
6335   {
6336     int r;
6337     suppress_error = 0;
6338     r = guestfs_lvm_remove_all (g);
6339     if (r == -1)
6340       return -1;
6341   }
6342   /* TestOutputTrue for blockdev_getro (0) */
6343   {
6344     char device[] = "/dev/sda";
6345     device[5] = devchar;
6346     int r;
6347     suppress_error = 0;
6348     r = guestfs_blockdev_setro (g, device);
6349     if (r == -1)
6350       return -1;
6351   }
6352   {
6353     char device[] = "/dev/sda";
6354     device[5] = devchar;
6355     int r;
6356     suppress_error = 0;
6357     r = guestfs_blockdev_getro (g, device);
6358     if (r == -1)
6359       return -1;
6360     if (!r) {
6361       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6362       return -1;
6363     }
6364   }
6365   return 0;
6366 }
6367
6368 static int test_blockdev_setrw_0_skip (void)
6369 {
6370   const char *str;
6371
6372   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6373   if (str && strcmp (str, "1") == 0) return 1;
6374   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6375   if (str && strcmp (str, "1") == 0) return 1;
6376   return 0;
6377 }
6378
6379 static int test_blockdev_setrw_0 (void)
6380 {
6381   if (test_blockdev_setrw_0_skip ()) {
6382     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6383     return 0;
6384   }
6385
6386   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6387   {
6388     char device[] = "/dev/sda";
6389     device[5] = devchar;
6390     int r;
6391     suppress_error = 0;
6392     r = guestfs_blockdev_setrw (g, device);
6393     if (r == -1)
6394       return -1;
6395   }
6396   {
6397     int r;
6398     suppress_error = 0;
6399     r = guestfs_umount_all (g);
6400     if (r == -1)
6401       return -1;
6402   }
6403   {
6404     int r;
6405     suppress_error = 0;
6406     r = guestfs_lvm_remove_all (g);
6407     if (r == -1)
6408       return -1;
6409   }
6410   /* TestOutputFalse for blockdev_setrw (0) */
6411   {
6412     char device[] = "/dev/sda";
6413     device[5] = devchar;
6414     int r;
6415     suppress_error = 0;
6416     r = guestfs_blockdev_setrw (g, device);
6417     if (r == -1)
6418       return -1;
6419   }
6420   {
6421     char device[] = "/dev/sda";
6422     device[5] = devchar;
6423     int r;
6424     suppress_error = 0;
6425     r = guestfs_blockdev_getro (g, device);
6426     if (r == -1)
6427       return -1;
6428     if (r) {
6429       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6430       return -1;
6431     }
6432   }
6433   return 0;
6434 }
6435
6436 static int test_blockdev_setro_0_skip (void)
6437 {
6438   const char *str;
6439
6440   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6441   if (str && strcmp (str, "1") == 0) return 1;
6442   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6443   if (str && strcmp (str, "1") == 0) return 1;
6444   return 0;
6445 }
6446
6447 static int test_blockdev_setro_0 (void)
6448 {
6449   if (test_blockdev_setro_0_skip ()) {
6450     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6451     return 0;
6452   }
6453
6454   /* InitNone|InitEmpty for test_blockdev_setro_0 */
6455   {
6456     char device[] = "/dev/sda";
6457     device[5] = devchar;
6458     int r;
6459     suppress_error = 0;
6460     r = guestfs_blockdev_setrw (g, device);
6461     if (r == -1)
6462       return -1;
6463   }
6464   {
6465     int r;
6466     suppress_error = 0;
6467     r = guestfs_umount_all (g);
6468     if (r == -1)
6469       return -1;
6470   }
6471   {
6472     int r;
6473     suppress_error = 0;
6474     r = guestfs_lvm_remove_all (g);
6475     if (r == -1)
6476       return -1;
6477   }
6478   /* TestOutputTrue for blockdev_setro (0) */
6479   {
6480     char device[] = "/dev/sda";
6481     device[5] = devchar;
6482     int r;
6483     suppress_error = 0;
6484     r = guestfs_blockdev_setro (g, device);
6485     if (r == -1)
6486       return -1;
6487   }
6488   {
6489     char device[] = "/dev/sda";
6490     device[5] = devchar;
6491     int r;
6492     suppress_error = 0;
6493     r = guestfs_blockdev_getro (g, device);
6494     if (r == -1)
6495       return -1;
6496     if (!r) {
6497       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6498       return -1;
6499     }
6500   }
6501   return 0;
6502 }
6503
6504 static int test_statvfs_0_skip (void)
6505 {
6506   const char *str;
6507
6508   str = getenv ("SKIP_TEST_STATVFS_0");
6509   if (str && strcmp (str, "1") == 0) return 1;
6510   str = getenv ("SKIP_TEST_STATVFS");
6511   if (str && strcmp (str, "1") == 0) return 1;
6512   return 0;
6513 }
6514
6515 static int test_statvfs_0 (void)
6516 {
6517   if (test_statvfs_0_skip ()) {
6518     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6519     return 0;
6520   }
6521
6522   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6523   {
6524     char device[] = "/dev/sda";
6525     device[5] = devchar;
6526     int r;
6527     suppress_error = 0;
6528     r = guestfs_blockdev_setrw (g, device);
6529     if (r == -1)
6530       return -1;
6531   }
6532   {
6533     int r;
6534     suppress_error = 0;
6535     r = guestfs_umount_all (g);
6536     if (r == -1)
6537       return -1;
6538   }
6539   {
6540     int r;
6541     suppress_error = 0;
6542     r = guestfs_lvm_remove_all (g);
6543     if (r == -1)
6544       return -1;
6545   }
6546   {
6547     char device[] = "/dev/sda";
6548     device[5] = devchar;
6549     char lines_0[] = ",";
6550     char *lines[] = {
6551       lines_0,
6552       NULL
6553     };
6554     int r;
6555     suppress_error = 0;
6556     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6557     if (r == -1)
6558       return -1;
6559   }
6560   {
6561     char fstype[] = "ext2";
6562     char device[] = "/dev/sda1";
6563     device[5] = devchar;
6564     int r;
6565     suppress_error = 0;
6566     r = guestfs_mkfs (g, fstype, device);
6567     if (r == -1)
6568       return -1;
6569   }
6570   {
6571     char device[] = "/dev/sda1";
6572     device[5] = devchar;
6573     char mountpoint[] = "/";
6574     int r;
6575     suppress_error = 0;
6576     r = guestfs_mount (g, device, mountpoint);
6577     if (r == -1)
6578       return -1;
6579   }
6580   /* TestOutputStruct for statvfs (0) */
6581   {
6582     char path[] = "/";
6583     struct guestfs_statvfs *r;
6584     suppress_error = 0;
6585     r = guestfs_statvfs (g, path);
6586     if (r == NULL)
6587       return -1;
6588     if (r->bfree != 487702) {
6589       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6590                (int) r->bfree);
6591       return -1;
6592     }
6593     if (r->blocks != 490020) {
6594       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6595                (int) r->blocks);
6596       return -1;
6597     }
6598     if (r->bsize != 1024) {
6599       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6600                (int) r->bsize);
6601       return -1;
6602     }
6603     free (r);
6604   }
6605   return 0;
6606 }
6607
6608 static int test_lstat_0_skip (void)
6609 {
6610   const char *str;
6611
6612   str = getenv ("SKIP_TEST_LSTAT_0");
6613   if (str && strcmp (str, "1") == 0) return 1;
6614   str = getenv ("SKIP_TEST_LSTAT");
6615   if (str && strcmp (str, "1") == 0) return 1;
6616   return 0;
6617 }
6618
6619 static int test_lstat_0 (void)
6620 {
6621   if (test_lstat_0_skip ()) {
6622     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6623     return 0;
6624   }
6625
6626   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6627   {
6628     char device[] = "/dev/sda";
6629     device[5] = devchar;
6630     int r;
6631     suppress_error = 0;
6632     r = guestfs_blockdev_setrw (g, device);
6633     if (r == -1)
6634       return -1;
6635   }
6636   {
6637     int r;
6638     suppress_error = 0;
6639     r = guestfs_umount_all (g);
6640     if (r == -1)
6641       return -1;
6642   }
6643   {
6644     int r;
6645     suppress_error = 0;
6646     r = guestfs_lvm_remove_all (g);
6647     if (r == -1)
6648       return -1;
6649   }
6650   {
6651     char device[] = "/dev/sda";
6652     device[5] = devchar;
6653     char lines_0[] = ",";
6654     char *lines[] = {
6655       lines_0,
6656       NULL
6657     };
6658     int r;
6659     suppress_error = 0;
6660     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6661     if (r == -1)
6662       return -1;
6663   }
6664   {
6665     char fstype[] = "ext2";
6666     char device[] = "/dev/sda1";
6667     device[5] = devchar;
6668     int r;
6669     suppress_error = 0;
6670     r = guestfs_mkfs (g, fstype, device);
6671     if (r == -1)
6672       return -1;
6673   }
6674   {
6675     char device[] = "/dev/sda1";
6676     device[5] = devchar;
6677     char mountpoint[] = "/";
6678     int r;
6679     suppress_error = 0;
6680     r = guestfs_mount (g, device, mountpoint);
6681     if (r == -1)
6682       return -1;
6683   }
6684   /* TestOutputStruct for lstat (0) */
6685   {
6686     char path[] = "/new";
6687     int r;
6688     suppress_error = 0;
6689     r = guestfs_touch (g, path);
6690     if (r == -1)
6691       return -1;
6692   }
6693   {
6694     char path[] = "/new";
6695     struct guestfs_stat *r;
6696     suppress_error = 0;
6697     r = guestfs_lstat (g, path);
6698     if (r == NULL)
6699       return -1;
6700     if (r->size != 0) {
6701       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6702                (int) r->size);
6703       return -1;
6704     }
6705     free (r);
6706   }
6707   return 0;
6708 }
6709
6710 static int test_stat_0_skip (void)
6711 {
6712   const char *str;
6713
6714   str = getenv ("SKIP_TEST_STAT_0");
6715   if (str && strcmp (str, "1") == 0) return 1;
6716   str = getenv ("SKIP_TEST_STAT");
6717   if (str && strcmp (str, "1") == 0) return 1;
6718   return 0;
6719 }
6720
6721 static int test_stat_0 (void)
6722 {
6723   if (test_stat_0_skip ()) {
6724     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6725     return 0;
6726   }
6727
6728   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6729   {
6730     char device[] = "/dev/sda";
6731     device[5] = devchar;
6732     int r;
6733     suppress_error = 0;
6734     r = guestfs_blockdev_setrw (g, device);
6735     if (r == -1)
6736       return -1;
6737   }
6738   {
6739     int r;
6740     suppress_error = 0;
6741     r = guestfs_umount_all (g);
6742     if (r == -1)
6743       return -1;
6744   }
6745   {
6746     int r;
6747     suppress_error = 0;
6748     r = guestfs_lvm_remove_all (g);
6749     if (r == -1)
6750       return -1;
6751   }
6752   {
6753     char device[] = "/dev/sda";
6754     device[5] = devchar;
6755     char lines_0[] = ",";
6756     char *lines[] = {
6757       lines_0,
6758       NULL
6759     };
6760     int r;
6761     suppress_error = 0;
6762     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6763     if (r == -1)
6764       return -1;
6765   }
6766   {
6767     char fstype[] = "ext2";
6768     char device[] = "/dev/sda1";
6769     device[5] = devchar;
6770     int r;
6771     suppress_error = 0;
6772     r = guestfs_mkfs (g, fstype, device);
6773     if (r == -1)
6774       return -1;
6775   }
6776   {
6777     char device[] = "/dev/sda1";
6778     device[5] = devchar;
6779     char mountpoint[] = "/";
6780     int r;
6781     suppress_error = 0;
6782     r = guestfs_mount (g, device, mountpoint);
6783     if (r == -1)
6784       return -1;
6785   }
6786   /* TestOutputStruct for stat (0) */
6787   {
6788     char path[] = "/new";
6789     int r;
6790     suppress_error = 0;
6791     r = guestfs_touch (g, path);
6792     if (r == -1)
6793       return -1;
6794   }
6795   {
6796     char path[] = "/new";
6797     struct guestfs_stat *r;
6798     suppress_error = 0;
6799     r = guestfs_stat (g, path);
6800     if (r == NULL)
6801       return -1;
6802     if (r->size != 0) {
6803       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6804                (int) r->size);
6805       return -1;
6806     }
6807     free (r);
6808   }
6809   return 0;
6810 }
6811
6812 static int test_command_lines_0_skip (void)
6813 {
6814   const char *str;
6815
6816   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6817   if (str && strcmp (str, "1") == 0) return 1;
6818   str = getenv ("SKIP_TEST_COMMAND_LINES");
6819   if (str && strcmp (str, "1") == 0) return 1;
6820   return 0;
6821 }
6822
6823 static int test_command_lines_0 (void)
6824 {
6825   if (test_command_lines_0_skip ()) {
6826     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6827     return 0;
6828   }
6829
6830   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6831   {
6832     char device[] = "/dev/sda";
6833     device[5] = devchar;
6834     int r;
6835     suppress_error = 0;
6836     r = guestfs_blockdev_setrw (g, device);
6837     if (r == -1)
6838       return -1;
6839   }
6840   {
6841     int r;
6842     suppress_error = 0;
6843     r = guestfs_umount_all (g);
6844     if (r == -1)
6845       return -1;
6846   }
6847   {
6848     int r;
6849     suppress_error = 0;
6850     r = guestfs_lvm_remove_all (g);
6851     if (r == -1)
6852       return -1;
6853   }
6854   {
6855     char device[] = "/dev/sda";
6856     device[5] = devchar;
6857     char lines_0[] = ",";
6858     char *lines[] = {
6859       lines_0,
6860       NULL
6861     };
6862     int r;
6863     suppress_error = 0;
6864     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6865     if (r == -1)
6866       return -1;
6867   }
6868   {
6869     char fstype[] = "ext2";
6870     char device[] = "/dev/sda1";
6871     device[5] = devchar;
6872     int r;
6873     suppress_error = 0;
6874     r = guestfs_mkfs (g, fstype, device);
6875     if (r == -1)
6876       return -1;
6877   }
6878   {
6879     char device[] = "/dev/sda1";
6880     device[5] = devchar;
6881     char mountpoint[] = "/";
6882     int r;
6883     suppress_error = 0;
6884     r = guestfs_mount (g, device, mountpoint);
6885     if (r == -1)
6886       return -1;
6887   }
6888   /* TestOutputList for command_lines (0) */
6889   {
6890     char remotefilename[] = "/test-command";
6891     int r;
6892     suppress_error = 0;
6893     r = guestfs_upload (g, "test-command", remotefilename);
6894     if (r == -1)
6895       return -1;
6896   }
6897   {
6898     char path[] = "/test-command";
6899     int r;
6900     suppress_error = 0;
6901     r = guestfs_chmod (g, 493, path);
6902     if (r == -1)
6903       return -1;
6904   }
6905   {
6906     char arguments_0[] = "/test-command";
6907     char arguments_1[] = "1";
6908     char *arguments[] = {
6909       arguments_0,
6910       arguments_1,
6911       NULL
6912     };
6913     char **r;
6914     int i;
6915     suppress_error = 0;
6916     r = guestfs_command_lines (g, arguments);
6917     if (r == NULL)
6918       return -1;
6919     if (!r[0]) {
6920       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
6921       print_strings (r);
6922       return -1;
6923     }
6924     {
6925       char expected[] = "Result1";
6926       if (strcmp (r[0], expected) != 0) {
6927         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6928         return -1;
6929       }
6930     }
6931     if (r[1] != NULL) {
6932       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
6933       print_strings (r);
6934       return -1;
6935     }
6936     for (i = 0; r[i] != NULL; ++i)
6937       free (r[i]);
6938     free (r);
6939   }
6940   return 0;
6941 }
6942
6943 static int test_command_lines_1_skip (void)
6944 {
6945   const char *str;
6946
6947   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
6948   if (str && strcmp (str, "1") == 0) return 1;
6949   str = getenv ("SKIP_TEST_COMMAND_LINES");
6950   if (str && strcmp (str, "1") == 0) return 1;
6951   return 0;
6952 }
6953
6954 static int test_command_lines_1 (void)
6955 {
6956   if (test_command_lines_1_skip ()) {
6957     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
6958     return 0;
6959   }
6960
6961   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
6962   {
6963     char device[] = "/dev/sda";
6964     device[5] = devchar;
6965     int r;
6966     suppress_error = 0;
6967     r = guestfs_blockdev_setrw (g, device);
6968     if (r == -1)
6969       return -1;
6970   }
6971   {
6972     int r;
6973     suppress_error = 0;
6974     r = guestfs_umount_all (g);
6975     if (r == -1)
6976       return -1;
6977   }
6978   {
6979     int r;
6980     suppress_error = 0;
6981     r = guestfs_lvm_remove_all (g);
6982     if (r == -1)
6983       return -1;
6984   }
6985   {
6986     char device[] = "/dev/sda";
6987     device[5] = devchar;
6988     char lines_0[] = ",";
6989     char *lines[] = {
6990       lines_0,
6991       NULL
6992     };
6993     int r;
6994     suppress_error = 0;
6995     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6996     if (r == -1)
6997       return -1;
6998   }
6999   {
7000     char fstype[] = "ext2";
7001     char device[] = "/dev/sda1";
7002     device[5] = devchar;
7003     int r;
7004     suppress_error = 0;
7005     r = guestfs_mkfs (g, fstype, device);
7006     if (r == -1)
7007       return -1;
7008   }
7009   {
7010     char device[] = "/dev/sda1";
7011     device[5] = devchar;
7012     char mountpoint[] = "/";
7013     int r;
7014     suppress_error = 0;
7015     r = guestfs_mount (g, device, mountpoint);
7016     if (r == -1)
7017       return -1;
7018   }
7019   /* TestOutputList for command_lines (1) */
7020   {
7021     char remotefilename[] = "/test-command";
7022     int r;
7023     suppress_error = 0;
7024     r = guestfs_upload (g, "test-command", remotefilename);
7025     if (r == -1)
7026       return -1;
7027   }
7028   {
7029     char path[] = "/test-command";
7030     int r;
7031     suppress_error = 0;
7032     r = guestfs_chmod (g, 493, path);
7033     if (r == -1)
7034       return -1;
7035   }
7036   {
7037     char arguments_0[] = "/test-command";
7038     char arguments_1[] = "2";
7039     char *arguments[] = {
7040       arguments_0,
7041       arguments_1,
7042       NULL
7043     };
7044     char **r;
7045     int i;
7046     suppress_error = 0;
7047     r = guestfs_command_lines (g, arguments);
7048     if (r == NULL)
7049       return -1;
7050     if (!r[0]) {
7051       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7052       print_strings (r);
7053       return -1;
7054     }
7055     {
7056       char expected[] = "Result2";
7057       if (strcmp (r[0], expected) != 0) {
7058         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7059         return -1;
7060       }
7061     }
7062     if (r[1] != NULL) {
7063       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7064       print_strings (r);
7065       return -1;
7066     }
7067     for (i = 0; r[i] != NULL; ++i)
7068       free (r[i]);
7069     free (r);
7070   }
7071   return 0;
7072 }
7073
7074 static int test_command_lines_2_skip (void)
7075 {
7076   const char *str;
7077
7078   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7079   if (str && strcmp (str, "1") == 0) return 1;
7080   str = getenv ("SKIP_TEST_COMMAND_LINES");
7081   if (str && strcmp (str, "1") == 0) return 1;
7082   return 0;
7083 }
7084
7085 static int test_command_lines_2 (void)
7086 {
7087   if (test_command_lines_2_skip ()) {
7088     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7089     return 0;
7090   }
7091
7092   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7093   {
7094     char device[] = "/dev/sda";
7095     device[5] = devchar;
7096     int r;
7097     suppress_error = 0;
7098     r = guestfs_blockdev_setrw (g, device);
7099     if (r == -1)
7100       return -1;
7101   }
7102   {
7103     int r;
7104     suppress_error = 0;
7105     r = guestfs_umount_all (g);
7106     if (r == -1)
7107       return -1;
7108   }
7109   {
7110     int r;
7111     suppress_error = 0;
7112     r = guestfs_lvm_remove_all (g);
7113     if (r == -1)
7114       return -1;
7115   }
7116   {
7117     char device[] = "/dev/sda";
7118     device[5] = devchar;
7119     char lines_0[] = ",";
7120     char *lines[] = {
7121       lines_0,
7122       NULL
7123     };
7124     int r;
7125     suppress_error = 0;
7126     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7127     if (r == -1)
7128       return -1;
7129   }
7130   {
7131     char fstype[] = "ext2";
7132     char device[] = "/dev/sda1";
7133     device[5] = devchar;
7134     int r;
7135     suppress_error = 0;
7136     r = guestfs_mkfs (g, fstype, device);
7137     if (r == -1)
7138       return -1;
7139   }
7140   {
7141     char device[] = "/dev/sda1";
7142     device[5] = devchar;
7143     char mountpoint[] = "/";
7144     int r;
7145     suppress_error = 0;
7146     r = guestfs_mount (g, device, mountpoint);
7147     if (r == -1)
7148       return -1;
7149   }
7150   /* TestOutputList for command_lines (2) */
7151   {
7152     char remotefilename[] = "/test-command";
7153     int r;
7154     suppress_error = 0;
7155     r = guestfs_upload (g, "test-command", remotefilename);
7156     if (r == -1)
7157       return -1;
7158   }
7159   {
7160     char path[] = "/test-command";
7161     int r;
7162     suppress_error = 0;
7163     r = guestfs_chmod (g, 493, path);
7164     if (r == -1)
7165       return -1;
7166   }
7167   {
7168     char arguments_0[] = "/test-command";
7169     char arguments_1[] = "3";
7170     char *arguments[] = {
7171       arguments_0,
7172       arguments_1,
7173       NULL
7174     };
7175     char **r;
7176     int i;
7177     suppress_error = 0;
7178     r = guestfs_command_lines (g, arguments);
7179     if (r == NULL)
7180       return -1;
7181     if (!r[0]) {
7182       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7183       print_strings (r);
7184       return -1;
7185     }
7186     {
7187       char expected[] = "";
7188       if (strcmp (r[0], expected) != 0) {
7189         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7190         return -1;
7191       }
7192     }
7193     if (!r[1]) {
7194       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7195       print_strings (r);
7196       return -1;
7197     }
7198     {
7199       char expected[] = "Result3";
7200       if (strcmp (r[1], expected) != 0) {
7201         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7202         return -1;
7203       }
7204     }
7205     if (r[2] != NULL) {
7206       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7207       print_strings (r);
7208       return -1;
7209     }
7210     for (i = 0; r[i] != NULL; ++i)
7211       free (r[i]);
7212     free (r);
7213   }
7214   return 0;
7215 }
7216
7217 static int test_command_lines_3_skip (void)
7218 {
7219   const char *str;
7220
7221   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7222   if (str && strcmp (str, "1") == 0) return 1;
7223   str = getenv ("SKIP_TEST_COMMAND_LINES");
7224   if (str && strcmp (str, "1") == 0) return 1;
7225   return 0;
7226 }
7227
7228 static int test_command_lines_3 (void)
7229 {
7230   if (test_command_lines_3_skip ()) {
7231     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7232     return 0;
7233   }
7234
7235   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7236   {
7237     char device[] = "/dev/sda";
7238     device[5] = devchar;
7239     int r;
7240     suppress_error = 0;
7241     r = guestfs_blockdev_setrw (g, device);
7242     if (r == -1)
7243       return -1;
7244   }
7245   {
7246     int r;
7247     suppress_error = 0;
7248     r = guestfs_umount_all (g);
7249     if (r == -1)
7250       return -1;
7251   }
7252   {
7253     int r;
7254     suppress_error = 0;
7255     r = guestfs_lvm_remove_all (g);
7256     if (r == -1)
7257       return -1;
7258   }
7259   {
7260     char device[] = "/dev/sda";
7261     device[5] = devchar;
7262     char lines_0[] = ",";
7263     char *lines[] = {
7264       lines_0,
7265       NULL
7266     };
7267     int r;
7268     suppress_error = 0;
7269     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7270     if (r == -1)
7271       return -1;
7272   }
7273   {
7274     char fstype[] = "ext2";
7275     char device[] = "/dev/sda1";
7276     device[5] = devchar;
7277     int r;
7278     suppress_error = 0;
7279     r = guestfs_mkfs (g, fstype, device);
7280     if (r == -1)
7281       return -1;
7282   }
7283   {
7284     char device[] = "/dev/sda1";
7285     device[5] = devchar;
7286     char mountpoint[] = "/";
7287     int r;
7288     suppress_error = 0;
7289     r = guestfs_mount (g, device, mountpoint);
7290     if (r == -1)
7291       return -1;
7292   }
7293   /* TestOutputList for command_lines (3) */
7294   {
7295     char remotefilename[] = "/test-command";
7296     int r;
7297     suppress_error = 0;
7298     r = guestfs_upload (g, "test-command", remotefilename);
7299     if (r == -1)
7300       return -1;
7301   }
7302   {
7303     char path[] = "/test-command";
7304     int r;
7305     suppress_error = 0;
7306     r = guestfs_chmod (g, 493, path);
7307     if (r == -1)
7308       return -1;
7309   }
7310   {
7311     char arguments_0[] = "/test-command";
7312     char arguments_1[] = "4";
7313     char *arguments[] = {
7314       arguments_0,
7315       arguments_1,
7316       NULL
7317     };
7318     char **r;
7319     int i;
7320     suppress_error = 0;
7321     r = guestfs_command_lines (g, arguments);
7322     if (r == NULL)
7323       return -1;
7324     if (!r[0]) {
7325       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7326       print_strings (r);
7327       return -1;
7328     }
7329     {
7330       char expected[] = "";
7331       if (strcmp (r[0], expected) != 0) {
7332         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7333         return -1;
7334       }
7335     }
7336     if (!r[1]) {
7337       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7338       print_strings (r);
7339       return -1;
7340     }
7341     {
7342       char expected[] = "Result4";
7343       if (strcmp (r[1], expected) != 0) {
7344         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7345         return -1;
7346       }
7347     }
7348     if (r[2] != NULL) {
7349       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7350       print_strings (r);
7351       return -1;
7352     }
7353     for (i = 0; r[i] != NULL; ++i)
7354       free (r[i]);
7355     free (r);
7356   }
7357   return 0;
7358 }
7359
7360 static int test_command_lines_4_skip (void)
7361 {
7362   const char *str;
7363
7364   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7365   if (str && strcmp (str, "1") == 0) return 1;
7366   str = getenv ("SKIP_TEST_COMMAND_LINES");
7367   if (str && strcmp (str, "1") == 0) return 1;
7368   return 0;
7369 }
7370
7371 static int test_command_lines_4 (void)
7372 {
7373   if (test_command_lines_4_skip ()) {
7374     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7375     return 0;
7376   }
7377
7378   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7379   {
7380     char device[] = "/dev/sda";
7381     device[5] = devchar;
7382     int r;
7383     suppress_error = 0;
7384     r = guestfs_blockdev_setrw (g, device);
7385     if (r == -1)
7386       return -1;
7387   }
7388   {
7389     int r;
7390     suppress_error = 0;
7391     r = guestfs_umount_all (g);
7392     if (r == -1)
7393       return -1;
7394   }
7395   {
7396     int r;
7397     suppress_error = 0;
7398     r = guestfs_lvm_remove_all (g);
7399     if (r == -1)
7400       return -1;
7401   }
7402   {
7403     char device[] = "/dev/sda";
7404     device[5] = devchar;
7405     char lines_0[] = ",";
7406     char *lines[] = {
7407       lines_0,
7408       NULL
7409     };
7410     int r;
7411     suppress_error = 0;
7412     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7413     if (r == -1)
7414       return -1;
7415   }
7416   {
7417     char fstype[] = "ext2";
7418     char device[] = "/dev/sda1";
7419     device[5] = devchar;
7420     int r;
7421     suppress_error = 0;
7422     r = guestfs_mkfs (g, fstype, device);
7423     if (r == -1)
7424       return -1;
7425   }
7426   {
7427     char device[] = "/dev/sda1";
7428     device[5] = devchar;
7429     char mountpoint[] = "/";
7430     int r;
7431     suppress_error = 0;
7432     r = guestfs_mount (g, device, mountpoint);
7433     if (r == -1)
7434       return -1;
7435   }
7436   /* TestOutputList for command_lines (4) */
7437   {
7438     char remotefilename[] = "/test-command";
7439     int r;
7440     suppress_error = 0;
7441     r = guestfs_upload (g, "test-command", remotefilename);
7442     if (r == -1)
7443       return -1;
7444   }
7445   {
7446     char path[] = "/test-command";
7447     int r;
7448     suppress_error = 0;
7449     r = guestfs_chmod (g, 493, path);
7450     if (r == -1)
7451       return -1;
7452   }
7453   {
7454     char arguments_0[] = "/test-command";
7455     char arguments_1[] = "5";
7456     char *arguments[] = {
7457       arguments_0,
7458       arguments_1,
7459       NULL
7460     };
7461     char **r;
7462     int i;
7463     suppress_error = 0;
7464     r = guestfs_command_lines (g, arguments);
7465     if (r == NULL)
7466       return -1;
7467     if (!r[0]) {
7468       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7469       print_strings (r);
7470       return -1;
7471     }
7472     {
7473       char expected[] = "";
7474       if (strcmp (r[0], expected) != 0) {
7475         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7476         return -1;
7477       }
7478     }
7479     if (!r[1]) {
7480       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7481       print_strings (r);
7482       return -1;
7483     }
7484     {
7485       char expected[] = "Result5";
7486       if (strcmp (r[1], expected) != 0) {
7487         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7488         return -1;
7489       }
7490     }
7491     if (!r[2]) {
7492       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7493       print_strings (r);
7494       return -1;
7495     }
7496     {
7497       char expected[] = "";
7498       if (strcmp (r[2], expected) != 0) {
7499         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7500         return -1;
7501       }
7502     }
7503     if (r[3] != NULL) {
7504       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7505       print_strings (r);
7506       return -1;
7507     }
7508     for (i = 0; r[i] != NULL; ++i)
7509       free (r[i]);
7510     free (r);
7511   }
7512   return 0;
7513 }
7514
7515 static int test_command_lines_5_skip (void)
7516 {
7517   const char *str;
7518
7519   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7520   if (str && strcmp (str, "1") == 0) return 1;
7521   str = getenv ("SKIP_TEST_COMMAND_LINES");
7522   if (str && strcmp (str, "1") == 0) return 1;
7523   return 0;
7524 }
7525
7526 static int test_command_lines_5 (void)
7527 {
7528   if (test_command_lines_5_skip ()) {
7529     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7530     return 0;
7531   }
7532
7533   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7534   {
7535     char device[] = "/dev/sda";
7536     device[5] = devchar;
7537     int r;
7538     suppress_error = 0;
7539     r = guestfs_blockdev_setrw (g, device);
7540     if (r == -1)
7541       return -1;
7542   }
7543   {
7544     int r;
7545     suppress_error = 0;
7546     r = guestfs_umount_all (g);
7547     if (r == -1)
7548       return -1;
7549   }
7550   {
7551     int r;
7552     suppress_error = 0;
7553     r = guestfs_lvm_remove_all (g);
7554     if (r == -1)
7555       return -1;
7556   }
7557   {
7558     char device[] = "/dev/sda";
7559     device[5] = devchar;
7560     char lines_0[] = ",";
7561     char *lines[] = {
7562       lines_0,
7563       NULL
7564     };
7565     int r;
7566     suppress_error = 0;
7567     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7568     if (r == -1)
7569       return -1;
7570   }
7571   {
7572     char fstype[] = "ext2";
7573     char device[] = "/dev/sda1";
7574     device[5] = devchar;
7575     int r;
7576     suppress_error = 0;
7577     r = guestfs_mkfs (g, fstype, device);
7578     if (r == -1)
7579       return -1;
7580   }
7581   {
7582     char device[] = "/dev/sda1";
7583     device[5] = devchar;
7584     char mountpoint[] = "/";
7585     int r;
7586     suppress_error = 0;
7587     r = guestfs_mount (g, device, mountpoint);
7588     if (r == -1)
7589       return -1;
7590   }
7591   /* TestOutputList for command_lines (5) */
7592   {
7593     char remotefilename[] = "/test-command";
7594     int r;
7595     suppress_error = 0;
7596     r = guestfs_upload (g, "test-command", remotefilename);
7597     if (r == -1)
7598       return -1;
7599   }
7600   {
7601     char path[] = "/test-command";
7602     int r;
7603     suppress_error = 0;
7604     r = guestfs_chmod (g, 493, path);
7605     if (r == -1)
7606       return -1;
7607   }
7608   {
7609     char arguments_0[] = "/test-command";
7610     char arguments_1[] = "6";
7611     char *arguments[] = {
7612       arguments_0,
7613       arguments_1,
7614       NULL
7615     };
7616     char **r;
7617     int i;
7618     suppress_error = 0;
7619     r = guestfs_command_lines (g, arguments);
7620     if (r == NULL)
7621       return -1;
7622     if (!r[0]) {
7623       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7624       print_strings (r);
7625       return -1;
7626     }
7627     {
7628       char expected[] = "";
7629       if (strcmp (r[0], expected) != 0) {
7630         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7631         return -1;
7632       }
7633     }
7634     if (!r[1]) {
7635       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7636       print_strings (r);
7637       return -1;
7638     }
7639     {
7640       char expected[] = "";
7641       if (strcmp (r[1], expected) != 0) {
7642         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7643         return -1;
7644       }
7645     }
7646     if (!r[2]) {
7647       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7648       print_strings (r);
7649       return -1;
7650     }
7651     {
7652       char expected[] = "Result6";
7653       if (strcmp (r[2], expected) != 0) {
7654         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7655         return -1;
7656       }
7657     }
7658     if (!r[3]) {
7659       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7660       print_strings (r);
7661       return -1;
7662     }
7663     {
7664       char expected[] = "";
7665       if (strcmp (r[3], expected) != 0) {
7666         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7667         return -1;
7668       }
7669     }
7670     if (r[4] != NULL) {
7671       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7672       print_strings (r);
7673       return -1;
7674     }
7675     for (i = 0; r[i] != NULL; ++i)
7676       free (r[i]);
7677     free (r);
7678   }
7679   return 0;
7680 }
7681
7682 static int test_command_lines_6_skip (void)
7683 {
7684   const char *str;
7685
7686   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7687   if (str && strcmp (str, "1") == 0) return 1;
7688   str = getenv ("SKIP_TEST_COMMAND_LINES");
7689   if (str && strcmp (str, "1") == 0) return 1;
7690   return 0;
7691 }
7692
7693 static int test_command_lines_6 (void)
7694 {
7695   if (test_command_lines_6_skip ()) {
7696     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7697     return 0;
7698   }
7699
7700   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7701   {
7702     char device[] = "/dev/sda";
7703     device[5] = devchar;
7704     int r;
7705     suppress_error = 0;
7706     r = guestfs_blockdev_setrw (g, device);
7707     if (r == -1)
7708       return -1;
7709   }
7710   {
7711     int r;
7712     suppress_error = 0;
7713     r = guestfs_umount_all (g);
7714     if (r == -1)
7715       return -1;
7716   }
7717   {
7718     int r;
7719     suppress_error = 0;
7720     r = guestfs_lvm_remove_all (g);
7721     if (r == -1)
7722       return -1;
7723   }
7724   {
7725     char device[] = "/dev/sda";
7726     device[5] = devchar;
7727     char lines_0[] = ",";
7728     char *lines[] = {
7729       lines_0,
7730       NULL
7731     };
7732     int r;
7733     suppress_error = 0;
7734     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7735     if (r == -1)
7736       return -1;
7737   }
7738   {
7739     char fstype[] = "ext2";
7740     char device[] = "/dev/sda1";
7741     device[5] = devchar;
7742     int r;
7743     suppress_error = 0;
7744     r = guestfs_mkfs (g, fstype, device);
7745     if (r == -1)
7746       return -1;
7747   }
7748   {
7749     char device[] = "/dev/sda1";
7750     device[5] = devchar;
7751     char mountpoint[] = "/";
7752     int r;
7753     suppress_error = 0;
7754     r = guestfs_mount (g, device, mountpoint);
7755     if (r == -1)
7756       return -1;
7757   }
7758   /* TestOutputList for command_lines (6) */
7759   {
7760     char remotefilename[] = "/test-command";
7761     int r;
7762     suppress_error = 0;
7763     r = guestfs_upload (g, "test-command", remotefilename);
7764     if (r == -1)
7765       return -1;
7766   }
7767   {
7768     char path[] = "/test-command";
7769     int r;
7770     suppress_error = 0;
7771     r = guestfs_chmod (g, 493, path);
7772     if (r == -1)
7773       return -1;
7774   }
7775   {
7776     char arguments_0[] = "/test-command";
7777     char arguments_1[] = "7";
7778     char *arguments[] = {
7779       arguments_0,
7780       arguments_1,
7781       NULL
7782     };
7783     char **r;
7784     int i;
7785     suppress_error = 0;
7786     r = guestfs_command_lines (g, arguments);
7787     if (r == NULL)
7788       return -1;
7789     if (r[0] != NULL) {
7790       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7791       print_strings (r);
7792       return -1;
7793     }
7794     for (i = 0; r[i] != NULL; ++i)
7795       free (r[i]);
7796     free (r);
7797   }
7798   return 0;
7799 }
7800
7801 static int test_command_lines_7_skip (void)
7802 {
7803   const char *str;
7804
7805   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7806   if (str && strcmp (str, "1") == 0) return 1;
7807   str = getenv ("SKIP_TEST_COMMAND_LINES");
7808   if (str && strcmp (str, "1") == 0) return 1;
7809   return 0;
7810 }
7811
7812 static int test_command_lines_7 (void)
7813 {
7814   if (test_command_lines_7_skip ()) {
7815     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7816     return 0;
7817   }
7818
7819   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7820   {
7821     char device[] = "/dev/sda";
7822     device[5] = devchar;
7823     int r;
7824     suppress_error = 0;
7825     r = guestfs_blockdev_setrw (g, device);
7826     if (r == -1)
7827       return -1;
7828   }
7829   {
7830     int r;
7831     suppress_error = 0;
7832     r = guestfs_umount_all (g);
7833     if (r == -1)
7834       return -1;
7835   }
7836   {
7837     int r;
7838     suppress_error = 0;
7839     r = guestfs_lvm_remove_all (g);
7840     if (r == -1)
7841       return -1;
7842   }
7843   {
7844     char device[] = "/dev/sda";
7845     device[5] = devchar;
7846     char lines_0[] = ",";
7847     char *lines[] = {
7848       lines_0,
7849       NULL
7850     };
7851     int r;
7852     suppress_error = 0;
7853     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7854     if (r == -1)
7855       return -1;
7856   }
7857   {
7858     char fstype[] = "ext2";
7859     char device[] = "/dev/sda1";
7860     device[5] = devchar;
7861     int r;
7862     suppress_error = 0;
7863     r = guestfs_mkfs (g, fstype, device);
7864     if (r == -1)
7865       return -1;
7866   }
7867   {
7868     char device[] = "/dev/sda1";
7869     device[5] = devchar;
7870     char mountpoint[] = "/";
7871     int r;
7872     suppress_error = 0;
7873     r = guestfs_mount (g, device, mountpoint);
7874     if (r == -1)
7875       return -1;
7876   }
7877   /* TestOutputList for command_lines (7) */
7878   {
7879     char remotefilename[] = "/test-command";
7880     int r;
7881     suppress_error = 0;
7882     r = guestfs_upload (g, "test-command", remotefilename);
7883     if (r == -1)
7884       return -1;
7885   }
7886   {
7887     char path[] = "/test-command";
7888     int r;
7889     suppress_error = 0;
7890     r = guestfs_chmod (g, 493, path);
7891     if (r == -1)
7892       return -1;
7893   }
7894   {
7895     char arguments_0[] = "/test-command";
7896     char arguments_1[] = "8";
7897     char *arguments[] = {
7898       arguments_0,
7899       arguments_1,
7900       NULL
7901     };
7902     char **r;
7903     int i;
7904     suppress_error = 0;
7905     r = guestfs_command_lines (g, arguments);
7906     if (r == NULL)
7907       return -1;
7908     if (!r[0]) {
7909       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
7910       print_strings (r);
7911       return -1;
7912     }
7913     {
7914       char expected[] = "";
7915       if (strcmp (r[0], expected) != 0) {
7916         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7917         return -1;
7918       }
7919     }
7920     if (r[1] != NULL) {
7921       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
7922       print_strings (r);
7923       return -1;
7924     }
7925     for (i = 0; r[i] != NULL; ++i)
7926       free (r[i]);
7927     free (r);
7928   }
7929   return 0;
7930 }
7931
7932 static int test_command_lines_8_skip (void)
7933 {
7934   const char *str;
7935
7936   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
7937   if (str && strcmp (str, "1") == 0) return 1;
7938   str = getenv ("SKIP_TEST_COMMAND_LINES");
7939   if (str && strcmp (str, "1") == 0) return 1;
7940   return 0;
7941 }
7942
7943 static int test_command_lines_8 (void)
7944 {
7945   if (test_command_lines_8_skip ()) {
7946     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
7947     return 0;
7948   }
7949
7950   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
7951   {
7952     char device[] = "/dev/sda";
7953     device[5] = devchar;
7954     int r;
7955     suppress_error = 0;
7956     r = guestfs_blockdev_setrw (g, device);
7957     if (r == -1)
7958       return -1;
7959   }
7960   {
7961     int r;
7962     suppress_error = 0;
7963     r = guestfs_umount_all (g);
7964     if (r == -1)
7965       return -1;
7966   }
7967   {
7968     int r;
7969     suppress_error = 0;
7970     r = guestfs_lvm_remove_all (g);
7971     if (r == -1)
7972       return -1;
7973   }
7974   {
7975     char device[] = "/dev/sda";
7976     device[5] = devchar;
7977     char lines_0[] = ",";
7978     char *lines[] = {
7979       lines_0,
7980       NULL
7981     };
7982     int r;
7983     suppress_error = 0;
7984     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7985     if (r == -1)
7986       return -1;
7987   }
7988   {
7989     char fstype[] = "ext2";
7990     char device[] = "/dev/sda1";
7991     device[5] = devchar;
7992     int r;
7993     suppress_error = 0;
7994     r = guestfs_mkfs (g, fstype, device);
7995     if (r == -1)
7996       return -1;
7997   }
7998   {
7999     char device[] = "/dev/sda1";
8000     device[5] = devchar;
8001     char mountpoint[] = "/";
8002     int r;
8003     suppress_error = 0;
8004     r = guestfs_mount (g, device, mountpoint);
8005     if (r == -1)
8006       return -1;
8007   }
8008   /* TestOutputList for command_lines (8) */
8009   {
8010     char remotefilename[] = "/test-command";
8011     int r;
8012     suppress_error = 0;
8013     r = guestfs_upload (g, "test-command", remotefilename);
8014     if (r == -1)
8015       return -1;
8016   }
8017   {
8018     char path[] = "/test-command";
8019     int r;
8020     suppress_error = 0;
8021     r = guestfs_chmod (g, 493, path);
8022     if (r == -1)
8023       return -1;
8024   }
8025   {
8026     char arguments_0[] = "/test-command";
8027     char arguments_1[] = "9";
8028     char *arguments[] = {
8029       arguments_0,
8030       arguments_1,
8031       NULL
8032     };
8033     char **r;
8034     int i;
8035     suppress_error = 0;
8036     r = guestfs_command_lines (g, arguments);
8037     if (r == NULL)
8038       return -1;
8039     if (!r[0]) {
8040       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8041       print_strings (r);
8042       return -1;
8043     }
8044     {
8045       char expected[] = "";
8046       if (strcmp (r[0], expected) != 0) {
8047         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8048         return -1;
8049       }
8050     }
8051     if (!r[1]) {
8052       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8053       print_strings (r);
8054       return -1;
8055     }
8056     {
8057       char expected[] = "";
8058       if (strcmp (r[1], expected) != 0) {
8059         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8060         return -1;
8061       }
8062     }
8063     if (r[2] != NULL) {
8064       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8065       print_strings (r);
8066       return -1;
8067     }
8068     for (i = 0; r[i] != NULL; ++i)
8069       free (r[i]);
8070     free (r);
8071   }
8072   return 0;
8073 }
8074
8075 static int test_command_lines_9_skip (void)
8076 {
8077   const char *str;
8078
8079   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8080   if (str && strcmp (str, "1") == 0) return 1;
8081   str = getenv ("SKIP_TEST_COMMAND_LINES");
8082   if (str && strcmp (str, "1") == 0) return 1;
8083   return 0;
8084 }
8085
8086 static int test_command_lines_9 (void)
8087 {
8088   if (test_command_lines_9_skip ()) {
8089     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8090     return 0;
8091   }
8092
8093   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8094   {
8095     char device[] = "/dev/sda";
8096     device[5] = devchar;
8097     int r;
8098     suppress_error = 0;
8099     r = guestfs_blockdev_setrw (g, device);
8100     if (r == -1)
8101       return -1;
8102   }
8103   {
8104     int r;
8105     suppress_error = 0;
8106     r = guestfs_umount_all (g);
8107     if (r == -1)
8108       return -1;
8109   }
8110   {
8111     int r;
8112     suppress_error = 0;
8113     r = guestfs_lvm_remove_all (g);
8114     if (r == -1)
8115       return -1;
8116   }
8117   {
8118     char device[] = "/dev/sda";
8119     device[5] = devchar;
8120     char lines_0[] = ",";
8121     char *lines[] = {
8122       lines_0,
8123       NULL
8124     };
8125     int r;
8126     suppress_error = 0;
8127     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8128     if (r == -1)
8129       return -1;
8130   }
8131   {
8132     char fstype[] = "ext2";
8133     char device[] = "/dev/sda1";
8134     device[5] = devchar;
8135     int r;
8136     suppress_error = 0;
8137     r = guestfs_mkfs (g, fstype, device);
8138     if (r == -1)
8139       return -1;
8140   }
8141   {
8142     char device[] = "/dev/sda1";
8143     device[5] = devchar;
8144     char mountpoint[] = "/";
8145     int r;
8146     suppress_error = 0;
8147     r = guestfs_mount (g, device, mountpoint);
8148     if (r == -1)
8149       return -1;
8150   }
8151   /* TestOutputList for command_lines (9) */
8152   {
8153     char remotefilename[] = "/test-command";
8154     int r;
8155     suppress_error = 0;
8156     r = guestfs_upload (g, "test-command", remotefilename);
8157     if (r == -1)
8158       return -1;
8159   }
8160   {
8161     char path[] = "/test-command";
8162     int r;
8163     suppress_error = 0;
8164     r = guestfs_chmod (g, 493, path);
8165     if (r == -1)
8166       return -1;
8167   }
8168   {
8169     char arguments_0[] = "/test-command";
8170     char arguments_1[] = "10";
8171     char *arguments[] = {
8172       arguments_0,
8173       arguments_1,
8174       NULL
8175     };
8176     char **r;
8177     int i;
8178     suppress_error = 0;
8179     r = guestfs_command_lines (g, arguments);
8180     if (r == NULL)
8181       return -1;
8182     if (!r[0]) {
8183       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8184       print_strings (r);
8185       return -1;
8186     }
8187     {
8188       char expected[] = "Result10-1";
8189       if (strcmp (r[0], expected) != 0) {
8190         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8191         return -1;
8192       }
8193     }
8194     if (!r[1]) {
8195       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8196       print_strings (r);
8197       return -1;
8198     }
8199     {
8200       char expected[] = "Result10-2";
8201       if (strcmp (r[1], expected) != 0) {
8202         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8203         return -1;
8204       }
8205     }
8206     if (r[2] != NULL) {
8207       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8208       print_strings (r);
8209       return -1;
8210     }
8211     for (i = 0; r[i] != NULL; ++i)
8212       free (r[i]);
8213     free (r);
8214   }
8215   return 0;
8216 }
8217
8218 static int test_command_lines_10_skip (void)
8219 {
8220   const char *str;
8221
8222   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8223   if (str && strcmp (str, "1") == 0) return 1;
8224   str = getenv ("SKIP_TEST_COMMAND_LINES");
8225   if (str && strcmp (str, "1") == 0) return 1;
8226   return 0;
8227 }
8228
8229 static int test_command_lines_10 (void)
8230 {
8231   if (test_command_lines_10_skip ()) {
8232     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8233     return 0;
8234   }
8235
8236   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8237   {
8238     char device[] = "/dev/sda";
8239     device[5] = devchar;
8240     int r;
8241     suppress_error = 0;
8242     r = guestfs_blockdev_setrw (g, device);
8243     if (r == -1)
8244       return -1;
8245   }
8246   {
8247     int r;
8248     suppress_error = 0;
8249     r = guestfs_umount_all (g);
8250     if (r == -1)
8251       return -1;
8252   }
8253   {
8254     int r;
8255     suppress_error = 0;
8256     r = guestfs_lvm_remove_all (g);
8257     if (r == -1)
8258       return -1;
8259   }
8260   {
8261     char device[] = "/dev/sda";
8262     device[5] = devchar;
8263     char lines_0[] = ",";
8264     char *lines[] = {
8265       lines_0,
8266       NULL
8267     };
8268     int r;
8269     suppress_error = 0;
8270     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8271     if (r == -1)
8272       return -1;
8273   }
8274   {
8275     char fstype[] = "ext2";
8276     char device[] = "/dev/sda1";
8277     device[5] = devchar;
8278     int r;
8279     suppress_error = 0;
8280     r = guestfs_mkfs (g, fstype, device);
8281     if (r == -1)
8282       return -1;
8283   }
8284   {
8285     char device[] = "/dev/sda1";
8286     device[5] = devchar;
8287     char mountpoint[] = "/";
8288     int r;
8289     suppress_error = 0;
8290     r = guestfs_mount (g, device, mountpoint);
8291     if (r == -1)
8292       return -1;
8293   }
8294   /* TestOutputList for command_lines (10) */
8295   {
8296     char remotefilename[] = "/test-command";
8297     int r;
8298     suppress_error = 0;
8299     r = guestfs_upload (g, "test-command", remotefilename);
8300     if (r == -1)
8301       return -1;
8302   }
8303   {
8304     char path[] = "/test-command";
8305     int r;
8306     suppress_error = 0;
8307     r = guestfs_chmod (g, 493, path);
8308     if (r == -1)
8309       return -1;
8310   }
8311   {
8312     char arguments_0[] = "/test-command";
8313     char arguments_1[] = "11";
8314     char *arguments[] = {
8315       arguments_0,
8316       arguments_1,
8317       NULL
8318     };
8319     char **r;
8320     int i;
8321     suppress_error = 0;
8322     r = guestfs_command_lines (g, arguments);
8323     if (r == NULL)
8324       return -1;
8325     if (!r[0]) {
8326       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8327       print_strings (r);
8328       return -1;
8329     }
8330     {
8331       char expected[] = "Result11-1";
8332       if (strcmp (r[0], expected) != 0) {
8333         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8334         return -1;
8335       }
8336     }
8337     if (!r[1]) {
8338       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8339       print_strings (r);
8340       return -1;
8341     }
8342     {
8343       char expected[] = "Result11-2";
8344       if (strcmp (r[1], expected) != 0) {
8345         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8346         return -1;
8347       }
8348     }
8349     if (r[2] != NULL) {
8350       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8351       print_strings (r);
8352       return -1;
8353     }
8354     for (i = 0; r[i] != NULL; ++i)
8355       free (r[i]);
8356     free (r);
8357   }
8358   return 0;
8359 }
8360
8361 static int test_command_0_skip (void)
8362 {
8363   const char *str;
8364
8365   str = getenv ("SKIP_TEST_COMMAND_0");
8366   if (str && strcmp (str, "1") == 0) return 1;
8367   str = getenv ("SKIP_TEST_COMMAND");
8368   if (str && strcmp (str, "1") == 0) return 1;
8369   return 0;
8370 }
8371
8372 static int test_command_0 (void)
8373 {
8374   if (test_command_0_skip ()) {
8375     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8376     return 0;
8377   }
8378
8379   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8380   {
8381     char device[] = "/dev/sda";
8382     device[5] = devchar;
8383     int r;
8384     suppress_error = 0;
8385     r = guestfs_blockdev_setrw (g, device);
8386     if (r == -1)
8387       return -1;
8388   }
8389   {
8390     int r;
8391     suppress_error = 0;
8392     r = guestfs_umount_all (g);
8393     if (r == -1)
8394       return -1;
8395   }
8396   {
8397     int r;
8398     suppress_error = 0;
8399     r = guestfs_lvm_remove_all (g);
8400     if (r == -1)
8401       return -1;
8402   }
8403   {
8404     char device[] = "/dev/sda";
8405     device[5] = devchar;
8406     char lines_0[] = ",";
8407     char *lines[] = {
8408       lines_0,
8409       NULL
8410     };
8411     int r;
8412     suppress_error = 0;
8413     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8414     if (r == -1)
8415       return -1;
8416   }
8417   {
8418     char fstype[] = "ext2";
8419     char device[] = "/dev/sda1";
8420     device[5] = devchar;
8421     int r;
8422     suppress_error = 0;
8423     r = guestfs_mkfs (g, fstype, device);
8424     if (r == -1)
8425       return -1;
8426   }
8427   {
8428     char device[] = "/dev/sda1";
8429     device[5] = devchar;
8430     char mountpoint[] = "/";
8431     int r;
8432     suppress_error = 0;
8433     r = guestfs_mount (g, device, mountpoint);
8434     if (r == -1)
8435       return -1;
8436   }
8437   /* TestOutput for command (0) */
8438   char expected[] = "Result1";
8439   {
8440     char remotefilename[] = "/test-command";
8441     int r;
8442     suppress_error = 0;
8443     r = guestfs_upload (g, "test-command", remotefilename);
8444     if (r == -1)
8445       return -1;
8446   }
8447   {
8448     char path[] = "/test-command";
8449     int r;
8450     suppress_error = 0;
8451     r = guestfs_chmod (g, 493, path);
8452     if (r == -1)
8453       return -1;
8454   }
8455   {
8456     char arguments_0[] = "/test-command";
8457     char arguments_1[] = "1";
8458     char *arguments[] = {
8459       arguments_0,
8460       arguments_1,
8461       NULL
8462     };
8463     char *r;
8464     suppress_error = 0;
8465     r = guestfs_command (g, arguments);
8466     if (r == NULL)
8467       return -1;
8468     if (strcmp (r, expected) != 0) {
8469       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8470       return -1;
8471     }
8472     free (r);
8473   }
8474   return 0;
8475 }
8476
8477 static int test_command_1_skip (void)
8478 {
8479   const char *str;
8480
8481   str = getenv ("SKIP_TEST_COMMAND_1");
8482   if (str && strcmp (str, "1") == 0) return 1;
8483   str = getenv ("SKIP_TEST_COMMAND");
8484   if (str && strcmp (str, "1") == 0) return 1;
8485   return 0;
8486 }
8487
8488 static int test_command_1 (void)
8489 {
8490   if (test_command_1_skip ()) {
8491     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8492     return 0;
8493   }
8494
8495   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8496   {
8497     char device[] = "/dev/sda";
8498     device[5] = devchar;
8499     int r;
8500     suppress_error = 0;
8501     r = guestfs_blockdev_setrw (g, device);
8502     if (r == -1)
8503       return -1;
8504   }
8505   {
8506     int r;
8507     suppress_error = 0;
8508     r = guestfs_umount_all (g);
8509     if (r == -1)
8510       return -1;
8511   }
8512   {
8513     int r;
8514     suppress_error = 0;
8515     r = guestfs_lvm_remove_all (g);
8516     if (r == -1)
8517       return -1;
8518   }
8519   {
8520     char device[] = "/dev/sda";
8521     device[5] = devchar;
8522     char lines_0[] = ",";
8523     char *lines[] = {
8524       lines_0,
8525       NULL
8526     };
8527     int r;
8528     suppress_error = 0;
8529     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8530     if (r == -1)
8531       return -1;
8532   }
8533   {
8534     char fstype[] = "ext2";
8535     char device[] = "/dev/sda1";
8536     device[5] = devchar;
8537     int r;
8538     suppress_error = 0;
8539     r = guestfs_mkfs (g, fstype, device);
8540     if (r == -1)
8541       return -1;
8542   }
8543   {
8544     char device[] = "/dev/sda1";
8545     device[5] = devchar;
8546     char mountpoint[] = "/";
8547     int r;
8548     suppress_error = 0;
8549     r = guestfs_mount (g, device, mountpoint);
8550     if (r == -1)
8551       return -1;
8552   }
8553   /* TestOutput for command (1) */
8554   char expected[] = "Result2\n";
8555   {
8556     char remotefilename[] = "/test-command";
8557     int r;
8558     suppress_error = 0;
8559     r = guestfs_upload (g, "test-command", remotefilename);
8560     if (r == -1)
8561       return -1;
8562   }
8563   {
8564     char path[] = "/test-command";
8565     int r;
8566     suppress_error = 0;
8567     r = guestfs_chmod (g, 493, path);
8568     if (r == -1)
8569       return -1;
8570   }
8571   {
8572     char arguments_0[] = "/test-command";
8573     char arguments_1[] = "2";
8574     char *arguments[] = {
8575       arguments_0,
8576       arguments_1,
8577       NULL
8578     };
8579     char *r;
8580     suppress_error = 0;
8581     r = guestfs_command (g, arguments);
8582     if (r == NULL)
8583       return -1;
8584     if (strcmp (r, expected) != 0) {
8585       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8586       return -1;
8587     }
8588     free (r);
8589   }
8590   return 0;
8591 }
8592
8593 static int test_command_2_skip (void)
8594 {
8595   const char *str;
8596
8597   str = getenv ("SKIP_TEST_COMMAND_2");
8598   if (str && strcmp (str, "1") == 0) return 1;
8599   str = getenv ("SKIP_TEST_COMMAND");
8600   if (str && strcmp (str, "1") == 0) return 1;
8601   return 0;
8602 }
8603
8604 static int test_command_2 (void)
8605 {
8606   if (test_command_2_skip ()) {
8607     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8608     return 0;
8609   }
8610
8611   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8612   {
8613     char device[] = "/dev/sda";
8614     device[5] = devchar;
8615     int r;
8616     suppress_error = 0;
8617     r = guestfs_blockdev_setrw (g, device);
8618     if (r == -1)
8619       return -1;
8620   }
8621   {
8622     int r;
8623     suppress_error = 0;
8624     r = guestfs_umount_all (g);
8625     if (r == -1)
8626       return -1;
8627   }
8628   {
8629     int r;
8630     suppress_error = 0;
8631     r = guestfs_lvm_remove_all (g);
8632     if (r == -1)
8633       return -1;
8634   }
8635   {
8636     char device[] = "/dev/sda";
8637     device[5] = devchar;
8638     char lines_0[] = ",";
8639     char *lines[] = {
8640       lines_0,
8641       NULL
8642     };
8643     int r;
8644     suppress_error = 0;
8645     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8646     if (r == -1)
8647       return -1;
8648   }
8649   {
8650     char fstype[] = "ext2";
8651     char device[] = "/dev/sda1";
8652     device[5] = devchar;
8653     int r;
8654     suppress_error = 0;
8655     r = guestfs_mkfs (g, fstype, device);
8656     if (r == -1)
8657       return -1;
8658   }
8659   {
8660     char device[] = "/dev/sda1";
8661     device[5] = devchar;
8662     char mountpoint[] = "/";
8663     int r;
8664     suppress_error = 0;
8665     r = guestfs_mount (g, device, mountpoint);
8666     if (r == -1)
8667       return -1;
8668   }
8669   /* TestOutput for command (2) */
8670   char expected[] = "\nResult3";
8671   {
8672     char remotefilename[] = "/test-command";
8673     int r;
8674     suppress_error = 0;
8675     r = guestfs_upload (g, "test-command", remotefilename);
8676     if (r == -1)
8677       return -1;
8678   }
8679   {
8680     char path[] = "/test-command";
8681     int r;
8682     suppress_error = 0;
8683     r = guestfs_chmod (g, 493, path);
8684     if (r == -1)
8685       return -1;
8686   }
8687   {
8688     char arguments_0[] = "/test-command";
8689     char arguments_1[] = "3";
8690     char *arguments[] = {
8691       arguments_0,
8692       arguments_1,
8693       NULL
8694     };
8695     char *r;
8696     suppress_error = 0;
8697     r = guestfs_command (g, arguments);
8698     if (r == NULL)
8699       return -1;
8700     if (strcmp (r, expected) != 0) {
8701       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8702       return -1;
8703     }
8704     free (r);
8705   }
8706   return 0;
8707 }
8708
8709 static int test_command_3_skip (void)
8710 {
8711   const char *str;
8712
8713   str = getenv ("SKIP_TEST_COMMAND_3");
8714   if (str && strcmp (str, "1") == 0) return 1;
8715   str = getenv ("SKIP_TEST_COMMAND");
8716   if (str && strcmp (str, "1") == 0) return 1;
8717   return 0;
8718 }
8719
8720 static int test_command_3 (void)
8721 {
8722   if (test_command_3_skip ()) {
8723     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8724     return 0;
8725   }
8726
8727   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8728   {
8729     char device[] = "/dev/sda";
8730     device[5] = devchar;
8731     int r;
8732     suppress_error = 0;
8733     r = guestfs_blockdev_setrw (g, device);
8734     if (r == -1)
8735       return -1;
8736   }
8737   {
8738     int r;
8739     suppress_error = 0;
8740     r = guestfs_umount_all (g);
8741     if (r == -1)
8742       return -1;
8743   }
8744   {
8745     int r;
8746     suppress_error = 0;
8747     r = guestfs_lvm_remove_all (g);
8748     if (r == -1)
8749       return -1;
8750   }
8751   {
8752     char device[] = "/dev/sda";
8753     device[5] = devchar;
8754     char lines_0[] = ",";
8755     char *lines[] = {
8756       lines_0,
8757       NULL
8758     };
8759     int r;
8760     suppress_error = 0;
8761     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8762     if (r == -1)
8763       return -1;
8764   }
8765   {
8766     char fstype[] = "ext2";
8767     char device[] = "/dev/sda1";
8768     device[5] = devchar;
8769     int r;
8770     suppress_error = 0;
8771     r = guestfs_mkfs (g, fstype, device);
8772     if (r == -1)
8773       return -1;
8774   }
8775   {
8776     char device[] = "/dev/sda1";
8777     device[5] = devchar;
8778     char mountpoint[] = "/";
8779     int r;
8780     suppress_error = 0;
8781     r = guestfs_mount (g, device, mountpoint);
8782     if (r == -1)
8783       return -1;
8784   }
8785   /* TestOutput for command (3) */
8786   char expected[] = "\nResult4\n";
8787   {
8788     char remotefilename[] = "/test-command";
8789     int r;
8790     suppress_error = 0;
8791     r = guestfs_upload (g, "test-command", remotefilename);
8792     if (r == -1)
8793       return -1;
8794   }
8795   {
8796     char path[] = "/test-command";
8797     int r;
8798     suppress_error = 0;
8799     r = guestfs_chmod (g, 493, path);
8800     if (r == -1)
8801       return -1;
8802   }
8803   {
8804     char arguments_0[] = "/test-command";
8805     char arguments_1[] = "4";
8806     char *arguments[] = {
8807       arguments_0,
8808       arguments_1,
8809       NULL
8810     };
8811     char *r;
8812     suppress_error = 0;
8813     r = guestfs_command (g, arguments);
8814     if (r == NULL)
8815       return -1;
8816     if (strcmp (r, expected) != 0) {
8817       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8818       return -1;
8819     }
8820     free (r);
8821   }
8822   return 0;
8823 }
8824
8825 static int test_command_4_skip (void)
8826 {
8827   const char *str;
8828
8829   str = getenv ("SKIP_TEST_COMMAND_4");
8830   if (str && strcmp (str, "1") == 0) return 1;
8831   str = getenv ("SKIP_TEST_COMMAND");
8832   if (str && strcmp (str, "1") == 0) return 1;
8833   return 0;
8834 }
8835
8836 static int test_command_4 (void)
8837 {
8838   if (test_command_4_skip ()) {
8839     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8840     return 0;
8841   }
8842
8843   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8844   {
8845     char device[] = "/dev/sda";
8846     device[5] = devchar;
8847     int r;
8848     suppress_error = 0;
8849     r = guestfs_blockdev_setrw (g, device);
8850     if (r == -1)
8851       return -1;
8852   }
8853   {
8854     int r;
8855     suppress_error = 0;
8856     r = guestfs_umount_all (g);
8857     if (r == -1)
8858       return -1;
8859   }
8860   {
8861     int r;
8862     suppress_error = 0;
8863     r = guestfs_lvm_remove_all (g);
8864     if (r == -1)
8865       return -1;
8866   }
8867   {
8868     char device[] = "/dev/sda";
8869     device[5] = devchar;
8870     char lines_0[] = ",";
8871     char *lines[] = {
8872       lines_0,
8873       NULL
8874     };
8875     int r;
8876     suppress_error = 0;
8877     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8878     if (r == -1)
8879       return -1;
8880   }
8881   {
8882     char fstype[] = "ext2";
8883     char device[] = "/dev/sda1";
8884     device[5] = devchar;
8885     int r;
8886     suppress_error = 0;
8887     r = guestfs_mkfs (g, fstype, device);
8888     if (r == -1)
8889       return -1;
8890   }
8891   {
8892     char device[] = "/dev/sda1";
8893     device[5] = devchar;
8894     char mountpoint[] = "/";
8895     int r;
8896     suppress_error = 0;
8897     r = guestfs_mount (g, device, mountpoint);
8898     if (r == -1)
8899       return -1;
8900   }
8901   /* TestOutput for command (4) */
8902   char expected[] = "\nResult5\n\n";
8903   {
8904     char remotefilename[] = "/test-command";
8905     int r;
8906     suppress_error = 0;
8907     r = guestfs_upload (g, "test-command", remotefilename);
8908     if (r == -1)
8909       return -1;
8910   }
8911   {
8912     char path[] = "/test-command";
8913     int r;
8914     suppress_error = 0;
8915     r = guestfs_chmod (g, 493, path);
8916     if (r == -1)
8917       return -1;
8918   }
8919   {
8920     char arguments_0[] = "/test-command";
8921     char arguments_1[] = "5";
8922     char *arguments[] = {
8923       arguments_0,
8924       arguments_1,
8925       NULL
8926     };
8927     char *r;
8928     suppress_error = 0;
8929     r = guestfs_command (g, arguments);
8930     if (r == NULL)
8931       return -1;
8932     if (strcmp (r, expected) != 0) {
8933       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
8934       return -1;
8935     }
8936     free (r);
8937   }
8938   return 0;
8939 }
8940
8941 static int test_command_5_skip (void)
8942 {
8943   const char *str;
8944
8945   str = getenv ("SKIP_TEST_COMMAND_5");
8946   if (str && strcmp (str, "1") == 0) return 1;
8947   str = getenv ("SKIP_TEST_COMMAND");
8948   if (str && strcmp (str, "1") == 0) return 1;
8949   return 0;
8950 }
8951
8952 static int test_command_5 (void)
8953 {
8954   if (test_command_5_skip ()) {
8955     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
8956     return 0;
8957   }
8958
8959   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
8960   {
8961     char device[] = "/dev/sda";
8962     device[5] = devchar;
8963     int r;
8964     suppress_error = 0;
8965     r = guestfs_blockdev_setrw (g, device);
8966     if (r == -1)
8967       return -1;
8968   }
8969   {
8970     int r;
8971     suppress_error = 0;
8972     r = guestfs_umount_all (g);
8973     if (r == -1)
8974       return -1;
8975   }
8976   {
8977     int r;
8978     suppress_error = 0;
8979     r = guestfs_lvm_remove_all (g);
8980     if (r == -1)
8981       return -1;
8982   }
8983   {
8984     char device[] = "/dev/sda";
8985     device[5] = devchar;
8986     char lines_0[] = ",";
8987     char *lines[] = {
8988       lines_0,
8989       NULL
8990     };
8991     int r;
8992     suppress_error = 0;
8993     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8994     if (r == -1)
8995       return -1;
8996   }
8997   {
8998     char fstype[] = "ext2";
8999     char device[] = "/dev/sda1";
9000     device[5] = devchar;
9001     int r;
9002     suppress_error = 0;
9003     r = guestfs_mkfs (g, fstype, device);
9004     if (r == -1)
9005       return -1;
9006   }
9007   {
9008     char device[] = "/dev/sda1";
9009     device[5] = devchar;
9010     char mountpoint[] = "/";
9011     int r;
9012     suppress_error = 0;
9013     r = guestfs_mount (g, device, mountpoint);
9014     if (r == -1)
9015       return -1;
9016   }
9017   /* TestOutput for command (5) */
9018   char expected[] = "\n\nResult6\n\n";
9019   {
9020     char remotefilename[] = "/test-command";
9021     int r;
9022     suppress_error = 0;
9023     r = guestfs_upload (g, "test-command", remotefilename);
9024     if (r == -1)
9025       return -1;
9026   }
9027   {
9028     char path[] = "/test-command";
9029     int r;
9030     suppress_error = 0;
9031     r = guestfs_chmod (g, 493, path);
9032     if (r == -1)
9033       return -1;
9034   }
9035   {
9036     char arguments_0[] = "/test-command";
9037     char arguments_1[] = "6";
9038     char *arguments[] = {
9039       arguments_0,
9040       arguments_1,
9041       NULL
9042     };
9043     char *r;
9044     suppress_error = 0;
9045     r = guestfs_command (g, arguments);
9046     if (r == NULL)
9047       return -1;
9048     if (strcmp (r, expected) != 0) {
9049       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9050       return -1;
9051     }
9052     free (r);
9053   }
9054   return 0;
9055 }
9056
9057 static int test_command_6_skip (void)
9058 {
9059   const char *str;
9060
9061   str = getenv ("SKIP_TEST_COMMAND_6");
9062   if (str && strcmp (str, "1") == 0) return 1;
9063   str = getenv ("SKIP_TEST_COMMAND");
9064   if (str && strcmp (str, "1") == 0) return 1;
9065   return 0;
9066 }
9067
9068 static int test_command_6 (void)
9069 {
9070   if (test_command_6_skip ()) {
9071     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9072     return 0;
9073   }
9074
9075   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9076   {
9077     char device[] = "/dev/sda";
9078     device[5] = devchar;
9079     int r;
9080     suppress_error = 0;
9081     r = guestfs_blockdev_setrw (g, device);
9082     if (r == -1)
9083       return -1;
9084   }
9085   {
9086     int r;
9087     suppress_error = 0;
9088     r = guestfs_umount_all (g);
9089     if (r == -1)
9090       return -1;
9091   }
9092   {
9093     int r;
9094     suppress_error = 0;
9095     r = guestfs_lvm_remove_all (g);
9096     if (r == -1)
9097       return -1;
9098   }
9099   {
9100     char device[] = "/dev/sda";
9101     device[5] = devchar;
9102     char lines_0[] = ",";
9103     char *lines[] = {
9104       lines_0,
9105       NULL
9106     };
9107     int r;
9108     suppress_error = 0;
9109     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9110     if (r == -1)
9111       return -1;
9112   }
9113   {
9114     char fstype[] = "ext2";
9115     char device[] = "/dev/sda1";
9116     device[5] = devchar;
9117     int r;
9118     suppress_error = 0;
9119     r = guestfs_mkfs (g, fstype, device);
9120     if (r == -1)
9121       return -1;
9122   }
9123   {
9124     char device[] = "/dev/sda1";
9125     device[5] = devchar;
9126     char mountpoint[] = "/";
9127     int r;
9128     suppress_error = 0;
9129     r = guestfs_mount (g, device, mountpoint);
9130     if (r == -1)
9131       return -1;
9132   }
9133   /* TestOutput for command (6) */
9134   char expected[] = "";
9135   {
9136     char remotefilename[] = "/test-command";
9137     int r;
9138     suppress_error = 0;
9139     r = guestfs_upload (g, "test-command", remotefilename);
9140     if (r == -1)
9141       return -1;
9142   }
9143   {
9144     char path[] = "/test-command";
9145     int r;
9146     suppress_error = 0;
9147     r = guestfs_chmod (g, 493, path);
9148     if (r == -1)
9149       return -1;
9150   }
9151   {
9152     char arguments_0[] = "/test-command";
9153     char arguments_1[] = "7";
9154     char *arguments[] = {
9155       arguments_0,
9156       arguments_1,
9157       NULL
9158     };
9159     char *r;
9160     suppress_error = 0;
9161     r = guestfs_command (g, arguments);
9162     if (r == NULL)
9163       return -1;
9164     if (strcmp (r, expected) != 0) {
9165       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9166       return -1;
9167     }
9168     free (r);
9169   }
9170   return 0;
9171 }
9172
9173 static int test_command_7_skip (void)
9174 {
9175   const char *str;
9176
9177   str = getenv ("SKIP_TEST_COMMAND_7");
9178   if (str && strcmp (str, "1") == 0) return 1;
9179   str = getenv ("SKIP_TEST_COMMAND");
9180   if (str && strcmp (str, "1") == 0) return 1;
9181   return 0;
9182 }
9183
9184 static int test_command_7 (void)
9185 {
9186   if (test_command_7_skip ()) {
9187     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9188     return 0;
9189   }
9190
9191   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9192   {
9193     char device[] = "/dev/sda";
9194     device[5] = devchar;
9195     int r;
9196     suppress_error = 0;
9197     r = guestfs_blockdev_setrw (g, device);
9198     if (r == -1)
9199       return -1;
9200   }
9201   {
9202     int r;
9203     suppress_error = 0;
9204     r = guestfs_umount_all (g);
9205     if (r == -1)
9206       return -1;
9207   }
9208   {
9209     int r;
9210     suppress_error = 0;
9211     r = guestfs_lvm_remove_all (g);
9212     if (r == -1)
9213       return -1;
9214   }
9215   {
9216     char device[] = "/dev/sda";
9217     device[5] = devchar;
9218     char lines_0[] = ",";
9219     char *lines[] = {
9220       lines_0,
9221       NULL
9222     };
9223     int r;
9224     suppress_error = 0;
9225     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9226     if (r == -1)
9227       return -1;
9228   }
9229   {
9230     char fstype[] = "ext2";
9231     char device[] = "/dev/sda1";
9232     device[5] = devchar;
9233     int r;
9234     suppress_error = 0;
9235     r = guestfs_mkfs (g, fstype, device);
9236     if (r == -1)
9237       return -1;
9238   }
9239   {
9240     char device[] = "/dev/sda1";
9241     device[5] = devchar;
9242     char mountpoint[] = "/";
9243     int r;
9244     suppress_error = 0;
9245     r = guestfs_mount (g, device, mountpoint);
9246     if (r == -1)
9247       return -1;
9248   }
9249   /* TestOutput for command (7) */
9250   char expected[] = "\n";
9251   {
9252     char remotefilename[] = "/test-command";
9253     int r;
9254     suppress_error = 0;
9255     r = guestfs_upload (g, "test-command", remotefilename);
9256     if (r == -1)
9257       return -1;
9258   }
9259   {
9260     char path[] = "/test-command";
9261     int r;
9262     suppress_error = 0;
9263     r = guestfs_chmod (g, 493, path);
9264     if (r == -1)
9265       return -1;
9266   }
9267   {
9268     char arguments_0[] = "/test-command";
9269     char arguments_1[] = "8";
9270     char *arguments[] = {
9271       arguments_0,
9272       arguments_1,
9273       NULL
9274     };
9275     char *r;
9276     suppress_error = 0;
9277     r = guestfs_command (g, arguments);
9278     if (r == NULL)
9279       return -1;
9280     if (strcmp (r, expected) != 0) {
9281       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9282       return -1;
9283     }
9284     free (r);
9285   }
9286   return 0;
9287 }
9288
9289 static int test_command_8_skip (void)
9290 {
9291   const char *str;
9292
9293   str = getenv ("SKIP_TEST_COMMAND_8");
9294   if (str && strcmp (str, "1") == 0) return 1;
9295   str = getenv ("SKIP_TEST_COMMAND");
9296   if (str && strcmp (str, "1") == 0) return 1;
9297   return 0;
9298 }
9299
9300 static int test_command_8 (void)
9301 {
9302   if (test_command_8_skip ()) {
9303     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9304     return 0;
9305   }
9306
9307   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9308   {
9309     char device[] = "/dev/sda";
9310     device[5] = devchar;
9311     int r;
9312     suppress_error = 0;
9313     r = guestfs_blockdev_setrw (g, device);
9314     if (r == -1)
9315       return -1;
9316   }
9317   {
9318     int r;
9319     suppress_error = 0;
9320     r = guestfs_umount_all (g);
9321     if (r == -1)
9322       return -1;
9323   }
9324   {
9325     int r;
9326     suppress_error = 0;
9327     r = guestfs_lvm_remove_all (g);
9328     if (r == -1)
9329       return -1;
9330   }
9331   {
9332     char device[] = "/dev/sda";
9333     device[5] = devchar;
9334     char lines_0[] = ",";
9335     char *lines[] = {
9336       lines_0,
9337       NULL
9338     };
9339     int r;
9340     suppress_error = 0;
9341     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9342     if (r == -1)
9343       return -1;
9344   }
9345   {
9346     char fstype[] = "ext2";
9347     char device[] = "/dev/sda1";
9348     device[5] = devchar;
9349     int r;
9350     suppress_error = 0;
9351     r = guestfs_mkfs (g, fstype, device);
9352     if (r == -1)
9353       return -1;
9354   }
9355   {
9356     char device[] = "/dev/sda1";
9357     device[5] = devchar;
9358     char mountpoint[] = "/";
9359     int r;
9360     suppress_error = 0;
9361     r = guestfs_mount (g, device, mountpoint);
9362     if (r == -1)
9363       return -1;
9364   }
9365   /* TestOutput for command (8) */
9366   char expected[] = "\n\n";
9367   {
9368     char remotefilename[] = "/test-command";
9369     int r;
9370     suppress_error = 0;
9371     r = guestfs_upload (g, "test-command", remotefilename);
9372     if (r == -1)
9373       return -1;
9374   }
9375   {
9376     char path[] = "/test-command";
9377     int r;
9378     suppress_error = 0;
9379     r = guestfs_chmod (g, 493, path);
9380     if (r == -1)
9381       return -1;
9382   }
9383   {
9384     char arguments_0[] = "/test-command";
9385     char arguments_1[] = "9";
9386     char *arguments[] = {
9387       arguments_0,
9388       arguments_1,
9389       NULL
9390     };
9391     char *r;
9392     suppress_error = 0;
9393     r = guestfs_command (g, arguments);
9394     if (r == NULL)
9395       return -1;
9396     if (strcmp (r, expected) != 0) {
9397       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9398       return -1;
9399     }
9400     free (r);
9401   }
9402   return 0;
9403 }
9404
9405 static int test_command_9_skip (void)
9406 {
9407   const char *str;
9408
9409   str = getenv ("SKIP_TEST_COMMAND_9");
9410   if (str && strcmp (str, "1") == 0) return 1;
9411   str = getenv ("SKIP_TEST_COMMAND");
9412   if (str && strcmp (str, "1") == 0) return 1;
9413   return 0;
9414 }
9415
9416 static int test_command_9 (void)
9417 {
9418   if (test_command_9_skip ()) {
9419     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9420     return 0;
9421   }
9422
9423   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9424   {
9425     char device[] = "/dev/sda";
9426     device[5] = devchar;
9427     int r;
9428     suppress_error = 0;
9429     r = guestfs_blockdev_setrw (g, device);
9430     if (r == -1)
9431       return -1;
9432   }
9433   {
9434     int r;
9435     suppress_error = 0;
9436     r = guestfs_umount_all (g);
9437     if (r == -1)
9438       return -1;
9439   }
9440   {
9441     int r;
9442     suppress_error = 0;
9443     r = guestfs_lvm_remove_all (g);
9444     if (r == -1)
9445       return -1;
9446   }
9447   {
9448     char device[] = "/dev/sda";
9449     device[5] = devchar;
9450     char lines_0[] = ",";
9451     char *lines[] = {
9452       lines_0,
9453       NULL
9454     };
9455     int r;
9456     suppress_error = 0;
9457     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9458     if (r == -1)
9459       return -1;
9460   }
9461   {
9462     char fstype[] = "ext2";
9463     char device[] = "/dev/sda1";
9464     device[5] = devchar;
9465     int r;
9466     suppress_error = 0;
9467     r = guestfs_mkfs (g, fstype, device);
9468     if (r == -1)
9469       return -1;
9470   }
9471   {
9472     char device[] = "/dev/sda1";
9473     device[5] = devchar;
9474     char mountpoint[] = "/";
9475     int r;
9476     suppress_error = 0;
9477     r = guestfs_mount (g, device, mountpoint);
9478     if (r == -1)
9479       return -1;
9480   }
9481   /* TestOutput for command (9) */
9482   char expected[] = "Result10-1\nResult10-2\n";
9483   {
9484     char remotefilename[] = "/test-command";
9485     int r;
9486     suppress_error = 0;
9487     r = guestfs_upload (g, "test-command", remotefilename);
9488     if (r == -1)
9489       return -1;
9490   }
9491   {
9492     char path[] = "/test-command";
9493     int r;
9494     suppress_error = 0;
9495     r = guestfs_chmod (g, 493, path);
9496     if (r == -1)
9497       return -1;
9498   }
9499   {
9500     char arguments_0[] = "/test-command";
9501     char arguments_1[] = "10";
9502     char *arguments[] = {
9503       arguments_0,
9504       arguments_1,
9505       NULL
9506     };
9507     char *r;
9508     suppress_error = 0;
9509     r = guestfs_command (g, arguments);
9510     if (r == NULL)
9511       return -1;
9512     if (strcmp (r, expected) != 0) {
9513       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9514       return -1;
9515     }
9516     free (r);
9517   }
9518   return 0;
9519 }
9520
9521 static int test_command_10_skip (void)
9522 {
9523   const char *str;
9524
9525   str = getenv ("SKIP_TEST_COMMAND_10");
9526   if (str && strcmp (str, "1") == 0) return 1;
9527   str = getenv ("SKIP_TEST_COMMAND");
9528   if (str && strcmp (str, "1") == 0) return 1;
9529   return 0;
9530 }
9531
9532 static int test_command_10 (void)
9533 {
9534   if (test_command_10_skip ()) {
9535     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9536     return 0;
9537   }
9538
9539   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9540   {
9541     char device[] = "/dev/sda";
9542     device[5] = devchar;
9543     int r;
9544     suppress_error = 0;
9545     r = guestfs_blockdev_setrw (g, device);
9546     if (r == -1)
9547       return -1;
9548   }
9549   {
9550     int r;
9551     suppress_error = 0;
9552     r = guestfs_umount_all (g);
9553     if (r == -1)
9554       return -1;
9555   }
9556   {
9557     int r;
9558     suppress_error = 0;
9559     r = guestfs_lvm_remove_all (g);
9560     if (r == -1)
9561       return -1;
9562   }
9563   {
9564     char device[] = "/dev/sda";
9565     device[5] = devchar;
9566     char lines_0[] = ",";
9567     char *lines[] = {
9568       lines_0,
9569       NULL
9570     };
9571     int r;
9572     suppress_error = 0;
9573     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9574     if (r == -1)
9575       return -1;
9576   }
9577   {
9578     char fstype[] = "ext2";
9579     char device[] = "/dev/sda1";
9580     device[5] = devchar;
9581     int r;
9582     suppress_error = 0;
9583     r = guestfs_mkfs (g, fstype, device);
9584     if (r == -1)
9585       return -1;
9586   }
9587   {
9588     char device[] = "/dev/sda1";
9589     device[5] = devchar;
9590     char mountpoint[] = "/";
9591     int r;
9592     suppress_error = 0;
9593     r = guestfs_mount (g, device, mountpoint);
9594     if (r == -1)
9595       return -1;
9596   }
9597   /* TestOutput for command (10) */
9598   char expected[] = "Result11-1\nResult11-2";
9599   {
9600     char remotefilename[] = "/test-command";
9601     int r;
9602     suppress_error = 0;
9603     r = guestfs_upload (g, "test-command", remotefilename);
9604     if (r == -1)
9605       return -1;
9606   }
9607   {
9608     char path[] = "/test-command";
9609     int r;
9610     suppress_error = 0;
9611     r = guestfs_chmod (g, 493, path);
9612     if (r == -1)
9613       return -1;
9614   }
9615   {
9616     char arguments_0[] = "/test-command";
9617     char arguments_1[] = "11";
9618     char *arguments[] = {
9619       arguments_0,
9620       arguments_1,
9621       NULL
9622     };
9623     char *r;
9624     suppress_error = 0;
9625     r = guestfs_command (g, arguments);
9626     if (r == NULL)
9627       return -1;
9628     if (strcmp (r, expected) != 0) {
9629       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9630       return -1;
9631     }
9632     free (r);
9633   }
9634   return 0;
9635 }
9636
9637 static int test_command_11_skip (void)
9638 {
9639   const char *str;
9640
9641   str = getenv ("SKIP_TEST_COMMAND_11");
9642   if (str && strcmp (str, "1") == 0) return 1;
9643   str = getenv ("SKIP_TEST_COMMAND");
9644   if (str && strcmp (str, "1") == 0) return 1;
9645   return 0;
9646 }
9647
9648 static int test_command_11 (void)
9649 {
9650   if (test_command_11_skip ()) {
9651     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9652     return 0;
9653   }
9654
9655   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9656   {
9657     char device[] = "/dev/sda";
9658     device[5] = devchar;
9659     int r;
9660     suppress_error = 0;
9661     r = guestfs_blockdev_setrw (g, device);
9662     if (r == -1)
9663       return -1;
9664   }
9665   {
9666     int r;
9667     suppress_error = 0;
9668     r = guestfs_umount_all (g);
9669     if (r == -1)
9670       return -1;
9671   }
9672   {
9673     int r;
9674     suppress_error = 0;
9675     r = guestfs_lvm_remove_all (g);
9676     if (r == -1)
9677       return -1;
9678   }
9679   {
9680     char device[] = "/dev/sda";
9681     device[5] = devchar;
9682     char lines_0[] = ",";
9683     char *lines[] = {
9684       lines_0,
9685       NULL
9686     };
9687     int r;
9688     suppress_error = 0;
9689     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9690     if (r == -1)
9691       return -1;
9692   }
9693   {
9694     char fstype[] = "ext2";
9695     char device[] = "/dev/sda1";
9696     device[5] = devchar;
9697     int r;
9698     suppress_error = 0;
9699     r = guestfs_mkfs (g, fstype, device);
9700     if (r == -1)
9701       return -1;
9702   }
9703   {
9704     char device[] = "/dev/sda1";
9705     device[5] = devchar;
9706     char mountpoint[] = "/";
9707     int r;
9708     suppress_error = 0;
9709     r = guestfs_mount (g, device, mountpoint);
9710     if (r == -1)
9711       return -1;
9712   }
9713   /* TestLastFail for command (11) */
9714   {
9715     char remotefilename[] = "/test-command";
9716     int r;
9717     suppress_error = 0;
9718     r = guestfs_upload (g, "test-command", remotefilename);
9719     if (r == -1)
9720       return -1;
9721   }
9722   {
9723     char path[] = "/test-command";
9724     int r;
9725     suppress_error = 0;
9726     r = guestfs_chmod (g, 493, path);
9727     if (r == -1)
9728       return -1;
9729   }
9730   {
9731     char arguments_0[] = "/test-command";
9732     char *arguments[] = {
9733       arguments_0,
9734       NULL
9735     };
9736     char *r;
9737     suppress_error = 1;
9738     r = guestfs_command (g, arguments);
9739     if (r != NULL)
9740       return -1;
9741     free (r);
9742   }
9743   return 0;
9744 }
9745
9746 static int test_file_0_skip (void)
9747 {
9748   const char *str;
9749
9750   str = getenv ("SKIP_TEST_FILE_0");
9751   if (str && strcmp (str, "1") == 0) return 1;
9752   str = getenv ("SKIP_TEST_FILE");
9753   if (str && strcmp (str, "1") == 0) return 1;
9754   return 0;
9755 }
9756
9757 static int test_file_0 (void)
9758 {
9759   if (test_file_0_skip ()) {
9760     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9761     return 0;
9762   }
9763
9764   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9765   {
9766     char device[] = "/dev/sda";
9767     device[5] = devchar;
9768     int r;
9769     suppress_error = 0;
9770     r = guestfs_blockdev_setrw (g, device);
9771     if (r == -1)
9772       return -1;
9773   }
9774   {
9775     int r;
9776     suppress_error = 0;
9777     r = guestfs_umount_all (g);
9778     if (r == -1)
9779       return -1;
9780   }
9781   {
9782     int r;
9783     suppress_error = 0;
9784     r = guestfs_lvm_remove_all (g);
9785     if (r == -1)
9786       return -1;
9787   }
9788   {
9789     char device[] = "/dev/sda";
9790     device[5] = devchar;
9791     char lines_0[] = ",";
9792     char *lines[] = {
9793       lines_0,
9794       NULL
9795     };
9796     int r;
9797     suppress_error = 0;
9798     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9799     if (r == -1)
9800       return -1;
9801   }
9802   {
9803     char fstype[] = "ext2";
9804     char device[] = "/dev/sda1";
9805     device[5] = devchar;
9806     int r;
9807     suppress_error = 0;
9808     r = guestfs_mkfs (g, fstype, device);
9809     if (r == -1)
9810       return -1;
9811   }
9812   {
9813     char device[] = "/dev/sda1";
9814     device[5] = devchar;
9815     char mountpoint[] = "/";
9816     int r;
9817     suppress_error = 0;
9818     r = guestfs_mount (g, device, mountpoint);
9819     if (r == -1)
9820       return -1;
9821   }
9822   /* TestOutput for file (0) */
9823   char expected[] = "empty";
9824   {
9825     char path[] = "/new";
9826     int r;
9827     suppress_error = 0;
9828     r = guestfs_touch (g, path);
9829     if (r == -1)
9830       return -1;
9831   }
9832   {
9833     char path[] = "/new";
9834     char *r;
9835     suppress_error = 0;
9836     r = guestfs_file (g, path);
9837     if (r == NULL)
9838       return -1;
9839     if (strcmp (r, expected) != 0) {
9840       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9841       return -1;
9842     }
9843     free (r);
9844   }
9845   return 0;
9846 }
9847
9848 static int test_file_1_skip (void)
9849 {
9850   const char *str;
9851
9852   str = getenv ("SKIP_TEST_FILE_1");
9853   if (str && strcmp (str, "1") == 0) return 1;
9854   str = getenv ("SKIP_TEST_FILE");
9855   if (str && strcmp (str, "1") == 0) return 1;
9856   return 0;
9857 }
9858
9859 static int test_file_1 (void)
9860 {
9861   if (test_file_1_skip ()) {
9862     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9863     return 0;
9864   }
9865
9866   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9867   {
9868     char device[] = "/dev/sda";
9869     device[5] = devchar;
9870     int r;
9871     suppress_error = 0;
9872     r = guestfs_blockdev_setrw (g, device);
9873     if (r == -1)
9874       return -1;
9875   }
9876   {
9877     int r;
9878     suppress_error = 0;
9879     r = guestfs_umount_all (g);
9880     if (r == -1)
9881       return -1;
9882   }
9883   {
9884     int r;
9885     suppress_error = 0;
9886     r = guestfs_lvm_remove_all (g);
9887     if (r == -1)
9888       return -1;
9889   }
9890   {
9891     char device[] = "/dev/sda";
9892     device[5] = devchar;
9893     char lines_0[] = ",";
9894     char *lines[] = {
9895       lines_0,
9896       NULL
9897     };
9898     int r;
9899     suppress_error = 0;
9900     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9901     if (r == -1)
9902       return -1;
9903   }
9904   {
9905     char fstype[] = "ext2";
9906     char device[] = "/dev/sda1";
9907     device[5] = devchar;
9908     int r;
9909     suppress_error = 0;
9910     r = guestfs_mkfs (g, fstype, device);
9911     if (r == -1)
9912       return -1;
9913   }
9914   {
9915     char device[] = "/dev/sda1";
9916     device[5] = devchar;
9917     char mountpoint[] = "/";
9918     int r;
9919     suppress_error = 0;
9920     r = guestfs_mount (g, device, mountpoint);
9921     if (r == -1)
9922       return -1;
9923   }
9924   /* TestOutput for file (1) */
9925   char expected[] = "ASCII text";
9926   {
9927     char path[] = "/new";
9928     char content[] = "some content\n";
9929     int r;
9930     suppress_error = 0;
9931     r = guestfs_write_file (g, path, content, 0);
9932     if (r == -1)
9933       return -1;
9934   }
9935   {
9936     char path[] = "/new";
9937     char *r;
9938     suppress_error = 0;
9939     r = guestfs_file (g, path);
9940     if (r == NULL)
9941       return -1;
9942     if (strcmp (r, expected) != 0) {
9943       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9944       return -1;
9945     }
9946     free (r);
9947   }
9948   return 0;
9949 }
9950
9951 static int test_file_2_skip (void)
9952 {
9953   const char *str;
9954
9955   str = getenv ("SKIP_TEST_FILE_2");
9956   if (str && strcmp (str, "1") == 0) return 1;
9957   str = getenv ("SKIP_TEST_FILE");
9958   if (str && strcmp (str, "1") == 0) return 1;
9959   return 0;
9960 }
9961
9962 static int test_file_2 (void)
9963 {
9964   if (test_file_2_skip ()) {
9965     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
9966     return 0;
9967   }
9968
9969   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
9970   {
9971     char device[] = "/dev/sda";
9972     device[5] = devchar;
9973     int r;
9974     suppress_error = 0;
9975     r = guestfs_blockdev_setrw (g, device);
9976     if (r == -1)
9977       return -1;
9978   }
9979   {
9980     int r;
9981     suppress_error = 0;
9982     r = guestfs_umount_all (g);
9983     if (r == -1)
9984       return -1;
9985   }
9986   {
9987     int r;
9988     suppress_error = 0;
9989     r = guestfs_lvm_remove_all (g);
9990     if (r == -1)
9991       return -1;
9992   }
9993   {
9994     char device[] = "/dev/sda";
9995     device[5] = devchar;
9996     char lines_0[] = ",";
9997     char *lines[] = {
9998       lines_0,
9999       NULL
10000     };
10001     int r;
10002     suppress_error = 0;
10003     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10004     if (r == -1)
10005       return -1;
10006   }
10007   {
10008     char fstype[] = "ext2";
10009     char device[] = "/dev/sda1";
10010     device[5] = devchar;
10011     int r;
10012     suppress_error = 0;
10013     r = guestfs_mkfs (g, fstype, device);
10014     if (r == -1)
10015       return -1;
10016   }
10017   {
10018     char device[] = "/dev/sda1";
10019     device[5] = devchar;
10020     char mountpoint[] = "/";
10021     int r;
10022     suppress_error = 0;
10023     r = guestfs_mount (g, device, mountpoint);
10024     if (r == -1)
10025       return -1;
10026   }
10027   /* TestLastFail for file (2) */
10028   {
10029     char path[] = "/nofile";
10030     char *r;
10031     suppress_error = 1;
10032     r = guestfs_file (g, path);
10033     if (r != NULL)
10034       return -1;
10035     free (r);
10036   }
10037   return 0;
10038 }
10039
10040 static int test_umount_all_0_skip (void)
10041 {
10042   const char *str;
10043
10044   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10045   if (str && strcmp (str, "1") == 0) return 1;
10046   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10047   if (str && strcmp (str, "1") == 0) return 1;
10048   return 0;
10049 }
10050
10051 static int test_umount_all_0 (void)
10052 {
10053   if (test_umount_all_0_skip ()) {
10054     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10055     return 0;
10056   }
10057
10058   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10059   {
10060     char device[] = "/dev/sda";
10061     device[5] = devchar;
10062     int r;
10063     suppress_error = 0;
10064     r = guestfs_blockdev_setrw (g, device);
10065     if (r == -1)
10066       return -1;
10067   }
10068   {
10069     int r;
10070     suppress_error = 0;
10071     r = guestfs_umount_all (g);
10072     if (r == -1)
10073       return -1;
10074   }
10075   {
10076     int r;
10077     suppress_error = 0;
10078     r = guestfs_lvm_remove_all (g);
10079     if (r == -1)
10080       return -1;
10081   }
10082   {
10083     char device[] = "/dev/sda";
10084     device[5] = devchar;
10085     char lines_0[] = ",";
10086     char *lines[] = {
10087       lines_0,
10088       NULL
10089     };
10090     int r;
10091     suppress_error = 0;
10092     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10093     if (r == -1)
10094       return -1;
10095   }
10096   {
10097     char fstype[] = "ext2";
10098     char device[] = "/dev/sda1";
10099     device[5] = devchar;
10100     int r;
10101     suppress_error = 0;
10102     r = guestfs_mkfs (g, fstype, device);
10103     if (r == -1)
10104       return -1;
10105   }
10106   {
10107     char device[] = "/dev/sda1";
10108     device[5] = devchar;
10109     char mountpoint[] = "/";
10110     int r;
10111     suppress_error = 0;
10112     r = guestfs_mount (g, device, mountpoint);
10113     if (r == -1)
10114       return -1;
10115   }
10116   /* TestOutputList for umount_all (0) */
10117   {
10118     int r;
10119     suppress_error = 0;
10120     r = guestfs_umount_all (g);
10121     if (r == -1)
10122       return -1;
10123   }
10124   {
10125     char **r;
10126     int i;
10127     suppress_error = 0;
10128     r = guestfs_mounts (g);
10129     if (r == NULL)
10130       return -1;
10131     if (r[0] != NULL) {
10132       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10133       print_strings (r);
10134       return -1;
10135     }
10136     for (i = 0; r[i] != NULL; ++i)
10137       free (r[i]);
10138     free (r);
10139   }
10140   return 0;
10141 }
10142
10143 static int test_umount_all_1_skip (void)
10144 {
10145   const char *str;
10146
10147   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10148   if (str && strcmp (str, "1") == 0) return 1;
10149   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10150   if (str && strcmp (str, "1") == 0) return 1;
10151   return 0;
10152 }
10153
10154 static int test_umount_all_1 (void)
10155 {
10156   if (test_umount_all_1_skip ()) {
10157     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10158     return 0;
10159   }
10160
10161   /* InitNone|InitEmpty for test_umount_all_1 */
10162   {
10163     char device[] = "/dev/sda";
10164     device[5] = devchar;
10165     int r;
10166     suppress_error = 0;
10167     r = guestfs_blockdev_setrw (g, device);
10168     if (r == -1)
10169       return -1;
10170   }
10171   {
10172     int r;
10173     suppress_error = 0;
10174     r = guestfs_umount_all (g);
10175     if (r == -1)
10176       return -1;
10177   }
10178   {
10179     int r;
10180     suppress_error = 0;
10181     r = guestfs_lvm_remove_all (g);
10182     if (r == -1)
10183       return -1;
10184   }
10185   /* TestOutputList for umount_all (1) */
10186   {
10187     char device[] = "/dev/sda";
10188     device[5] = devchar;
10189     char lines_0[] = ",10";
10190     char lines_1[] = ",20";
10191     char lines_2[] = ",";
10192     char *lines[] = {
10193       lines_0,
10194       lines_1,
10195       lines_2,
10196       NULL
10197     };
10198     int r;
10199     suppress_error = 0;
10200     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10201     if (r == -1)
10202       return -1;
10203   }
10204   {
10205     char fstype[] = "ext2";
10206     char device[] = "/dev/sda1";
10207     device[5] = devchar;
10208     int r;
10209     suppress_error = 0;
10210     r = guestfs_mkfs (g, fstype, device);
10211     if (r == -1)
10212       return -1;
10213   }
10214   {
10215     char fstype[] = "ext2";
10216     char device[] = "/dev/sda2";
10217     device[5] = devchar;
10218     int r;
10219     suppress_error = 0;
10220     r = guestfs_mkfs (g, fstype, device);
10221     if (r == -1)
10222       return -1;
10223   }
10224   {
10225     char fstype[] = "ext2";
10226     char device[] = "/dev/sda3";
10227     device[5] = devchar;
10228     int r;
10229     suppress_error = 0;
10230     r = guestfs_mkfs (g, fstype, device);
10231     if (r == -1)
10232       return -1;
10233   }
10234   {
10235     char device[] = "/dev/sda1";
10236     device[5] = devchar;
10237     char mountpoint[] = "/";
10238     int r;
10239     suppress_error = 0;
10240     r = guestfs_mount (g, device, mountpoint);
10241     if (r == -1)
10242       return -1;
10243   }
10244   {
10245     char path[] = "/mp1";
10246     int r;
10247     suppress_error = 0;
10248     r = guestfs_mkdir (g, path);
10249     if (r == -1)
10250       return -1;
10251   }
10252   {
10253     char device[] = "/dev/sda2";
10254     device[5] = devchar;
10255     char mountpoint[] = "/mp1";
10256     int r;
10257     suppress_error = 0;
10258     r = guestfs_mount (g, device, mountpoint);
10259     if (r == -1)
10260       return -1;
10261   }
10262   {
10263     char path[] = "/mp1/mp2";
10264     int r;
10265     suppress_error = 0;
10266     r = guestfs_mkdir (g, path);
10267     if (r == -1)
10268       return -1;
10269   }
10270   {
10271     char device[] = "/dev/sda3";
10272     device[5] = devchar;
10273     char mountpoint[] = "/mp1/mp2";
10274     int r;
10275     suppress_error = 0;
10276     r = guestfs_mount (g, device, mountpoint);
10277     if (r == -1)
10278       return -1;
10279   }
10280   {
10281     char path[] = "/mp1/mp2/mp3";
10282     int r;
10283     suppress_error = 0;
10284     r = guestfs_mkdir (g, path);
10285     if (r == -1)
10286       return -1;
10287   }
10288   {
10289     int r;
10290     suppress_error = 0;
10291     r = guestfs_umount_all (g);
10292     if (r == -1)
10293       return -1;
10294   }
10295   {
10296     char **r;
10297     int i;
10298     suppress_error = 0;
10299     r = guestfs_mounts (g);
10300     if (r == NULL)
10301       return -1;
10302     if (r[0] != NULL) {
10303       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10304       print_strings (r);
10305       return -1;
10306     }
10307     for (i = 0; r[i] != NULL; ++i)
10308       free (r[i]);
10309     free (r);
10310   }
10311   return 0;
10312 }
10313
10314 static int test_mounts_0_skip (void)
10315 {
10316   const char *str;
10317
10318   str = getenv ("SKIP_TEST_MOUNTS_0");
10319   if (str && strcmp (str, "1") == 0) return 1;
10320   str = getenv ("SKIP_TEST_MOUNTS");
10321   if (str && strcmp (str, "1") == 0) return 1;
10322   return 0;
10323 }
10324
10325 static int test_mounts_0 (void)
10326 {
10327   if (test_mounts_0_skip ()) {
10328     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10329     return 0;
10330   }
10331
10332   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10333   {
10334     char device[] = "/dev/sda";
10335     device[5] = devchar;
10336     int r;
10337     suppress_error = 0;
10338     r = guestfs_blockdev_setrw (g, device);
10339     if (r == -1)
10340       return -1;
10341   }
10342   {
10343     int r;
10344     suppress_error = 0;
10345     r = guestfs_umount_all (g);
10346     if (r == -1)
10347       return -1;
10348   }
10349   {
10350     int r;
10351     suppress_error = 0;
10352     r = guestfs_lvm_remove_all (g);
10353     if (r == -1)
10354       return -1;
10355   }
10356   {
10357     char device[] = "/dev/sda";
10358     device[5] = devchar;
10359     char lines_0[] = ",";
10360     char *lines[] = {
10361       lines_0,
10362       NULL
10363     };
10364     int r;
10365     suppress_error = 0;
10366     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10367     if (r == -1)
10368       return -1;
10369   }
10370   {
10371     char fstype[] = "ext2";
10372     char device[] = "/dev/sda1";
10373     device[5] = devchar;
10374     int r;
10375     suppress_error = 0;
10376     r = guestfs_mkfs (g, fstype, device);
10377     if (r == -1)
10378       return -1;
10379   }
10380   {
10381     char device[] = "/dev/sda1";
10382     device[5] = devchar;
10383     char mountpoint[] = "/";
10384     int r;
10385     suppress_error = 0;
10386     r = guestfs_mount (g, device, mountpoint);
10387     if (r == -1)
10388       return -1;
10389   }
10390   /* TestOutputList for mounts (0) */
10391   {
10392     char **r;
10393     int i;
10394     suppress_error = 0;
10395     r = guestfs_mounts (g);
10396     if (r == NULL)
10397       return -1;
10398     if (!r[0]) {
10399       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10400       print_strings (r);
10401       return -1;
10402     }
10403     {
10404       char expected[] = "/dev/sda1";
10405       expected[5] = devchar;
10406       if (strcmp (r[0], expected) != 0) {
10407         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10408         return -1;
10409       }
10410     }
10411     if (r[1] != NULL) {
10412       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10413       print_strings (r);
10414       return -1;
10415     }
10416     for (i = 0; r[i] != NULL; ++i)
10417       free (r[i]);
10418     free (r);
10419   }
10420   return 0;
10421 }
10422
10423 static int test_umount_0_skip (void)
10424 {
10425   const char *str;
10426
10427   str = getenv ("SKIP_TEST_UMOUNT_0");
10428   if (str && strcmp (str, "1") == 0) return 1;
10429   str = getenv ("SKIP_TEST_UMOUNT");
10430   if (str && strcmp (str, "1") == 0) return 1;
10431   return 0;
10432 }
10433
10434 static int test_umount_0 (void)
10435 {
10436   if (test_umount_0_skip ()) {
10437     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10438     return 0;
10439   }
10440
10441   /* InitNone|InitEmpty for test_umount_0 */
10442   {
10443     char device[] = "/dev/sda";
10444     device[5] = devchar;
10445     int r;
10446     suppress_error = 0;
10447     r = guestfs_blockdev_setrw (g, device);
10448     if (r == -1)
10449       return -1;
10450   }
10451   {
10452     int r;
10453     suppress_error = 0;
10454     r = guestfs_umount_all (g);
10455     if (r == -1)
10456       return -1;
10457   }
10458   {
10459     int r;
10460     suppress_error = 0;
10461     r = guestfs_lvm_remove_all (g);
10462     if (r == -1)
10463       return -1;
10464   }
10465   /* TestOutputList for umount (0) */
10466   {
10467     char device[] = "/dev/sda";
10468     device[5] = devchar;
10469     char lines_0[] = ",";
10470     char *lines[] = {
10471       lines_0,
10472       NULL
10473     };
10474     int r;
10475     suppress_error = 0;
10476     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10477     if (r == -1)
10478       return -1;
10479   }
10480   {
10481     char fstype[] = "ext2";
10482     char device[] = "/dev/sda1";
10483     device[5] = devchar;
10484     int r;
10485     suppress_error = 0;
10486     r = guestfs_mkfs (g, fstype, device);
10487     if (r == -1)
10488       return -1;
10489   }
10490   {
10491     char device[] = "/dev/sda1";
10492     device[5] = devchar;
10493     char mountpoint[] = "/";
10494     int r;
10495     suppress_error = 0;
10496     r = guestfs_mount (g, device, mountpoint);
10497     if (r == -1)
10498       return -1;
10499   }
10500   {
10501     char **r;
10502     int i;
10503     suppress_error = 0;
10504     r = guestfs_mounts (g);
10505     if (r == NULL)
10506       return -1;
10507     if (!r[0]) {
10508       fprintf (stderr, "test_umount_0: short list returned from command\n");
10509       print_strings (r);
10510       return -1;
10511     }
10512     {
10513       char expected[] = "/dev/sda1";
10514       expected[5] = devchar;
10515       if (strcmp (r[0], expected) != 0) {
10516         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10517         return -1;
10518       }
10519     }
10520     if (r[1] != NULL) {
10521       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10522       print_strings (r);
10523       return -1;
10524     }
10525     for (i = 0; r[i] != NULL; ++i)
10526       free (r[i]);
10527     free (r);
10528   }
10529   return 0;
10530 }
10531
10532 static int test_umount_1_skip (void)
10533 {
10534   const char *str;
10535
10536   str = getenv ("SKIP_TEST_UMOUNT_1");
10537   if (str && strcmp (str, "1") == 0) return 1;
10538   str = getenv ("SKIP_TEST_UMOUNT");
10539   if (str && strcmp (str, "1") == 0) return 1;
10540   return 0;
10541 }
10542
10543 static int test_umount_1 (void)
10544 {
10545   if (test_umount_1_skip ()) {
10546     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10547     return 0;
10548   }
10549
10550   /* InitNone|InitEmpty for test_umount_1 */
10551   {
10552     char device[] = "/dev/sda";
10553     device[5] = devchar;
10554     int r;
10555     suppress_error = 0;
10556     r = guestfs_blockdev_setrw (g, device);
10557     if (r == -1)
10558       return -1;
10559   }
10560   {
10561     int r;
10562     suppress_error = 0;
10563     r = guestfs_umount_all (g);
10564     if (r == -1)
10565       return -1;
10566   }
10567   {
10568     int r;
10569     suppress_error = 0;
10570     r = guestfs_lvm_remove_all (g);
10571     if (r == -1)
10572       return -1;
10573   }
10574   /* TestOutputList for umount (1) */
10575   {
10576     char device[] = "/dev/sda";
10577     device[5] = devchar;
10578     char lines_0[] = ",";
10579     char *lines[] = {
10580       lines_0,
10581       NULL
10582     };
10583     int r;
10584     suppress_error = 0;
10585     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10586     if (r == -1)
10587       return -1;
10588   }
10589   {
10590     char fstype[] = "ext2";
10591     char device[] = "/dev/sda1";
10592     device[5] = devchar;
10593     int r;
10594     suppress_error = 0;
10595     r = guestfs_mkfs (g, fstype, device);
10596     if (r == -1)
10597       return -1;
10598   }
10599   {
10600     char device[] = "/dev/sda1";
10601     device[5] = devchar;
10602     char mountpoint[] = "/";
10603     int r;
10604     suppress_error = 0;
10605     r = guestfs_mount (g, device, mountpoint);
10606     if (r == -1)
10607       return -1;
10608   }
10609   {
10610     char pathordevice[] = "/";
10611     int r;
10612     suppress_error = 0;
10613     r = guestfs_umount (g, pathordevice);
10614     if (r == -1)
10615       return -1;
10616   }
10617   {
10618     char **r;
10619     int i;
10620     suppress_error = 0;
10621     r = guestfs_mounts (g);
10622     if (r == NULL)
10623       return -1;
10624     if (r[0] != NULL) {
10625       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10626       print_strings (r);
10627       return -1;
10628     }
10629     for (i = 0; r[i] != NULL; ++i)
10630       free (r[i]);
10631     free (r);
10632   }
10633   return 0;
10634 }
10635
10636 static int test_write_file_0_skip (void)
10637 {
10638   const char *str;
10639
10640   str = getenv ("SKIP_TEST_WRITE_FILE_0");
10641   if (str && strcmp (str, "1") == 0) return 1;
10642   str = getenv ("SKIP_TEST_WRITE_FILE");
10643   if (str && strcmp (str, "1") == 0) return 1;
10644   return 0;
10645 }
10646
10647 static int test_write_file_0 (void)
10648 {
10649   if (test_write_file_0_skip ()) {
10650     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10651     return 0;
10652   }
10653
10654   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10655   {
10656     char device[] = "/dev/sda";
10657     device[5] = devchar;
10658     int r;
10659     suppress_error = 0;
10660     r = guestfs_blockdev_setrw (g, device);
10661     if (r == -1)
10662       return -1;
10663   }
10664   {
10665     int r;
10666     suppress_error = 0;
10667     r = guestfs_umount_all (g);
10668     if (r == -1)
10669       return -1;
10670   }
10671   {
10672     int r;
10673     suppress_error = 0;
10674     r = guestfs_lvm_remove_all (g);
10675     if (r == -1)
10676       return -1;
10677   }
10678   {
10679     char device[] = "/dev/sda";
10680     device[5] = devchar;
10681     char lines_0[] = ",";
10682     char *lines[] = {
10683       lines_0,
10684       NULL
10685     };
10686     int r;
10687     suppress_error = 0;
10688     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10689     if (r == -1)
10690       return -1;
10691   }
10692   {
10693     char fstype[] = "ext2";
10694     char device[] = "/dev/sda1";
10695     device[5] = devchar;
10696     int r;
10697     suppress_error = 0;
10698     r = guestfs_mkfs (g, fstype, device);
10699     if (r == -1)
10700       return -1;
10701   }
10702   {
10703     char device[] = "/dev/sda1";
10704     device[5] = devchar;
10705     char mountpoint[] = "/";
10706     int r;
10707     suppress_error = 0;
10708     r = guestfs_mount (g, device, mountpoint);
10709     if (r == -1)
10710       return -1;
10711   }
10712   /* TestOutput for write_file (0) */
10713   char expected[] = "new file contents";
10714   {
10715     char path[] = "/new";
10716     char content[] = "new file contents";
10717     int r;
10718     suppress_error = 0;
10719     r = guestfs_write_file (g, path, content, 0);
10720     if (r == -1)
10721       return -1;
10722   }
10723   {
10724     char path[] = "/new";
10725     char *r;
10726     suppress_error = 0;
10727     r = guestfs_cat (g, path);
10728     if (r == NULL)
10729       return -1;
10730     if (strcmp (r, expected) != 0) {
10731       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10732       return -1;
10733     }
10734     free (r);
10735   }
10736   return 0;
10737 }
10738
10739 static int test_write_file_1_skip (void)
10740 {
10741   const char *str;
10742
10743   str = getenv ("SKIP_TEST_WRITE_FILE_1");
10744   if (str && strcmp (str, "1") == 0) return 1;
10745   str = getenv ("SKIP_TEST_WRITE_FILE");
10746   if (str && strcmp (str, "1") == 0) return 1;
10747   return 0;
10748 }
10749
10750 static int test_write_file_1 (void)
10751 {
10752   if (test_write_file_1_skip ()) {
10753     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10754     return 0;
10755   }
10756
10757   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10758   {
10759     char device[] = "/dev/sda";
10760     device[5] = devchar;
10761     int r;
10762     suppress_error = 0;
10763     r = guestfs_blockdev_setrw (g, device);
10764     if (r == -1)
10765       return -1;
10766   }
10767   {
10768     int r;
10769     suppress_error = 0;
10770     r = guestfs_umount_all (g);
10771     if (r == -1)
10772       return -1;
10773   }
10774   {
10775     int r;
10776     suppress_error = 0;
10777     r = guestfs_lvm_remove_all (g);
10778     if (r == -1)
10779       return -1;
10780   }
10781   {
10782     char device[] = "/dev/sda";
10783     device[5] = devchar;
10784     char lines_0[] = ",";
10785     char *lines[] = {
10786       lines_0,
10787       NULL
10788     };
10789     int r;
10790     suppress_error = 0;
10791     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10792     if (r == -1)
10793       return -1;
10794   }
10795   {
10796     char fstype[] = "ext2";
10797     char device[] = "/dev/sda1";
10798     device[5] = devchar;
10799     int r;
10800     suppress_error = 0;
10801     r = guestfs_mkfs (g, fstype, device);
10802     if (r == -1)
10803       return -1;
10804   }
10805   {
10806     char device[] = "/dev/sda1";
10807     device[5] = devchar;
10808     char mountpoint[] = "/";
10809     int r;
10810     suppress_error = 0;
10811     r = guestfs_mount (g, device, mountpoint);
10812     if (r == -1)
10813       return -1;
10814   }
10815   /* TestOutput for write_file (1) */
10816   char expected[] = "\nnew file contents\n";
10817   {
10818     char path[] = "/new";
10819     char content[] = "\nnew file contents\n";
10820     int r;
10821     suppress_error = 0;
10822     r = guestfs_write_file (g, path, content, 0);
10823     if (r == -1)
10824       return -1;
10825   }
10826   {
10827     char path[] = "/new";
10828     char *r;
10829     suppress_error = 0;
10830     r = guestfs_cat (g, path);
10831     if (r == NULL)
10832       return -1;
10833     if (strcmp (r, expected) != 0) {
10834       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10835       return -1;
10836     }
10837     free (r);
10838   }
10839   return 0;
10840 }
10841
10842 static int test_write_file_2_skip (void)
10843 {
10844   const char *str;
10845
10846   str = getenv ("SKIP_TEST_WRITE_FILE_2");
10847   if (str && strcmp (str, "1") == 0) return 1;
10848   str = getenv ("SKIP_TEST_WRITE_FILE");
10849   if (str && strcmp (str, "1") == 0) return 1;
10850   return 0;
10851 }
10852
10853 static int test_write_file_2 (void)
10854 {
10855   if (test_write_file_2_skip ()) {
10856     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10857     return 0;
10858   }
10859
10860   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10861   {
10862     char device[] = "/dev/sda";
10863     device[5] = devchar;
10864     int r;
10865     suppress_error = 0;
10866     r = guestfs_blockdev_setrw (g, device);
10867     if (r == -1)
10868       return -1;
10869   }
10870   {
10871     int r;
10872     suppress_error = 0;
10873     r = guestfs_umount_all (g);
10874     if (r == -1)
10875       return -1;
10876   }
10877   {
10878     int r;
10879     suppress_error = 0;
10880     r = guestfs_lvm_remove_all (g);
10881     if (r == -1)
10882       return -1;
10883   }
10884   {
10885     char device[] = "/dev/sda";
10886     device[5] = devchar;
10887     char lines_0[] = ",";
10888     char *lines[] = {
10889       lines_0,
10890       NULL
10891     };
10892     int r;
10893     suppress_error = 0;
10894     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10895     if (r == -1)
10896       return -1;
10897   }
10898   {
10899     char fstype[] = "ext2";
10900     char device[] = "/dev/sda1";
10901     device[5] = devchar;
10902     int r;
10903     suppress_error = 0;
10904     r = guestfs_mkfs (g, fstype, device);
10905     if (r == -1)
10906       return -1;
10907   }
10908   {
10909     char device[] = "/dev/sda1";
10910     device[5] = devchar;
10911     char mountpoint[] = "/";
10912     int r;
10913     suppress_error = 0;
10914     r = guestfs_mount (g, device, mountpoint);
10915     if (r == -1)
10916       return -1;
10917   }
10918   /* TestOutput for write_file (2) */
10919   char expected[] = "\n\n";
10920   {
10921     char path[] = "/new";
10922     char content[] = "\n\n";
10923     int r;
10924     suppress_error = 0;
10925     r = guestfs_write_file (g, path, content, 0);
10926     if (r == -1)
10927       return -1;
10928   }
10929   {
10930     char path[] = "/new";
10931     char *r;
10932     suppress_error = 0;
10933     r = guestfs_cat (g, path);
10934     if (r == NULL)
10935       return -1;
10936     if (strcmp (r, expected) != 0) {
10937       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
10938       return -1;
10939     }
10940     free (r);
10941   }
10942   return 0;
10943 }
10944
10945 static int test_write_file_3_skip (void)
10946 {
10947   const char *str;
10948
10949   str = getenv ("SKIP_TEST_WRITE_FILE_3");
10950   if (str && strcmp (str, "1") == 0) return 1;
10951   str = getenv ("SKIP_TEST_WRITE_FILE");
10952   if (str && strcmp (str, "1") == 0) return 1;
10953   return 0;
10954 }
10955
10956 static int test_write_file_3 (void)
10957 {
10958   if (test_write_file_3_skip ()) {
10959     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
10960     return 0;
10961   }
10962
10963   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
10964   {
10965     char device[] = "/dev/sda";
10966     device[5] = devchar;
10967     int r;
10968     suppress_error = 0;
10969     r = guestfs_blockdev_setrw (g, device);
10970     if (r == -1)
10971       return -1;
10972   }
10973   {
10974     int r;
10975     suppress_error = 0;
10976     r = guestfs_umount_all (g);
10977     if (r == -1)
10978       return -1;
10979   }
10980   {
10981     int r;
10982     suppress_error = 0;
10983     r = guestfs_lvm_remove_all (g);
10984     if (r == -1)
10985       return -1;
10986   }
10987   {
10988     char device[] = "/dev/sda";
10989     device[5] = devchar;
10990     char lines_0[] = ",";
10991     char *lines[] = {
10992       lines_0,
10993       NULL
10994     };
10995     int r;
10996     suppress_error = 0;
10997     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10998     if (r == -1)
10999       return -1;
11000   }
11001   {
11002     char fstype[] = "ext2";
11003     char device[] = "/dev/sda1";
11004     device[5] = devchar;
11005     int r;
11006     suppress_error = 0;
11007     r = guestfs_mkfs (g, fstype, device);
11008     if (r == -1)
11009       return -1;
11010   }
11011   {
11012     char device[] = "/dev/sda1";
11013     device[5] = devchar;
11014     char mountpoint[] = "/";
11015     int r;
11016     suppress_error = 0;
11017     r = guestfs_mount (g, device, mountpoint);
11018     if (r == -1)
11019       return -1;
11020   }
11021   /* TestOutput for write_file (3) */
11022   char expected[] = "";
11023   {
11024     char path[] = "/new";
11025     char content[] = "";
11026     int r;
11027     suppress_error = 0;
11028     r = guestfs_write_file (g, path, content, 0);
11029     if (r == -1)
11030       return -1;
11031   }
11032   {
11033     char path[] = "/new";
11034     char *r;
11035     suppress_error = 0;
11036     r = guestfs_cat (g, path);
11037     if (r == NULL)
11038       return -1;
11039     if (strcmp (r, expected) != 0) {
11040       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11041       return -1;
11042     }
11043     free (r);
11044   }
11045   return 0;
11046 }
11047
11048 static int test_write_file_4_skip (void)
11049 {
11050   const char *str;
11051
11052   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11053   if (str && strcmp (str, "1") == 0) return 1;
11054   str = getenv ("SKIP_TEST_WRITE_FILE");
11055   if (str && strcmp (str, "1") == 0) return 1;
11056   return 0;
11057 }
11058
11059 static int test_write_file_4 (void)
11060 {
11061   if (test_write_file_4_skip ()) {
11062     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11063     return 0;
11064   }
11065
11066   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11067   {
11068     char device[] = "/dev/sda";
11069     device[5] = devchar;
11070     int r;
11071     suppress_error = 0;
11072     r = guestfs_blockdev_setrw (g, device);
11073     if (r == -1)
11074       return -1;
11075   }
11076   {
11077     int r;
11078     suppress_error = 0;
11079     r = guestfs_umount_all (g);
11080     if (r == -1)
11081       return -1;
11082   }
11083   {
11084     int r;
11085     suppress_error = 0;
11086     r = guestfs_lvm_remove_all (g);
11087     if (r == -1)
11088       return -1;
11089   }
11090   {
11091     char device[] = "/dev/sda";
11092     device[5] = devchar;
11093     char lines_0[] = ",";
11094     char *lines[] = {
11095       lines_0,
11096       NULL
11097     };
11098     int r;
11099     suppress_error = 0;
11100     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11101     if (r == -1)
11102       return -1;
11103   }
11104   {
11105     char fstype[] = "ext2";
11106     char device[] = "/dev/sda1";
11107     device[5] = devchar;
11108     int r;
11109     suppress_error = 0;
11110     r = guestfs_mkfs (g, fstype, device);
11111     if (r == -1)
11112       return -1;
11113   }
11114   {
11115     char device[] = "/dev/sda1";
11116     device[5] = devchar;
11117     char mountpoint[] = "/";
11118     int r;
11119     suppress_error = 0;
11120     r = guestfs_mount (g, device, mountpoint);
11121     if (r == -1)
11122       return -1;
11123   }
11124   /* TestOutput for write_file (4) */
11125   char expected[] = "\n\n\n";
11126   {
11127     char path[] = "/new";
11128     char content[] = "\n\n\n";
11129     int r;
11130     suppress_error = 0;
11131     r = guestfs_write_file (g, path, content, 0);
11132     if (r == -1)
11133       return -1;
11134   }
11135   {
11136     char path[] = "/new";
11137     char *r;
11138     suppress_error = 0;
11139     r = guestfs_cat (g, path);
11140     if (r == NULL)
11141       return -1;
11142     if (strcmp (r, expected) != 0) {
11143       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11144       return -1;
11145     }
11146     free (r);
11147   }
11148   return 0;
11149 }
11150
11151 static int test_write_file_5_skip (void)
11152 {
11153   const char *str;
11154
11155   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11156   if (str && strcmp (str, "1") == 0) return 1;
11157   str = getenv ("SKIP_TEST_WRITE_FILE");
11158   if (str && strcmp (str, "1") == 0) return 1;
11159   return 0;
11160 }
11161
11162 static int test_write_file_5 (void)
11163 {
11164   if (test_write_file_5_skip ()) {
11165     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11166     return 0;
11167   }
11168
11169   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11170   {
11171     char device[] = "/dev/sda";
11172     device[5] = devchar;
11173     int r;
11174     suppress_error = 0;
11175     r = guestfs_blockdev_setrw (g, device);
11176     if (r == -1)
11177       return -1;
11178   }
11179   {
11180     int r;
11181     suppress_error = 0;
11182     r = guestfs_umount_all (g);
11183     if (r == -1)
11184       return -1;
11185   }
11186   {
11187     int r;
11188     suppress_error = 0;
11189     r = guestfs_lvm_remove_all (g);
11190     if (r == -1)
11191       return -1;
11192   }
11193   {
11194     char device[] = "/dev/sda";
11195     device[5] = devchar;
11196     char lines_0[] = ",";
11197     char *lines[] = {
11198       lines_0,
11199       NULL
11200     };
11201     int r;
11202     suppress_error = 0;
11203     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11204     if (r == -1)
11205       return -1;
11206   }
11207   {
11208     char fstype[] = "ext2";
11209     char device[] = "/dev/sda1";
11210     device[5] = devchar;
11211     int r;
11212     suppress_error = 0;
11213     r = guestfs_mkfs (g, fstype, device);
11214     if (r == -1)
11215       return -1;
11216   }
11217   {
11218     char device[] = "/dev/sda1";
11219     device[5] = devchar;
11220     char mountpoint[] = "/";
11221     int r;
11222     suppress_error = 0;
11223     r = guestfs_mount (g, device, mountpoint);
11224     if (r == -1)
11225       return -1;
11226   }
11227   /* TestOutput for write_file (5) */
11228   char expected[] = "\n";
11229   {
11230     char path[] = "/new";
11231     char content[] = "\n";
11232     int r;
11233     suppress_error = 0;
11234     r = guestfs_write_file (g, path, content, 0);
11235     if (r == -1)
11236       return -1;
11237   }
11238   {
11239     char path[] = "/new";
11240     char *r;
11241     suppress_error = 0;
11242     r = guestfs_cat (g, path);
11243     if (r == NULL)
11244       return -1;
11245     if (strcmp (r, expected) != 0) {
11246       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11247       return -1;
11248     }
11249     free (r);
11250   }
11251   return 0;
11252 }
11253
11254 static int test_mkfs_0_skip (void)
11255 {
11256   const char *str;
11257
11258   str = getenv ("SKIP_TEST_MKFS_0");
11259   if (str && strcmp (str, "1") == 0) return 1;
11260   str = getenv ("SKIP_TEST_MKFS");
11261   if (str && strcmp (str, "1") == 0) return 1;
11262   return 0;
11263 }
11264
11265 static int test_mkfs_0 (void)
11266 {
11267   if (test_mkfs_0_skip ()) {
11268     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11269     return 0;
11270   }
11271
11272   /* InitNone|InitEmpty for test_mkfs_0 */
11273   {
11274     char device[] = "/dev/sda";
11275     device[5] = devchar;
11276     int r;
11277     suppress_error = 0;
11278     r = guestfs_blockdev_setrw (g, device);
11279     if (r == -1)
11280       return -1;
11281   }
11282   {
11283     int r;
11284     suppress_error = 0;
11285     r = guestfs_umount_all (g);
11286     if (r == -1)
11287       return -1;
11288   }
11289   {
11290     int r;
11291     suppress_error = 0;
11292     r = guestfs_lvm_remove_all (g);
11293     if (r == -1)
11294       return -1;
11295   }
11296   /* TestOutput for mkfs (0) */
11297   char expected[] = "new file contents";
11298   {
11299     char device[] = "/dev/sda";
11300     device[5] = devchar;
11301     char lines_0[] = ",";
11302     char *lines[] = {
11303       lines_0,
11304       NULL
11305     };
11306     int r;
11307     suppress_error = 0;
11308     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11309     if (r == -1)
11310       return -1;
11311   }
11312   {
11313     char fstype[] = "ext2";
11314     char device[] = "/dev/sda1";
11315     device[5] = devchar;
11316     int r;
11317     suppress_error = 0;
11318     r = guestfs_mkfs (g, fstype, device);
11319     if (r == -1)
11320       return -1;
11321   }
11322   {
11323     char device[] = "/dev/sda1";
11324     device[5] = devchar;
11325     char mountpoint[] = "/";
11326     int r;
11327     suppress_error = 0;
11328     r = guestfs_mount (g, device, mountpoint);
11329     if (r == -1)
11330       return -1;
11331   }
11332   {
11333     char path[] = "/new";
11334     char content[] = "new file contents";
11335     int r;
11336     suppress_error = 0;
11337     r = guestfs_write_file (g, path, content, 0);
11338     if (r == -1)
11339       return -1;
11340   }
11341   {
11342     char path[] = "/new";
11343     char *r;
11344     suppress_error = 0;
11345     r = guestfs_cat (g, path);
11346     if (r == NULL)
11347       return -1;
11348     if (strcmp (r, expected) != 0) {
11349       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11350       return -1;
11351     }
11352     free (r);
11353   }
11354   return 0;
11355 }
11356
11357 static int test_lvcreate_0_skip (void)
11358 {
11359   const char *str;
11360
11361   str = getenv ("SKIP_TEST_LVCREATE_0");
11362   if (str && strcmp (str, "1") == 0) return 1;
11363   str = getenv ("SKIP_TEST_LVCREATE");
11364   if (str && strcmp (str, "1") == 0) return 1;
11365   return 0;
11366 }
11367
11368 static int test_lvcreate_0 (void)
11369 {
11370   if (test_lvcreate_0_skip ()) {
11371     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11372     return 0;
11373   }
11374
11375   /* InitNone|InitEmpty for test_lvcreate_0 */
11376   {
11377     char device[] = "/dev/sda";
11378     device[5] = devchar;
11379     int r;
11380     suppress_error = 0;
11381     r = guestfs_blockdev_setrw (g, device);
11382     if (r == -1)
11383       return -1;
11384   }
11385   {
11386     int r;
11387     suppress_error = 0;
11388     r = guestfs_umount_all (g);
11389     if (r == -1)
11390       return -1;
11391   }
11392   {
11393     int r;
11394     suppress_error = 0;
11395     r = guestfs_lvm_remove_all (g);
11396     if (r == -1)
11397       return -1;
11398   }
11399   /* TestOutputList for lvcreate (0) */
11400   {
11401     char device[] = "/dev/sda";
11402     device[5] = devchar;
11403     char lines_0[] = ",10";
11404     char lines_1[] = ",20";
11405     char lines_2[] = ",";
11406     char *lines[] = {
11407       lines_0,
11408       lines_1,
11409       lines_2,
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 device[] = "/dev/sda1";
11420     device[5] = devchar;
11421     int r;
11422     suppress_error = 0;
11423     r = guestfs_pvcreate (g, device);
11424     if (r == -1)
11425       return -1;
11426   }
11427   {
11428     char device[] = "/dev/sda2";
11429     device[5] = devchar;
11430     int r;
11431     suppress_error = 0;
11432     r = guestfs_pvcreate (g, device);
11433     if (r == -1)
11434       return -1;
11435   }
11436   {
11437     char device[] = "/dev/sda3";
11438     device[5] = devchar;
11439     int r;
11440     suppress_error = 0;
11441     r = guestfs_pvcreate (g, device);
11442     if (r == -1)
11443       return -1;
11444   }
11445   {
11446     char volgroup[] = "VG1";
11447     char physvols_0[] = "/dev/sda1";
11448     physvols_0[5] = devchar;
11449     char physvols_1[] = "/dev/sda2";
11450     physvols_1[5] = devchar;
11451     char *physvols[] = {
11452       physvols_0,
11453       physvols_1,
11454       NULL
11455     };
11456     int r;
11457     suppress_error = 0;
11458     r = guestfs_vgcreate (g, volgroup, physvols);
11459     if (r == -1)
11460       return -1;
11461   }
11462   {
11463     char volgroup[] = "VG2";
11464     char physvols_0[] = "/dev/sda3";
11465     physvols_0[5] = devchar;
11466     char *physvols[] = {
11467       physvols_0,
11468       NULL
11469     };
11470     int r;
11471     suppress_error = 0;
11472     r = guestfs_vgcreate (g, volgroup, physvols);
11473     if (r == -1)
11474       return -1;
11475   }
11476   {
11477     char logvol[] = "LV1";
11478     char volgroup[] = "VG1";
11479     int r;
11480     suppress_error = 0;
11481     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11482     if (r == -1)
11483       return -1;
11484   }
11485   {
11486     char logvol[] = "LV2";
11487     char volgroup[] = "VG1";
11488     int r;
11489     suppress_error = 0;
11490     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11491     if (r == -1)
11492       return -1;
11493   }
11494   {
11495     char logvol[] = "LV3";
11496     char volgroup[] = "VG2";
11497     int r;
11498     suppress_error = 0;
11499     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11500     if (r == -1)
11501       return -1;
11502   }
11503   {
11504     char logvol[] = "LV4";
11505     char volgroup[] = "VG2";
11506     int r;
11507     suppress_error = 0;
11508     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11509     if (r == -1)
11510       return -1;
11511   }
11512   {
11513     char logvol[] = "LV5";
11514     char volgroup[] = "VG2";
11515     int r;
11516     suppress_error = 0;
11517     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11518     if (r == -1)
11519       return -1;
11520   }
11521   {
11522     char **r;
11523     int i;
11524     suppress_error = 0;
11525     r = guestfs_lvs (g);
11526     if (r == NULL)
11527       return -1;
11528     if (!r[0]) {
11529       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11530       print_strings (r);
11531       return -1;
11532     }
11533     {
11534       char expected[] = "/dev/VG1/LV1";
11535       if (strcmp (r[0], expected) != 0) {
11536         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11537         return -1;
11538       }
11539     }
11540     if (!r[1]) {
11541       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11542       print_strings (r);
11543       return -1;
11544     }
11545     {
11546       char expected[] = "/dev/VG1/LV2";
11547       if (strcmp (r[1], expected) != 0) {
11548         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11549         return -1;
11550       }
11551     }
11552     if (!r[2]) {
11553       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11554       print_strings (r);
11555       return -1;
11556     }
11557     {
11558       char expected[] = "/dev/VG2/LV3";
11559       if (strcmp (r[2], expected) != 0) {
11560         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11561         return -1;
11562       }
11563     }
11564     if (!r[3]) {
11565       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11566       print_strings (r);
11567       return -1;
11568     }
11569     {
11570       char expected[] = "/dev/VG2/LV4";
11571       if (strcmp (r[3], expected) != 0) {
11572         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11573         return -1;
11574       }
11575     }
11576     if (!r[4]) {
11577       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11578       print_strings (r);
11579       return -1;
11580     }
11581     {
11582       char expected[] = "/dev/VG2/LV5";
11583       if (strcmp (r[4], expected) != 0) {
11584         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11585         return -1;
11586       }
11587     }
11588     if (r[5] != NULL) {
11589       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11590       print_strings (r);
11591       return -1;
11592     }
11593     for (i = 0; r[i] != NULL; ++i)
11594       free (r[i]);
11595     free (r);
11596   }
11597   return 0;
11598 }
11599
11600 static int test_vgcreate_0_skip (void)
11601 {
11602   const char *str;
11603
11604   str = getenv ("SKIP_TEST_VGCREATE_0");
11605   if (str && strcmp (str, "1") == 0) return 1;
11606   str = getenv ("SKIP_TEST_VGCREATE");
11607   if (str && strcmp (str, "1") == 0) return 1;
11608   return 0;
11609 }
11610
11611 static int test_vgcreate_0 (void)
11612 {
11613   if (test_vgcreate_0_skip ()) {
11614     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11615     return 0;
11616   }
11617
11618   /* InitNone|InitEmpty for test_vgcreate_0 */
11619   {
11620     char device[] = "/dev/sda";
11621     device[5] = devchar;
11622     int r;
11623     suppress_error = 0;
11624     r = guestfs_blockdev_setrw (g, device);
11625     if (r == -1)
11626       return -1;
11627   }
11628   {
11629     int r;
11630     suppress_error = 0;
11631     r = guestfs_umount_all (g);
11632     if (r == -1)
11633       return -1;
11634   }
11635   {
11636     int r;
11637     suppress_error = 0;
11638     r = guestfs_lvm_remove_all (g);
11639     if (r == -1)
11640       return -1;
11641   }
11642   /* TestOutputList for vgcreate (0) */
11643   {
11644     char device[] = "/dev/sda";
11645     device[5] = devchar;
11646     char lines_0[] = ",10";
11647     char lines_1[] = ",20";
11648     char lines_2[] = ",";
11649     char *lines[] = {
11650       lines_0,
11651       lines_1,
11652       lines_2,
11653       NULL
11654     };
11655     int r;
11656     suppress_error = 0;
11657     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11658     if (r == -1)
11659       return -1;
11660   }
11661   {
11662     char device[] = "/dev/sda1";
11663     device[5] = devchar;
11664     int r;
11665     suppress_error = 0;
11666     r = guestfs_pvcreate (g, device);
11667     if (r == -1)
11668       return -1;
11669   }
11670   {
11671     char device[] = "/dev/sda2";
11672     device[5] = devchar;
11673     int r;
11674     suppress_error = 0;
11675     r = guestfs_pvcreate (g, device);
11676     if (r == -1)
11677       return -1;
11678   }
11679   {
11680     char device[] = "/dev/sda3";
11681     device[5] = devchar;
11682     int r;
11683     suppress_error = 0;
11684     r = guestfs_pvcreate (g, device);
11685     if (r == -1)
11686       return -1;
11687   }
11688   {
11689     char volgroup[] = "VG1";
11690     char physvols_0[] = "/dev/sda1";
11691     physvols_0[5] = devchar;
11692     char physvols_1[] = "/dev/sda2";
11693     physvols_1[5] = devchar;
11694     char *physvols[] = {
11695       physvols_0,
11696       physvols_1,
11697       NULL
11698     };
11699     int r;
11700     suppress_error = 0;
11701     r = guestfs_vgcreate (g, volgroup, physvols);
11702     if (r == -1)
11703       return -1;
11704   }
11705   {
11706     char volgroup[] = "VG2";
11707     char physvols_0[] = "/dev/sda3";
11708     physvols_0[5] = devchar;
11709     char *physvols[] = {
11710       physvols_0,
11711       NULL
11712     };
11713     int r;
11714     suppress_error = 0;
11715     r = guestfs_vgcreate (g, volgroup, physvols);
11716     if (r == -1)
11717       return -1;
11718   }
11719   {
11720     char **r;
11721     int i;
11722     suppress_error = 0;
11723     r = guestfs_vgs (g);
11724     if (r == NULL)
11725       return -1;
11726     if (!r[0]) {
11727       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11728       print_strings (r);
11729       return -1;
11730     }
11731     {
11732       char expected[] = "VG1";
11733       if (strcmp (r[0], expected) != 0) {
11734         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11735         return -1;
11736       }
11737     }
11738     if (!r[1]) {
11739       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11740       print_strings (r);
11741       return -1;
11742     }
11743     {
11744       char expected[] = "VG2";
11745       if (strcmp (r[1], expected) != 0) {
11746         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11747         return -1;
11748       }
11749     }
11750     if (r[2] != NULL) {
11751       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11752       print_strings (r);
11753       return -1;
11754     }
11755     for (i = 0; r[i] != NULL; ++i)
11756       free (r[i]);
11757     free (r);
11758   }
11759   return 0;
11760 }
11761
11762 static int test_pvcreate_0_skip (void)
11763 {
11764   const char *str;
11765
11766   str = getenv ("SKIP_TEST_PVCREATE_0");
11767   if (str && strcmp (str, "1") == 0) return 1;
11768   str = getenv ("SKIP_TEST_PVCREATE");
11769   if (str && strcmp (str, "1") == 0) return 1;
11770   return 0;
11771 }
11772
11773 static int test_pvcreate_0 (void)
11774 {
11775   if (test_pvcreate_0_skip ()) {
11776     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11777     return 0;
11778   }
11779
11780   /* InitNone|InitEmpty for test_pvcreate_0 */
11781   {
11782     char device[] = "/dev/sda";
11783     device[5] = devchar;
11784     int r;
11785     suppress_error = 0;
11786     r = guestfs_blockdev_setrw (g, device);
11787     if (r == -1)
11788       return -1;
11789   }
11790   {
11791     int r;
11792     suppress_error = 0;
11793     r = guestfs_umount_all (g);
11794     if (r == -1)
11795       return -1;
11796   }
11797   {
11798     int r;
11799     suppress_error = 0;
11800     r = guestfs_lvm_remove_all (g);
11801     if (r == -1)
11802       return -1;
11803   }
11804   /* TestOutputList for pvcreate (0) */
11805   {
11806     char device[] = "/dev/sda";
11807     device[5] = devchar;
11808     char lines_0[] = ",10";
11809     char lines_1[] = ",20";
11810     char lines_2[] = ",";
11811     char *lines[] = {
11812       lines_0,
11813       lines_1,
11814       lines_2,
11815       NULL
11816     };
11817     int r;
11818     suppress_error = 0;
11819     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11820     if (r == -1)
11821       return -1;
11822   }
11823   {
11824     char device[] = "/dev/sda1";
11825     device[5] = devchar;
11826     int r;
11827     suppress_error = 0;
11828     r = guestfs_pvcreate (g, device);
11829     if (r == -1)
11830       return -1;
11831   }
11832   {
11833     char device[] = "/dev/sda2";
11834     device[5] = devchar;
11835     int r;
11836     suppress_error = 0;
11837     r = guestfs_pvcreate (g, device);
11838     if (r == -1)
11839       return -1;
11840   }
11841   {
11842     char device[] = "/dev/sda3";
11843     device[5] = devchar;
11844     int r;
11845     suppress_error = 0;
11846     r = guestfs_pvcreate (g, device);
11847     if (r == -1)
11848       return -1;
11849   }
11850   {
11851     char **r;
11852     int i;
11853     suppress_error = 0;
11854     r = guestfs_pvs (g);
11855     if (r == NULL)
11856       return -1;
11857     if (!r[0]) {
11858       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11859       print_strings (r);
11860       return -1;
11861     }
11862     {
11863       char expected[] = "/dev/sda1";
11864       expected[5] = devchar;
11865       if (strcmp (r[0], expected) != 0) {
11866         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11867         return -1;
11868       }
11869     }
11870     if (!r[1]) {
11871       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11872       print_strings (r);
11873       return -1;
11874     }
11875     {
11876       char expected[] = "/dev/sda2";
11877       expected[5] = devchar;
11878       if (strcmp (r[1], expected) != 0) {
11879         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11880         return -1;
11881       }
11882     }
11883     if (!r[2]) {
11884       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11885       print_strings (r);
11886       return -1;
11887     }
11888     {
11889       char expected[] = "/dev/sda3";
11890       expected[5] = devchar;
11891       if (strcmp (r[2], expected) != 0) {
11892         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11893         return -1;
11894       }
11895     }
11896     if (r[3] != NULL) {
11897       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
11898       print_strings (r);
11899       return -1;
11900     }
11901     for (i = 0; r[i] != NULL; ++i)
11902       free (r[i]);
11903     free (r);
11904   }
11905   return 0;
11906 }
11907
11908 static int test_is_dir_0_skip (void)
11909 {
11910   const char *str;
11911
11912   str = getenv ("SKIP_TEST_IS_DIR_0");
11913   if (str && strcmp (str, "1") == 0) return 1;
11914   str = getenv ("SKIP_TEST_IS_DIR");
11915   if (str && strcmp (str, "1") == 0) return 1;
11916   return 0;
11917 }
11918
11919 static int test_is_dir_0 (void)
11920 {
11921   if (test_is_dir_0_skip ()) {
11922     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
11923     return 0;
11924   }
11925
11926   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
11927   {
11928     char device[] = "/dev/sda";
11929     device[5] = devchar;
11930     int r;
11931     suppress_error = 0;
11932     r = guestfs_blockdev_setrw (g, device);
11933     if (r == -1)
11934       return -1;
11935   }
11936   {
11937     int r;
11938     suppress_error = 0;
11939     r = guestfs_umount_all (g);
11940     if (r == -1)
11941       return -1;
11942   }
11943   {
11944     int r;
11945     suppress_error = 0;
11946     r = guestfs_lvm_remove_all (g);
11947     if (r == -1)
11948       return -1;
11949   }
11950   {
11951     char device[] = "/dev/sda";
11952     device[5] = devchar;
11953     char lines_0[] = ",";
11954     char *lines[] = {
11955       lines_0,
11956       NULL
11957     };
11958     int r;
11959     suppress_error = 0;
11960     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11961     if (r == -1)
11962       return -1;
11963   }
11964   {
11965     char fstype[] = "ext2";
11966     char device[] = "/dev/sda1";
11967     device[5] = devchar;
11968     int r;
11969     suppress_error = 0;
11970     r = guestfs_mkfs (g, fstype, device);
11971     if (r == -1)
11972       return -1;
11973   }
11974   {
11975     char device[] = "/dev/sda1";
11976     device[5] = devchar;
11977     char mountpoint[] = "/";
11978     int r;
11979     suppress_error = 0;
11980     r = guestfs_mount (g, device, mountpoint);
11981     if (r == -1)
11982       return -1;
11983   }
11984   /* TestOutputFalse for is_dir (0) */
11985   {
11986     char path[] = "/new";
11987     int r;
11988     suppress_error = 0;
11989     r = guestfs_touch (g, path);
11990     if (r == -1)
11991       return -1;
11992   }
11993   {
11994     char path[] = "/new";
11995     int r;
11996     suppress_error = 0;
11997     r = guestfs_is_dir (g, path);
11998     if (r == -1)
11999       return -1;
12000     if (r) {
12001       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12002       return -1;
12003     }
12004   }
12005   return 0;
12006 }
12007
12008 static int test_is_dir_1_skip (void)
12009 {
12010   const char *str;
12011
12012   str = getenv ("SKIP_TEST_IS_DIR_1");
12013   if (str && strcmp (str, "1") == 0) return 1;
12014   str = getenv ("SKIP_TEST_IS_DIR");
12015   if (str && strcmp (str, "1") == 0) return 1;
12016   return 0;
12017 }
12018
12019 static int test_is_dir_1 (void)
12020 {
12021   if (test_is_dir_1_skip ()) {
12022     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12023     return 0;
12024   }
12025
12026   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12027   {
12028     char device[] = "/dev/sda";
12029     device[5] = devchar;
12030     int r;
12031     suppress_error = 0;
12032     r = guestfs_blockdev_setrw (g, device);
12033     if (r == -1)
12034       return -1;
12035   }
12036   {
12037     int r;
12038     suppress_error = 0;
12039     r = guestfs_umount_all (g);
12040     if (r == -1)
12041       return -1;
12042   }
12043   {
12044     int r;
12045     suppress_error = 0;
12046     r = guestfs_lvm_remove_all (g);
12047     if (r == -1)
12048       return -1;
12049   }
12050   {
12051     char device[] = "/dev/sda";
12052     device[5] = devchar;
12053     char lines_0[] = ",";
12054     char *lines[] = {
12055       lines_0,
12056       NULL
12057     };
12058     int r;
12059     suppress_error = 0;
12060     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12061     if (r == -1)
12062       return -1;
12063   }
12064   {
12065     char fstype[] = "ext2";
12066     char device[] = "/dev/sda1";
12067     device[5] = devchar;
12068     int r;
12069     suppress_error = 0;
12070     r = guestfs_mkfs (g, fstype, device);
12071     if (r == -1)
12072       return -1;
12073   }
12074   {
12075     char device[] = "/dev/sda1";
12076     device[5] = devchar;
12077     char mountpoint[] = "/";
12078     int r;
12079     suppress_error = 0;
12080     r = guestfs_mount (g, device, mountpoint);
12081     if (r == -1)
12082       return -1;
12083   }
12084   /* TestOutputTrue for is_dir (1) */
12085   {
12086     char path[] = "/new";
12087     int r;
12088     suppress_error = 0;
12089     r = guestfs_mkdir (g, path);
12090     if (r == -1)
12091       return -1;
12092   }
12093   {
12094     char path[] = "/new";
12095     int r;
12096     suppress_error = 0;
12097     r = guestfs_is_dir (g, path);
12098     if (r == -1)
12099       return -1;
12100     if (!r) {
12101       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12102       return -1;
12103     }
12104   }
12105   return 0;
12106 }
12107
12108 static int test_is_file_0_skip (void)
12109 {
12110   const char *str;
12111
12112   str = getenv ("SKIP_TEST_IS_FILE_0");
12113   if (str && strcmp (str, "1") == 0) return 1;
12114   str = getenv ("SKIP_TEST_IS_FILE");
12115   if (str && strcmp (str, "1") == 0) return 1;
12116   return 0;
12117 }
12118
12119 static int test_is_file_0 (void)
12120 {
12121   if (test_is_file_0_skip ()) {
12122     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12123     return 0;
12124   }
12125
12126   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12127   {
12128     char device[] = "/dev/sda";
12129     device[5] = devchar;
12130     int r;
12131     suppress_error = 0;
12132     r = guestfs_blockdev_setrw (g, device);
12133     if (r == -1)
12134       return -1;
12135   }
12136   {
12137     int r;
12138     suppress_error = 0;
12139     r = guestfs_umount_all (g);
12140     if (r == -1)
12141       return -1;
12142   }
12143   {
12144     int r;
12145     suppress_error = 0;
12146     r = guestfs_lvm_remove_all (g);
12147     if (r == -1)
12148       return -1;
12149   }
12150   {
12151     char device[] = "/dev/sda";
12152     device[5] = devchar;
12153     char lines_0[] = ",";
12154     char *lines[] = {
12155       lines_0,
12156       NULL
12157     };
12158     int r;
12159     suppress_error = 0;
12160     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12161     if (r == -1)
12162       return -1;
12163   }
12164   {
12165     char fstype[] = "ext2";
12166     char device[] = "/dev/sda1";
12167     device[5] = devchar;
12168     int r;
12169     suppress_error = 0;
12170     r = guestfs_mkfs (g, fstype, device);
12171     if (r == -1)
12172       return -1;
12173   }
12174   {
12175     char device[] = "/dev/sda1";
12176     device[5] = devchar;
12177     char mountpoint[] = "/";
12178     int r;
12179     suppress_error = 0;
12180     r = guestfs_mount (g, device, mountpoint);
12181     if (r == -1)
12182       return -1;
12183   }
12184   /* TestOutputTrue for is_file (0) */
12185   {
12186     char path[] = "/new";
12187     int r;
12188     suppress_error = 0;
12189     r = guestfs_touch (g, path);
12190     if (r == -1)
12191       return -1;
12192   }
12193   {
12194     char path[] = "/new";
12195     int r;
12196     suppress_error = 0;
12197     r = guestfs_is_file (g, path);
12198     if (r == -1)
12199       return -1;
12200     if (!r) {
12201       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12202       return -1;
12203     }
12204   }
12205   return 0;
12206 }
12207
12208 static int test_is_file_1_skip (void)
12209 {
12210   const char *str;
12211
12212   str = getenv ("SKIP_TEST_IS_FILE_1");
12213   if (str && strcmp (str, "1") == 0) return 1;
12214   str = getenv ("SKIP_TEST_IS_FILE");
12215   if (str && strcmp (str, "1") == 0) return 1;
12216   return 0;
12217 }
12218
12219 static int test_is_file_1 (void)
12220 {
12221   if (test_is_file_1_skip ()) {
12222     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12223     return 0;
12224   }
12225
12226   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12227   {
12228     char device[] = "/dev/sda";
12229     device[5] = devchar;
12230     int r;
12231     suppress_error = 0;
12232     r = guestfs_blockdev_setrw (g, device);
12233     if (r == -1)
12234       return -1;
12235   }
12236   {
12237     int r;
12238     suppress_error = 0;
12239     r = guestfs_umount_all (g);
12240     if (r == -1)
12241       return -1;
12242   }
12243   {
12244     int r;
12245     suppress_error = 0;
12246     r = guestfs_lvm_remove_all (g);
12247     if (r == -1)
12248       return -1;
12249   }
12250   {
12251     char device[] = "/dev/sda";
12252     device[5] = devchar;
12253     char lines_0[] = ",";
12254     char *lines[] = {
12255       lines_0,
12256       NULL
12257     };
12258     int r;
12259     suppress_error = 0;
12260     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12261     if (r == -1)
12262       return -1;
12263   }
12264   {
12265     char fstype[] = "ext2";
12266     char device[] = "/dev/sda1";
12267     device[5] = devchar;
12268     int r;
12269     suppress_error = 0;
12270     r = guestfs_mkfs (g, fstype, device);
12271     if (r == -1)
12272       return -1;
12273   }
12274   {
12275     char device[] = "/dev/sda1";
12276     device[5] = devchar;
12277     char mountpoint[] = "/";
12278     int r;
12279     suppress_error = 0;
12280     r = guestfs_mount (g, device, mountpoint);
12281     if (r == -1)
12282       return -1;
12283   }
12284   /* TestOutputFalse for is_file (1) */
12285   {
12286     char path[] = "/new";
12287     int r;
12288     suppress_error = 0;
12289     r = guestfs_mkdir (g, path);
12290     if (r == -1)
12291       return -1;
12292   }
12293   {
12294     char path[] = "/new";
12295     int r;
12296     suppress_error = 0;
12297     r = guestfs_is_file (g, path);
12298     if (r == -1)
12299       return -1;
12300     if (r) {
12301       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12302       return -1;
12303     }
12304   }
12305   return 0;
12306 }
12307
12308 static int test_exists_0_skip (void)
12309 {
12310   const char *str;
12311
12312   str = getenv ("SKIP_TEST_EXISTS_0");
12313   if (str && strcmp (str, "1") == 0) return 1;
12314   str = getenv ("SKIP_TEST_EXISTS");
12315   if (str && strcmp (str, "1") == 0) return 1;
12316   return 0;
12317 }
12318
12319 static int test_exists_0 (void)
12320 {
12321   if (test_exists_0_skip ()) {
12322     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12323     return 0;
12324   }
12325
12326   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12327   {
12328     char device[] = "/dev/sda";
12329     device[5] = devchar;
12330     int r;
12331     suppress_error = 0;
12332     r = guestfs_blockdev_setrw (g, device);
12333     if (r == -1)
12334       return -1;
12335   }
12336   {
12337     int r;
12338     suppress_error = 0;
12339     r = guestfs_umount_all (g);
12340     if (r == -1)
12341       return -1;
12342   }
12343   {
12344     int r;
12345     suppress_error = 0;
12346     r = guestfs_lvm_remove_all (g);
12347     if (r == -1)
12348       return -1;
12349   }
12350   {
12351     char device[] = "/dev/sda";
12352     device[5] = devchar;
12353     char lines_0[] = ",";
12354     char *lines[] = {
12355       lines_0,
12356       NULL
12357     };
12358     int r;
12359     suppress_error = 0;
12360     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12361     if (r == -1)
12362       return -1;
12363   }
12364   {
12365     char fstype[] = "ext2";
12366     char device[] = "/dev/sda1";
12367     device[5] = devchar;
12368     int r;
12369     suppress_error = 0;
12370     r = guestfs_mkfs (g, fstype, device);
12371     if (r == -1)
12372       return -1;
12373   }
12374   {
12375     char device[] = "/dev/sda1";
12376     device[5] = devchar;
12377     char mountpoint[] = "/";
12378     int r;
12379     suppress_error = 0;
12380     r = guestfs_mount (g, device, mountpoint);
12381     if (r == -1)
12382       return -1;
12383   }
12384   /* TestOutputTrue for exists (0) */
12385   {
12386     char path[] = "/new";
12387     int r;
12388     suppress_error = 0;
12389     r = guestfs_touch (g, path);
12390     if (r == -1)
12391       return -1;
12392   }
12393   {
12394     char path[] = "/new";
12395     int r;
12396     suppress_error = 0;
12397     r = guestfs_exists (g, path);
12398     if (r == -1)
12399       return -1;
12400     if (!r) {
12401       fprintf (stderr, "test_exists_0: expected true, got false\n");
12402       return -1;
12403     }
12404   }
12405   return 0;
12406 }
12407
12408 static int test_exists_1_skip (void)
12409 {
12410   const char *str;
12411
12412   str = getenv ("SKIP_TEST_EXISTS_1");
12413   if (str && strcmp (str, "1") == 0) return 1;
12414   str = getenv ("SKIP_TEST_EXISTS");
12415   if (str && strcmp (str, "1") == 0) return 1;
12416   return 0;
12417 }
12418
12419 static int test_exists_1 (void)
12420 {
12421   if (test_exists_1_skip ()) {
12422     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12423     return 0;
12424   }
12425
12426   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12427   {
12428     char device[] = "/dev/sda";
12429     device[5] = devchar;
12430     int r;
12431     suppress_error = 0;
12432     r = guestfs_blockdev_setrw (g, device);
12433     if (r == -1)
12434       return -1;
12435   }
12436   {
12437     int r;
12438     suppress_error = 0;
12439     r = guestfs_umount_all (g);
12440     if (r == -1)
12441       return -1;
12442   }
12443   {
12444     int r;
12445     suppress_error = 0;
12446     r = guestfs_lvm_remove_all (g);
12447     if (r == -1)
12448       return -1;
12449   }
12450   {
12451     char device[] = "/dev/sda";
12452     device[5] = devchar;
12453     char lines_0[] = ",";
12454     char *lines[] = {
12455       lines_0,
12456       NULL
12457     };
12458     int r;
12459     suppress_error = 0;
12460     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12461     if (r == -1)
12462       return -1;
12463   }
12464   {
12465     char fstype[] = "ext2";
12466     char device[] = "/dev/sda1";
12467     device[5] = devchar;
12468     int r;
12469     suppress_error = 0;
12470     r = guestfs_mkfs (g, fstype, device);
12471     if (r == -1)
12472       return -1;
12473   }
12474   {
12475     char device[] = "/dev/sda1";
12476     device[5] = devchar;
12477     char mountpoint[] = "/";
12478     int r;
12479     suppress_error = 0;
12480     r = guestfs_mount (g, device, mountpoint);
12481     if (r == -1)
12482       return -1;
12483   }
12484   /* TestOutputTrue for exists (1) */
12485   {
12486     char path[] = "/new";
12487     int r;
12488     suppress_error = 0;
12489     r = guestfs_mkdir (g, path);
12490     if (r == -1)
12491       return -1;
12492   }
12493   {
12494     char path[] = "/new";
12495     int r;
12496     suppress_error = 0;
12497     r = guestfs_exists (g, path);
12498     if (r == -1)
12499       return -1;
12500     if (!r) {
12501       fprintf (stderr, "test_exists_1: expected true, got false\n");
12502       return -1;
12503     }
12504   }
12505   return 0;
12506 }
12507
12508 static int test_mkdir_p_0_skip (void)
12509 {
12510   const char *str;
12511
12512   str = getenv ("SKIP_TEST_MKDIR_P_0");
12513   if (str && strcmp (str, "1") == 0) return 1;
12514   str = getenv ("SKIP_TEST_MKDIR_P");
12515   if (str && strcmp (str, "1") == 0) return 1;
12516   return 0;
12517 }
12518
12519 static int test_mkdir_p_0 (void)
12520 {
12521   if (test_mkdir_p_0_skip ()) {
12522     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12523     return 0;
12524   }
12525
12526   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12527   {
12528     char device[] = "/dev/sda";
12529     device[5] = devchar;
12530     int r;
12531     suppress_error = 0;
12532     r = guestfs_blockdev_setrw (g, device);
12533     if (r == -1)
12534       return -1;
12535   }
12536   {
12537     int r;
12538     suppress_error = 0;
12539     r = guestfs_umount_all (g);
12540     if (r == -1)
12541       return -1;
12542   }
12543   {
12544     int r;
12545     suppress_error = 0;
12546     r = guestfs_lvm_remove_all (g);
12547     if (r == -1)
12548       return -1;
12549   }
12550   {
12551     char device[] = "/dev/sda";
12552     device[5] = devchar;
12553     char lines_0[] = ",";
12554     char *lines[] = {
12555       lines_0,
12556       NULL
12557     };
12558     int r;
12559     suppress_error = 0;
12560     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12561     if (r == -1)
12562       return -1;
12563   }
12564   {
12565     char fstype[] = "ext2";
12566     char device[] = "/dev/sda1";
12567     device[5] = devchar;
12568     int r;
12569     suppress_error = 0;
12570     r = guestfs_mkfs (g, fstype, device);
12571     if (r == -1)
12572       return -1;
12573   }
12574   {
12575     char device[] = "/dev/sda1";
12576     device[5] = devchar;
12577     char mountpoint[] = "/";
12578     int r;
12579     suppress_error = 0;
12580     r = guestfs_mount (g, device, mountpoint);
12581     if (r == -1)
12582       return -1;
12583   }
12584   /* TestOutputTrue for mkdir_p (0) */
12585   {
12586     char path[] = "/new/foo/bar";
12587     int r;
12588     suppress_error = 0;
12589     r = guestfs_mkdir_p (g, path);
12590     if (r == -1)
12591       return -1;
12592   }
12593   {
12594     char path[] = "/new/foo/bar";
12595     int r;
12596     suppress_error = 0;
12597     r = guestfs_is_dir (g, path);
12598     if (r == -1)
12599       return -1;
12600     if (!r) {
12601       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12602       return -1;
12603     }
12604   }
12605   return 0;
12606 }
12607
12608 static int test_mkdir_p_1_skip (void)
12609 {
12610   const char *str;
12611
12612   str = getenv ("SKIP_TEST_MKDIR_P_1");
12613   if (str && strcmp (str, "1") == 0) return 1;
12614   str = getenv ("SKIP_TEST_MKDIR_P");
12615   if (str && strcmp (str, "1") == 0) return 1;
12616   return 0;
12617 }
12618
12619 static int test_mkdir_p_1 (void)
12620 {
12621   if (test_mkdir_p_1_skip ()) {
12622     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12623     return 0;
12624   }
12625
12626   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12627   {
12628     char device[] = "/dev/sda";
12629     device[5] = devchar;
12630     int r;
12631     suppress_error = 0;
12632     r = guestfs_blockdev_setrw (g, device);
12633     if (r == -1)
12634       return -1;
12635   }
12636   {
12637     int r;
12638     suppress_error = 0;
12639     r = guestfs_umount_all (g);
12640     if (r == -1)
12641       return -1;
12642   }
12643   {
12644     int r;
12645     suppress_error = 0;
12646     r = guestfs_lvm_remove_all (g);
12647     if (r == -1)
12648       return -1;
12649   }
12650   {
12651     char device[] = "/dev/sda";
12652     device[5] = devchar;
12653     char lines_0[] = ",";
12654     char *lines[] = {
12655       lines_0,
12656       NULL
12657     };
12658     int r;
12659     suppress_error = 0;
12660     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12661     if (r == -1)
12662       return -1;
12663   }
12664   {
12665     char fstype[] = "ext2";
12666     char device[] = "/dev/sda1";
12667     device[5] = devchar;
12668     int r;
12669     suppress_error = 0;
12670     r = guestfs_mkfs (g, fstype, device);
12671     if (r == -1)
12672       return -1;
12673   }
12674   {
12675     char device[] = "/dev/sda1";
12676     device[5] = devchar;
12677     char mountpoint[] = "/";
12678     int r;
12679     suppress_error = 0;
12680     r = guestfs_mount (g, device, mountpoint);
12681     if (r == -1)
12682       return -1;
12683   }
12684   /* TestOutputTrue for mkdir_p (1) */
12685   {
12686     char path[] = "/new/foo/bar";
12687     int r;
12688     suppress_error = 0;
12689     r = guestfs_mkdir_p (g, path);
12690     if (r == -1)
12691       return -1;
12692   }
12693   {
12694     char path[] = "/new/foo";
12695     int r;
12696     suppress_error = 0;
12697     r = guestfs_is_dir (g, path);
12698     if (r == -1)
12699       return -1;
12700     if (!r) {
12701       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12702       return -1;
12703     }
12704   }
12705   return 0;
12706 }
12707
12708 static int test_mkdir_p_2_skip (void)
12709 {
12710   const char *str;
12711
12712   str = getenv ("SKIP_TEST_MKDIR_P_2");
12713   if (str && strcmp (str, "1") == 0) return 1;
12714   str = getenv ("SKIP_TEST_MKDIR_P");
12715   if (str && strcmp (str, "1") == 0) return 1;
12716   return 0;
12717 }
12718
12719 static int test_mkdir_p_2 (void)
12720 {
12721   if (test_mkdir_p_2_skip ()) {
12722     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12723     return 0;
12724   }
12725
12726   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12727   {
12728     char device[] = "/dev/sda";
12729     device[5] = devchar;
12730     int r;
12731     suppress_error = 0;
12732     r = guestfs_blockdev_setrw (g, device);
12733     if (r == -1)
12734       return -1;
12735   }
12736   {
12737     int r;
12738     suppress_error = 0;
12739     r = guestfs_umount_all (g);
12740     if (r == -1)
12741       return -1;
12742   }
12743   {
12744     int r;
12745     suppress_error = 0;
12746     r = guestfs_lvm_remove_all (g);
12747     if (r == -1)
12748       return -1;
12749   }
12750   {
12751     char device[] = "/dev/sda";
12752     device[5] = devchar;
12753     char lines_0[] = ",";
12754     char *lines[] = {
12755       lines_0,
12756       NULL
12757     };
12758     int r;
12759     suppress_error = 0;
12760     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12761     if (r == -1)
12762       return -1;
12763   }
12764   {
12765     char fstype[] = "ext2";
12766     char device[] = "/dev/sda1";
12767     device[5] = devchar;
12768     int r;
12769     suppress_error = 0;
12770     r = guestfs_mkfs (g, fstype, device);
12771     if (r == -1)
12772       return -1;
12773   }
12774   {
12775     char device[] = "/dev/sda1";
12776     device[5] = devchar;
12777     char mountpoint[] = "/";
12778     int r;
12779     suppress_error = 0;
12780     r = guestfs_mount (g, device, mountpoint);
12781     if (r == -1)
12782       return -1;
12783   }
12784   /* TestOutputTrue for mkdir_p (2) */
12785   {
12786     char path[] = "/new/foo/bar";
12787     int r;
12788     suppress_error = 0;
12789     r = guestfs_mkdir_p (g, path);
12790     if (r == -1)
12791       return -1;
12792   }
12793   {
12794     char path[] = "/new";
12795     int r;
12796     suppress_error = 0;
12797     r = guestfs_is_dir (g, path);
12798     if (r == -1)
12799       return -1;
12800     if (!r) {
12801       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12802       return -1;
12803     }
12804   }
12805   return 0;
12806 }
12807
12808 static int test_mkdir_0_skip (void)
12809 {
12810   const char *str;
12811
12812   str = getenv ("SKIP_TEST_MKDIR_0");
12813   if (str && strcmp (str, "1") == 0) return 1;
12814   str = getenv ("SKIP_TEST_MKDIR");
12815   if (str && strcmp (str, "1") == 0) return 1;
12816   return 0;
12817 }
12818
12819 static int test_mkdir_0 (void)
12820 {
12821   if (test_mkdir_0_skip ()) {
12822     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
12823     return 0;
12824   }
12825
12826   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
12827   {
12828     char device[] = "/dev/sda";
12829     device[5] = devchar;
12830     int r;
12831     suppress_error = 0;
12832     r = guestfs_blockdev_setrw (g, device);
12833     if (r == -1)
12834       return -1;
12835   }
12836   {
12837     int r;
12838     suppress_error = 0;
12839     r = guestfs_umount_all (g);
12840     if (r == -1)
12841       return -1;
12842   }
12843   {
12844     int r;
12845     suppress_error = 0;
12846     r = guestfs_lvm_remove_all (g);
12847     if (r == -1)
12848       return -1;
12849   }
12850   {
12851     char device[] = "/dev/sda";
12852     device[5] = devchar;
12853     char lines_0[] = ",";
12854     char *lines[] = {
12855       lines_0,
12856       NULL
12857     };
12858     int r;
12859     suppress_error = 0;
12860     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12861     if (r == -1)
12862       return -1;
12863   }
12864   {
12865     char fstype[] = "ext2";
12866     char device[] = "/dev/sda1";
12867     device[5] = devchar;
12868     int r;
12869     suppress_error = 0;
12870     r = guestfs_mkfs (g, fstype, device);
12871     if (r == -1)
12872       return -1;
12873   }
12874   {
12875     char device[] = "/dev/sda1";
12876     device[5] = devchar;
12877     char mountpoint[] = "/";
12878     int r;
12879     suppress_error = 0;
12880     r = guestfs_mount (g, device, mountpoint);
12881     if (r == -1)
12882       return -1;
12883   }
12884   /* TestOutputTrue for mkdir (0) */
12885   {
12886     char path[] = "/new";
12887     int r;
12888     suppress_error = 0;
12889     r = guestfs_mkdir (g, path);
12890     if (r == -1)
12891       return -1;
12892   }
12893   {
12894     char path[] = "/new";
12895     int r;
12896     suppress_error = 0;
12897     r = guestfs_is_dir (g, path);
12898     if (r == -1)
12899       return -1;
12900     if (!r) {
12901       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
12902       return -1;
12903     }
12904   }
12905   return 0;
12906 }
12907
12908 static int test_mkdir_1_skip (void)
12909 {
12910   const char *str;
12911
12912   str = getenv ("SKIP_TEST_MKDIR_1");
12913   if (str && strcmp (str, "1") == 0) return 1;
12914   str = getenv ("SKIP_TEST_MKDIR");
12915   if (str && strcmp (str, "1") == 0) return 1;
12916   return 0;
12917 }
12918
12919 static int test_mkdir_1 (void)
12920 {
12921   if (test_mkdir_1_skip ()) {
12922     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
12923     return 0;
12924   }
12925
12926   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
12927   {
12928     char device[] = "/dev/sda";
12929     device[5] = devchar;
12930     int r;
12931     suppress_error = 0;
12932     r = guestfs_blockdev_setrw (g, device);
12933     if (r == -1)
12934       return -1;
12935   }
12936   {
12937     int r;
12938     suppress_error = 0;
12939     r = guestfs_umount_all (g);
12940     if (r == -1)
12941       return -1;
12942   }
12943   {
12944     int r;
12945     suppress_error = 0;
12946     r = guestfs_lvm_remove_all (g);
12947     if (r == -1)
12948       return -1;
12949   }
12950   {
12951     char device[] = "/dev/sda";
12952     device[5] = devchar;
12953     char lines_0[] = ",";
12954     char *lines[] = {
12955       lines_0,
12956       NULL
12957     };
12958     int r;
12959     suppress_error = 0;
12960     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12961     if (r == -1)
12962       return -1;
12963   }
12964   {
12965     char fstype[] = "ext2";
12966     char device[] = "/dev/sda1";
12967     device[5] = devchar;
12968     int r;
12969     suppress_error = 0;
12970     r = guestfs_mkfs (g, fstype, device);
12971     if (r == -1)
12972       return -1;
12973   }
12974   {
12975     char device[] = "/dev/sda1";
12976     device[5] = devchar;
12977     char mountpoint[] = "/";
12978     int r;
12979     suppress_error = 0;
12980     r = guestfs_mount (g, device, mountpoint);
12981     if (r == -1)
12982       return -1;
12983   }
12984   /* TestLastFail for mkdir (1) */
12985   {
12986     char path[] = "/new/foo/bar";
12987     int r;
12988     suppress_error = 1;
12989     r = guestfs_mkdir (g, path);
12990     if (r != -1)
12991       return -1;
12992   }
12993   return 0;
12994 }
12995
12996 static int test_rm_rf_0_skip (void)
12997 {
12998   const char *str;
12999
13000   str = getenv ("SKIP_TEST_RM_RF_0");
13001   if (str && strcmp (str, "1") == 0) return 1;
13002   str = getenv ("SKIP_TEST_RM_RF");
13003   if (str && strcmp (str, "1") == 0) return 1;
13004   return 0;
13005 }
13006
13007 static int test_rm_rf_0 (void)
13008 {
13009   if (test_rm_rf_0_skip ()) {
13010     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13011     return 0;
13012   }
13013
13014   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13015   {
13016     char device[] = "/dev/sda";
13017     device[5] = devchar;
13018     int r;
13019     suppress_error = 0;
13020     r = guestfs_blockdev_setrw (g, device);
13021     if (r == -1)
13022       return -1;
13023   }
13024   {
13025     int r;
13026     suppress_error = 0;
13027     r = guestfs_umount_all (g);
13028     if (r == -1)
13029       return -1;
13030   }
13031   {
13032     int r;
13033     suppress_error = 0;
13034     r = guestfs_lvm_remove_all (g);
13035     if (r == -1)
13036       return -1;
13037   }
13038   {
13039     char device[] = "/dev/sda";
13040     device[5] = devchar;
13041     char lines_0[] = ",";
13042     char *lines[] = {
13043       lines_0,
13044       NULL
13045     };
13046     int r;
13047     suppress_error = 0;
13048     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13049     if (r == -1)
13050       return -1;
13051   }
13052   {
13053     char fstype[] = "ext2";
13054     char device[] = "/dev/sda1";
13055     device[5] = devchar;
13056     int r;
13057     suppress_error = 0;
13058     r = guestfs_mkfs (g, fstype, device);
13059     if (r == -1)
13060       return -1;
13061   }
13062   {
13063     char device[] = "/dev/sda1";
13064     device[5] = devchar;
13065     char mountpoint[] = "/";
13066     int r;
13067     suppress_error = 0;
13068     r = guestfs_mount (g, device, mountpoint);
13069     if (r == -1)
13070       return -1;
13071   }
13072   /* TestOutputFalse for rm_rf (0) */
13073   {
13074     char path[] = "/new";
13075     int r;
13076     suppress_error = 0;
13077     r = guestfs_mkdir (g, path);
13078     if (r == -1)
13079       return -1;
13080   }
13081   {
13082     char path[] = "/new/foo";
13083     int r;
13084     suppress_error = 0;
13085     r = guestfs_mkdir (g, path);
13086     if (r == -1)
13087       return -1;
13088   }
13089   {
13090     char path[] = "/new/foo/bar";
13091     int r;
13092     suppress_error = 0;
13093     r = guestfs_touch (g, path);
13094     if (r == -1)
13095       return -1;
13096   }
13097   {
13098     char path[] = "/new";
13099     int r;
13100     suppress_error = 0;
13101     r = guestfs_rm_rf (g, path);
13102     if (r == -1)
13103       return -1;
13104   }
13105   {
13106     char path[] = "/new";
13107     int r;
13108     suppress_error = 0;
13109     r = guestfs_exists (g, path);
13110     if (r == -1)
13111       return -1;
13112     if (r) {
13113       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13114       return -1;
13115     }
13116   }
13117   return 0;
13118 }
13119
13120 static int test_rmdir_0_skip (void)
13121 {
13122   const char *str;
13123
13124   str = getenv ("SKIP_TEST_RMDIR_0");
13125   if (str && strcmp (str, "1") == 0) return 1;
13126   str = getenv ("SKIP_TEST_RMDIR");
13127   if (str && strcmp (str, "1") == 0) return 1;
13128   return 0;
13129 }
13130
13131 static int test_rmdir_0 (void)
13132 {
13133   if (test_rmdir_0_skip ()) {
13134     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13135     return 0;
13136   }
13137
13138   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13139   {
13140     char device[] = "/dev/sda";
13141     device[5] = devchar;
13142     int r;
13143     suppress_error = 0;
13144     r = guestfs_blockdev_setrw (g, device);
13145     if (r == -1)
13146       return -1;
13147   }
13148   {
13149     int r;
13150     suppress_error = 0;
13151     r = guestfs_umount_all (g);
13152     if (r == -1)
13153       return -1;
13154   }
13155   {
13156     int r;
13157     suppress_error = 0;
13158     r = guestfs_lvm_remove_all (g);
13159     if (r == -1)
13160       return -1;
13161   }
13162   {
13163     char device[] = "/dev/sda";
13164     device[5] = devchar;
13165     char lines_0[] = ",";
13166     char *lines[] = {
13167       lines_0,
13168       NULL
13169     };
13170     int r;
13171     suppress_error = 0;
13172     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13173     if (r == -1)
13174       return -1;
13175   }
13176   {
13177     char fstype[] = "ext2";
13178     char device[] = "/dev/sda1";
13179     device[5] = devchar;
13180     int r;
13181     suppress_error = 0;
13182     r = guestfs_mkfs (g, fstype, device);
13183     if (r == -1)
13184       return -1;
13185   }
13186   {
13187     char device[] = "/dev/sda1";
13188     device[5] = devchar;
13189     char mountpoint[] = "/";
13190     int r;
13191     suppress_error = 0;
13192     r = guestfs_mount (g, device, mountpoint);
13193     if (r == -1)
13194       return -1;
13195   }
13196   /* TestRun for rmdir (0) */
13197   {
13198     char path[] = "/new";
13199     int r;
13200     suppress_error = 0;
13201     r = guestfs_mkdir (g, path);
13202     if (r == -1)
13203       return -1;
13204   }
13205   {
13206     char path[] = "/new";
13207     int r;
13208     suppress_error = 0;
13209     r = guestfs_rmdir (g, path);
13210     if (r == -1)
13211       return -1;
13212   }
13213   return 0;
13214 }
13215
13216 static int test_rmdir_1_skip (void)
13217 {
13218   const char *str;
13219
13220   str = getenv ("SKIP_TEST_RMDIR_1");
13221   if (str && strcmp (str, "1") == 0) return 1;
13222   str = getenv ("SKIP_TEST_RMDIR");
13223   if (str && strcmp (str, "1") == 0) return 1;
13224   return 0;
13225 }
13226
13227 static int test_rmdir_1 (void)
13228 {
13229   if (test_rmdir_1_skip ()) {
13230     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13231     return 0;
13232   }
13233
13234   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13235   {
13236     char device[] = "/dev/sda";
13237     device[5] = devchar;
13238     int r;
13239     suppress_error = 0;
13240     r = guestfs_blockdev_setrw (g, device);
13241     if (r == -1)
13242       return -1;
13243   }
13244   {
13245     int r;
13246     suppress_error = 0;
13247     r = guestfs_umount_all (g);
13248     if (r == -1)
13249       return -1;
13250   }
13251   {
13252     int r;
13253     suppress_error = 0;
13254     r = guestfs_lvm_remove_all (g);
13255     if (r == -1)
13256       return -1;
13257   }
13258   {
13259     char device[] = "/dev/sda";
13260     device[5] = devchar;
13261     char lines_0[] = ",";
13262     char *lines[] = {
13263       lines_0,
13264       NULL
13265     };
13266     int r;
13267     suppress_error = 0;
13268     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13269     if (r == -1)
13270       return -1;
13271   }
13272   {
13273     char fstype[] = "ext2";
13274     char device[] = "/dev/sda1";
13275     device[5] = devchar;
13276     int r;
13277     suppress_error = 0;
13278     r = guestfs_mkfs (g, fstype, device);
13279     if (r == -1)
13280       return -1;
13281   }
13282   {
13283     char device[] = "/dev/sda1";
13284     device[5] = devchar;
13285     char mountpoint[] = "/";
13286     int r;
13287     suppress_error = 0;
13288     r = guestfs_mount (g, device, mountpoint);
13289     if (r == -1)
13290       return -1;
13291   }
13292   /* TestLastFail for rmdir (1) */
13293   {
13294     char path[] = "/new";
13295     int r;
13296     suppress_error = 1;
13297     r = guestfs_rmdir (g, path);
13298     if (r != -1)
13299       return -1;
13300   }
13301   return 0;
13302 }
13303
13304 static int test_rmdir_2_skip (void)
13305 {
13306   const char *str;
13307
13308   str = getenv ("SKIP_TEST_RMDIR_2");
13309   if (str && strcmp (str, "1") == 0) return 1;
13310   str = getenv ("SKIP_TEST_RMDIR");
13311   if (str && strcmp (str, "1") == 0) return 1;
13312   return 0;
13313 }
13314
13315 static int test_rmdir_2 (void)
13316 {
13317   if (test_rmdir_2_skip ()) {
13318     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13319     return 0;
13320   }
13321
13322   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13323   {
13324     char device[] = "/dev/sda";
13325     device[5] = devchar;
13326     int r;
13327     suppress_error = 0;
13328     r = guestfs_blockdev_setrw (g, device);
13329     if (r == -1)
13330       return -1;
13331   }
13332   {
13333     int r;
13334     suppress_error = 0;
13335     r = guestfs_umount_all (g);
13336     if (r == -1)
13337       return -1;
13338   }
13339   {
13340     int r;
13341     suppress_error = 0;
13342     r = guestfs_lvm_remove_all (g);
13343     if (r == -1)
13344       return -1;
13345   }
13346   {
13347     char device[] = "/dev/sda";
13348     device[5] = devchar;
13349     char lines_0[] = ",";
13350     char *lines[] = {
13351       lines_0,
13352       NULL
13353     };
13354     int r;
13355     suppress_error = 0;
13356     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13357     if (r == -1)
13358       return -1;
13359   }
13360   {
13361     char fstype[] = "ext2";
13362     char device[] = "/dev/sda1";
13363     device[5] = devchar;
13364     int r;
13365     suppress_error = 0;
13366     r = guestfs_mkfs (g, fstype, device);
13367     if (r == -1)
13368       return -1;
13369   }
13370   {
13371     char device[] = "/dev/sda1";
13372     device[5] = devchar;
13373     char mountpoint[] = "/";
13374     int r;
13375     suppress_error = 0;
13376     r = guestfs_mount (g, device, mountpoint);
13377     if (r == -1)
13378       return -1;
13379   }
13380   /* TestLastFail for rmdir (2) */
13381   {
13382     char path[] = "/new";
13383     int r;
13384     suppress_error = 0;
13385     r = guestfs_touch (g, path);
13386     if (r == -1)
13387       return -1;
13388   }
13389   {
13390     char path[] = "/new";
13391     int r;
13392     suppress_error = 1;
13393     r = guestfs_rmdir (g, path);
13394     if (r != -1)
13395       return -1;
13396   }
13397   return 0;
13398 }
13399
13400 static int test_rm_0_skip (void)
13401 {
13402   const char *str;
13403
13404   str = getenv ("SKIP_TEST_RM_0");
13405   if (str && strcmp (str, "1") == 0) return 1;
13406   str = getenv ("SKIP_TEST_RM");
13407   if (str && strcmp (str, "1") == 0) return 1;
13408   return 0;
13409 }
13410
13411 static int test_rm_0 (void)
13412 {
13413   if (test_rm_0_skip ()) {
13414     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13415     return 0;
13416   }
13417
13418   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13419   {
13420     char device[] = "/dev/sda";
13421     device[5] = devchar;
13422     int r;
13423     suppress_error = 0;
13424     r = guestfs_blockdev_setrw (g, device);
13425     if (r == -1)
13426       return -1;
13427   }
13428   {
13429     int r;
13430     suppress_error = 0;
13431     r = guestfs_umount_all (g);
13432     if (r == -1)
13433       return -1;
13434   }
13435   {
13436     int r;
13437     suppress_error = 0;
13438     r = guestfs_lvm_remove_all (g);
13439     if (r == -1)
13440       return -1;
13441   }
13442   {
13443     char device[] = "/dev/sda";
13444     device[5] = devchar;
13445     char lines_0[] = ",";
13446     char *lines[] = {
13447       lines_0,
13448       NULL
13449     };
13450     int r;
13451     suppress_error = 0;
13452     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13453     if (r == -1)
13454       return -1;
13455   }
13456   {
13457     char fstype[] = "ext2";
13458     char device[] = "/dev/sda1";
13459     device[5] = devchar;
13460     int r;
13461     suppress_error = 0;
13462     r = guestfs_mkfs (g, fstype, device);
13463     if (r == -1)
13464       return -1;
13465   }
13466   {
13467     char device[] = "/dev/sda1";
13468     device[5] = devchar;
13469     char mountpoint[] = "/";
13470     int r;
13471     suppress_error = 0;
13472     r = guestfs_mount (g, device, mountpoint);
13473     if (r == -1)
13474       return -1;
13475   }
13476   /* TestRun for rm (0) */
13477   {
13478     char path[] = "/new";
13479     int r;
13480     suppress_error = 0;
13481     r = guestfs_touch (g, path);
13482     if (r == -1)
13483       return -1;
13484   }
13485   {
13486     char path[] = "/new";
13487     int r;
13488     suppress_error = 0;
13489     r = guestfs_rm (g, path);
13490     if (r == -1)
13491       return -1;
13492   }
13493   return 0;
13494 }
13495
13496 static int test_rm_1_skip (void)
13497 {
13498   const char *str;
13499
13500   str = getenv ("SKIP_TEST_RM_1");
13501   if (str && strcmp (str, "1") == 0) return 1;
13502   str = getenv ("SKIP_TEST_RM");
13503   if (str && strcmp (str, "1") == 0) return 1;
13504   return 0;
13505 }
13506
13507 static int test_rm_1 (void)
13508 {
13509   if (test_rm_1_skip ()) {
13510     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13511     return 0;
13512   }
13513
13514   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13515   {
13516     char device[] = "/dev/sda";
13517     device[5] = devchar;
13518     int r;
13519     suppress_error = 0;
13520     r = guestfs_blockdev_setrw (g, device);
13521     if (r == -1)
13522       return -1;
13523   }
13524   {
13525     int r;
13526     suppress_error = 0;
13527     r = guestfs_umount_all (g);
13528     if (r == -1)
13529       return -1;
13530   }
13531   {
13532     int r;
13533     suppress_error = 0;
13534     r = guestfs_lvm_remove_all (g);
13535     if (r == -1)
13536       return -1;
13537   }
13538   {
13539     char device[] = "/dev/sda";
13540     device[5] = devchar;
13541     char lines_0[] = ",";
13542     char *lines[] = {
13543       lines_0,
13544       NULL
13545     };
13546     int r;
13547     suppress_error = 0;
13548     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13549     if (r == -1)
13550       return -1;
13551   }
13552   {
13553     char fstype[] = "ext2";
13554     char device[] = "/dev/sda1";
13555     device[5] = devchar;
13556     int r;
13557     suppress_error = 0;
13558     r = guestfs_mkfs (g, fstype, device);
13559     if (r == -1)
13560       return -1;
13561   }
13562   {
13563     char device[] = "/dev/sda1";
13564     device[5] = devchar;
13565     char mountpoint[] = "/";
13566     int r;
13567     suppress_error = 0;
13568     r = guestfs_mount (g, device, mountpoint);
13569     if (r == -1)
13570       return -1;
13571   }
13572   /* TestLastFail for rm (1) */
13573   {
13574     char path[] = "/new";
13575     int r;
13576     suppress_error = 1;
13577     r = guestfs_rm (g, path);
13578     if (r != -1)
13579       return -1;
13580   }
13581   return 0;
13582 }
13583
13584 static int test_rm_2_skip (void)
13585 {
13586   const char *str;
13587
13588   str = getenv ("SKIP_TEST_RM_2");
13589   if (str && strcmp (str, "1") == 0) return 1;
13590   str = getenv ("SKIP_TEST_RM");
13591   if (str && strcmp (str, "1") == 0) return 1;
13592   return 0;
13593 }
13594
13595 static int test_rm_2 (void)
13596 {
13597   if (test_rm_2_skip ()) {
13598     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13599     return 0;
13600   }
13601
13602   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13603   {
13604     char device[] = "/dev/sda";
13605     device[5] = devchar;
13606     int r;
13607     suppress_error = 0;
13608     r = guestfs_blockdev_setrw (g, device);
13609     if (r == -1)
13610       return -1;
13611   }
13612   {
13613     int r;
13614     suppress_error = 0;
13615     r = guestfs_umount_all (g);
13616     if (r == -1)
13617       return -1;
13618   }
13619   {
13620     int r;
13621     suppress_error = 0;
13622     r = guestfs_lvm_remove_all (g);
13623     if (r == -1)
13624       return -1;
13625   }
13626   {
13627     char device[] = "/dev/sda";
13628     device[5] = devchar;
13629     char lines_0[] = ",";
13630     char *lines[] = {
13631       lines_0,
13632       NULL
13633     };
13634     int r;
13635     suppress_error = 0;
13636     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13637     if (r == -1)
13638       return -1;
13639   }
13640   {
13641     char fstype[] = "ext2";
13642     char device[] = "/dev/sda1";
13643     device[5] = devchar;
13644     int r;
13645     suppress_error = 0;
13646     r = guestfs_mkfs (g, fstype, device);
13647     if (r == -1)
13648       return -1;
13649   }
13650   {
13651     char device[] = "/dev/sda1";
13652     device[5] = devchar;
13653     char mountpoint[] = "/";
13654     int r;
13655     suppress_error = 0;
13656     r = guestfs_mount (g, device, mountpoint);
13657     if (r == -1)
13658       return -1;
13659   }
13660   /* TestLastFail for rm (2) */
13661   {
13662     char path[] = "/new";
13663     int r;
13664     suppress_error = 0;
13665     r = guestfs_mkdir (g, path);
13666     if (r == -1)
13667       return -1;
13668   }
13669   {
13670     char path[] = "/new";
13671     int r;
13672     suppress_error = 1;
13673     r = guestfs_rm (g, path);
13674     if (r != -1)
13675       return -1;
13676   }
13677   return 0;
13678 }
13679
13680 static int test_read_lines_0_skip (void)
13681 {
13682   const char *str;
13683
13684   str = getenv ("SKIP_TEST_READ_LINES_0");
13685   if (str && strcmp (str, "1") == 0) return 1;
13686   str = getenv ("SKIP_TEST_READ_LINES");
13687   if (str && strcmp (str, "1") == 0) return 1;
13688   return 0;
13689 }
13690
13691 static int test_read_lines_0 (void)
13692 {
13693   if (test_read_lines_0_skip ()) {
13694     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13695     return 0;
13696   }
13697
13698   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13699   {
13700     char device[] = "/dev/sda";
13701     device[5] = devchar;
13702     int r;
13703     suppress_error = 0;
13704     r = guestfs_blockdev_setrw (g, device);
13705     if (r == -1)
13706       return -1;
13707   }
13708   {
13709     int r;
13710     suppress_error = 0;
13711     r = guestfs_umount_all (g);
13712     if (r == -1)
13713       return -1;
13714   }
13715   {
13716     int r;
13717     suppress_error = 0;
13718     r = guestfs_lvm_remove_all (g);
13719     if (r == -1)
13720       return -1;
13721   }
13722   {
13723     char device[] = "/dev/sda";
13724     device[5] = devchar;
13725     char lines_0[] = ",";
13726     char *lines[] = {
13727       lines_0,
13728       NULL
13729     };
13730     int r;
13731     suppress_error = 0;
13732     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13733     if (r == -1)
13734       return -1;
13735   }
13736   {
13737     char fstype[] = "ext2";
13738     char device[] = "/dev/sda1";
13739     device[5] = devchar;
13740     int r;
13741     suppress_error = 0;
13742     r = guestfs_mkfs (g, fstype, device);
13743     if (r == -1)
13744       return -1;
13745   }
13746   {
13747     char device[] = "/dev/sda1";
13748     device[5] = devchar;
13749     char mountpoint[] = "/";
13750     int r;
13751     suppress_error = 0;
13752     r = guestfs_mount (g, device, mountpoint);
13753     if (r == -1)
13754       return -1;
13755   }
13756   /* TestOutputList for read_lines (0) */
13757   {
13758     char path[] = "/new";
13759     char content[] = "line1\r\nline2\nline3";
13760     int r;
13761     suppress_error = 0;
13762     r = guestfs_write_file (g, path, content, 0);
13763     if (r == -1)
13764       return -1;
13765   }
13766   {
13767     char path[] = "/new";
13768     char **r;
13769     int i;
13770     suppress_error = 0;
13771     r = guestfs_read_lines (g, path);
13772     if (r == NULL)
13773       return -1;
13774     if (!r[0]) {
13775       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13776       print_strings (r);
13777       return -1;
13778     }
13779     {
13780       char expected[] = "line1";
13781       if (strcmp (r[0], expected) != 0) {
13782         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13783         return -1;
13784       }
13785     }
13786     if (!r[1]) {
13787       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13788       print_strings (r);
13789       return -1;
13790     }
13791     {
13792       char expected[] = "line2";
13793       if (strcmp (r[1], expected) != 0) {
13794         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13795         return -1;
13796       }
13797     }
13798     if (!r[2]) {
13799       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13800       print_strings (r);
13801       return -1;
13802     }
13803     {
13804       char expected[] = "line3";
13805       if (strcmp (r[2], expected) != 0) {
13806         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13807         return -1;
13808       }
13809     }
13810     if (r[3] != NULL) {
13811       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
13812       print_strings (r);
13813       return -1;
13814     }
13815     for (i = 0; r[i] != NULL; ++i)
13816       free (r[i]);
13817     free (r);
13818   }
13819   return 0;
13820 }
13821
13822 static int test_read_lines_1_skip (void)
13823 {
13824   const char *str;
13825
13826   str = getenv ("SKIP_TEST_READ_LINES_1");
13827   if (str && strcmp (str, "1") == 0) return 1;
13828   str = getenv ("SKIP_TEST_READ_LINES");
13829   if (str && strcmp (str, "1") == 0) return 1;
13830   return 0;
13831 }
13832
13833 static int test_read_lines_1 (void)
13834 {
13835   if (test_read_lines_1_skip ()) {
13836     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
13837     return 0;
13838   }
13839
13840   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
13841   {
13842     char device[] = "/dev/sda";
13843     device[5] = devchar;
13844     int r;
13845     suppress_error = 0;
13846     r = guestfs_blockdev_setrw (g, device);
13847     if (r == -1)
13848       return -1;
13849   }
13850   {
13851     int r;
13852     suppress_error = 0;
13853     r = guestfs_umount_all (g);
13854     if (r == -1)
13855       return -1;
13856   }
13857   {
13858     int r;
13859     suppress_error = 0;
13860     r = guestfs_lvm_remove_all (g);
13861     if (r == -1)
13862       return -1;
13863   }
13864   {
13865     char device[] = "/dev/sda";
13866     device[5] = devchar;
13867     char lines_0[] = ",";
13868     char *lines[] = {
13869       lines_0,
13870       NULL
13871     };
13872     int r;
13873     suppress_error = 0;
13874     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13875     if (r == -1)
13876       return -1;
13877   }
13878   {
13879     char fstype[] = "ext2";
13880     char device[] = "/dev/sda1";
13881     device[5] = devchar;
13882     int r;
13883     suppress_error = 0;
13884     r = guestfs_mkfs (g, fstype, device);
13885     if (r == -1)
13886       return -1;
13887   }
13888   {
13889     char device[] = "/dev/sda1";
13890     device[5] = devchar;
13891     char mountpoint[] = "/";
13892     int r;
13893     suppress_error = 0;
13894     r = guestfs_mount (g, device, mountpoint);
13895     if (r == -1)
13896       return -1;
13897   }
13898   /* TestOutputList for read_lines (1) */
13899   {
13900     char path[] = "/new";
13901     char content[] = "";
13902     int r;
13903     suppress_error = 0;
13904     r = guestfs_write_file (g, path, content, 0);
13905     if (r == -1)
13906       return -1;
13907   }
13908   {
13909     char path[] = "/new";
13910     char **r;
13911     int i;
13912     suppress_error = 0;
13913     r = guestfs_read_lines (g, path);
13914     if (r == NULL)
13915       return -1;
13916     if (r[0] != NULL) {
13917       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
13918       print_strings (r);
13919       return -1;
13920     }
13921     for (i = 0; r[i] != NULL; ++i)
13922       free (r[i]);
13923     free (r);
13924   }
13925   return 0;
13926 }
13927
13928 static int test_lvs_0_skip (void)
13929 {
13930   const char *str;
13931
13932   str = getenv ("SKIP_TEST_LVS_0");
13933   if (str && strcmp (str, "1") == 0) return 1;
13934   str = getenv ("SKIP_TEST_LVS");
13935   if (str && strcmp (str, "1") == 0) return 1;
13936   return 0;
13937 }
13938
13939 static int test_lvs_0 (void)
13940 {
13941   if (test_lvs_0_skip ()) {
13942     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
13943     return 0;
13944   }
13945
13946   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
13947   {
13948     char device[] = "/dev/sda";
13949     device[5] = devchar;
13950     int r;
13951     suppress_error = 0;
13952     r = guestfs_blockdev_setrw (g, device);
13953     if (r == -1)
13954       return -1;
13955   }
13956   {
13957     int r;
13958     suppress_error = 0;
13959     r = guestfs_umount_all (g);
13960     if (r == -1)
13961       return -1;
13962   }
13963   {
13964     int r;
13965     suppress_error = 0;
13966     r = guestfs_lvm_remove_all (g);
13967     if (r == -1)
13968       return -1;
13969   }
13970   {
13971     char device[] = "/dev/sda";
13972     device[5] = devchar;
13973     char lines_0[] = ",";
13974     char *lines[] = {
13975       lines_0,
13976       NULL
13977     };
13978     int r;
13979     suppress_error = 0;
13980     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13981     if (r == -1)
13982       return -1;
13983   }
13984   {
13985     char device[] = "/dev/sda1";
13986     device[5] = devchar;
13987     int r;
13988     suppress_error = 0;
13989     r = guestfs_pvcreate (g, device);
13990     if (r == -1)
13991       return -1;
13992   }
13993   {
13994     char volgroup[] = "VG";
13995     char physvols_0[] = "/dev/sda1";
13996     physvols_0[5] = devchar;
13997     char *physvols[] = {
13998       physvols_0,
13999       NULL
14000     };
14001     int r;
14002     suppress_error = 0;
14003     r = guestfs_vgcreate (g, volgroup, physvols);
14004     if (r == -1)
14005       return -1;
14006   }
14007   {
14008     char logvol[] = "LV";
14009     char volgroup[] = "VG";
14010     int r;
14011     suppress_error = 0;
14012     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14013     if (r == -1)
14014       return -1;
14015   }
14016   {
14017     char fstype[] = "ext2";
14018     char device[] = "/dev/VG/LV";
14019     int r;
14020     suppress_error = 0;
14021     r = guestfs_mkfs (g, fstype, device);
14022     if (r == -1)
14023       return -1;
14024   }
14025   {
14026     char device[] = "/dev/VG/LV";
14027     char mountpoint[] = "/";
14028     int r;
14029     suppress_error = 0;
14030     r = guestfs_mount (g, device, mountpoint);
14031     if (r == -1)
14032       return -1;
14033   }
14034   /* TestOutputList for lvs (0) */
14035   {
14036     char **r;
14037     int i;
14038     suppress_error = 0;
14039     r = guestfs_lvs (g);
14040     if (r == NULL)
14041       return -1;
14042     if (!r[0]) {
14043       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14044       print_strings (r);
14045       return -1;
14046     }
14047     {
14048       char expected[] = "/dev/VG/LV";
14049       if (strcmp (r[0], expected) != 0) {
14050         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14051         return -1;
14052       }
14053     }
14054     if (r[1] != NULL) {
14055       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14056       print_strings (r);
14057       return -1;
14058     }
14059     for (i = 0; r[i] != NULL; ++i)
14060       free (r[i]);
14061     free (r);
14062   }
14063   return 0;
14064 }
14065
14066 static int test_lvs_1_skip (void)
14067 {
14068   const char *str;
14069
14070   str = getenv ("SKIP_TEST_LVS_1");
14071   if (str && strcmp (str, "1") == 0) return 1;
14072   str = getenv ("SKIP_TEST_LVS");
14073   if (str && strcmp (str, "1") == 0) return 1;
14074   return 0;
14075 }
14076
14077 static int test_lvs_1 (void)
14078 {
14079   if (test_lvs_1_skip ()) {
14080     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14081     return 0;
14082   }
14083
14084   /* InitNone|InitEmpty for test_lvs_1 */
14085   {
14086     char device[] = "/dev/sda";
14087     device[5] = devchar;
14088     int r;
14089     suppress_error = 0;
14090     r = guestfs_blockdev_setrw (g, device);
14091     if (r == -1)
14092       return -1;
14093   }
14094   {
14095     int r;
14096     suppress_error = 0;
14097     r = guestfs_umount_all (g);
14098     if (r == -1)
14099       return -1;
14100   }
14101   {
14102     int r;
14103     suppress_error = 0;
14104     r = guestfs_lvm_remove_all (g);
14105     if (r == -1)
14106       return -1;
14107   }
14108   /* TestOutputList for lvs (1) */
14109   {
14110     char device[] = "/dev/sda";
14111     device[5] = devchar;
14112     char lines_0[] = ",10";
14113     char lines_1[] = ",20";
14114     char lines_2[] = ",";
14115     char *lines[] = {
14116       lines_0,
14117       lines_1,
14118       lines_2,
14119       NULL
14120     };
14121     int r;
14122     suppress_error = 0;
14123     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14124     if (r == -1)
14125       return -1;
14126   }
14127   {
14128     char device[] = "/dev/sda1";
14129     device[5] = devchar;
14130     int r;
14131     suppress_error = 0;
14132     r = guestfs_pvcreate (g, device);
14133     if (r == -1)
14134       return -1;
14135   }
14136   {
14137     char device[] = "/dev/sda2";
14138     device[5] = devchar;
14139     int r;
14140     suppress_error = 0;
14141     r = guestfs_pvcreate (g, device);
14142     if (r == -1)
14143       return -1;
14144   }
14145   {
14146     char device[] = "/dev/sda3";
14147     device[5] = devchar;
14148     int r;
14149     suppress_error = 0;
14150     r = guestfs_pvcreate (g, device);
14151     if (r == -1)
14152       return -1;
14153   }
14154   {
14155     char volgroup[] = "VG1";
14156     char physvols_0[] = "/dev/sda1";
14157     physvols_0[5] = devchar;
14158     char physvols_1[] = "/dev/sda2";
14159     physvols_1[5] = devchar;
14160     char *physvols[] = {
14161       physvols_0,
14162       physvols_1,
14163       NULL
14164     };
14165     int r;
14166     suppress_error = 0;
14167     r = guestfs_vgcreate (g, volgroup, physvols);
14168     if (r == -1)
14169       return -1;
14170   }
14171   {
14172     char volgroup[] = "VG2";
14173     char physvols_0[] = "/dev/sda3";
14174     physvols_0[5] = devchar;
14175     char *physvols[] = {
14176       physvols_0,
14177       NULL
14178     };
14179     int r;
14180     suppress_error = 0;
14181     r = guestfs_vgcreate (g, volgroup, physvols);
14182     if (r == -1)
14183       return -1;
14184   }
14185   {
14186     char logvol[] = "LV1";
14187     char volgroup[] = "VG1";
14188     int r;
14189     suppress_error = 0;
14190     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14191     if (r == -1)
14192       return -1;
14193   }
14194   {
14195     char logvol[] = "LV2";
14196     char volgroup[] = "VG1";
14197     int r;
14198     suppress_error = 0;
14199     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14200     if (r == -1)
14201       return -1;
14202   }
14203   {
14204     char logvol[] = "LV3";
14205     char volgroup[] = "VG2";
14206     int r;
14207     suppress_error = 0;
14208     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14209     if (r == -1)
14210       return -1;
14211   }
14212   {
14213     char **r;
14214     int i;
14215     suppress_error = 0;
14216     r = guestfs_lvs (g);
14217     if (r == NULL)
14218       return -1;
14219     if (!r[0]) {
14220       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14221       print_strings (r);
14222       return -1;
14223     }
14224     {
14225       char expected[] = "/dev/VG1/LV1";
14226       if (strcmp (r[0], expected) != 0) {
14227         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14228         return -1;
14229       }
14230     }
14231     if (!r[1]) {
14232       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14233       print_strings (r);
14234       return -1;
14235     }
14236     {
14237       char expected[] = "/dev/VG1/LV2";
14238       if (strcmp (r[1], expected) != 0) {
14239         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14240         return -1;
14241       }
14242     }
14243     if (!r[2]) {
14244       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14245       print_strings (r);
14246       return -1;
14247     }
14248     {
14249       char expected[] = "/dev/VG2/LV3";
14250       if (strcmp (r[2], expected) != 0) {
14251         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14252         return -1;
14253       }
14254     }
14255     if (r[3] != NULL) {
14256       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14257       print_strings (r);
14258       return -1;
14259     }
14260     for (i = 0; r[i] != NULL; ++i)
14261       free (r[i]);
14262     free (r);
14263   }
14264   return 0;
14265 }
14266
14267 static int test_vgs_0_skip (void)
14268 {
14269   const char *str;
14270
14271   str = getenv ("SKIP_TEST_VGS_0");
14272   if (str && strcmp (str, "1") == 0) return 1;
14273   str = getenv ("SKIP_TEST_VGS");
14274   if (str && strcmp (str, "1") == 0) return 1;
14275   return 0;
14276 }
14277
14278 static int test_vgs_0 (void)
14279 {
14280   if (test_vgs_0_skip ()) {
14281     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14282     return 0;
14283   }
14284
14285   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14286   {
14287     char device[] = "/dev/sda";
14288     device[5] = devchar;
14289     int r;
14290     suppress_error = 0;
14291     r = guestfs_blockdev_setrw (g, device);
14292     if (r == -1)
14293       return -1;
14294   }
14295   {
14296     int r;
14297     suppress_error = 0;
14298     r = guestfs_umount_all (g);
14299     if (r == -1)
14300       return -1;
14301   }
14302   {
14303     int r;
14304     suppress_error = 0;
14305     r = guestfs_lvm_remove_all (g);
14306     if (r == -1)
14307       return -1;
14308   }
14309   {
14310     char device[] = "/dev/sda";
14311     device[5] = devchar;
14312     char lines_0[] = ",";
14313     char *lines[] = {
14314       lines_0,
14315       NULL
14316     };
14317     int r;
14318     suppress_error = 0;
14319     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14320     if (r == -1)
14321       return -1;
14322   }
14323   {
14324     char device[] = "/dev/sda1";
14325     device[5] = devchar;
14326     int r;
14327     suppress_error = 0;
14328     r = guestfs_pvcreate (g, device);
14329     if (r == -1)
14330       return -1;
14331   }
14332   {
14333     char volgroup[] = "VG";
14334     char physvols_0[] = "/dev/sda1";
14335     physvols_0[5] = devchar;
14336     char *physvols[] = {
14337       physvols_0,
14338       NULL
14339     };
14340     int r;
14341     suppress_error = 0;
14342     r = guestfs_vgcreate (g, volgroup, physvols);
14343     if (r == -1)
14344       return -1;
14345   }
14346   {
14347     char logvol[] = "LV";
14348     char volgroup[] = "VG";
14349     int r;
14350     suppress_error = 0;
14351     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14352     if (r == -1)
14353       return -1;
14354   }
14355   {
14356     char fstype[] = "ext2";
14357     char device[] = "/dev/VG/LV";
14358     int r;
14359     suppress_error = 0;
14360     r = guestfs_mkfs (g, fstype, device);
14361     if (r == -1)
14362       return -1;
14363   }
14364   {
14365     char device[] = "/dev/VG/LV";
14366     char mountpoint[] = "/";
14367     int r;
14368     suppress_error = 0;
14369     r = guestfs_mount (g, device, mountpoint);
14370     if (r == -1)
14371       return -1;
14372   }
14373   /* TestOutputList for vgs (0) */
14374   {
14375     char **r;
14376     int i;
14377     suppress_error = 0;
14378     r = guestfs_vgs (g);
14379     if (r == NULL)
14380       return -1;
14381     if (!r[0]) {
14382       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14383       print_strings (r);
14384       return -1;
14385     }
14386     {
14387       char expected[] = "VG";
14388       if (strcmp (r[0], expected) != 0) {
14389         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14390         return -1;
14391       }
14392     }
14393     if (r[1] != NULL) {
14394       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14395       print_strings (r);
14396       return -1;
14397     }
14398     for (i = 0; r[i] != NULL; ++i)
14399       free (r[i]);
14400     free (r);
14401   }
14402   return 0;
14403 }
14404
14405 static int test_vgs_1_skip (void)
14406 {
14407   const char *str;
14408
14409   str = getenv ("SKIP_TEST_VGS_1");
14410   if (str && strcmp (str, "1") == 0) return 1;
14411   str = getenv ("SKIP_TEST_VGS");
14412   if (str && strcmp (str, "1") == 0) return 1;
14413   return 0;
14414 }
14415
14416 static int test_vgs_1 (void)
14417 {
14418   if (test_vgs_1_skip ()) {
14419     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14420     return 0;
14421   }
14422
14423   /* InitNone|InitEmpty for test_vgs_1 */
14424   {
14425     char device[] = "/dev/sda";
14426     device[5] = devchar;
14427     int r;
14428     suppress_error = 0;
14429     r = guestfs_blockdev_setrw (g, device);
14430     if (r == -1)
14431       return -1;
14432   }
14433   {
14434     int r;
14435     suppress_error = 0;
14436     r = guestfs_umount_all (g);
14437     if (r == -1)
14438       return -1;
14439   }
14440   {
14441     int r;
14442     suppress_error = 0;
14443     r = guestfs_lvm_remove_all (g);
14444     if (r == -1)
14445       return -1;
14446   }
14447   /* TestOutputList for vgs (1) */
14448   {
14449     char device[] = "/dev/sda";
14450     device[5] = devchar;
14451     char lines_0[] = ",10";
14452     char lines_1[] = ",20";
14453     char lines_2[] = ",";
14454     char *lines[] = {
14455       lines_0,
14456       lines_1,
14457       lines_2,
14458       NULL
14459     };
14460     int r;
14461     suppress_error = 0;
14462     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14463     if (r == -1)
14464       return -1;
14465   }
14466   {
14467     char device[] = "/dev/sda1";
14468     device[5] = devchar;
14469     int r;
14470     suppress_error = 0;
14471     r = guestfs_pvcreate (g, device);
14472     if (r == -1)
14473       return -1;
14474   }
14475   {
14476     char device[] = "/dev/sda2";
14477     device[5] = devchar;
14478     int r;
14479     suppress_error = 0;
14480     r = guestfs_pvcreate (g, device);
14481     if (r == -1)
14482       return -1;
14483   }
14484   {
14485     char device[] = "/dev/sda3";
14486     device[5] = devchar;
14487     int r;
14488     suppress_error = 0;
14489     r = guestfs_pvcreate (g, device);
14490     if (r == -1)
14491       return -1;
14492   }
14493   {
14494     char volgroup[] = "VG1";
14495     char physvols_0[] = "/dev/sda1";
14496     physvols_0[5] = devchar;
14497     char physvols_1[] = "/dev/sda2";
14498     physvols_1[5] = devchar;
14499     char *physvols[] = {
14500       physvols_0,
14501       physvols_1,
14502       NULL
14503     };
14504     int r;
14505     suppress_error = 0;
14506     r = guestfs_vgcreate (g, volgroup, physvols);
14507     if (r == -1)
14508       return -1;
14509   }
14510   {
14511     char volgroup[] = "VG2";
14512     char physvols_0[] = "/dev/sda3";
14513     physvols_0[5] = devchar;
14514     char *physvols[] = {
14515       physvols_0,
14516       NULL
14517     };
14518     int r;
14519     suppress_error = 0;
14520     r = guestfs_vgcreate (g, volgroup, physvols);
14521     if (r == -1)
14522       return -1;
14523   }
14524   {
14525     char **r;
14526     int i;
14527     suppress_error = 0;
14528     r = guestfs_vgs (g);
14529     if (r == NULL)
14530       return -1;
14531     if (!r[0]) {
14532       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14533       print_strings (r);
14534       return -1;
14535     }
14536     {
14537       char expected[] = "VG1";
14538       if (strcmp (r[0], expected) != 0) {
14539         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14540         return -1;
14541       }
14542     }
14543     if (!r[1]) {
14544       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14545       print_strings (r);
14546       return -1;
14547     }
14548     {
14549       char expected[] = "VG2";
14550       if (strcmp (r[1], expected) != 0) {
14551         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14552         return -1;
14553       }
14554     }
14555     if (r[2] != NULL) {
14556       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14557       print_strings (r);
14558       return -1;
14559     }
14560     for (i = 0; r[i] != NULL; ++i)
14561       free (r[i]);
14562     free (r);
14563   }
14564   return 0;
14565 }
14566
14567 static int test_pvs_0_skip (void)
14568 {
14569   const char *str;
14570
14571   str = getenv ("SKIP_TEST_PVS_0");
14572   if (str && strcmp (str, "1") == 0) return 1;
14573   str = getenv ("SKIP_TEST_PVS");
14574   if (str && strcmp (str, "1") == 0) return 1;
14575   return 0;
14576 }
14577
14578 static int test_pvs_0 (void)
14579 {
14580   if (test_pvs_0_skip ()) {
14581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14582     return 0;
14583   }
14584
14585   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14586   {
14587     char device[] = "/dev/sda";
14588     device[5] = devchar;
14589     int r;
14590     suppress_error = 0;
14591     r = guestfs_blockdev_setrw (g, device);
14592     if (r == -1)
14593       return -1;
14594   }
14595   {
14596     int r;
14597     suppress_error = 0;
14598     r = guestfs_umount_all (g);
14599     if (r == -1)
14600       return -1;
14601   }
14602   {
14603     int r;
14604     suppress_error = 0;
14605     r = guestfs_lvm_remove_all (g);
14606     if (r == -1)
14607       return -1;
14608   }
14609   {
14610     char device[] = "/dev/sda";
14611     device[5] = devchar;
14612     char lines_0[] = ",";
14613     char *lines[] = {
14614       lines_0,
14615       NULL
14616     };
14617     int r;
14618     suppress_error = 0;
14619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14620     if (r == -1)
14621       return -1;
14622   }
14623   {
14624     char device[] = "/dev/sda1";
14625     device[5] = devchar;
14626     int r;
14627     suppress_error = 0;
14628     r = guestfs_pvcreate (g, device);
14629     if (r == -1)
14630       return -1;
14631   }
14632   {
14633     char volgroup[] = "VG";
14634     char physvols_0[] = "/dev/sda1";
14635     physvols_0[5] = devchar;
14636     char *physvols[] = {
14637       physvols_0,
14638       NULL
14639     };
14640     int r;
14641     suppress_error = 0;
14642     r = guestfs_vgcreate (g, volgroup, physvols);
14643     if (r == -1)
14644       return -1;
14645   }
14646   {
14647     char logvol[] = "LV";
14648     char volgroup[] = "VG";
14649     int r;
14650     suppress_error = 0;
14651     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14652     if (r == -1)
14653       return -1;
14654   }
14655   {
14656     char fstype[] = "ext2";
14657     char device[] = "/dev/VG/LV";
14658     int r;
14659     suppress_error = 0;
14660     r = guestfs_mkfs (g, fstype, device);
14661     if (r == -1)
14662       return -1;
14663   }
14664   {
14665     char device[] = "/dev/VG/LV";
14666     char mountpoint[] = "/";
14667     int r;
14668     suppress_error = 0;
14669     r = guestfs_mount (g, device, mountpoint);
14670     if (r == -1)
14671       return -1;
14672   }
14673   /* TestOutputList for pvs (0) */
14674   {
14675     char **r;
14676     int i;
14677     suppress_error = 0;
14678     r = guestfs_pvs (g);
14679     if (r == NULL)
14680       return -1;
14681     if (!r[0]) {
14682       fprintf (stderr, "test_pvs_0: short list returned from command\n");
14683       print_strings (r);
14684       return -1;
14685     }
14686     {
14687       char expected[] = "/dev/sda1";
14688       expected[5] = devchar;
14689       if (strcmp (r[0], expected) != 0) {
14690         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14691         return -1;
14692       }
14693     }
14694     if (r[1] != NULL) {
14695       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14696       print_strings (r);
14697       return -1;
14698     }
14699     for (i = 0; r[i] != NULL; ++i)
14700       free (r[i]);
14701     free (r);
14702   }
14703   return 0;
14704 }
14705
14706 static int test_pvs_1_skip (void)
14707 {
14708   const char *str;
14709
14710   str = getenv ("SKIP_TEST_PVS_1");
14711   if (str && strcmp (str, "1") == 0) return 1;
14712   str = getenv ("SKIP_TEST_PVS");
14713   if (str && strcmp (str, "1") == 0) return 1;
14714   return 0;
14715 }
14716
14717 static int test_pvs_1 (void)
14718 {
14719   if (test_pvs_1_skip ()) {
14720     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
14721     return 0;
14722   }
14723
14724   /* InitNone|InitEmpty for test_pvs_1 */
14725   {
14726     char device[] = "/dev/sda";
14727     device[5] = devchar;
14728     int r;
14729     suppress_error = 0;
14730     r = guestfs_blockdev_setrw (g, device);
14731     if (r == -1)
14732       return -1;
14733   }
14734   {
14735     int r;
14736     suppress_error = 0;
14737     r = guestfs_umount_all (g);
14738     if (r == -1)
14739       return -1;
14740   }
14741   {
14742     int r;
14743     suppress_error = 0;
14744     r = guestfs_lvm_remove_all (g);
14745     if (r == -1)
14746       return -1;
14747   }
14748   /* TestOutputList for pvs (1) */
14749   {
14750     char device[] = "/dev/sda";
14751     device[5] = devchar;
14752     char lines_0[] = ",10";
14753     char lines_1[] = ",20";
14754     char lines_2[] = ",";
14755     char *lines[] = {
14756       lines_0,
14757       lines_1,
14758       lines_2,
14759       NULL
14760     };
14761     int r;
14762     suppress_error = 0;
14763     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14764     if (r == -1)
14765       return -1;
14766   }
14767   {
14768     char device[] = "/dev/sda1";
14769     device[5] = devchar;
14770     int r;
14771     suppress_error = 0;
14772     r = guestfs_pvcreate (g, device);
14773     if (r == -1)
14774       return -1;
14775   }
14776   {
14777     char device[] = "/dev/sda2";
14778     device[5] = devchar;
14779     int r;
14780     suppress_error = 0;
14781     r = guestfs_pvcreate (g, device);
14782     if (r == -1)
14783       return -1;
14784   }
14785   {
14786     char device[] = "/dev/sda3";
14787     device[5] = devchar;
14788     int r;
14789     suppress_error = 0;
14790     r = guestfs_pvcreate (g, device);
14791     if (r == -1)
14792       return -1;
14793   }
14794   {
14795     char **r;
14796     int i;
14797     suppress_error = 0;
14798     r = guestfs_pvs (g);
14799     if (r == NULL)
14800       return -1;
14801     if (!r[0]) {
14802       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14803       print_strings (r);
14804       return -1;
14805     }
14806     {
14807       char expected[] = "/dev/sda1";
14808       expected[5] = devchar;
14809       if (strcmp (r[0], expected) != 0) {
14810         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14811         return -1;
14812       }
14813     }
14814     if (!r[1]) {
14815       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14816       print_strings (r);
14817       return -1;
14818     }
14819     {
14820       char expected[] = "/dev/sda2";
14821       expected[5] = devchar;
14822       if (strcmp (r[1], expected) != 0) {
14823         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14824         return -1;
14825       }
14826     }
14827     if (!r[2]) {
14828       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14829       print_strings (r);
14830       return -1;
14831     }
14832     {
14833       char expected[] = "/dev/sda3";
14834       expected[5] = devchar;
14835       if (strcmp (r[2], expected) != 0) {
14836         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14837         return -1;
14838       }
14839     }
14840     if (r[3] != NULL) {
14841       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
14842       print_strings (r);
14843       return -1;
14844     }
14845     for (i = 0; r[i] != NULL; ++i)
14846       free (r[i]);
14847     free (r);
14848   }
14849   return 0;
14850 }
14851
14852 static int test_list_partitions_0_skip (void)
14853 {
14854   const char *str;
14855
14856   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
14857   if (str && strcmp (str, "1") == 0) return 1;
14858   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14859   if (str && strcmp (str, "1") == 0) return 1;
14860   return 0;
14861 }
14862
14863 static int test_list_partitions_0 (void)
14864 {
14865   if (test_list_partitions_0_skip ()) {
14866     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
14867     return 0;
14868   }
14869
14870   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
14871   {
14872     char device[] = "/dev/sda";
14873     device[5] = devchar;
14874     int r;
14875     suppress_error = 0;
14876     r = guestfs_blockdev_setrw (g, device);
14877     if (r == -1)
14878       return -1;
14879   }
14880   {
14881     int r;
14882     suppress_error = 0;
14883     r = guestfs_umount_all (g);
14884     if (r == -1)
14885       return -1;
14886   }
14887   {
14888     int r;
14889     suppress_error = 0;
14890     r = guestfs_lvm_remove_all (g);
14891     if (r == -1)
14892       return -1;
14893   }
14894   {
14895     char device[] = "/dev/sda";
14896     device[5] = devchar;
14897     char lines_0[] = ",";
14898     char *lines[] = {
14899       lines_0,
14900       NULL
14901     };
14902     int r;
14903     suppress_error = 0;
14904     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14905     if (r == -1)
14906       return -1;
14907   }
14908   {
14909     char fstype[] = "ext2";
14910     char device[] = "/dev/sda1";
14911     device[5] = devchar;
14912     int r;
14913     suppress_error = 0;
14914     r = guestfs_mkfs (g, fstype, device);
14915     if (r == -1)
14916       return -1;
14917   }
14918   {
14919     char device[] = "/dev/sda1";
14920     device[5] = devchar;
14921     char mountpoint[] = "/";
14922     int r;
14923     suppress_error = 0;
14924     r = guestfs_mount (g, device, mountpoint);
14925     if (r == -1)
14926       return -1;
14927   }
14928   /* TestOutputList for list_partitions (0) */
14929   {
14930     char **r;
14931     int i;
14932     suppress_error = 0;
14933     r = guestfs_list_partitions (g);
14934     if (r == NULL)
14935       return -1;
14936     if (!r[0]) {
14937       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
14938       print_strings (r);
14939       return -1;
14940     }
14941     {
14942       char expected[] = "/dev/sda1";
14943       expected[5] = devchar;
14944       if (strcmp (r[0], expected) != 0) {
14945         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14946         return -1;
14947       }
14948     }
14949     if (r[1] != NULL) {
14950       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
14951       print_strings (r);
14952       return -1;
14953     }
14954     for (i = 0; r[i] != NULL; ++i)
14955       free (r[i]);
14956     free (r);
14957   }
14958   return 0;
14959 }
14960
14961 static int test_list_partitions_1_skip (void)
14962 {
14963   const char *str;
14964
14965   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
14966   if (str && strcmp (str, "1") == 0) return 1;
14967   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14968   if (str && strcmp (str, "1") == 0) return 1;
14969   return 0;
14970 }
14971
14972 static int test_list_partitions_1 (void)
14973 {
14974   if (test_list_partitions_1_skip ()) {
14975     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
14976     return 0;
14977   }
14978
14979   /* InitNone|InitEmpty for test_list_partitions_1 */
14980   {
14981     char device[] = "/dev/sda";
14982     device[5] = devchar;
14983     int r;
14984     suppress_error = 0;
14985     r = guestfs_blockdev_setrw (g, device);
14986     if (r == -1)
14987       return -1;
14988   }
14989   {
14990     int r;
14991     suppress_error = 0;
14992     r = guestfs_umount_all (g);
14993     if (r == -1)
14994       return -1;
14995   }
14996   {
14997     int r;
14998     suppress_error = 0;
14999     r = guestfs_lvm_remove_all (g);
15000     if (r == -1)
15001       return -1;
15002   }
15003   /* TestOutputList for list_partitions (1) */
15004   {
15005     char device[] = "/dev/sda";
15006     device[5] = devchar;
15007     char lines_0[] = ",10";
15008     char lines_1[] = ",20";
15009     char lines_2[] = ",";
15010     char *lines[] = {
15011       lines_0,
15012       lines_1,
15013       lines_2,
15014       NULL
15015     };
15016     int r;
15017     suppress_error = 0;
15018     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15019     if (r == -1)
15020       return -1;
15021   }
15022   {
15023     char **r;
15024     int i;
15025     suppress_error = 0;
15026     r = guestfs_list_partitions (g);
15027     if (r == NULL)
15028       return -1;
15029     if (!r[0]) {
15030       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15031       print_strings (r);
15032       return -1;
15033     }
15034     {
15035       char expected[] = "/dev/sda1";
15036       expected[5] = devchar;
15037       if (strcmp (r[0], expected) != 0) {
15038         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15039         return -1;
15040       }
15041     }
15042     if (!r[1]) {
15043       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15044       print_strings (r);
15045       return -1;
15046     }
15047     {
15048       char expected[] = "/dev/sda2";
15049       expected[5] = devchar;
15050       if (strcmp (r[1], expected) != 0) {
15051         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15052         return -1;
15053       }
15054     }
15055     if (!r[2]) {
15056       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15057       print_strings (r);
15058       return -1;
15059     }
15060     {
15061       char expected[] = "/dev/sda3";
15062       expected[5] = devchar;
15063       if (strcmp (r[2], expected) != 0) {
15064         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15065         return -1;
15066       }
15067     }
15068     if (r[3] != NULL) {
15069       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15070       print_strings (r);
15071       return -1;
15072     }
15073     for (i = 0; r[i] != NULL; ++i)
15074       free (r[i]);
15075     free (r);
15076   }
15077   return 0;
15078 }
15079
15080 static int test_list_devices_0_skip (void)
15081 {
15082   const char *str;
15083
15084   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15085   if (str && strcmp (str, "1") == 0) return 1;
15086   str = getenv ("SKIP_TEST_LIST_DEVICES");
15087   if (str && strcmp (str, "1") == 0) return 1;
15088   return 0;
15089 }
15090
15091 static int test_list_devices_0 (void)
15092 {
15093   if (test_list_devices_0_skip ()) {
15094     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15095     return 0;
15096   }
15097
15098   /* InitNone|InitEmpty for test_list_devices_0 */
15099   {
15100     char device[] = "/dev/sda";
15101     device[5] = devchar;
15102     int r;
15103     suppress_error = 0;
15104     r = guestfs_blockdev_setrw (g, device);
15105     if (r == -1)
15106       return -1;
15107   }
15108   {
15109     int r;
15110     suppress_error = 0;
15111     r = guestfs_umount_all (g);
15112     if (r == -1)
15113       return -1;
15114   }
15115   {
15116     int r;
15117     suppress_error = 0;
15118     r = guestfs_lvm_remove_all (g);
15119     if (r == -1)
15120       return -1;
15121   }
15122   /* TestOutputList for list_devices (0) */
15123   {
15124     char **r;
15125     int i;
15126     suppress_error = 0;
15127     r = guestfs_list_devices (g);
15128     if (r == NULL)
15129       return -1;
15130     if (!r[0]) {
15131       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15132       print_strings (r);
15133       return -1;
15134     }
15135     {
15136       char expected[] = "/dev/sda";
15137       expected[5] = devchar;
15138       if (strcmp (r[0], expected) != 0) {
15139         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15140         return -1;
15141       }
15142     }
15143     if (!r[1]) {
15144       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15145       print_strings (r);
15146       return -1;
15147     }
15148     {
15149       char expected[] = "/dev/sdb";
15150       expected[5] = devchar;
15151       if (strcmp (r[1], expected) != 0) {
15152         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15153         return -1;
15154       }
15155     }
15156     if (!r[2]) {
15157       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15158       print_strings (r);
15159       return -1;
15160     }
15161     {
15162       char expected[] = "/dev/sdc";
15163       expected[5] = devchar;
15164       if (strcmp (r[2], expected) != 0) {
15165         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15166         return -1;
15167       }
15168     }
15169     if (r[3] != NULL) {
15170       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15171       print_strings (r);
15172       return -1;
15173     }
15174     for (i = 0; r[i] != NULL; ++i)
15175       free (r[i]);
15176     free (r);
15177   }
15178   return 0;
15179 }
15180
15181 static int test_ls_0_skip (void)
15182 {
15183   const char *str;
15184
15185   str = getenv ("SKIP_TEST_LS_0");
15186   if (str && strcmp (str, "1") == 0) return 1;
15187   str = getenv ("SKIP_TEST_LS");
15188   if (str && strcmp (str, "1") == 0) return 1;
15189   return 0;
15190 }
15191
15192 static int test_ls_0 (void)
15193 {
15194   if (test_ls_0_skip ()) {
15195     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15196     return 0;
15197   }
15198
15199   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15200   {
15201     char device[] = "/dev/sda";
15202     device[5] = devchar;
15203     int r;
15204     suppress_error = 0;
15205     r = guestfs_blockdev_setrw (g, device);
15206     if (r == -1)
15207       return -1;
15208   }
15209   {
15210     int r;
15211     suppress_error = 0;
15212     r = guestfs_umount_all (g);
15213     if (r == -1)
15214       return -1;
15215   }
15216   {
15217     int r;
15218     suppress_error = 0;
15219     r = guestfs_lvm_remove_all (g);
15220     if (r == -1)
15221       return -1;
15222   }
15223   {
15224     char device[] = "/dev/sda";
15225     device[5] = devchar;
15226     char lines_0[] = ",";
15227     char *lines[] = {
15228       lines_0,
15229       NULL
15230     };
15231     int r;
15232     suppress_error = 0;
15233     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15234     if (r == -1)
15235       return -1;
15236   }
15237   {
15238     char fstype[] = "ext2";
15239     char device[] = "/dev/sda1";
15240     device[5] = devchar;
15241     int r;
15242     suppress_error = 0;
15243     r = guestfs_mkfs (g, fstype, device);
15244     if (r == -1)
15245       return -1;
15246   }
15247   {
15248     char device[] = "/dev/sda1";
15249     device[5] = devchar;
15250     char mountpoint[] = "/";
15251     int r;
15252     suppress_error = 0;
15253     r = guestfs_mount (g, device, mountpoint);
15254     if (r == -1)
15255       return -1;
15256   }
15257   /* TestOutputList for ls (0) */
15258   {
15259     char path[] = "/new";
15260     int r;
15261     suppress_error = 0;
15262     r = guestfs_touch (g, path);
15263     if (r == -1)
15264       return -1;
15265   }
15266   {
15267     char path[] = "/newer";
15268     int r;
15269     suppress_error = 0;
15270     r = guestfs_touch (g, path);
15271     if (r == -1)
15272       return -1;
15273   }
15274   {
15275     char path[] = "/newest";
15276     int r;
15277     suppress_error = 0;
15278     r = guestfs_touch (g, path);
15279     if (r == -1)
15280       return -1;
15281   }
15282   {
15283     char directory[] = "/";
15284     char **r;
15285     int i;
15286     suppress_error = 0;
15287     r = guestfs_ls (g, directory);
15288     if (r == NULL)
15289       return -1;
15290     if (!r[0]) {
15291       fprintf (stderr, "test_ls_0: short list returned from command\n");
15292       print_strings (r);
15293       return -1;
15294     }
15295     {
15296       char expected[] = "lost+found";
15297       if (strcmp (r[0], expected) != 0) {
15298         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15299         return -1;
15300       }
15301     }
15302     if (!r[1]) {
15303       fprintf (stderr, "test_ls_0: short list returned from command\n");
15304       print_strings (r);
15305       return -1;
15306     }
15307     {
15308       char expected[] = "new";
15309       if (strcmp (r[1], expected) != 0) {
15310         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15311         return -1;
15312       }
15313     }
15314     if (!r[2]) {
15315       fprintf (stderr, "test_ls_0: short list returned from command\n");
15316       print_strings (r);
15317       return -1;
15318     }
15319     {
15320       char expected[] = "newer";
15321       if (strcmp (r[2], expected) != 0) {
15322         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15323         return -1;
15324       }
15325     }
15326     if (!r[3]) {
15327       fprintf (stderr, "test_ls_0: short list returned from command\n");
15328       print_strings (r);
15329       return -1;
15330     }
15331     {
15332       char expected[] = "newest";
15333       if (strcmp (r[3], expected) != 0) {
15334         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15335         return -1;
15336       }
15337     }
15338     if (r[4] != NULL) {
15339       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15340       print_strings (r);
15341       return -1;
15342     }
15343     for (i = 0; r[i] != NULL; ++i)
15344       free (r[i]);
15345     free (r);
15346   }
15347   return 0;
15348 }
15349
15350 static int test_cat_0_skip (void)
15351 {
15352   const char *str;
15353
15354   str = getenv ("SKIP_TEST_CAT_0");
15355   if (str && strcmp (str, "1") == 0) return 1;
15356   str = getenv ("SKIP_TEST_CAT");
15357   if (str && strcmp (str, "1") == 0) return 1;
15358   return 0;
15359 }
15360
15361 static int test_cat_0 (void)
15362 {
15363   if (test_cat_0_skip ()) {
15364     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15365     return 0;
15366   }
15367
15368   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15369   {
15370     char device[] = "/dev/sda";
15371     device[5] = devchar;
15372     int r;
15373     suppress_error = 0;
15374     r = guestfs_blockdev_setrw (g, device);
15375     if (r == -1)
15376       return -1;
15377   }
15378   {
15379     int r;
15380     suppress_error = 0;
15381     r = guestfs_umount_all (g);
15382     if (r == -1)
15383       return -1;
15384   }
15385   {
15386     int r;
15387     suppress_error = 0;
15388     r = guestfs_lvm_remove_all (g);
15389     if (r == -1)
15390       return -1;
15391   }
15392   {
15393     char device[] = "/dev/sda";
15394     device[5] = devchar;
15395     char lines_0[] = ",";
15396     char *lines[] = {
15397       lines_0,
15398       NULL
15399     };
15400     int r;
15401     suppress_error = 0;
15402     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15403     if (r == -1)
15404       return -1;
15405   }
15406   {
15407     char fstype[] = "ext2";
15408     char device[] = "/dev/sda1";
15409     device[5] = devchar;
15410     int r;
15411     suppress_error = 0;
15412     r = guestfs_mkfs (g, fstype, device);
15413     if (r == -1)
15414       return -1;
15415   }
15416   {
15417     char device[] = "/dev/sda1";
15418     device[5] = devchar;
15419     char mountpoint[] = "/";
15420     int r;
15421     suppress_error = 0;
15422     r = guestfs_mount (g, device, mountpoint);
15423     if (r == -1)
15424       return -1;
15425   }
15426   /* TestOutput for cat (0) */
15427   char expected[] = "new file contents";
15428   {
15429     char path[] = "/new";
15430     char content[] = "new file contents";
15431     int r;
15432     suppress_error = 0;
15433     r = guestfs_write_file (g, path, content, 0);
15434     if (r == -1)
15435       return -1;
15436   }
15437   {
15438     char path[] = "/new";
15439     char *r;
15440     suppress_error = 0;
15441     r = guestfs_cat (g, path);
15442     if (r == NULL)
15443       return -1;
15444     if (strcmp (r, expected) != 0) {
15445       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15446       return -1;
15447     }
15448     free (r);
15449   }
15450   return 0;
15451 }
15452
15453 static int test_touch_0_skip (void)
15454 {
15455   const char *str;
15456
15457   str = getenv ("SKIP_TEST_TOUCH_0");
15458   if (str && strcmp (str, "1") == 0) return 1;
15459   str = getenv ("SKIP_TEST_TOUCH");
15460   if (str && strcmp (str, "1") == 0) return 1;
15461   return 0;
15462 }
15463
15464 static int test_touch_0 (void)
15465 {
15466   if (test_touch_0_skip ()) {
15467     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15468     return 0;
15469   }
15470
15471   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15472   {
15473     char device[] = "/dev/sda";
15474     device[5] = devchar;
15475     int r;
15476     suppress_error = 0;
15477     r = guestfs_blockdev_setrw (g, device);
15478     if (r == -1)
15479       return -1;
15480   }
15481   {
15482     int r;
15483     suppress_error = 0;
15484     r = guestfs_umount_all (g);
15485     if (r == -1)
15486       return -1;
15487   }
15488   {
15489     int r;
15490     suppress_error = 0;
15491     r = guestfs_lvm_remove_all (g);
15492     if (r == -1)
15493       return -1;
15494   }
15495   {
15496     char device[] = "/dev/sda";
15497     device[5] = devchar;
15498     char lines_0[] = ",";
15499     char *lines[] = {
15500       lines_0,
15501       NULL
15502     };
15503     int r;
15504     suppress_error = 0;
15505     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15506     if (r == -1)
15507       return -1;
15508   }
15509   {
15510     char fstype[] = "ext2";
15511     char device[] = "/dev/sda1";
15512     device[5] = devchar;
15513     int r;
15514     suppress_error = 0;
15515     r = guestfs_mkfs (g, fstype, device);
15516     if (r == -1)
15517       return -1;
15518   }
15519   {
15520     char device[] = "/dev/sda1";
15521     device[5] = devchar;
15522     char mountpoint[] = "/";
15523     int r;
15524     suppress_error = 0;
15525     r = guestfs_mount (g, device, mountpoint);
15526     if (r == -1)
15527       return -1;
15528   }
15529   /* TestOutputTrue for touch (0) */
15530   {
15531     char path[] = "/new";
15532     int r;
15533     suppress_error = 0;
15534     r = guestfs_touch (g, path);
15535     if (r == -1)
15536       return -1;
15537   }
15538   {
15539     char path[] = "/new";
15540     int r;
15541     suppress_error = 0;
15542     r = guestfs_exists (g, path);
15543     if (r == -1)
15544       return -1;
15545     if (!r) {
15546       fprintf (stderr, "test_touch_0: expected true, got false\n");
15547       return -1;
15548     }
15549   }
15550   return 0;
15551 }
15552
15553 static int test_sync_0_skip (void)
15554 {
15555   const char *str;
15556
15557   str = getenv ("SKIP_TEST_SYNC_0");
15558   if (str && strcmp (str, "1") == 0) return 1;
15559   str = getenv ("SKIP_TEST_SYNC");
15560   if (str && strcmp (str, "1") == 0) return 1;
15561   return 0;
15562 }
15563
15564 static int test_sync_0 (void)
15565 {
15566   if (test_sync_0_skip ()) {
15567     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15568     return 0;
15569   }
15570
15571   /* InitNone|InitEmpty for test_sync_0 */
15572   {
15573     char device[] = "/dev/sda";
15574     device[5] = devchar;
15575     int r;
15576     suppress_error = 0;
15577     r = guestfs_blockdev_setrw (g, device);
15578     if (r == -1)
15579       return -1;
15580   }
15581   {
15582     int r;
15583     suppress_error = 0;
15584     r = guestfs_umount_all (g);
15585     if (r == -1)
15586       return -1;
15587   }
15588   {
15589     int r;
15590     suppress_error = 0;
15591     r = guestfs_lvm_remove_all (g);
15592     if (r == -1)
15593       return -1;
15594   }
15595   /* TestRun for sync (0) */
15596   {
15597     int r;
15598     suppress_error = 0;
15599     r = guestfs_sync (g);
15600     if (r == -1)
15601       return -1;
15602   }
15603   return 0;
15604 }
15605
15606 static int test_mount_0_skip (void)
15607 {
15608   const char *str;
15609
15610   str = getenv ("SKIP_TEST_MOUNT_0");
15611   if (str && strcmp (str, "1") == 0) return 1;
15612   str = getenv ("SKIP_TEST_MOUNT");
15613   if (str && strcmp (str, "1") == 0) return 1;
15614   return 0;
15615 }
15616
15617 static int test_mount_0 (void)
15618 {
15619   if (test_mount_0_skip ()) {
15620     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15621     return 0;
15622   }
15623
15624   /* InitNone|InitEmpty for test_mount_0 */
15625   {
15626     char device[] = "/dev/sda";
15627     device[5] = devchar;
15628     int r;
15629     suppress_error = 0;
15630     r = guestfs_blockdev_setrw (g, device);
15631     if (r == -1)
15632       return -1;
15633   }
15634   {
15635     int r;
15636     suppress_error = 0;
15637     r = guestfs_umount_all (g);
15638     if (r == -1)
15639       return -1;
15640   }
15641   {
15642     int r;
15643     suppress_error = 0;
15644     r = guestfs_lvm_remove_all (g);
15645     if (r == -1)
15646       return -1;
15647   }
15648   /* TestOutput for mount (0) */
15649   char expected[] = "new file contents";
15650   {
15651     char device[] = "/dev/sda";
15652     device[5] = devchar;
15653     char lines_0[] = ",";
15654     char *lines[] = {
15655       lines_0,
15656       NULL
15657     };
15658     int r;
15659     suppress_error = 0;
15660     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15661     if (r == -1)
15662       return -1;
15663   }
15664   {
15665     char fstype[] = "ext2";
15666     char device[] = "/dev/sda1";
15667     device[5] = devchar;
15668     int r;
15669     suppress_error = 0;
15670     r = guestfs_mkfs (g, fstype, device);
15671     if (r == -1)
15672       return -1;
15673   }
15674   {
15675     char device[] = "/dev/sda1";
15676     device[5] = devchar;
15677     char mountpoint[] = "/";
15678     int r;
15679     suppress_error = 0;
15680     r = guestfs_mount (g, device, mountpoint);
15681     if (r == -1)
15682       return -1;
15683   }
15684   {
15685     char path[] = "/new";
15686     char content[] = "new file contents";
15687     int r;
15688     suppress_error = 0;
15689     r = guestfs_write_file (g, path, content, 0);
15690     if (r == -1)
15691       return -1;
15692   }
15693   {
15694     char path[] = "/new";
15695     char *r;
15696     suppress_error = 0;
15697     r = guestfs_cat (g, path);
15698     if (r == NULL)
15699       return -1;
15700     if (strcmp (r, expected) != 0) {
15701       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
15702       return -1;
15703     }
15704     free (r);
15705   }
15706   return 0;
15707 }
15708
15709 int main (int argc, char *argv[])
15710 {
15711   char c = 0;
15712   int failed = 0;
15713   const char *srcdir;
15714   const char *filename;
15715   int fd, i;
15716   int nr_tests, test_num = 0;
15717   char **devs;
15718
15719   no_test_warnings ();
15720
15721   g = guestfs_create ();
15722   if (g == NULL) {
15723     printf ("guestfs_create FAILED\n");
15724     exit (1);
15725   }
15726
15727   guestfs_set_error_handler (g, print_error, NULL);
15728
15729   guestfs_set_path (g, "../appliance");
15730
15731   filename = "test1.img";
15732   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15733   if (fd == -1) {
15734     perror (filename);
15735     exit (1);
15736   }
15737   if (lseek (fd, 524288000, SEEK_SET) == -1) {
15738     perror ("lseek");
15739     close (fd);
15740     unlink (filename);
15741     exit (1);
15742   }
15743   if (write (fd, &c, 1) == -1) {
15744     perror ("write");
15745     close (fd);
15746     unlink (filename);
15747     exit (1);
15748   }
15749   if (close (fd) == -1) {
15750     perror (filename);
15751     unlink (filename);
15752     exit (1);
15753   }
15754   if (guestfs_add_drive (g, filename) == -1) {
15755     printf ("guestfs_add_drive %s FAILED\n", filename);
15756     exit (1);
15757   }
15758
15759   filename = "test2.img";
15760   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15761   if (fd == -1) {
15762     perror (filename);
15763     exit (1);
15764   }
15765   if (lseek (fd, 52428800, SEEK_SET) == -1) {
15766     perror ("lseek");
15767     close (fd);
15768     unlink (filename);
15769     exit (1);
15770   }
15771   if (write (fd, &c, 1) == -1) {
15772     perror ("write");
15773     close (fd);
15774     unlink (filename);
15775     exit (1);
15776   }
15777   if (close (fd) == -1) {
15778     perror (filename);
15779     unlink (filename);
15780     exit (1);
15781   }
15782   if (guestfs_add_drive (g, filename) == -1) {
15783     printf ("guestfs_add_drive %s FAILED\n", filename);
15784     exit (1);
15785   }
15786
15787   filename = "test3.img";
15788   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15789   if (fd == -1) {
15790     perror (filename);
15791     exit (1);
15792   }
15793   if (lseek (fd, 10485760, SEEK_SET) == -1) {
15794     perror ("lseek");
15795     close (fd);
15796     unlink (filename);
15797     exit (1);
15798   }
15799   if (write (fd, &c, 1) == -1) {
15800     perror ("write");
15801     close (fd);
15802     unlink (filename);
15803     exit (1);
15804   }
15805   if (close (fd) == -1) {
15806     perror (filename);
15807     unlink (filename);
15808     exit (1);
15809   }
15810   if (guestfs_add_drive (g, filename) == -1) {
15811     printf ("guestfs_add_drive %s FAILED\n", filename);
15812     exit (1);
15813   }
15814
15815   if (guestfs_launch (g) == -1) {
15816     printf ("guestfs_launch FAILED\n");
15817     exit (1);
15818   }
15819   if (guestfs_wait_ready (g) == -1) {
15820     printf ("guestfs_wait_ready FAILED\n");
15821     exit (1);
15822   }
15823
15824   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
15825    * names.  This changed between RHEL 5 and RHEL 6 so we have to
15826    * support both.
15827    */
15828   devs = guestfs_list_devices (g);
15829   if (devs == NULL || devs[0] == NULL) {
15830     printf ("guestfs_list_devices FAILED\n");
15831     exit (1);
15832   }
15833   if (strncmp (devs[0], "/dev/sd", 7) == 0)
15834     devchar = 's';
15835   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
15836     devchar = 'h';
15837   else {
15838     printf ("guestfs_list_devices returned unexpected string '%s'\n",
15839             devs[0]);
15840     exit (1);
15841   }
15842   for (i = 0; devs[i] != NULL; ++i)
15843     free (devs[i]);
15844   free (devs);
15845
15846   nr_tests = 140;
15847
15848   test_num++;
15849   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
15850   if (test_find_0 () == -1) {
15851     printf ("test_find_0 FAILED\n");
15852     failed++;
15853   }
15854   test_num++;
15855   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
15856   if (test_find_1 () == -1) {
15857     printf ("test_find_1 FAILED\n");
15858     failed++;
15859   }
15860   test_num++;
15861   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
15862   if (test_find_2 () == -1) {
15863     printf ("test_find_2 FAILED\n");
15864     failed++;
15865   }
15866   test_num++;
15867   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
15868   if (test_lvresize_0 () == -1) {
15869     printf ("test_lvresize_0 FAILED\n");
15870     failed++;
15871   }
15872   test_num++;
15873   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
15874   if (test_zerofree_0 () == -1) {
15875     printf ("test_zerofree_0 FAILED\n");
15876     failed++;
15877   }
15878   test_num++;
15879   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
15880   if (test_hexdump_0 () == -1) {
15881     printf ("test_hexdump_0 FAILED\n");
15882     failed++;
15883   }
15884   test_num++;
15885   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
15886   if (test_strings_e_0 () == -1) {
15887     printf ("test_strings_e_0 FAILED\n");
15888     failed++;
15889   }
15890   test_num++;
15891   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
15892   if (test_strings_e_1 () == -1) {
15893     printf ("test_strings_e_1 FAILED\n");
15894     failed++;
15895   }
15896   test_num++;
15897   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
15898   if (test_strings_0 () == -1) {
15899     printf ("test_strings_0 FAILED\n");
15900     failed++;
15901   }
15902   test_num++;
15903   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
15904   if (test_strings_1 () == -1) {
15905     printf ("test_strings_1 FAILED\n");
15906     failed++;
15907   }
15908   test_num++;
15909   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
15910   if (test_equal_0 () == -1) {
15911     printf ("test_equal_0 FAILED\n");
15912     failed++;
15913   }
15914   test_num++;
15915   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
15916   if (test_equal_1 () == -1) {
15917     printf ("test_equal_1 FAILED\n");
15918     failed++;
15919   }
15920   test_num++;
15921   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
15922   if (test_equal_2 () == -1) {
15923     printf ("test_equal_2 FAILED\n");
15924     failed++;
15925   }
15926   test_num++;
15927   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
15928   if (test_ping_daemon_0 () == -1) {
15929     printf ("test_ping_daemon_0 FAILED\n");
15930     failed++;
15931   }
15932   test_num++;
15933   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
15934   if (test_dmesg_0 () == -1) {
15935     printf ("test_dmesg_0 FAILED\n");
15936     failed++;
15937   }
15938   test_num++;
15939   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
15940   if (test_drop_caches_0 () == -1) {
15941     printf ("test_drop_caches_0 FAILED\n");
15942     failed++;
15943   }
15944   test_num++;
15945   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
15946   if (test_mv_0 () == -1) {
15947     printf ("test_mv_0 FAILED\n");
15948     failed++;
15949   }
15950   test_num++;
15951   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
15952   if (test_mv_1 () == -1) {
15953     printf ("test_mv_1 FAILED\n");
15954     failed++;
15955   }
15956   test_num++;
15957   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
15958   if (test_cp_a_0 () == -1) {
15959     printf ("test_cp_a_0 FAILED\n");
15960     failed++;
15961   }
15962   test_num++;
15963   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
15964   if (test_cp_0 () == -1) {
15965     printf ("test_cp_0 FAILED\n");
15966     failed++;
15967   }
15968   test_num++;
15969   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
15970   if (test_cp_1 () == -1) {
15971     printf ("test_cp_1 FAILED\n");
15972     failed++;
15973   }
15974   test_num++;
15975   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
15976   if (test_cp_2 () == -1) {
15977     printf ("test_cp_2 FAILED\n");
15978     failed++;
15979   }
15980   test_num++;
15981   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
15982   if (test_grub_install_0 () == -1) {
15983     printf ("test_grub_install_0 FAILED\n");
15984     failed++;
15985   }
15986   test_num++;
15987   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
15988   if (test_zero_0 () == -1) {
15989     printf ("test_zero_0 FAILED\n");
15990     failed++;
15991   }
15992   test_num++;
15993   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
15994   if (test_fsck_0 () == -1) {
15995     printf ("test_fsck_0 FAILED\n");
15996     failed++;
15997   }
15998   test_num++;
15999   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16000   if (test_fsck_1 () == -1) {
16001     printf ("test_fsck_1 FAILED\n");
16002     failed++;
16003   }
16004   test_num++;
16005   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16006   if (test_set_e2uuid_0 () == -1) {
16007     printf ("test_set_e2uuid_0 FAILED\n");
16008     failed++;
16009   }
16010   test_num++;
16011   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16012   if (test_set_e2uuid_1 () == -1) {
16013     printf ("test_set_e2uuid_1 FAILED\n");
16014     failed++;
16015   }
16016   test_num++;
16017   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16018   if (test_set_e2uuid_2 () == -1) {
16019     printf ("test_set_e2uuid_2 FAILED\n");
16020     failed++;
16021   }
16022   test_num++;
16023   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16024   if (test_set_e2uuid_3 () == -1) {
16025     printf ("test_set_e2uuid_3 FAILED\n");
16026     failed++;
16027   }
16028   test_num++;
16029   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16030   if (test_set_e2label_0 () == -1) {
16031     printf ("test_set_e2label_0 FAILED\n");
16032     failed++;
16033   }
16034   test_num++;
16035   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16036   if (test_pvremove_0 () == -1) {
16037     printf ("test_pvremove_0 FAILED\n");
16038     failed++;
16039   }
16040   test_num++;
16041   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16042   if (test_pvremove_1 () == -1) {
16043     printf ("test_pvremove_1 FAILED\n");
16044     failed++;
16045   }
16046   test_num++;
16047   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16048   if (test_pvremove_2 () == -1) {
16049     printf ("test_pvremove_2 FAILED\n");
16050     failed++;
16051   }
16052   test_num++;
16053   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16054   if (test_vgremove_0 () == -1) {
16055     printf ("test_vgremove_0 FAILED\n");
16056     failed++;
16057   }
16058   test_num++;
16059   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16060   if (test_vgremove_1 () == -1) {
16061     printf ("test_vgremove_1 FAILED\n");
16062     failed++;
16063   }
16064   test_num++;
16065   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16066   if (test_lvremove_0 () == -1) {
16067     printf ("test_lvremove_0 FAILED\n");
16068     failed++;
16069   }
16070   test_num++;
16071   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16072   if (test_lvremove_1 () == -1) {
16073     printf ("test_lvremove_1 FAILED\n");
16074     failed++;
16075   }
16076   test_num++;
16077   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16078   if (test_lvremove_2 () == -1) {
16079     printf ("test_lvremove_2 FAILED\n");
16080     failed++;
16081   }
16082   test_num++;
16083   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16084   if (test_mount_ro_0 () == -1) {
16085     printf ("test_mount_ro_0 FAILED\n");
16086     failed++;
16087   }
16088   test_num++;
16089   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16090   if (test_mount_ro_1 () == -1) {
16091     printf ("test_mount_ro_1 FAILED\n");
16092     failed++;
16093   }
16094   test_num++;
16095   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16096   if (test_tgz_in_0 () == -1) {
16097     printf ("test_tgz_in_0 FAILED\n");
16098     failed++;
16099   }
16100   test_num++;
16101   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16102   if (test_tar_in_0 () == -1) {
16103     printf ("test_tar_in_0 FAILED\n");
16104     failed++;
16105   }
16106   test_num++;
16107   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16108   if (test_checksum_0 () == -1) {
16109     printf ("test_checksum_0 FAILED\n");
16110     failed++;
16111   }
16112   test_num++;
16113   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16114   if (test_checksum_1 () == -1) {
16115     printf ("test_checksum_1 FAILED\n");
16116     failed++;
16117   }
16118   test_num++;
16119   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16120   if (test_checksum_2 () == -1) {
16121     printf ("test_checksum_2 FAILED\n");
16122     failed++;
16123   }
16124   test_num++;
16125   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16126   if (test_checksum_3 () == -1) {
16127     printf ("test_checksum_3 FAILED\n");
16128     failed++;
16129   }
16130   test_num++;
16131   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16132   if (test_checksum_4 () == -1) {
16133     printf ("test_checksum_4 FAILED\n");
16134     failed++;
16135   }
16136   test_num++;
16137   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16138   if (test_checksum_5 () == -1) {
16139     printf ("test_checksum_5 FAILED\n");
16140     failed++;
16141   }
16142   test_num++;
16143   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16144   if (test_checksum_6 () == -1) {
16145     printf ("test_checksum_6 FAILED\n");
16146     failed++;
16147   }
16148   test_num++;
16149   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16150   if (test_checksum_7 () == -1) {
16151     printf ("test_checksum_7 FAILED\n");
16152     failed++;
16153   }
16154   test_num++;
16155   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16156   if (test_download_0 () == -1) {
16157     printf ("test_download_0 FAILED\n");
16158     failed++;
16159   }
16160   test_num++;
16161   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16162   if (test_upload_0 () == -1) {
16163     printf ("test_upload_0 FAILED\n");
16164     failed++;
16165   }
16166   test_num++;
16167   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16168   if (test_blockdev_rereadpt_0 () == -1) {
16169     printf ("test_blockdev_rereadpt_0 FAILED\n");
16170     failed++;
16171   }
16172   test_num++;
16173   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16174   if (test_blockdev_flushbufs_0 () == -1) {
16175     printf ("test_blockdev_flushbufs_0 FAILED\n");
16176     failed++;
16177   }
16178   test_num++;
16179   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16180   if (test_blockdev_getsize64_0 () == -1) {
16181     printf ("test_blockdev_getsize64_0 FAILED\n");
16182     failed++;
16183   }
16184   test_num++;
16185   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16186   if (test_blockdev_getsz_0 () == -1) {
16187     printf ("test_blockdev_getsz_0 FAILED\n");
16188     failed++;
16189   }
16190   test_num++;
16191   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16192   if (test_blockdev_getbsz_0 () == -1) {
16193     printf ("test_blockdev_getbsz_0 FAILED\n");
16194     failed++;
16195   }
16196   test_num++;
16197   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16198   if (test_blockdev_getss_0 () == -1) {
16199     printf ("test_blockdev_getss_0 FAILED\n");
16200     failed++;
16201   }
16202   test_num++;
16203   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16204   if (test_blockdev_getro_0 () == -1) {
16205     printf ("test_blockdev_getro_0 FAILED\n");
16206     failed++;
16207   }
16208   test_num++;
16209   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16210   if (test_blockdev_setrw_0 () == -1) {
16211     printf ("test_blockdev_setrw_0 FAILED\n");
16212     failed++;
16213   }
16214   test_num++;
16215   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16216   if (test_blockdev_setro_0 () == -1) {
16217     printf ("test_blockdev_setro_0 FAILED\n");
16218     failed++;
16219   }
16220   test_num++;
16221   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16222   if (test_statvfs_0 () == -1) {
16223     printf ("test_statvfs_0 FAILED\n");
16224     failed++;
16225   }
16226   test_num++;
16227   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16228   if (test_lstat_0 () == -1) {
16229     printf ("test_lstat_0 FAILED\n");
16230     failed++;
16231   }
16232   test_num++;
16233   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16234   if (test_stat_0 () == -1) {
16235     printf ("test_stat_0 FAILED\n");
16236     failed++;
16237   }
16238   test_num++;
16239   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16240   if (test_command_lines_0 () == -1) {
16241     printf ("test_command_lines_0 FAILED\n");
16242     failed++;
16243   }
16244   test_num++;
16245   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16246   if (test_command_lines_1 () == -1) {
16247     printf ("test_command_lines_1 FAILED\n");
16248     failed++;
16249   }
16250   test_num++;
16251   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16252   if (test_command_lines_2 () == -1) {
16253     printf ("test_command_lines_2 FAILED\n");
16254     failed++;
16255   }
16256   test_num++;
16257   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16258   if (test_command_lines_3 () == -1) {
16259     printf ("test_command_lines_3 FAILED\n");
16260     failed++;
16261   }
16262   test_num++;
16263   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16264   if (test_command_lines_4 () == -1) {
16265     printf ("test_command_lines_4 FAILED\n");
16266     failed++;
16267   }
16268   test_num++;
16269   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16270   if (test_command_lines_5 () == -1) {
16271     printf ("test_command_lines_5 FAILED\n");
16272     failed++;
16273   }
16274   test_num++;
16275   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16276   if (test_command_lines_6 () == -1) {
16277     printf ("test_command_lines_6 FAILED\n");
16278     failed++;
16279   }
16280   test_num++;
16281   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16282   if (test_command_lines_7 () == -1) {
16283     printf ("test_command_lines_7 FAILED\n");
16284     failed++;
16285   }
16286   test_num++;
16287   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16288   if (test_command_lines_8 () == -1) {
16289     printf ("test_command_lines_8 FAILED\n");
16290     failed++;
16291   }
16292   test_num++;
16293   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16294   if (test_command_lines_9 () == -1) {
16295     printf ("test_command_lines_9 FAILED\n");
16296     failed++;
16297   }
16298   test_num++;
16299   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16300   if (test_command_lines_10 () == -1) {
16301     printf ("test_command_lines_10 FAILED\n");
16302     failed++;
16303   }
16304   test_num++;
16305   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16306   if (test_command_0 () == -1) {
16307     printf ("test_command_0 FAILED\n");
16308     failed++;
16309   }
16310   test_num++;
16311   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16312   if (test_command_1 () == -1) {
16313     printf ("test_command_1 FAILED\n");
16314     failed++;
16315   }
16316   test_num++;
16317   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16318   if (test_command_2 () == -1) {
16319     printf ("test_command_2 FAILED\n");
16320     failed++;
16321   }
16322   test_num++;
16323   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16324   if (test_command_3 () == -1) {
16325     printf ("test_command_3 FAILED\n");
16326     failed++;
16327   }
16328   test_num++;
16329   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16330   if (test_command_4 () == -1) {
16331     printf ("test_command_4 FAILED\n");
16332     failed++;
16333   }
16334   test_num++;
16335   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16336   if (test_command_5 () == -1) {
16337     printf ("test_command_5 FAILED\n");
16338     failed++;
16339   }
16340   test_num++;
16341   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16342   if (test_command_6 () == -1) {
16343     printf ("test_command_6 FAILED\n");
16344     failed++;
16345   }
16346   test_num++;
16347   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16348   if (test_command_7 () == -1) {
16349     printf ("test_command_7 FAILED\n");
16350     failed++;
16351   }
16352   test_num++;
16353   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16354   if (test_command_8 () == -1) {
16355     printf ("test_command_8 FAILED\n");
16356     failed++;
16357   }
16358   test_num++;
16359   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16360   if (test_command_9 () == -1) {
16361     printf ("test_command_9 FAILED\n");
16362     failed++;
16363   }
16364   test_num++;
16365   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16366   if (test_command_10 () == -1) {
16367     printf ("test_command_10 FAILED\n");
16368     failed++;
16369   }
16370   test_num++;
16371   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16372   if (test_command_11 () == -1) {
16373     printf ("test_command_11 FAILED\n");
16374     failed++;
16375   }
16376   test_num++;
16377   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16378   if (test_file_0 () == -1) {
16379     printf ("test_file_0 FAILED\n");
16380     failed++;
16381   }
16382   test_num++;
16383   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16384   if (test_file_1 () == -1) {
16385     printf ("test_file_1 FAILED\n");
16386     failed++;
16387   }
16388   test_num++;
16389   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16390   if (test_file_2 () == -1) {
16391     printf ("test_file_2 FAILED\n");
16392     failed++;
16393   }
16394   test_num++;
16395   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16396   if (test_umount_all_0 () == -1) {
16397     printf ("test_umount_all_0 FAILED\n");
16398     failed++;
16399   }
16400   test_num++;
16401   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16402   if (test_umount_all_1 () == -1) {
16403     printf ("test_umount_all_1 FAILED\n");
16404     failed++;
16405   }
16406   test_num++;
16407   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16408   if (test_mounts_0 () == -1) {
16409     printf ("test_mounts_0 FAILED\n");
16410     failed++;
16411   }
16412   test_num++;
16413   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16414   if (test_umount_0 () == -1) {
16415     printf ("test_umount_0 FAILED\n");
16416     failed++;
16417   }
16418   test_num++;
16419   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16420   if (test_umount_1 () == -1) {
16421     printf ("test_umount_1 FAILED\n");
16422     failed++;
16423   }
16424   test_num++;
16425   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16426   if (test_write_file_0 () == -1) {
16427     printf ("test_write_file_0 FAILED\n");
16428     failed++;
16429   }
16430   test_num++;
16431   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16432   if (test_write_file_1 () == -1) {
16433     printf ("test_write_file_1 FAILED\n");
16434     failed++;
16435   }
16436   test_num++;
16437   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16438   if (test_write_file_2 () == -1) {
16439     printf ("test_write_file_2 FAILED\n");
16440     failed++;
16441   }
16442   test_num++;
16443   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16444   if (test_write_file_3 () == -1) {
16445     printf ("test_write_file_3 FAILED\n");
16446     failed++;
16447   }
16448   test_num++;
16449   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16450   if (test_write_file_4 () == -1) {
16451     printf ("test_write_file_4 FAILED\n");
16452     failed++;
16453   }
16454   test_num++;
16455   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16456   if (test_write_file_5 () == -1) {
16457     printf ("test_write_file_5 FAILED\n");
16458     failed++;
16459   }
16460   test_num++;
16461   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16462   if (test_mkfs_0 () == -1) {
16463     printf ("test_mkfs_0 FAILED\n");
16464     failed++;
16465   }
16466   test_num++;
16467   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16468   if (test_lvcreate_0 () == -1) {
16469     printf ("test_lvcreate_0 FAILED\n");
16470     failed++;
16471   }
16472   test_num++;
16473   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16474   if (test_vgcreate_0 () == -1) {
16475     printf ("test_vgcreate_0 FAILED\n");
16476     failed++;
16477   }
16478   test_num++;
16479   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16480   if (test_pvcreate_0 () == -1) {
16481     printf ("test_pvcreate_0 FAILED\n");
16482     failed++;
16483   }
16484   test_num++;
16485   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16486   if (test_is_dir_0 () == -1) {
16487     printf ("test_is_dir_0 FAILED\n");
16488     failed++;
16489   }
16490   test_num++;
16491   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16492   if (test_is_dir_1 () == -1) {
16493     printf ("test_is_dir_1 FAILED\n");
16494     failed++;
16495   }
16496   test_num++;
16497   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16498   if (test_is_file_0 () == -1) {
16499     printf ("test_is_file_0 FAILED\n");
16500     failed++;
16501   }
16502   test_num++;
16503   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16504   if (test_is_file_1 () == -1) {
16505     printf ("test_is_file_1 FAILED\n");
16506     failed++;
16507   }
16508   test_num++;
16509   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16510   if (test_exists_0 () == -1) {
16511     printf ("test_exists_0 FAILED\n");
16512     failed++;
16513   }
16514   test_num++;
16515   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16516   if (test_exists_1 () == -1) {
16517     printf ("test_exists_1 FAILED\n");
16518     failed++;
16519   }
16520   test_num++;
16521   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16522   if (test_mkdir_p_0 () == -1) {
16523     printf ("test_mkdir_p_0 FAILED\n");
16524     failed++;
16525   }
16526   test_num++;
16527   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16528   if (test_mkdir_p_1 () == -1) {
16529     printf ("test_mkdir_p_1 FAILED\n");
16530     failed++;
16531   }
16532   test_num++;
16533   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16534   if (test_mkdir_p_2 () == -1) {
16535     printf ("test_mkdir_p_2 FAILED\n");
16536     failed++;
16537   }
16538   test_num++;
16539   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16540   if (test_mkdir_0 () == -1) {
16541     printf ("test_mkdir_0 FAILED\n");
16542     failed++;
16543   }
16544   test_num++;
16545   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16546   if (test_mkdir_1 () == -1) {
16547     printf ("test_mkdir_1 FAILED\n");
16548     failed++;
16549   }
16550   test_num++;
16551   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16552   if (test_rm_rf_0 () == -1) {
16553     printf ("test_rm_rf_0 FAILED\n");
16554     failed++;
16555   }
16556   test_num++;
16557   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16558   if (test_rmdir_0 () == -1) {
16559     printf ("test_rmdir_0 FAILED\n");
16560     failed++;
16561   }
16562   test_num++;
16563   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16564   if (test_rmdir_1 () == -1) {
16565     printf ("test_rmdir_1 FAILED\n");
16566     failed++;
16567   }
16568   test_num++;
16569   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16570   if (test_rmdir_2 () == -1) {
16571     printf ("test_rmdir_2 FAILED\n");
16572     failed++;
16573   }
16574   test_num++;
16575   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16576   if (test_rm_0 () == -1) {
16577     printf ("test_rm_0 FAILED\n");
16578     failed++;
16579   }
16580   test_num++;
16581   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16582   if (test_rm_1 () == -1) {
16583     printf ("test_rm_1 FAILED\n");
16584     failed++;
16585   }
16586   test_num++;
16587   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16588   if (test_rm_2 () == -1) {
16589     printf ("test_rm_2 FAILED\n");
16590     failed++;
16591   }
16592   test_num++;
16593   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16594   if (test_read_lines_0 () == -1) {
16595     printf ("test_read_lines_0 FAILED\n");
16596     failed++;
16597   }
16598   test_num++;
16599   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16600   if (test_read_lines_1 () == -1) {
16601     printf ("test_read_lines_1 FAILED\n");
16602     failed++;
16603   }
16604   test_num++;
16605   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16606   if (test_lvs_0 () == -1) {
16607     printf ("test_lvs_0 FAILED\n");
16608     failed++;
16609   }
16610   test_num++;
16611   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16612   if (test_lvs_1 () == -1) {
16613     printf ("test_lvs_1 FAILED\n");
16614     failed++;
16615   }
16616   test_num++;
16617   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16618   if (test_vgs_0 () == -1) {
16619     printf ("test_vgs_0 FAILED\n");
16620     failed++;
16621   }
16622   test_num++;
16623   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16624   if (test_vgs_1 () == -1) {
16625     printf ("test_vgs_1 FAILED\n");
16626     failed++;
16627   }
16628   test_num++;
16629   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16630   if (test_pvs_0 () == -1) {
16631     printf ("test_pvs_0 FAILED\n");
16632     failed++;
16633   }
16634   test_num++;
16635   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16636   if (test_pvs_1 () == -1) {
16637     printf ("test_pvs_1 FAILED\n");
16638     failed++;
16639   }
16640   test_num++;
16641   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16642   if (test_list_partitions_0 () == -1) {
16643     printf ("test_list_partitions_0 FAILED\n");
16644     failed++;
16645   }
16646   test_num++;
16647   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16648   if (test_list_partitions_1 () == -1) {
16649     printf ("test_list_partitions_1 FAILED\n");
16650     failed++;
16651   }
16652   test_num++;
16653   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16654   if (test_list_devices_0 () == -1) {
16655     printf ("test_list_devices_0 FAILED\n");
16656     failed++;
16657   }
16658   test_num++;
16659   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16660   if (test_ls_0 () == -1) {
16661     printf ("test_ls_0 FAILED\n");
16662     failed++;
16663   }
16664   test_num++;
16665   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16666   if (test_cat_0 () == -1) {
16667     printf ("test_cat_0 FAILED\n");
16668     failed++;
16669   }
16670   test_num++;
16671   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
16672   if (test_touch_0 () == -1) {
16673     printf ("test_touch_0 FAILED\n");
16674     failed++;
16675   }
16676   test_num++;
16677   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
16678   if (test_sync_0 () == -1) {
16679     printf ("test_sync_0 FAILED\n");
16680     failed++;
16681   }
16682   test_num++;
16683   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
16684   if (test_mount_0 () == -1) {
16685     printf ("test_mount_0 FAILED\n");
16686     failed++;
16687   }
16688
16689   guestfs_close (g);
16690   unlink ("test1.img");
16691   unlink ("test2.img");
16692   unlink ("test3.img");
16693
16694   if (failed > 0) {
16695     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
16696     exit (1);
16697   }
16698
16699   exit (0);
16700 }