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_checksum_8_skip (void)
5733 {
5734   const char *str;
5735
5736   str = getenv ("SKIP_TEST_CHECKSUM_8");
5737   if (str && strcmp (str, "1") == 0) return 1;
5738   str = getenv ("SKIP_TEST_CHECKSUM");
5739   if (str && strcmp (str, "1") == 0) return 1;
5740   return 0;
5741 }
5742
5743 static int test_checksum_8 (void)
5744 {
5745   if (test_checksum_8_skip ()) {
5746     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
5747     return 0;
5748   }
5749
5750   /* InitBasicFS for test_checksum_8: 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 checksum (8) */
5809   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
5810   {
5811     char device[] = "/dev/sdd";
5812     device[5] = devchar;
5813     char mountpoint[] = "/";
5814     int r;
5815     suppress_error = 0;
5816     r = guestfs_mount (g, device, mountpoint);
5817     if (r == -1)
5818       return -1;
5819   }
5820   {
5821     char csumtype[] = "md5";
5822     char path[] = "/known-3";
5823     char *r;
5824     suppress_error = 0;
5825     r = guestfs_checksum (g, csumtype, path);
5826     if (r == NULL)
5827       return -1;
5828     if (strcmp (r, expected) != 0) {
5829       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
5830       return -1;
5831     }
5832     free (r);
5833   }
5834   return 0;
5835 }
5836
5837 static int test_download_0_skip (void)
5838 {
5839   const char *str;
5840
5841   str = getenv ("SKIP_TEST_DOWNLOAD_0");
5842   if (str && strcmp (str, "1") == 0) return 1;
5843   str = getenv ("SKIP_TEST_DOWNLOAD");
5844   if (str && strcmp (str, "1") == 0) return 1;
5845   return 0;
5846 }
5847
5848 static int test_download_0 (void)
5849 {
5850   if (test_download_0_skip ()) {
5851     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5852     return 0;
5853   }
5854
5855   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5856   {
5857     char device[] = "/dev/sda";
5858     device[5] = devchar;
5859     int r;
5860     suppress_error = 0;
5861     r = guestfs_blockdev_setrw (g, device);
5862     if (r == -1)
5863       return -1;
5864   }
5865   {
5866     int r;
5867     suppress_error = 0;
5868     r = guestfs_umount_all (g);
5869     if (r == -1)
5870       return -1;
5871   }
5872   {
5873     int r;
5874     suppress_error = 0;
5875     r = guestfs_lvm_remove_all (g);
5876     if (r == -1)
5877       return -1;
5878   }
5879   {
5880     char device[] = "/dev/sda";
5881     device[5] = devchar;
5882     char lines_0[] = ",";
5883     char *lines[] = {
5884       lines_0,
5885       NULL
5886     };
5887     int r;
5888     suppress_error = 0;
5889     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5890     if (r == -1)
5891       return -1;
5892   }
5893   {
5894     char fstype[] = "ext2";
5895     char device[] = "/dev/sda1";
5896     device[5] = devchar;
5897     int r;
5898     suppress_error = 0;
5899     r = guestfs_mkfs (g, fstype, device);
5900     if (r == -1)
5901       return -1;
5902   }
5903   {
5904     char device[] = "/dev/sda1";
5905     device[5] = devchar;
5906     char mountpoint[] = "/";
5907     int r;
5908     suppress_error = 0;
5909     r = guestfs_mount (g, device, mountpoint);
5910     if (r == -1)
5911       return -1;
5912   }
5913   /* TestOutput for download (0) */
5914   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5915   {
5916     char remotefilename[] = "/COPYING.LIB";
5917     int r;
5918     suppress_error = 0;
5919     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5920     if (r == -1)
5921       return -1;
5922   }
5923   {
5924     char remotefilename[] = "/COPYING.LIB";
5925     int r;
5926     suppress_error = 0;
5927     r = guestfs_download (g, remotefilename, "testdownload.tmp");
5928     if (r == -1)
5929       return -1;
5930   }
5931   {
5932     char remotefilename[] = "/upload";
5933     int r;
5934     suppress_error = 0;
5935     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5936     if (r == -1)
5937       return -1;
5938   }
5939   {
5940     char csumtype[] = "md5";
5941     char path[] = "/upload";
5942     char *r;
5943     suppress_error = 0;
5944     r = guestfs_checksum (g, csumtype, path);
5945     if (r == NULL)
5946       return -1;
5947     if (strcmp (r, expected) != 0) {
5948       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5949       return -1;
5950     }
5951     free (r);
5952   }
5953   return 0;
5954 }
5955
5956 static int test_upload_0_skip (void)
5957 {
5958   const char *str;
5959
5960   str = getenv ("SKIP_TEST_UPLOAD_0");
5961   if (str && strcmp (str, "1") == 0) return 1;
5962   str = getenv ("SKIP_TEST_UPLOAD");
5963   if (str && strcmp (str, "1") == 0) return 1;
5964   return 0;
5965 }
5966
5967 static int test_upload_0 (void)
5968 {
5969   if (test_upload_0_skip ()) {
5970     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5971     return 0;
5972   }
5973
5974   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5975   {
5976     char device[] = "/dev/sda";
5977     device[5] = devchar;
5978     int r;
5979     suppress_error = 0;
5980     r = guestfs_blockdev_setrw (g, device);
5981     if (r == -1)
5982       return -1;
5983   }
5984   {
5985     int r;
5986     suppress_error = 0;
5987     r = guestfs_umount_all (g);
5988     if (r == -1)
5989       return -1;
5990   }
5991   {
5992     int r;
5993     suppress_error = 0;
5994     r = guestfs_lvm_remove_all (g);
5995     if (r == -1)
5996       return -1;
5997   }
5998   {
5999     char device[] = "/dev/sda";
6000     device[5] = devchar;
6001     char lines_0[] = ",";
6002     char *lines[] = {
6003       lines_0,
6004       NULL
6005     };
6006     int r;
6007     suppress_error = 0;
6008     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6009     if (r == -1)
6010       return -1;
6011   }
6012   {
6013     char fstype[] = "ext2";
6014     char device[] = "/dev/sda1";
6015     device[5] = devchar;
6016     int r;
6017     suppress_error = 0;
6018     r = guestfs_mkfs (g, fstype, device);
6019     if (r == -1)
6020       return -1;
6021   }
6022   {
6023     char device[] = "/dev/sda1";
6024     device[5] = devchar;
6025     char mountpoint[] = "/";
6026     int r;
6027     suppress_error = 0;
6028     r = guestfs_mount (g, device, mountpoint);
6029     if (r == -1)
6030       return -1;
6031   }
6032   /* TestOutput for upload (0) */
6033   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6034   {
6035     char remotefilename[] = "/COPYING.LIB";
6036     int r;
6037     suppress_error = 0;
6038     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6039     if (r == -1)
6040       return -1;
6041   }
6042   {
6043     char csumtype[] = "md5";
6044     char path[] = "/COPYING.LIB";
6045     char *r;
6046     suppress_error = 0;
6047     r = guestfs_checksum (g, csumtype, path);
6048     if (r == NULL)
6049       return -1;
6050     if (strcmp (r, expected) != 0) {
6051       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6052       return -1;
6053     }
6054     free (r);
6055   }
6056   return 0;
6057 }
6058
6059 static int test_blockdev_rereadpt_0_skip (void)
6060 {
6061   const char *str;
6062
6063   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6064   if (str && strcmp (str, "1") == 0) return 1;
6065   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6066   if (str && strcmp (str, "1") == 0) return 1;
6067   return 0;
6068 }
6069
6070 static int test_blockdev_rereadpt_0 (void)
6071 {
6072   if (test_blockdev_rereadpt_0_skip ()) {
6073     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6074     return 0;
6075   }
6076
6077   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6078   {
6079     char device[] = "/dev/sda";
6080     device[5] = devchar;
6081     int r;
6082     suppress_error = 0;
6083     r = guestfs_blockdev_setrw (g, device);
6084     if (r == -1)
6085       return -1;
6086   }
6087   {
6088     int r;
6089     suppress_error = 0;
6090     r = guestfs_umount_all (g);
6091     if (r == -1)
6092       return -1;
6093   }
6094   {
6095     int r;
6096     suppress_error = 0;
6097     r = guestfs_lvm_remove_all (g);
6098     if (r == -1)
6099       return -1;
6100   }
6101   /* TestRun for blockdev_rereadpt (0) */
6102   {
6103     char device[] = "/dev/sda";
6104     device[5] = devchar;
6105     int r;
6106     suppress_error = 0;
6107     r = guestfs_blockdev_rereadpt (g, device);
6108     if (r == -1)
6109       return -1;
6110   }
6111   return 0;
6112 }
6113
6114 static int test_blockdev_flushbufs_0_skip (void)
6115 {
6116   const char *str;
6117
6118   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6119   if (str && strcmp (str, "1") == 0) return 1;
6120   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6121   if (str && strcmp (str, "1") == 0) return 1;
6122   return 0;
6123 }
6124
6125 static int test_blockdev_flushbufs_0 (void)
6126 {
6127   if (test_blockdev_flushbufs_0_skip ()) {
6128     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6129     return 0;
6130   }
6131
6132   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6133   {
6134     char device[] = "/dev/sda";
6135     device[5] = devchar;
6136     int r;
6137     suppress_error = 0;
6138     r = guestfs_blockdev_setrw (g, device);
6139     if (r == -1)
6140       return -1;
6141   }
6142   {
6143     int r;
6144     suppress_error = 0;
6145     r = guestfs_umount_all (g);
6146     if (r == -1)
6147       return -1;
6148   }
6149   {
6150     int r;
6151     suppress_error = 0;
6152     r = guestfs_lvm_remove_all (g);
6153     if (r == -1)
6154       return -1;
6155   }
6156   /* TestRun for blockdev_flushbufs (0) */
6157   {
6158     char device[] = "/dev/sda";
6159     device[5] = devchar;
6160     int r;
6161     suppress_error = 0;
6162     r = guestfs_blockdev_flushbufs (g, device);
6163     if (r == -1)
6164       return -1;
6165   }
6166   return 0;
6167 }
6168
6169 static int test_blockdev_getsize64_0_skip (void)
6170 {
6171   const char *str;
6172
6173   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6174   if (str && strcmp (str, "1") == 0) return 1;
6175   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6176   if (str && strcmp (str, "1") == 0) return 1;
6177   return 0;
6178 }
6179
6180 static int test_blockdev_getsize64_0 (void)
6181 {
6182   if (test_blockdev_getsize64_0_skip ()) {
6183     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6184     return 0;
6185   }
6186
6187   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6188   {
6189     char device[] = "/dev/sda";
6190     device[5] = devchar;
6191     int r;
6192     suppress_error = 0;
6193     r = guestfs_blockdev_setrw (g, device);
6194     if (r == -1)
6195       return -1;
6196   }
6197   {
6198     int r;
6199     suppress_error = 0;
6200     r = guestfs_umount_all (g);
6201     if (r == -1)
6202       return -1;
6203   }
6204   {
6205     int r;
6206     suppress_error = 0;
6207     r = guestfs_lvm_remove_all (g);
6208     if (r == -1)
6209       return -1;
6210   }
6211   /* TestOutputInt for blockdev_getsize64 (0) */
6212   {
6213     char device[] = "/dev/sda";
6214     device[5] = devchar;
6215     int64_t r;
6216     suppress_error = 0;
6217     r = guestfs_blockdev_getsize64 (g, device);
6218     if (r == -1)
6219       return -1;
6220     if (r != 524288000) {
6221       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6222       return -1;
6223     }
6224   }
6225   return 0;
6226 }
6227
6228 static int test_blockdev_getsz_0_skip (void)
6229 {
6230   const char *str;
6231
6232   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6233   if (str && strcmp (str, "1") == 0) return 1;
6234   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6235   if (str && strcmp (str, "1") == 0) return 1;
6236   return 0;
6237 }
6238
6239 static int test_blockdev_getsz_0 (void)
6240 {
6241   if (test_blockdev_getsz_0_skip ()) {
6242     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6243     return 0;
6244   }
6245
6246   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6247   {
6248     char device[] = "/dev/sda";
6249     device[5] = devchar;
6250     int r;
6251     suppress_error = 0;
6252     r = guestfs_blockdev_setrw (g, device);
6253     if (r == -1)
6254       return -1;
6255   }
6256   {
6257     int r;
6258     suppress_error = 0;
6259     r = guestfs_umount_all (g);
6260     if (r == -1)
6261       return -1;
6262   }
6263   {
6264     int r;
6265     suppress_error = 0;
6266     r = guestfs_lvm_remove_all (g);
6267     if (r == -1)
6268       return -1;
6269   }
6270   /* TestOutputInt for blockdev_getsz (0) */
6271   {
6272     char device[] = "/dev/sda";
6273     device[5] = devchar;
6274     int64_t r;
6275     suppress_error = 0;
6276     r = guestfs_blockdev_getsz (g, device);
6277     if (r == -1)
6278       return -1;
6279     if (r != 1024000) {
6280       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6281       return -1;
6282     }
6283   }
6284   return 0;
6285 }
6286
6287 static int test_blockdev_getbsz_0_skip (void)
6288 {
6289   const char *str;
6290
6291   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6292   if (str && strcmp (str, "1") == 0) return 1;
6293   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6294   if (str && strcmp (str, "1") == 0) return 1;
6295   return 0;
6296 }
6297
6298 static int test_blockdev_getbsz_0 (void)
6299 {
6300   if (test_blockdev_getbsz_0_skip ()) {
6301     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6302     return 0;
6303   }
6304
6305   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6306   {
6307     char device[] = "/dev/sda";
6308     device[5] = devchar;
6309     int r;
6310     suppress_error = 0;
6311     r = guestfs_blockdev_setrw (g, device);
6312     if (r == -1)
6313       return -1;
6314   }
6315   {
6316     int r;
6317     suppress_error = 0;
6318     r = guestfs_umount_all (g);
6319     if (r == -1)
6320       return -1;
6321   }
6322   {
6323     int r;
6324     suppress_error = 0;
6325     r = guestfs_lvm_remove_all (g);
6326     if (r == -1)
6327       return -1;
6328   }
6329   /* TestOutputInt for blockdev_getbsz (0) */
6330   {
6331     char device[] = "/dev/sda";
6332     device[5] = devchar;
6333     int r;
6334     suppress_error = 0;
6335     r = guestfs_blockdev_getbsz (g, device);
6336     if (r == -1)
6337       return -1;
6338     if (r != 4096) {
6339       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6340       return -1;
6341     }
6342   }
6343   return 0;
6344 }
6345
6346 static int test_blockdev_getss_0_skip (void)
6347 {
6348   const char *str;
6349
6350   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6351   if (str && strcmp (str, "1") == 0) return 1;
6352   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6353   if (str && strcmp (str, "1") == 0) return 1;
6354   return 0;
6355 }
6356
6357 static int test_blockdev_getss_0 (void)
6358 {
6359   if (test_blockdev_getss_0_skip ()) {
6360     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6361     return 0;
6362   }
6363
6364   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6365   {
6366     char device[] = "/dev/sda";
6367     device[5] = devchar;
6368     int r;
6369     suppress_error = 0;
6370     r = guestfs_blockdev_setrw (g, device);
6371     if (r == -1)
6372       return -1;
6373   }
6374   {
6375     int r;
6376     suppress_error = 0;
6377     r = guestfs_umount_all (g);
6378     if (r == -1)
6379       return -1;
6380   }
6381   {
6382     int r;
6383     suppress_error = 0;
6384     r = guestfs_lvm_remove_all (g);
6385     if (r == -1)
6386       return -1;
6387   }
6388   /* TestOutputInt for blockdev_getss (0) */
6389   {
6390     char device[] = "/dev/sda";
6391     device[5] = devchar;
6392     int r;
6393     suppress_error = 0;
6394     r = guestfs_blockdev_getss (g, device);
6395     if (r == -1)
6396       return -1;
6397     if (r != 512) {
6398       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6399       return -1;
6400     }
6401   }
6402   return 0;
6403 }
6404
6405 static int test_blockdev_getro_0_skip (void)
6406 {
6407   const char *str;
6408
6409   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6410   if (str && strcmp (str, "1") == 0) return 1;
6411   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6412   if (str && strcmp (str, "1") == 0) return 1;
6413   return 0;
6414 }
6415
6416 static int test_blockdev_getro_0 (void)
6417 {
6418   if (test_blockdev_getro_0_skip ()) {
6419     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6420     return 0;
6421   }
6422
6423   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6424   {
6425     char device[] = "/dev/sda";
6426     device[5] = devchar;
6427     int r;
6428     suppress_error = 0;
6429     r = guestfs_blockdev_setrw (g, device);
6430     if (r == -1)
6431       return -1;
6432   }
6433   {
6434     int r;
6435     suppress_error = 0;
6436     r = guestfs_umount_all (g);
6437     if (r == -1)
6438       return -1;
6439   }
6440   {
6441     int r;
6442     suppress_error = 0;
6443     r = guestfs_lvm_remove_all (g);
6444     if (r == -1)
6445       return -1;
6446   }
6447   /* TestOutputTrue for blockdev_getro (0) */
6448   {
6449     char device[] = "/dev/sda";
6450     device[5] = devchar;
6451     int r;
6452     suppress_error = 0;
6453     r = guestfs_blockdev_setro (g, device);
6454     if (r == -1)
6455       return -1;
6456   }
6457   {
6458     char device[] = "/dev/sda";
6459     device[5] = devchar;
6460     int r;
6461     suppress_error = 0;
6462     r = guestfs_blockdev_getro (g, device);
6463     if (r == -1)
6464       return -1;
6465     if (!r) {
6466       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6467       return -1;
6468     }
6469   }
6470   return 0;
6471 }
6472
6473 static int test_blockdev_setrw_0_skip (void)
6474 {
6475   const char *str;
6476
6477   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6478   if (str && strcmp (str, "1") == 0) return 1;
6479   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6480   if (str && strcmp (str, "1") == 0) return 1;
6481   return 0;
6482 }
6483
6484 static int test_blockdev_setrw_0 (void)
6485 {
6486   if (test_blockdev_setrw_0_skip ()) {
6487     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6488     return 0;
6489   }
6490
6491   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6492   {
6493     char device[] = "/dev/sda";
6494     device[5] = devchar;
6495     int r;
6496     suppress_error = 0;
6497     r = guestfs_blockdev_setrw (g, device);
6498     if (r == -1)
6499       return -1;
6500   }
6501   {
6502     int r;
6503     suppress_error = 0;
6504     r = guestfs_umount_all (g);
6505     if (r == -1)
6506       return -1;
6507   }
6508   {
6509     int r;
6510     suppress_error = 0;
6511     r = guestfs_lvm_remove_all (g);
6512     if (r == -1)
6513       return -1;
6514   }
6515   /* TestOutputFalse for blockdev_setrw (0) */
6516   {
6517     char device[] = "/dev/sda";
6518     device[5] = devchar;
6519     int r;
6520     suppress_error = 0;
6521     r = guestfs_blockdev_setrw (g, device);
6522     if (r == -1)
6523       return -1;
6524   }
6525   {
6526     char device[] = "/dev/sda";
6527     device[5] = devchar;
6528     int r;
6529     suppress_error = 0;
6530     r = guestfs_blockdev_getro (g, device);
6531     if (r == -1)
6532       return -1;
6533     if (r) {
6534       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6535       return -1;
6536     }
6537   }
6538   return 0;
6539 }
6540
6541 static int test_blockdev_setro_0_skip (void)
6542 {
6543   const char *str;
6544
6545   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6546   if (str && strcmp (str, "1") == 0) return 1;
6547   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6548   if (str && strcmp (str, "1") == 0) return 1;
6549   return 0;
6550 }
6551
6552 static int test_blockdev_setro_0 (void)
6553 {
6554   if (test_blockdev_setro_0_skip ()) {
6555     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6556     return 0;
6557   }
6558
6559   /* InitNone|InitEmpty for test_blockdev_setro_0 */
6560   {
6561     char device[] = "/dev/sda";
6562     device[5] = devchar;
6563     int r;
6564     suppress_error = 0;
6565     r = guestfs_blockdev_setrw (g, device);
6566     if (r == -1)
6567       return -1;
6568   }
6569   {
6570     int r;
6571     suppress_error = 0;
6572     r = guestfs_umount_all (g);
6573     if (r == -1)
6574       return -1;
6575   }
6576   {
6577     int r;
6578     suppress_error = 0;
6579     r = guestfs_lvm_remove_all (g);
6580     if (r == -1)
6581       return -1;
6582   }
6583   /* TestOutputTrue for blockdev_setro (0) */
6584   {
6585     char device[] = "/dev/sda";
6586     device[5] = devchar;
6587     int r;
6588     suppress_error = 0;
6589     r = guestfs_blockdev_setro (g, device);
6590     if (r == -1)
6591       return -1;
6592   }
6593   {
6594     char device[] = "/dev/sda";
6595     device[5] = devchar;
6596     int r;
6597     suppress_error = 0;
6598     r = guestfs_blockdev_getro (g, device);
6599     if (r == -1)
6600       return -1;
6601     if (!r) {
6602       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6603       return -1;
6604     }
6605   }
6606   return 0;
6607 }
6608
6609 static int test_statvfs_0_skip (void)
6610 {
6611   const char *str;
6612
6613   str = getenv ("SKIP_TEST_STATVFS_0");
6614   if (str && strcmp (str, "1") == 0) return 1;
6615   str = getenv ("SKIP_TEST_STATVFS");
6616   if (str && strcmp (str, "1") == 0) return 1;
6617   return 0;
6618 }
6619
6620 static int test_statvfs_0 (void)
6621 {
6622   if (test_statvfs_0_skip ()) {
6623     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6624     return 0;
6625   }
6626
6627   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6628   {
6629     char device[] = "/dev/sda";
6630     device[5] = devchar;
6631     int r;
6632     suppress_error = 0;
6633     r = guestfs_blockdev_setrw (g, device);
6634     if (r == -1)
6635       return -1;
6636   }
6637   {
6638     int r;
6639     suppress_error = 0;
6640     r = guestfs_umount_all (g);
6641     if (r == -1)
6642       return -1;
6643   }
6644   {
6645     int r;
6646     suppress_error = 0;
6647     r = guestfs_lvm_remove_all (g);
6648     if (r == -1)
6649       return -1;
6650   }
6651   {
6652     char device[] = "/dev/sda";
6653     device[5] = devchar;
6654     char lines_0[] = ",";
6655     char *lines[] = {
6656       lines_0,
6657       NULL
6658     };
6659     int r;
6660     suppress_error = 0;
6661     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6662     if (r == -1)
6663       return -1;
6664   }
6665   {
6666     char fstype[] = "ext2";
6667     char device[] = "/dev/sda1";
6668     device[5] = devchar;
6669     int r;
6670     suppress_error = 0;
6671     r = guestfs_mkfs (g, fstype, device);
6672     if (r == -1)
6673       return -1;
6674   }
6675   {
6676     char device[] = "/dev/sda1";
6677     device[5] = devchar;
6678     char mountpoint[] = "/";
6679     int r;
6680     suppress_error = 0;
6681     r = guestfs_mount (g, device, mountpoint);
6682     if (r == -1)
6683       return -1;
6684   }
6685   /* TestOutputStruct for statvfs (0) */
6686   {
6687     char path[] = "/";
6688     struct guestfs_statvfs *r;
6689     suppress_error = 0;
6690     r = guestfs_statvfs (g, path);
6691     if (r == NULL)
6692       return -1;
6693     if (r->bfree != 487702) {
6694       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6695                (int) r->bfree);
6696       return -1;
6697     }
6698     if (r->blocks != 490020) {
6699       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6700                (int) r->blocks);
6701       return -1;
6702     }
6703     if (r->bsize != 1024) {
6704       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6705                (int) r->bsize);
6706       return -1;
6707     }
6708     free (r);
6709   }
6710   return 0;
6711 }
6712
6713 static int test_lstat_0_skip (void)
6714 {
6715   const char *str;
6716
6717   str = getenv ("SKIP_TEST_LSTAT_0");
6718   if (str && strcmp (str, "1") == 0) return 1;
6719   str = getenv ("SKIP_TEST_LSTAT");
6720   if (str && strcmp (str, "1") == 0) return 1;
6721   return 0;
6722 }
6723
6724 static int test_lstat_0 (void)
6725 {
6726   if (test_lstat_0_skip ()) {
6727     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6728     return 0;
6729   }
6730
6731   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6732   {
6733     char device[] = "/dev/sda";
6734     device[5] = devchar;
6735     int r;
6736     suppress_error = 0;
6737     r = guestfs_blockdev_setrw (g, device);
6738     if (r == -1)
6739       return -1;
6740   }
6741   {
6742     int r;
6743     suppress_error = 0;
6744     r = guestfs_umount_all (g);
6745     if (r == -1)
6746       return -1;
6747   }
6748   {
6749     int r;
6750     suppress_error = 0;
6751     r = guestfs_lvm_remove_all (g);
6752     if (r == -1)
6753       return -1;
6754   }
6755   {
6756     char device[] = "/dev/sda";
6757     device[5] = devchar;
6758     char lines_0[] = ",";
6759     char *lines[] = {
6760       lines_0,
6761       NULL
6762     };
6763     int r;
6764     suppress_error = 0;
6765     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6766     if (r == -1)
6767       return -1;
6768   }
6769   {
6770     char fstype[] = "ext2";
6771     char device[] = "/dev/sda1";
6772     device[5] = devchar;
6773     int r;
6774     suppress_error = 0;
6775     r = guestfs_mkfs (g, fstype, device);
6776     if (r == -1)
6777       return -1;
6778   }
6779   {
6780     char device[] = "/dev/sda1";
6781     device[5] = devchar;
6782     char mountpoint[] = "/";
6783     int r;
6784     suppress_error = 0;
6785     r = guestfs_mount (g, device, mountpoint);
6786     if (r == -1)
6787       return -1;
6788   }
6789   /* TestOutputStruct for lstat (0) */
6790   {
6791     char path[] = "/new";
6792     int r;
6793     suppress_error = 0;
6794     r = guestfs_touch (g, path);
6795     if (r == -1)
6796       return -1;
6797   }
6798   {
6799     char path[] = "/new";
6800     struct guestfs_stat *r;
6801     suppress_error = 0;
6802     r = guestfs_lstat (g, path);
6803     if (r == NULL)
6804       return -1;
6805     if (r->size != 0) {
6806       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6807                (int) r->size);
6808       return -1;
6809     }
6810     free (r);
6811   }
6812   return 0;
6813 }
6814
6815 static int test_stat_0_skip (void)
6816 {
6817   const char *str;
6818
6819   str = getenv ("SKIP_TEST_STAT_0");
6820   if (str && strcmp (str, "1") == 0) return 1;
6821   str = getenv ("SKIP_TEST_STAT");
6822   if (str && strcmp (str, "1") == 0) return 1;
6823   return 0;
6824 }
6825
6826 static int test_stat_0 (void)
6827 {
6828   if (test_stat_0_skip ()) {
6829     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6830     return 0;
6831   }
6832
6833   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6834   {
6835     char device[] = "/dev/sda";
6836     device[5] = devchar;
6837     int r;
6838     suppress_error = 0;
6839     r = guestfs_blockdev_setrw (g, device);
6840     if (r == -1)
6841       return -1;
6842   }
6843   {
6844     int r;
6845     suppress_error = 0;
6846     r = guestfs_umount_all (g);
6847     if (r == -1)
6848       return -1;
6849   }
6850   {
6851     int r;
6852     suppress_error = 0;
6853     r = guestfs_lvm_remove_all (g);
6854     if (r == -1)
6855       return -1;
6856   }
6857   {
6858     char device[] = "/dev/sda";
6859     device[5] = devchar;
6860     char lines_0[] = ",";
6861     char *lines[] = {
6862       lines_0,
6863       NULL
6864     };
6865     int r;
6866     suppress_error = 0;
6867     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6868     if (r == -1)
6869       return -1;
6870   }
6871   {
6872     char fstype[] = "ext2";
6873     char device[] = "/dev/sda1";
6874     device[5] = devchar;
6875     int r;
6876     suppress_error = 0;
6877     r = guestfs_mkfs (g, fstype, device);
6878     if (r == -1)
6879       return -1;
6880   }
6881   {
6882     char device[] = "/dev/sda1";
6883     device[5] = devchar;
6884     char mountpoint[] = "/";
6885     int r;
6886     suppress_error = 0;
6887     r = guestfs_mount (g, device, mountpoint);
6888     if (r == -1)
6889       return -1;
6890   }
6891   /* TestOutputStruct for stat (0) */
6892   {
6893     char path[] = "/new";
6894     int r;
6895     suppress_error = 0;
6896     r = guestfs_touch (g, path);
6897     if (r == -1)
6898       return -1;
6899   }
6900   {
6901     char path[] = "/new";
6902     struct guestfs_stat *r;
6903     suppress_error = 0;
6904     r = guestfs_stat (g, path);
6905     if (r == NULL)
6906       return -1;
6907     if (r->size != 0) {
6908       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6909                (int) r->size);
6910       return -1;
6911     }
6912     free (r);
6913   }
6914   return 0;
6915 }
6916
6917 static int test_command_lines_0_skip (void)
6918 {
6919   const char *str;
6920
6921   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6922   if (str && strcmp (str, "1") == 0) return 1;
6923   str = getenv ("SKIP_TEST_COMMAND_LINES");
6924   if (str && strcmp (str, "1") == 0) return 1;
6925   return 0;
6926 }
6927
6928 static int test_command_lines_0 (void)
6929 {
6930   if (test_command_lines_0_skip ()) {
6931     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6932     return 0;
6933   }
6934
6935   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6936   {
6937     char device[] = "/dev/sda";
6938     device[5] = devchar;
6939     int r;
6940     suppress_error = 0;
6941     r = guestfs_blockdev_setrw (g, device);
6942     if (r == -1)
6943       return -1;
6944   }
6945   {
6946     int r;
6947     suppress_error = 0;
6948     r = guestfs_umount_all (g);
6949     if (r == -1)
6950       return -1;
6951   }
6952   {
6953     int r;
6954     suppress_error = 0;
6955     r = guestfs_lvm_remove_all (g);
6956     if (r == -1)
6957       return -1;
6958   }
6959   {
6960     char device[] = "/dev/sda";
6961     device[5] = devchar;
6962     char lines_0[] = ",";
6963     char *lines[] = {
6964       lines_0,
6965       NULL
6966     };
6967     int r;
6968     suppress_error = 0;
6969     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6970     if (r == -1)
6971       return -1;
6972   }
6973   {
6974     char fstype[] = "ext2";
6975     char device[] = "/dev/sda1";
6976     device[5] = devchar;
6977     int r;
6978     suppress_error = 0;
6979     r = guestfs_mkfs (g, fstype, device);
6980     if (r == -1)
6981       return -1;
6982   }
6983   {
6984     char device[] = "/dev/sda1";
6985     device[5] = devchar;
6986     char mountpoint[] = "/";
6987     int r;
6988     suppress_error = 0;
6989     r = guestfs_mount (g, device, mountpoint);
6990     if (r == -1)
6991       return -1;
6992   }
6993   /* TestOutputList for command_lines (0) */
6994   {
6995     char remotefilename[] = "/test-command";
6996     int r;
6997     suppress_error = 0;
6998     r = guestfs_upload (g, "test-command", remotefilename);
6999     if (r == -1)
7000       return -1;
7001   }
7002   {
7003     char path[] = "/test-command";
7004     int r;
7005     suppress_error = 0;
7006     r = guestfs_chmod (g, 493, path);
7007     if (r == -1)
7008       return -1;
7009   }
7010   {
7011     char arguments_0[] = "/test-command";
7012     char arguments_1[] = "1";
7013     char *arguments[] = {
7014       arguments_0,
7015       arguments_1,
7016       NULL
7017     };
7018     char **r;
7019     int i;
7020     suppress_error = 0;
7021     r = guestfs_command_lines (g, arguments);
7022     if (r == NULL)
7023       return -1;
7024     if (!r[0]) {
7025       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7026       print_strings (r);
7027       return -1;
7028     }
7029     {
7030       char expected[] = "Result1";
7031       if (strcmp (r[0], expected) != 0) {
7032         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7033         return -1;
7034       }
7035     }
7036     if (r[1] != NULL) {
7037       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7038       print_strings (r);
7039       return -1;
7040     }
7041     for (i = 0; r[i] != NULL; ++i)
7042       free (r[i]);
7043     free (r);
7044   }
7045   return 0;
7046 }
7047
7048 static int test_command_lines_1_skip (void)
7049 {
7050   const char *str;
7051
7052   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7053   if (str && strcmp (str, "1") == 0) return 1;
7054   str = getenv ("SKIP_TEST_COMMAND_LINES");
7055   if (str && strcmp (str, "1") == 0) return 1;
7056   return 0;
7057 }
7058
7059 static int test_command_lines_1 (void)
7060 {
7061   if (test_command_lines_1_skip ()) {
7062     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7063     return 0;
7064   }
7065
7066   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7067   {
7068     char device[] = "/dev/sda";
7069     device[5] = devchar;
7070     int r;
7071     suppress_error = 0;
7072     r = guestfs_blockdev_setrw (g, device);
7073     if (r == -1)
7074       return -1;
7075   }
7076   {
7077     int r;
7078     suppress_error = 0;
7079     r = guestfs_umount_all (g);
7080     if (r == -1)
7081       return -1;
7082   }
7083   {
7084     int r;
7085     suppress_error = 0;
7086     r = guestfs_lvm_remove_all (g);
7087     if (r == -1)
7088       return -1;
7089   }
7090   {
7091     char device[] = "/dev/sda";
7092     device[5] = devchar;
7093     char lines_0[] = ",";
7094     char *lines[] = {
7095       lines_0,
7096       NULL
7097     };
7098     int r;
7099     suppress_error = 0;
7100     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7101     if (r == -1)
7102       return -1;
7103   }
7104   {
7105     char fstype[] = "ext2";
7106     char device[] = "/dev/sda1";
7107     device[5] = devchar;
7108     int r;
7109     suppress_error = 0;
7110     r = guestfs_mkfs (g, fstype, device);
7111     if (r == -1)
7112       return -1;
7113   }
7114   {
7115     char device[] = "/dev/sda1";
7116     device[5] = devchar;
7117     char mountpoint[] = "/";
7118     int r;
7119     suppress_error = 0;
7120     r = guestfs_mount (g, device, mountpoint);
7121     if (r == -1)
7122       return -1;
7123   }
7124   /* TestOutputList for command_lines (1) */
7125   {
7126     char remotefilename[] = "/test-command";
7127     int r;
7128     suppress_error = 0;
7129     r = guestfs_upload (g, "test-command", remotefilename);
7130     if (r == -1)
7131       return -1;
7132   }
7133   {
7134     char path[] = "/test-command";
7135     int r;
7136     suppress_error = 0;
7137     r = guestfs_chmod (g, 493, path);
7138     if (r == -1)
7139       return -1;
7140   }
7141   {
7142     char arguments_0[] = "/test-command";
7143     char arguments_1[] = "2";
7144     char *arguments[] = {
7145       arguments_0,
7146       arguments_1,
7147       NULL
7148     };
7149     char **r;
7150     int i;
7151     suppress_error = 0;
7152     r = guestfs_command_lines (g, arguments);
7153     if (r == NULL)
7154       return -1;
7155     if (!r[0]) {
7156       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7157       print_strings (r);
7158       return -1;
7159     }
7160     {
7161       char expected[] = "Result2";
7162       if (strcmp (r[0], expected) != 0) {
7163         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7164         return -1;
7165       }
7166     }
7167     if (r[1] != NULL) {
7168       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7169       print_strings (r);
7170       return -1;
7171     }
7172     for (i = 0; r[i] != NULL; ++i)
7173       free (r[i]);
7174     free (r);
7175   }
7176   return 0;
7177 }
7178
7179 static int test_command_lines_2_skip (void)
7180 {
7181   const char *str;
7182
7183   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7184   if (str && strcmp (str, "1") == 0) return 1;
7185   str = getenv ("SKIP_TEST_COMMAND_LINES");
7186   if (str && strcmp (str, "1") == 0) return 1;
7187   return 0;
7188 }
7189
7190 static int test_command_lines_2 (void)
7191 {
7192   if (test_command_lines_2_skip ()) {
7193     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7194     return 0;
7195   }
7196
7197   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7198   {
7199     char device[] = "/dev/sda";
7200     device[5] = devchar;
7201     int r;
7202     suppress_error = 0;
7203     r = guestfs_blockdev_setrw (g, device);
7204     if (r == -1)
7205       return -1;
7206   }
7207   {
7208     int r;
7209     suppress_error = 0;
7210     r = guestfs_umount_all (g);
7211     if (r == -1)
7212       return -1;
7213   }
7214   {
7215     int r;
7216     suppress_error = 0;
7217     r = guestfs_lvm_remove_all (g);
7218     if (r == -1)
7219       return -1;
7220   }
7221   {
7222     char device[] = "/dev/sda";
7223     device[5] = devchar;
7224     char lines_0[] = ",";
7225     char *lines[] = {
7226       lines_0,
7227       NULL
7228     };
7229     int r;
7230     suppress_error = 0;
7231     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7232     if (r == -1)
7233       return -1;
7234   }
7235   {
7236     char fstype[] = "ext2";
7237     char device[] = "/dev/sda1";
7238     device[5] = devchar;
7239     int r;
7240     suppress_error = 0;
7241     r = guestfs_mkfs (g, fstype, device);
7242     if (r == -1)
7243       return -1;
7244   }
7245   {
7246     char device[] = "/dev/sda1";
7247     device[5] = devchar;
7248     char mountpoint[] = "/";
7249     int r;
7250     suppress_error = 0;
7251     r = guestfs_mount (g, device, mountpoint);
7252     if (r == -1)
7253       return -1;
7254   }
7255   /* TestOutputList for command_lines (2) */
7256   {
7257     char remotefilename[] = "/test-command";
7258     int r;
7259     suppress_error = 0;
7260     r = guestfs_upload (g, "test-command", remotefilename);
7261     if (r == -1)
7262       return -1;
7263   }
7264   {
7265     char path[] = "/test-command";
7266     int r;
7267     suppress_error = 0;
7268     r = guestfs_chmod (g, 493, path);
7269     if (r == -1)
7270       return -1;
7271   }
7272   {
7273     char arguments_0[] = "/test-command";
7274     char arguments_1[] = "3";
7275     char *arguments[] = {
7276       arguments_0,
7277       arguments_1,
7278       NULL
7279     };
7280     char **r;
7281     int i;
7282     suppress_error = 0;
7283     r = guestfs_command_lines (g, arguments);
7284     if (r == NULL)
7285       return -1;
7286     if (!r[0]) {
7287       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7288       print_strings (r);
7289       return -1;
7290     }
7291     {
7292       char expected[] = "";
7293       if (strcmp (r[0], expected) != 0) {
7294         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7295         return -1;
7296       }
7297     }
7298     if (!r[1]) {
7299       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7300       print_strings (r);
7301       return -1;
7302     }
7303     {
7304       char expected[] = "Result3";
7305       if (strcmp (r[1], expected) != 0) {
7306         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7307         return -1;
7308       }
7309     }
7310     if (r[2] != NULL) {
7311       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7312       print_strings (r);
7313       return -1;
7314     }
7315     for (i = 0; r[i] != NULL; ++i)
7316       free (r[i]);
7317     free (r);
7318   }
7319   return 0;
7320 }
7321
7322 static int test_command_lines_3_skip (void)
7323 {
7324   const char *str;
7325
7326   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7327   if (str && strcmp (str, "1") == 0) return 1;
7328   str = getenv ("SKIP_TEST_COMMAND_LINES");
7329   if (str && strcmp (str, "1") == 0) return 1;
7330   return 0;
7331 }
7332
7333 static int test_command_lines_3 (void)
7334 {
7335   if (test_command_lines_3_skip ()) {
7336     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7337     return 0;
7338   }
7339
7340   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7341   {
7342     char device[] = "/dev/sda";
7343     device[5] = devchar;
7344     int r;
7345     suppress_error = 0;
7346     r = guestfs_blockdev_setrw (g, device);
7347     if (r == -1)
7348       return -1;
7349   }
7350   {
7351     int r;
7352     suppress_error = 0;
7353     r = guestfs_umount_all (g);
7354     if (r == -1)
7355       return -1;
7356   }
7357   {
7358     int r;
7359     suppress_error = 0;
7360     r = guestfs_lvm_remove_all (g);
7361     if (r == -1)
7362       return -1;
7363   }
7364   {
7365     char device[] = "/dev/sda";
7366     device[5] = devchar;
7367     char lines_0[] = ",";
7368     char *lines[] = {
7369       lines_0,
7370       NULL
7371     };
7372     int r;
7373     suppress_error = 0;
7374     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7375     if (r == -1)
7376       return -1;
7377   }
7378   {
7379     char fstype[] = "ext2";
7380     char device[] = "/dev/sda1";
7381     device[5] = devchar;
7382     int r;
7383     suppress_error = 0;
7384     r = guestfs_mkfs (g, fstype, device);
7385     if (r == -1)
7386       return -1;
7387   }
7388   {
7389     char device[] = "/dev/sda1";
7390     device[5] = devchar;
7391     char mountpoint[] = "/";
7392     int r;
7393     suppress_error = 0;
7394     r = guestfs_mount (g, device, mountpoint);
7395     if (r == -1)
7396       return -1;
7397   }
7398   /* TestOutputList for command_lines (3) */
7399   {
7400     char remotefilename[] = "/test-command";
7401     int r;
7402     suppress_error = 0;
7403     r = guestfs_upload (g, "test-command", remotefilename);
7404     if (r == -1)
7405       return -1;
7406   }
7407   {
7408     char path[] = "/test-command";
7409     int r;
7410     suppress_error = 0;
7411     r = guestfs_chmod (g, 493, path);
7412     if (r == -1)
7413       return -1;
7414   }
7415   {
7416     char arguments_0[] = "/test-command";
7417     char arguments_1[] = "4";
7418     char *arguments[] = {
7419       arguments_0,
7420       arguments_1,
7421       NULL
7422     };
7423     char **r;
7424     int i;
7425     suppress_error = 0;
7426     r = guestfs_command_lines (g, arguments);
7427     if (r == NULL)
7428       return -1;
7429     if (!r[0]) {
7430       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7431       print_strings (r);
7432       return -1;
7433     }
7434     {
7435       char expected[] = "";
7436       if (strcmp (r[0], expected) != 0) {
7437         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7438         return -1;
7439       }
7440     }
7441     if (!r[1]) {
7442       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7443       print_strings (r);
7444       return -1;
7445     }
7446     {
7447       char expected[] = "Result4";
7448       if (strcmp (r[1], expected) != 0) {
7449         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7450         return -1;
7451       }
7452     }
7453     if (r[2] != NULL) {
7454       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7455       print_strings (r);
7456       return -1;
7457     }
7458     for (i = 0; r[i] != NULL; ++i)
7459       free (r[i]);
7460     free (r);
7461   }
7462   return 0;
7463 }
7464
7465 static int test_command_lines_4_skip (void)
7466 {
7467   const char *str;
7468
7469   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7470   if (str && strcmp (str, "1") == 0) return 1;
7471   str = getenv ("SKIP_TEST_COMMAND_LINES");
7472   if (str && strcmp (str, "1") == 0) return 1;
7473   return 0;
7474 }
7475
7476 static int test_command_lines_4 (void)
7477 {
7478   if (test_command_lines_4_skip ()) {
7479     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7480     return 0;
7481   }
7482
7483   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7484   {
7485     char device[] = "/dev/sda";
7486     device[5] = devchar;
7487     int r;
7488     suppress_error = 0;
7489     r = guestfs_blockdev_setrw (g, device);
7490     if (r == -1)
7491       return -1;
7492   }
7493   {
7494     int r;
7495     suppress_error = 0;
7496     r = guestfs_umount_all (g);
7497     if (r == -1)
7498       return -1;
7499   }
7500   {
7501     int r;
7502     suppress_error = 0;
7503     r = guestfs_lvm_remove_all (g);
7504     if (r == -1)
7505       return -1;
7506   }
7507   {
7508     char device[] = "/dev/sda";
7509     device[5] = devchar;
7510     char lines_0[] = ",";
7511     char *lines[] = {
7512       lines_0,
7513       NULL
7514     };
7515     int r;
7516     suppress_error = 0;
7517     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7518     if (r == -1)
7519       return -1;
7520   }
7521   {
7522     char fstype[] = "ext2";
7523     char device[] = "/dev/sda1";
7524     device[5] = devchar;
7525     int r;
7526     suppress_error = 0;
7527     r = guestfs_mkfs (g, fstype, device);
7528     if (r == -1)
7529       return -1;
7530   }
7531   {
7532     char device[] = "/dev/sda1";
7533     device[5] = devchar;
7534     char mountpoint[] = "/";
7535     int r;
7536     suppress_error = 0;
7537     r = guestfs_mount (g, device, mountpoint);
7538     if (r == -1)
7539       return -1;
7540   }
7541   /* TestOutputList for command_lines (4) */
7542   {
7543     char remotefilename[] = "/test-command";
7544     int r;
7545     suppress_error = 0;
7546     r = guestfs_upload (g, "test-command", remotefilename);
7547     if (r == -1)
7548       return -1;
7549   }
7550   {
7551     char path[] = "/test-command";
7552     int r;
7553     suppress_error = 0;
7554     r = guestfs_chmod (g, 493, path);
7555     if (r == -1)
7556       return -1;
7557   }
7558   {
7559     char arguments_0[] = "/test-command";
7560     char arguments_1[] = "5";
7561     char *arguments[] = {
7562       arguments_0,
7563       arguments_1,
7564       NULL
7565     };
7566     char **r;
7567     int i;
7568     suppress_error = 0;
7569     r = guestfs_command_lines (g, arguments);
7570     if (r == NULL)
7571       return -1;
7572     if (!r[0]) {
7573       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7574       print_strings (r);
7575       return -1;
7576     }
7577     {
7578       char expected[] = "";
7579       if (strcmp (r[0], expected) != 0) {
7580         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7581         return -1;
7582       }
7583     }
7584     if (!r[1]) {
7585       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7586       print_strings (r);
7587       return -1;
7588     }
7589     {
7590       char expected[] = "Result5";
7591       if (strcmp (r[1], expected) != 0) {
7592         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7593         return -1;
7594       }
7595     }
7596     if (!r[2]) {
7597       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7598       print_strings (r);
7599       return -1;
7600     }
7601     {
7602       char expected[] = "";
7603       if (strcmp (r[2], expected) != 0) {
7604         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7605         return -1;
7606       }
7607     }
7608     if (r[3] != NULL) {
7609       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7610       print_strings (r);
7611       return -1;
7612     }
7613     for (i = 0; r[i] != NULL; ++i)
7614       free (r[i]);
7615     free (r);
7616   }
7617   return 0;
7618 }
7619
7620 static int test_command_lines_5_skip (void)
7621 {
7622   const char *str;
7623
7624   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7625   if (str && strcmp (str, "1") == 0) return 1;
7626   str = getenv ("SKIP_TEST_COMMAND_LINES");
7627   if (str && strcmp (str, "1") == 0) return 1;
7628   return 0;
7629 }
7630
7631 static int test_command_lines_5 (void)
7632 {
7633   if (test_command_lines_5_skip ()) {
7634     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7635     return 0;
7636   }
7637
7638   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7639   {
7640     char device[] = "/dev/sda";
7641     device[5] = devchar;
7642     int r;
7643     suppress_error = 0;
7644     r = guestfs_blockdev_setrw (g, device);
7645     if (r == -1)
7646       return -1;
7647   }
7648   {
7649     int r;
7650     suppress_error = 0;
7651     r = guestfs_umount_all (g);
7652     if (r == -1)
7653       return -1;
7654   }
7655   {
7656     int r;
7657     suppress_error = 0;
7658     r = guestfs_lvm_remove_all (g);
7659     if (r == -1)
7660       return -1;
7661   }
7662   {
7663     char device[] = "/dev/sda";
7664     device[5] = devchar;
7665     char lines_0[] = ",";
7666     char *lines[] = {
7667       lines_0,
7668       NULL
7669     };
7670     int r;
7671     suppress_error = 0;
7672     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7673     if (r == -1)
7674       return -1;
7675   }
7676   {
7677     char fstype[] = "ext2";
7678     char device[] = "/dev/sda1";
7679     device[5] = devchar;
7680     int r;
7681     suppress_error = 0;
7682     r = guestfs_mkfs (g, fstype, device);
7683     if (r == -1)
7684       return -1;
7685   }
7686   {
7687     char device[] = "/dev/sda1";
7688     device[5] = devchar;
7689     char mountpoint[] = "/";
7690     int r;
7691     suppress_error = 0;
7692     r = guestfs_mount (g, device, mountpoint);
7693     if (r == -1)
7694       return -1;
7695   }
7696   /* TestOutputList for command_lines (5) */
7697   {
7698     char remotefilename[] = "/test-command";
7699     int r;
7700     suppress_error = 0;
7701     r = guestfs_upload (g, "test-command", remotefilename);
7702     if (r == -1)
7703       return -1;
7704   }
7705   {
7706     char path[] = "/test-command";
7707     int r;
7708     suppress_error = 0;
7709     r = guestfs_chmod (g, 493, path);
7710     if (r == -1)
7711       return -1;
7712   }
7713   {
7714     char arguments_0[] = "/test-command";
7715     char arguments_1[] = "6";
7716     char *arguments[] = {
7717       arguments_0,
7718       arguments_1,
7719       NULL
7720     };
7721     char **r;
7722     int i;
7723     suppress_error = 0;
7724     r = guestfs_command_lines (g, arguments);
7725     if (r == NULL)
7726       return -1;
7727     if (!r[0]) {
7728       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7729       print_strings (r);
7730       return -1;
7731     }
7732     {
7733       char expected[] = "";
7734       if (strcmp (r[0], expected) != 0) {
7735         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7736         return -1;
7737       }
7738     }
7739     if (!r[1]) {
7740       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7741       print_strings (r);
7742       return -1;
7743     }
7744     {
7745       char expected[] = "";
7746       if (strcmp (r[1], expected) != 0) {
7747         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7748         return -1;
7749       }
7750     }
7751     if (!r[2]) {
7752       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7753       print_strings (r);
7754       return -1;
7755     }
7756     {
7757       char expected[] = "Result6";
7758       if (strcmp (r[2], expected) != 0) {
7759         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7760         return -1;
7761       }
7762     }
7763     if (!r[3]) {
7764       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7765       print_strings (r);
7766       return -1;
7767     }
7768     {
7769       char expected[] = "";
7770       if (strcmp (r[3], expected) != 0) {
7771         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7772         return -1;
7773       }
7774     }
7775     if (r[4] != NULL) {
7776       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7777       print_strings (r);
7778       return -1;
7779     }
7780     for (i = 0; r[i] != NULL; ++i)
7781       free (r[i]);
7782     free (r);
7783   }
7784   return 0;
7785 }
7786
7787 static int test_command_lines_6_skip (void)
7788 {
7789   const char *str;
7790
7791   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7792   if (str && strcmp (str, "1") == 0) return 1;
7793   str = getenv ("SKIP_TEST_COMMAND_LINES");
7794   if (str && strcmp (str, "1") == 0) return 1;
7795   return 0;
7796 }
7797
7798 static int test_command_lines_6 (void)
7799 {
7800   if (test_command_lines_6_skip ()) {
7801     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7802     return 0;
7803   }
7804
7805   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7806   {
7807     char device[] = "/dev/sda";
7808     device[5] = devchar;
7809     int r;
7810     suppress_error = 0;
7811     r = guestfs_blockdev_setrw (g, device);
7812     if (r == -1)
7813       return -1;
7814   }
7815   {
7816     int r;
7817     suppress_error = 0;
7818     r = guestfs_umount_all (g);
7819     if (r == -1)
7820       return -1;
7821   }
7822   {
7823     int r;
7824     suppress_error = 0;
7825     r = guestfs_lvm_remove_all (g);
7826     if (r == -1)
7827       return -1;
7828   }
7829   {
7830     char device[] = "/dev/sda";
7831     device[5] = devchar;
7832     char lines_0[] = ",";
7833     char *lines[] = {
7834       lines_0,
7835       NULL
7836     };
7837     int r;
7838     suppress_error = 0;
7839     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7840     if (r == -1)
7841       return -1;
7842   }
7843   {
7844     char fstype[] = "ext2";
7845     char device[] = "/dev/sda1";
7846     device[5] = devchar;
7847     int r;
7848     suppress_error = 0;
7849     r = guestfs_mkfs (g, fstype, device);
7850     if (r == -1)
7851       return -1;
7852   }
7853   {
7854     char device[] = "/dev/sda1";
7855     device[5] = devchar;
7856     char mountpoint[] = "/";
7857     int r;
7858     suppress_error = 0;
7859     r = guestfs_mount (g, device, mountpoint);
7860     if (r == -1)
7861       return -1;
7862   }
7863   /* TestOutputList for command_lines (6) */
7864   {
7865     char remotefilename[] = "/test-command";
7866     int r;
7867     suppress_error = 0;
7868     r = guestfs_upload (g, "test-command", remotefilename);
7869     if (r == -1)
7870       return -1;
7871   }
7872   {
7873     char path[] = "/test-command";
7874     int r;
7875     suppress_error = 0;
7876     r = guestfs_chmod (g, 493, path);
7877     if (r == -1)
7878       return -1;
7879   }
7880   {
7881     char arguments_0[] = "/test-command";
7882     char arguments_1[] = "7";
7883     char *arguments[] = {
7884       arguments_0,
7885       arguments_1,
7886       NULL
7887     };
7888     char **r;
7889     int i;
7890     suppress_error = 0;
7891     r = guestfs_command_lines (g, arguments);
7892     if (r == NULL)
7893       return -1;
7894     if (r[0] != NULL) {
7895       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7896       print_strings (r);
7897       return -1;
7898     }
7899     for (i = 0; r[i] != NULL; ++i)
7900       free (r[i]);
7901     free (r);
7902   }
7903   return 0;
7904 }
7905
7906 static int test_command_lines_7_skip (void)
7907 {
7908   const char *str;
7909
7910   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7911   if (str && strcmp (str, "1") == 0) return 1;
7912   str = getenv ("SKIP_TEST_COMMAND_LINES");
7913   if (str && strcmp (str, "1") == 0) return 1;
7914   return 0;
7915 }
7916
7917 static int test_command_lines_7 (void)
7918 {
7919   if (test_command_lines_7_skip ()) {
7920     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7921     return 0;
7922   }
7923
7924   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7925   {
7926     char device[] = "/dev/sda";
7927     device[5] = devchar;
7928     int r;
7929     suppress_error = 0;
7930     r = guestfs_blockdev_setrw (g, device);
7931     if (r == -1)
7932       return -1;
7933   }
7934   {
7935     int r;
7936     suppress_error = 0;
7937     r = guestfs_umount_all (g);
7938     if (r == -1)
7939       return -1;
7940   }
7941   {
7942     int r;
7943     suppress_error = 0;
7944     r = guestfs_lvm_remove_all (g);
7945     if (r == -1)
7946       return -1;
7947   }
7948   {
7949     char device[] = "/dev/sda";
7950     device[5] = devchar;
7951     char lines_0[] = ",";
7952     char *lines[] = {
7953       lines_0,
7954       NULL
7955     };
7956     int r;
7957     suppress_error = 0;
7958     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7959     if (r == -1)
7960       return -1;
7961   }
7962   {
7963     char fstype[] = "ext2";
7964     char device[] = "/dev/sda1";
7965     device[5] = devchar;
7966     int r;
7967     suppress_error = 0;
7968     r = guestfs_mkfs (g, fstype, device);
7969     if (r == -1)
7970       return -1;
7971   }
7972   {
7973     char device[] = "/dev/sda1";
7974     device[5] = devchar;
7975     char mountpoint[] = "/";
7976     int r;
7977     suppress_error = 0;
7978     r = guestfs_mount (g, device, mountpoint);
7979     if (r == -1)
7980       return -1;
7981   }
7982   /* TestOutputList for command_lines (7) */
7983   {
7984     char remotefilename[] = "/test-command";
7985     int r;
7986     suppress_error = 0;
7987     r = guestfs_upload (g, "test-command", remotefilename);
7988     if (r == -1)
7989       return -1;
7990   }
7991   {
7992     char path[] = "/test-command";
7993     int r;
7994     suppress_error = 0;
7995     r = guestfs_chmod (g, 493, path);
7996     if (r == -1)
7997       return -1;
7998   }
7999   {
8000     char arguments_0[] = "/test-command";
8001     char arguments_1[] = "8";
8002     char *arguments[] = {
8003       arguments_0,
8004       arguments_1,
8005       NULL
8006     };
8007     char **r;
8008     int i;
8009     suppress_error = 0;
8010     r = guestfs_command_lines (g, arguments);
8011     if (r == NULL)
8012       return -1;
8013     if (!r[0]) {
8014       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8015       print_strings (r);
8016       return -1;
8017     }
8018     {
8019       char expected[] = "";
8020       if (strcmp (r[0], expected) != 0) {
8021         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8022         return -1;
8023       }
8024     }
8025     if (r[1] != NULL) {
8026       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8027       print_strings (r);
8028       return -1;
8029     }
8030     for (i = 0; r[i] != NULL; ++i)
8031       free (r[i]);
8032     free (r);
8033   }
8034   return 0;
8035 }
8036
8037 static int test_command_lines_8_skip (void)
8038 {
8039   const char *str;
8040
8041   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8042   if (str && strcmp (str, "1") == 0) return 1;
8043   str = getenv ("SKIP_TEST_COMMAND_LINES");
8044   if (str && strcmp (str, "1") == 0) return 1;
8045   return 0;
8046 }
8047
8048 static int test_command_lines_8 (void)
8049 {
8050   if (test_command_lines_8_skip ()) {
8051     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8052     return 0;
8053   }
8054
8055   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8056   {
8057     char device[] = "/dev/sda";
8058     device[5] = devchar;
8059     int r;
8060     suppress_error = 0;
8061     r = guestfs_blockdev_setrw (g, device);
8062     if (r == -1)
8063       return -1;
8064   }
8065   {
8066     int r;
8067     suppress_error = 0;
8068     r = guestfs_umount_all (g);
8069     if (r == -1)
8070       return -1;
8071   }
8072   {
8073     int r;
8074     suppress_error = 0;
8075     r = guestfs_lvm_remove_all (g);
8076     if (r == -1)
8077       return -1;
8078   }
8079   {
8080     char device[] = "/dev/sda";
8081     device[5] = devchar;
8082     char lines_0[] = ",";
8083     char *lines[] = {
8084       lines_0,
8085       NULL
8086     };
8087     int r;
8088     suppress_error = 0;
8089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8090     if (r == -1)
8091       return -1;
8092   }
8093   {
8094     char fstype[] = "ext2";
8095     char device[] = "/dev/sda1";
8096     device[5] = devchar;
8097     int r;
8098     suppress_error = 0;
8099     r = guestfs_mkfs (g, fstype, device);
8100     if (r == -1)
8101       return -1;
8102   }
8103   {
8104     char device[] = "/dev/sda1";
8105     device[5] = devchar;
8106     char mountpoint[] = "/";
8107     int r;
8108     suppress_error = 0;
8109     r = guestfs_mount (g, device, mountpoint);
8110     if (r == -1)
8111       return -1;
8112   }
8113   /* TestOutputList for command_lines (8) */
8114   {
8115     char remotefilename[] = "/test-command";
8116     int r;
8117     suppress_error = 0;
8118     r = guestfs_upload (g, "test-command", remotefilename);
8119     if (r == -1)
8120       return -1;
8121   }
8122   {
8123     char path[] = "/test-command";
8124     int r;
8125     suppress_error = 0;
8126     r = guestfs_chmod (g, 493, path);
8127     if (r == -1)
8128       return -1;
8129   }
8130   {
8131     char arguments_0[] = "/test-command";
8132     char arguments_1[] = "9";
8133     char *arguments[] = {
8134       arguments_0,
8135       arguments_1,
8136       NULL
8137     };
8138     char **r;
8139     int i;
8140     suppress_error = 0;
8141     r = guestfs_command_lines (g, arguments);
8142     if (r == NULL)
8143       return -1;
8144     if (!r[0]) {
8145       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8146       print_strings (r);
8147       return -1;
8148     }
8149     {
8150       char expected[] = "";
8151       if (strcmp (r[0], expected) != 0) {
8152         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8153         return -1;
8154       }
8155     }
8156     if (!r[1]) {
8157       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8158       print_strings (r);
8159       return -1;
8160     }
8161     {
8162       char expected[] = "";
8163       if (strcmp (r[1], expected) != 0) {
8164         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8165         return -1;
8166       }
8167     }
8168     if (r[2] != NULL) {
8169       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8170       print_strings (r);
8171       return -1;
8172     }
8173     for (i = 0; r[i] != NULL; ++i)
8174       free (r[i]);
8175     free (r);
8176   }
8177   return 0;
8178 }
8179
8180 static int test_command_lines_9_skip (void)
8181 {
8182   const char *str;
8183
8184   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8185   if (str && strcmp (str, "1") == 0) return 1;
8186   str = getenv ("SKIP_TEST_COMMAND_LINES");
8187   if (str && strcmp (str, "1") == 0) return 1;
8188   return 0;
8189 }
8190
8191 static int test_command_lines_9 (void)
8192 {
8193   if (test_command_lines_9_skip ()) {
8194     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8195     return 0;
8196   }
8197
8198   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8199   {
8200     char device[] = "/dev/sda";
8201     device[5] = devchar;
8202     int r;
8203     suppress_error = 0;
8204     r = guestfs_blockdev_setrw (g, device);
8205     if (r == -1)
8206       return -1;
8207   }
8208   {
8209     int r;
8210     suppress_error = 0;
8211     r = guestfs_umount_all (g);
8212     if (r == -1)
8213       return -1;
8214   }
8215   {
8216     int r;
8217     suppress_error = 0;
8218     r = guestfs_lvm_remove_all (g);
8219     if (r == -1)
8220       return -1;
8221   }
8222   {
8223     char device[] = "/dev/sda";
8224     device[5] = devchar;
8225     char lines_0[] = ",";
8226     char *lines[] = {
8227       lines_0,
8228       NULL
8229     };
8230     int r;
8231     suppress_error = 0;
8232     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8233     if (r == -1)
8234       return -1;
8235   }
8236   {
8237     char fstype[] = "ext2";
8238     char device[] = "/dev/sda1";
8239     device[5] = devchar;
8240     int r;
8241     suppress_error = 0;
8242     r = guestfs_mkfs (g, fstype, device);
8243     if (r == -1)
8244       return -1;
8245   }
8246   {
8247     char device[] = "/dev/sda1";
8248     device[5] = devchar;
8249     char mountpoint[] = "/";
8250     int r;
8251     suppress_error = 0;
8252     r = guestfs_mount (g, device, mountpoint);
8253     if (r == -1)
8254       return -1;
8255   }
8256   /* TestOutputList for command_lines (9) */
8257   {
8258     char remotefilename[] = "/test-command";
8259     int r;
8260     suppress_error = 0;
8261     r = guestfs_upload (g, "test-command", remotefilename);
8262     if (r == -1)
8263       return -1;
8264   }
8265   {
8266     char path[] = "/test-command";
8267     int r;
8268     suppress_error = 0;
8269     r = guestfs_chmod (g, 493, path);
8270     if (r == -1)
8271       return -1;
8272   }
8273   {
8274     char arguments_0[] = "/test-command";
8275     char arguments_1[] = "10";
8276     char *arguments[] = {
8277       arguments_0,
8278       arguments_1,
8279       NULL
8280     };
8281     char **r;
8282     int i;
8283     suppress_error = 0;
8284     r = guestfs_command_lines (g, arguments);
8285     if (r == NULL)
8286       return -1;
8287     if (!r[0]) {
8288       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8289       print_strings (r);
8290       return -1;
8291     }
8292     {
8293       char expected[] = "Result10-1";
8294       if (strcmp (r[0], expected) != 0) {
8295         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8296         return -1;
8297       }
8298     }
8299     if (!r[1]) {
8300       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8301       print_strings (r);
8302       return -1;
8303     }
8304     {
8305       char expected[] = "Result10-2";
8306       if (strcmp (r[1], expected) != 0) {
8307         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8308         return -1;
8309       }
8310     }
8311     if (r[2] != NULL) {
8312       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8313       print_strings (r);
8314       return -1;
8315     }
8316     for (i = 0; r[i] != NULL; ++i)
8317       free (r[i]);
8318     free (r);
8319   }
8320   return 0;
8321 }
8322
8323 static int test_command_lines_10_skip (void)
8324 {
8325   const char *str;
8326
8327   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8328   if (str && strcmp (str, "1") == 0) return 1;
8329   str = getenv ("SKIP_TEST_COMMAND_LINES");
8330   if (str && strcmp (str, "1") == 0) return 1;
8331   return 0;
8332 }
8333
8334 static int test_command_lines_10 (void)
8335 {
8336   if (test_command_lines_10_skip ()) {
8337     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8338     return 0;
8339   }
8340
8341   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8342   {
8343     char device[] = "/dev/sda";
8344     device[5] = devchar;
8345     int r;
8346     suppress_error = 0;
8347     r = guestfs_blockdev_setrw (g, device);
8348     if (r == -1)
8349       return -1;
8350   }
8351   {
8352     int r;
8353     suppress_error = 0;
8354     r = guestfs_umount_all (g);
8355     if (r == -1)
8356       return -1;
8357   }
8358   {
8359     int r;
8360     suppress_error = 0;
8361     r = guestfs_lvm_remove_all (g);
8362     if (r == -1)
8363       return -1;
8364   }
8365   {
8366     char device[] = "/dev/sda";
8367     device[5] = devchar;
8368     char lines_0[] = ",";
8369     char *lines[] = {
8370       lines_0,
8371       NULL
8372     };
8373     int r;
8374     suppress_error = 0;
8375     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8376     if (r == -1)
8377       return -1;
8378   }
8379   {
8380     char fstype[] = "ext2";
8381     char device[] = "/dev/sda1";
8382     device[5] = devchar;
8383     int r;
8384     suppress_error = 0;
8385     r = guestfs_mkfs (g, fstype, device);
8386     if (r == -1)
8387       return -1;
8388   }
8389   {
8390     char device[] = "/dev/sda1";
8391     device[5] = devchar;
8392     char mountpoint[] = "/";
8393     int r;
8394     suppress_error = 0;
8395     r = guestfs_mount (g, device, mountpoint);
8396     if (r == -1)
8397       return -1;
8398   }
8399   /* TestOutputList for command_lines (10) */
8400   {
8401     char remotefilename[] = "/test-command";
8402     int r;
8403     suppress_error = 0;
8404     r = guestfs_upload (g, "test-command", remotefilename);
8405     if (r == -1)
8406       return -1;
8407   }
8408   {
8409     char path[] = "/test-command";
8410     int r;
8411     suppress_error = 0;
8412     r = guestfs_chmod (g, 493, path);
8413     if (r == -1)
8414       return -1;
8415   }
8416   {
8417     char arguments_0[] = "/test-command";
8418     char arguments_1[] = "11";
8419     char *arguments[] = {
8420       arguments_0,
8421       arguments_1,
8422       NULL
8423     };
8424     char **r;
8425     int i;
8426     suppress_error = 0;
8427     r = guestfs_command_lines (g, arguments);
8428     if (r == NULL)
8429       return -1;
8430     if (!r[0]) {
8431       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8432       print_strings (r);
8433       return -1;
8434     }
8435     {
8436       char expected[] = "Result11-1";
8437       if (strcmp (r[0], expected) != 0) {
8438         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8439         return -1;
8440       }
8441     }
8442     if (!r[1]) {
8443       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8444       print_strings (r);
8445       return -1;
8446     }
8447     {
8448       char expected[] = "Result11-2";
8449       if (strcmp (r[1], expected) != 0) {
8450         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8451         return -1;
8452       }
8453     }
8454     if (r[2] != NULL) {
8455       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8456       print_strings (r);
8457       return -1;
8458     }
8459     for (i = 0; r[i] != NULL; ++i)
8460       free (r[i]);
8461     free (r);
8462   }
8463   return 0;
8464 }
8465
8466 static int test_command_0_skip (void)
8467 {
8468   const char *str;
8469
8470   str = getenv ("SKIP_TEST_COMMAND_0");
8471   if (str && strcmp (str, "1") == 0) return 1;
8472   str = getenv ("SKIP_TEST_COMMAND");
8473   if (str && strcmp (str, "1") == 0) return 1;
8474   return 0;
8475 }
8476
8477 static int test_command_0 (void)
8478 {
8479   if (test_command_0_skip ()) {
8480     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8481     return 0;
8482   }
8483
8484   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8485   {
8486     char device[] = "/dev/sda";
8487     device[5] = devchar;
8488     int r;
8489     suppress_error = 0;
8490     r = guestfs_blockdev_setrw (g, device);
8491     if (r == -1)
8492       return -1;
8493   }
8494   {
8495     int r;
8496     suppress_error = 0;
8497     r = guestfs_umount_all (g);
8498     if (r == -1)
8499       return -1;
8500   }
8501   {
8502     int r;
8503     suppress_error = 0;
8504     r = guestfs_lvm_remove_all (g);
8505     if (r == -1)
8506       return -1;
8507   }
8508   {
8509     char device[] = "/dev/sda";
8510     device[5] = devchar;
8511     char lines_0[] = ",";
8512     char *lines[] = {
8513       lines_0,
8514       NULL
8515     };
8516     int r;
8517     suppress_error = 0;
8518     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8519     if (r == -1)
8520       return -1;
8521   }
8522   {
8523     char fstype[] = "ext2";
8524     char device[] = "/dev/sda1";
8525     device[5] = devchar;
8526     int r;
8527     suppress_error = 0;
8528     r = guestfs_mkfs (g, fstype, device);
8529     if (r == -1)
8530       return -1;
8531   }
8532   {
8533     char device[] = "/dev/sda1";
8534     device[5] = devchar;
8535     char mountpoint[] = "/";
8536     int r;
8537     suppress_error = 0;
8538     r = guestfs_mount (g, device, mountpoint);
8539     if (r == -1)
8540       return -1;
8541   }
8542   /* TestOutput for command (0) */
8543   char expected[] = "Result1";
8544   {
8545     char remotefilename[] = "/test-command";
8546     int r;
8547     suppress_error = 0;
8548     r = guestfs_upload (g, "test-command", remotefilename);
8549     if (r == -1)
8550       return -1;
8551   }
8552   {
8553     char path[] = "/test-command";
8554     int r;
8555     suppress_error = 0;
8556     r = guestfs_chmod (g, 493, path);
8557     if (r == -1)
8558       return -1;
8559   }
8560   {
8561     char arguments_0[] = "/test-command";
8562     char arguments_1[] = "1";
8563     char *arguments[] = {
8564       arguments_0,
8565       arguments_1,
8566       NULL
8567     };
8568     char *r;
8569     suppress_error = 0;
8570     r = guestfs_command (g, arguments);
8571     if (r == NULL)
8572       return -1;
8573     if (strcmp (r, expected) != 0) {
8574       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8575       return -1;
8576     }
8577     free (r);
8578   }
8579   return 0;
8580 }
8581
8582 static int test_command_1_skip (void)
8583 {
8584   const char *str;
8585
8586   str = getenv ("SKIP_TEST_COMMAND_1");
8587   if (str && strcmp (str, "1") == 0) return 1;
8588   str = getenv ("SKIP_TEST_COMMAND");
8589   if (str && strcmp (str, "1") == 0) return 1;
8590   return 0;
8591 }
8592
8593 static int test_command_1 (void)
8594 {
8595   if (test_command_1_skip ()) {
8596     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8597     return 0;
8598   }
8599
8600   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8601   {
8602     char device[] = "/dev/sda";
8603     device[5] = devchar;
8604     int r;
8605     suppress_error = 0;
8606     r = guestfs_blockdev_setrw (g, device);
8607     if (r == -1)
8608       return -1;
8609   }
8610   {
8611     int r;
8612     suppress_error = 0;
8613     r = guestfs_umount_all (g);
8614     if (r == -1)
8615       return -1;
8616   }
8617   {
8618     int r;
8619     suppress_error = 0;
8620     r = guestfs_lvm_remove_all (g);
8621     if (r == -1)
8622       return -1;
8623   }
8624   {
8625     char device[] = "/dev/sda";
8626     device[5] = devchar;
8627     char lines_0[] = ",";
8628     char *lines[] = {
8629       lines_0,
8630       NULL
8631     };
8632     int r;
8633     suppress_error = 0;
8634     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8635     if (r == -1)
8636       return -1;
8637   }
8638   {
8639     char fstype[] = "ext2";
8640     char device[] = "/dev/sda1";
8641     device[5] = devchar;
8642     int r;
8643     suppress_error = 0;
8644     r = guestfs_mkfs (g, fstype, device);
8645     if (r == -1)
8646       return -1;
8647   }
8648   {
8649     char device[] = "/dev/sda1";
8650     device[5] = devchar;
8651     char mountpoint[] = "/";
8652     int r;
8653     suppress_error = 0;
8654     r = guestfs_mount (g, device, mountpoint);
8655     if (r == -1)
8656       return -1;
8657   }
8658   /* TestOutput for command (1) */
8659   char expected[] = "Result2\n";
8660   {
8661     char remotefilename[] = "/test-command";
8662     int r;
8663     suppress_error = 0;
8664     r = guestfs_upload (g, "test-command", remotefilename);
8665     if (r == -1)
8666       return -1;
8667   }
8668   {
8669     char path[] = "/test-command";
8670     int r;
8671     suppress_error = 0;
8672     r = guestfs_chmod (g, 493, path);
8673     if (r == -1)
8674       return -1;
8675   }
8676   {
8677     char arguments_0[] = "/test-command";
8678     char arguments_1[] = "2";
8679     char *arguments[] = {
8680       arguments_0,
8681       arguments_1,
8682       NULL
8683     };
8684     char *r;
8685     suppress_error = 0;
8686     r = guestfs_command (g, arguments);
8687     if (r == NULL)
8688       return -1;
8689     if (strcmp (r, expected) != 0) {
8690       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8691       return -1;
8692     }
8693     free (r);
8694   }
8695   return 0;
8696 }
8697
8698 static int test_command_2_skip (void)
8699 {
8700   const char *str;
8701
8702   str = getenv ("SKIP_TEST_COMMAND_2");
8703   if (str && strcmp (str, "1") == 0) return 1;
8704   str = getenv ("SKIP_TEST_COMMAND");
8705   if (str && strcmp (str, "1") == 0) return 1;
8706   return 0;
8707 }
8708
8709 static int test_command_2 (void)
8710 {
8711   if (test_command_2_skip ()) {
8712     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8713     return 0;
8714   }
8715
8716   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8717   {
8718     char device[] = "/dev/sda";
8719     device[5] = devchar;
8720     int r;
8721     suppress_error = 0;
8722     r = guestfs_blockdev_setrw (g, device);
8723     if (r == -1)
8724       return -1;
8725   }
8726   {
8727     int r;
8728     suppress_error = 0;
8729     r = guestfs_umount_all (g);
8730     if (r == -1)
8731       return -1;
8732   }
8733   {
8734     int r;
8735     suppress_error = 0;
8736     r = guestfs_lvm_remove_all (g);
8737     if (r == -1)
8738       return -1;
8739   }
8740   {
8741     char device[] = "/dev/sda";
8742     device[5] = devchar;
8743     char lines_0[] = ",";
8744     char *lines[] = {
8745       lines_0,
8746       NULL
8747     };
8748     int r;
8749     suppress_error = 0;
8750     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8751     if (r == -1)
8752       return -1;
8753   }
8754   {
8755     char fstype[] = "ext2";
8756     char device[] = "/dev/sda1";
8757     device[5] = devchar;
8758     int r;
8759     suppress_error = 0;
8760     r = guestfs_mkfs (g, fstype, device);
8761     if (r == -1)
8762       return -1;
8763   }
8764   {
8765     char device[] = "/dev/sda1";
8766     device[5] = devchar;
8767     char mountpoint[] = "/";
8768     int r;
8769     suppress_error = 0;
8770     r = guestfs_mount (g, device, mountpoint);
8771     if (r == -1)
8772       return -1;
8773   }
8774   /* TestOutput for command (2) */
8775   char expected[] = "\nResult3";
8776   {
8777     char remotefilename[] = "/test-command";
8778     int r;
8779     suppress_error = 0;
8780     r = guestfs_upload (g, "test-command", remotefilename);
8781     if (r == -1)
8782       return -1;
8783   }
8784   {
8785     char path[] = "/test-command";
8786     int r;
8787     suppress_error = 0;
8788     r = guestfs_chmod (g, 493, path);
8789     if (r == -1)
8790       return -1;
8791   }
8792   {
8793     char arguments_0[] = "/test-command";
8794     char arguments_1[] = "3";
8795     char *arguments[] = {
8796       arguments_0,
8797       arguments_1,
8798       NULL
8799     };
8800     char *r;
8801     suppress_error = 0;
8802     r = guestfs_command (g, arguments);
8803     if (r == NULL)
8804       return -1;
8805     if (strcmp (r, expected) != 0) {
8806       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8807       return -1;
8808     }
8809     free (r);
8810   }
8811   return 0;
8812 }
8813
8814 static int test_command_3_skip (void)
8815 {
8816   const char *str;
8817
8818   str = getenv ("SKIP_TEST_COMMAND_3");
8819   if (str && strcmp (str, "1") == 0) return 1;
8820   str = getenv ("SKIP_TEST_COMMAND");
8821   if (str && strcmp (str, "1") == 0) return 1;
8822   return 0;
8823 }
8824
8825 static int test_command_3 (void)
8826 {
8827   if (test_command_3_skip ()) {
8828     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8829     return 0;
8830   }
8831
8832   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8833   {
8834     char device[] = "/dev/sda";
8835     device[5] = devchar;
8836     int r;
8837     suppress_error = 0;
8838     r = guestfs_blockdev_setrw (g, device);
8839     if (r == -1)
8840       return -1;
8841   }
8842   {
8843     int r;
8844     suppress_error = 0;
8845     r = guestfs_umount_all (g);
8846     if (r == -1)
8847       return -1;
8848   }
8849   {
8850     int r;
8851     suppress_error = 0;
8852     r = guestfs_lvm_remove_all (g);
8853     if (r == -1)
8854       return -1;
8855   }
8856   {
8857     char device[] = "/dev/sda";
8858     device[5] = devchar;
8859     char lines_0[] = ",";
8860     char *lines[] = {
8861       lines_0,
8862       NULL
8863     };
8864     int r;
8865     suppress_error = 0;
8866     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8867     if (r == -1)
8868       return -1;
8869   }
8870   {
8871     char fstype[] = "ext2";
8872     char device[] = "/dev/sda1";
8873     device[5] = devchar;
8874     int r;
8875     suppress_error = 0;
8876     r = guestfs_mkfs (g, fstype, device);
8877     if (r == -1)
8878       return -1;
8879   }
8880   {
8881     char device[] = "/dev/sda1";
8882     device[5] = devchar;
8883     char mountpoint[] = "/";
8884     int r;
8885     suppress_error = 0;
8886     r = guestfs_mount (g, device, mountpoint);
8887     if (r == -1)
8888       return -1;
8889   }
8890   /* TestOutput for command (3) */
8891   char expected[] = "\nResult4\n";
8892   {
8893     char remotefilename[] = "/test-command";
8894     int r;
8895     suppress_error = 0;
8896     r = guestfs_upload (g, "test-command", remotefilename);
8897     if (r == -1)
8898       return -1;
8899   }
8900   {
8901     char path[] = "/test-command";
8902     int r;
8903     suppress_error = 0;
8904     r = guestfs_chmod (g, 493, path);
8905     if (r == -1)
8906       return -1;
8907   }
8908   {
8909     char arguments_0[] = "/test-command";
8910     char arguments_1[] = "4";
8911     char *arguments[] = {
8912       arguments_0,
8913       arguments_1,
8914       NULL
8915     };
8916     char *r;
8917     suppress_error = 0;
8918     r = guestfs_command (g, arguments);
8919     if (r == NULL)
8920       return -1;
8921     if (strcmp (r, expected) != 0) {
8922       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8923       return -1;
8924     }
8925     free (r);
8926   }
8927   return 0;
8928 }
8929
8930 static int test_command_4_skip (void)
8931 {
8932   const char *str;
8933
8934   str = getenv ("SKIP_TEST_COMMAND_4");
8935   if (str && strcmp (str, "1") == 0) return 1;
8936   str = getenv ("SKIP_TEST_COMMAND");
8937   if (str && strcmp (str, "1") == 0) return 1;
8938   return 0;
8939 }
8940
8941 static int test_command_4 (void)
8942 {
8943   if (test_command_4_skip ()) {
8944     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8945     return 0;
8946   }
8947
8948   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8949   {
8950     char device[] = "/dev/sda";
8951     device[5] = devchar;
8952     int r;
8953     suppress_error = 0;
8954     r = guestfs_blockdev_setrw (g, device);
8955     if (r == -1)
8956       return -1;
8957   }
8958   {
8959     int r;
8960     suppress_error = 0;
8961     r = guestfs_umount_all (g);
8962     if (r == -1)
8963       return -1;
8964   }
8965   {
8966     int r;
8967     suppress_error = 0;
8968     r = guestfs_lvm_remove_all (g);
8969     if (r == -1)
8970       return -1;
8971   }
8972   {
8973     char device[] = "/dev/sda";
8974     device[5] = devchar;
8975     char lines_0[] = ",";
8976     char *lines[] = {
8977       lines_0,
8978       NULL
8979     };
8980     int r;
8981     suppress_error = 0;
8982     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8983     if (r == -1)
8984       return -1;
8985   }
8986   {
8987     char fstype[] = "ext2";
8988     char device[] = "/dev/sda1";
8989     device[5] = devchar;
8990     int r;
8991     suppress_error = 0;
8992     r = guestfs_mkfs (g, fstype, device);
8993     if (r == -1)
8994       return -1;
8995   }
8996   {
8997     char device[] = "/dev/sda1";
8998     device[5] = devchar;
8999     char mountpoint[] = "/";
9000     int r;
9001     suppress_error = 0;
9002     r = guestfs_mount (g, device, mountpoint);
9003     if (r == -1)
9004       return -1;
9005   }
9006   /* TestOutput for command (4) */
9007   char expected[] = "\nResult5\n\n";
9008   {
9009     char remotefilename[] = "/test-command";
9010     int r;
9011     suppress_error = 0;
9012     r = guestfs_upload (g, "test-command", remotefilename);
9013     if (r == -1)
9014       return -1;
9015   }
9016   {
9017     char path[] = "/test-command";
9018     int r;
9019     suppress_error = 0;
9020     r = guestfs_chmod (g, 493, path);
9021     if (r == -1)
9022       return -1;
9023   }
9024   {
9025     char arguments_0[] = "/test-command";
9026     char arguments_1[] = "5";
9027     char *arguments[] = {
9028       arguments_0,
9029       arguments_1,
9030       NULL
9031     };
9032     char *r;
9033     suppress_error = 0;
9034     r = guestfs_command (g, arguments);
9035     if (r == NULL)
9036       return -1;
9037     if (strcmp (r, expected) != 0) {
9038       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9039       return -1;
9040     }
9041     free (r);
9042   }
9043   return 0;
9044 }
9045
9046 static int test_command_5_skip (void)
9047 {
9048   const char *str;
9049
9050   str = getenv ("SKIP_TEST_COMMAND_5");
9051   if (str && strcmp (str, "1") == 0) return 1;
9052   str = getenv ("SKIP_TEST_COMMAND");
9053   if (str && strcmp (str, "1") == 0) return 1;
9054   return 0;
9055 }
9056
9057 static int test_command_5 (void)
9058 {
9059   if (test_command_5_skip ()) {
9060     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9061     return 0;
9062   }
9063
9064   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9065   {
9066     char device[] = "/dev/sda";
9067     device[5] = devchar;
9068     int r;
9069     suppress_error = 0;
9070     r = guestfs_blockdev_setrw (g, device);
9071     if (r == -1)
9072       return -1;
9073   }
9074   {
9075     int r;
9076     suppress_error = 0;
9077     r = guestfs_umount_all (g);
9078     if (r == -1)
9079       return -1;
9080   }
9081   {
9082     int r;
9083     suppress_error = 0;
9084     r = guestfs_lvm_remove_all (g);
9085     if (r == -1)
9086       return -1;
9087   }
9088   {
9089     char device[] = "/dev/sda";
9090     device[5] = devchar;
9091     char lines_0[] = ",";
9092     char *lines[] = {
9093       lines_0,
9094       NULL
9095     };
9096     int r;
9097     suppress_error = 0;
9098     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9099     if (r == -1)
9100       return -1;
9101   }
9102   {
9103     char fstype[] = "ext2";
9104     char device[] = "/dev/sda1";
9105     device[5] = devchar;
9106     int r;
9107     suppress_error = 0;
9108     r = guestfs_mkfs (g, fstype, device);
9109     if (r == -1)
9110       return -1;
9111   }
9112   {
9113     char device[] = "/dev/sda1";
9114     device[5] = devchar;
9115     char mountpoint[] = "/";
9116     int r;
9117     suppress_error = 0;
9118     r = guestfs_mount (g, device, mountpoint);
9119     if (r == -1)
9120       return -1;
9121   }
9122   /* TestOutput for command (5) */
9123   char expected[] = "\n\nResult6\n\n";
9124   {
9125     char remotefilename[] = "/test-command";
9126     int r;
9127     suppress_error = 0;
9128     r = guestfs_upload (g, "test-command", remotefilename);
9129     if (r == -1)
9130       return -1;
9131   }
9132   {
9133     char path[] = "/test-command";
9134     int r;
9135     suppress_error = 0;
9136     r = guestfs_chmod (g, 493, path);
9137     if (r == -1)
9138       return -1;
9139   }
9140   {
9141     char arguments_0[] = "/test-command";
9142     char arguments_1[] = "6";
9143     char *arguments[] = {
9144       arguments_0,
9145       arguments_1,
9146       NULL
9147     };
9148     char *r;
9149     suppress_error = 0;
9150     r = guestfs_command (g, arguments);
9151     if (r == NULL)
9152       return -1;
9153     if (strcmp (r, expected) != 0) {
9154       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9155       return -1;
9156     }
9157     free (r);
9158   }
9159   return 0;
9160 }
9161
9162 static int test_command_6_skip (void)
9163 {
9164   const char *str;
9165
9166   str = getenv ("SKIP_TEST_COMMAND_6");
9167   if (str && strcmp (str, "1") == 0) return 1;
9168   str = getenv ("SKIP_TEST_COMMAND");
9169   if (str && strcmp (str, "1") == 0) return 1;
9170   return 0;
9171 }
9172
9173 static int test_command_6 (void)
9174 {
9175   if (test_command_6_skip ()) {
9176     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9177     return 0;
9178   }
9179
9180   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9181   {
9182     char device[] = "/dev/sda";
9183     device[5] = devchar;
9184     int r;
9185     suppress_error = 0;
9186     r = guestfs_blockdev_setrw (g, device);
9187     if (r == -1)
9188       return -1;
9189   }
9190   {
9191     int r;
9192     suppress_error = 0;
9193     r = guestfs_umount_all (g);
9194     if (r == -1)
9195       return -1;
9196   }
9197   {
9198     int r;
9199     suppress_error = 0;
9200     r = guestfs_lvm_remove_all (g);
9201     if (r == -1)
9202       return -1;
9203   }
9204   {
9205     char device[] = "/dev/sda";
9206     device[5] = devchar;
9207     char lines_0[] = ",";
9208     char *lines[] = {
9209       lines_0,
9210       NULL
9211     };
9212     int r;
9213     suppress_error = 0;
9214     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9215     if (r == -1)
9216       return -1;
9217   }
9218   {
9219     char fstype[] = "ext2";
9220     char device[] = "/dev/sda1";
9221     device[5] = devchar;
9222     int r;
9223     suppress_error = 0;
9224     r = guestfs_mkfs (g, fstype, device);
9225     if (r == -1)
9226       return -1;
9227   }
9228   {
9229     char device[] = "/dev/sda1";
9230     device[5] = devchar;
9231     char mountpoint[] = "/";
9232     int r;
9233     suppress_error = 0;
9234     r = guestfs_mount (g, device, mountpoint);
9235     if (r == -1)
9236       return -1;
9237   }
9238   /* TestOutput for command (6) */
9239   char expected[] = "";
9240   {
9241     char remotefilename[] = "/test-command";
9242     int r;
9243     suppress_error = 0;
9244     r = guestfs_upload (g, "test-command", remotefilename);
9245     if (r == -1)
9246       return -1;
9247   }
9248   {
9249     char path[] = "/test-command";
9250     int r;
9251     suppress_error = 0;
9252     r = guestfs_chmod (g, 493, path);
9253     if (r == -1)
9254       return -1;
9255   }
9256   {
9257     char arguments_0[] = "/test-command";
9258     char arguments_1[] = "7";
9259     char *arguments[] = {
9260       arguments_0,
9261       arguments_1,
9262       NULL
9263     };
9264     char *r;
9265     suppress_error = 0;
9266     r = guestfs_command (g, arguments);
9267     if (r == NULL)
9268       return -1;
9269     if (strcmp (r, expected) != 0) {
9270       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9271       return -1;
9272     }
9273     free (r);
9274   }
9275   return 0;
9276 }
9277
9278 static int test_command_7_skip (void)
9279 {
9280   const char *str;
9281
9282   str = getenv ("SKIP_TEST_COMMAND_7");
9283   if (str && strcmp (str, "1") == 0) return 1;
9284   str = getenv ("SKIP_TEST_COMMAND");
9285   if (str && strcmp (str, "1") == 0) return 1;
9286   return 0;
9287 }
9288
9289 static int test_command_7 (void)
9290 {
9291   if (test_command_7_skip ()) {
9292     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9293     return 0;
9294   }
9295
9296   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9297   {
9298     char device[] = "/dev/sda";
9299     device[5] = devchar;
9300     int r;
9301     suppress_error = 0;
9302     r = guestfs_blockdev_setrw (g, device);
9303     if (r == -1)
9304       return -1;
9305   }
9306   {
9307     int r;
9308     suppress_error = 0;
9309     r = guestfs_umount_all (g);
9310     if (r == -1)
9311       return -1;
9312   }
9313   {
9314     int r;
9315     suppress_error = 0;
9316     r = guestfs_lvm_remove_all (g);
9317     if (r == -1)
9318       return -1;
9319   }
9320   {
9321     char device[] = "/dev/sda";
9322     device[5] = devchar;
9323     char lines_0[] = ",";
9324     char *lines[] = {
9325       lines_0,
9326       NULL
9327     };
9328     int r;
9329     suppress_error = 0;
9330     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9331     if (r == -1)
9332       return -1;
9333   }
9334   {
9335     char fstype[] = "ext2";
9336     char device[] = "/dev/sda1";
9337     device[5] = devchar;
9338     int r;
9339     suppress_error = 0;
9340     r = guestfs_mkfs (g, fstype, device);
9341     if (r == -1)
9342       return -1;
9343   }
9344   {
9345     char device[] = "/dev/sda1";
9346     device[5] = devchar;
9347     char mountpoint[] = "/";
9348     int r;
9349     suppress_error = 0;
9350     r = guestfs_mount (g, device, mountpoint);
9351     if (r == -1)
9352       return -1;
9353   }
9354   /* TestOutput for command (7) */
9355   char expected[] = "\n";
9356   {
9357     char remotefilename[] = "/test-command";
9358     int r;
9359     suppress_error = 0;
9360     r = guestfs_upload (g, "test-command", remotefilename);
9361     if (r == -1)
9362       return -1;
9363   }
9364   {
9365     char path[] = "/test-command";
9366     int r;
9367     suppress_error = 0;
9368     r = guestfs_chmod (g, 493, path);
9369     if (r == -1)
9370       return -1;
9371   }
9372   {
9373     char arguments_0[] = "/test-command";
9374     char arguments_1[] = "8";
9375     char *arguments[] = {
9376       arguments_0,
9377       arguments_1,
9378       NULL
9379     };
9380     char *r;
9381     suppress_error = 0;
9382     r = guestfs_command (g, arguments);
9383     if (r == NULL)
9384       return -1;
9385     if (strcmp (r, expected) != 0) {
9386       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9387       return -1;
9388     }
9389     free (r);
9390   }
9391   return 0;
9392 }
9393
9394 static int test_command_8_skip (void)
9395 {
9396   const char *str;
9397
9398   str = getenv ("SKIP_TEST_COMMAND_8");
9399   if (str && strcmp (str, "1") == 0) return 1;
9400   str = getenv ("SKIP_TEST_COMMAND");
9401   if (str && strcmp (str, "1") == 0) return 1;
9402   return 0;
9403 }
9404
9405 static int test_command_8 (void)
9406 {
9407   if (test_command_8_skip ()) {
9408     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9409     return 0;
9410   }
9411
9412   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9413   {
9414     char device[] = "/dev/sda";
9415     device[5] = devchar;
9416     int r;
9417     suppress_error = 0;
9418     r = guestfs_blockdev_setrw (g, device);
9419     if (r == -1)
9420       return -1;
9421   }
9422   {
9423     int r;
9424     suppress_error = 0;
9425     r = guestfs_umount_all (g);
9426     if (r == -1)
9427       return -1;
9428   }
9429   {
9430     int r;
9431     suppress_error = 0;
9432     r = guestfs_lvm_remove_all (g);
9433     if (r == -1)
9434       return -1;
9435   }
9436   {
9437     char device[] = "/dev/sda";
9438     device[5] = devchar;
9439     char lines_0[] = ",";
9440     char *lines[] = {
9441       lines_0,
9442       NULL
9443     };
9444     int r;
9445     suppress_error = 0;
9446     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9447     if (r == -1)
9448       return -1;
9449   }
9450   {
9451     char fstype[] = "ext2";
9452     char device[] = "/dev/sda1";
9453     device[5] = devchar;
9454     int r;
9455     suppress_error = 0;
9456     r = guestfs_mkfs (g, fstype, device);
9457     if (r == -1)
9458       return -1;
9459   }
9460   {
9461     char device[] = "/dev/sda1";
9462     device[5] = devchar;
9463     char mountpoint[] = "/";
9464     int r;
9465     suppress_error = 0;
9466     r = guestfs_mount (g, device, mountpoint);
9467     if (r == -1)
9468       return -1;
9469   }
9470   /* TestOutput for command (8) */
9471   char expected[] = "\n\n";
9472   {
9473     char remotefilename[] = "/test-command";
9474     int r;
9475     suppress_error = 0;
9476     r = guestfs_upload (g, "test-command", remotefilename);
9477     if (r == -1)
9478       return -1;
9479   }
9480   {
9481     char path[] = "/test-command";
9482     int r;
9483     suppress_error = 0;
9484     r = guestfs_chmod (g, 493, path);
9485     if (r == -1)
9486       return -1;
9487   }
9488   {
9489     char arguments_0[] = "/test-command";
9490     char arguments_1[] = "9";
9491     char *arguments[] = {
9492       arguments_0,
9493       arguments_1,
9494       NULL
9495     };
9496     char *r;
9497     suppress_error = 0;
9498     r = guestfs_command (g, arguments);
9499     if (r == NULL)
9500       return -1;
9501     if (strcmp (r, expected) != 0) {
9502       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9503       return -1;
9504     }
9505     free (r);
9506   }
9507   return 0;
9508 }
9509
9510 static int test_command_9_skip (void)
9511 {
9512   const char *str;
9513
9514   str = getenv ("SKIP_TEST_COMMAND_9");
9515   if (str && strcmp (str, "1") == 0) return 1;
9516   str = getenv ("SKIP_TEST_COMMAND");
9517   if (str && strcmp (str, "1") == 0) return 1;
9518   return 0;
9519 }
9520
9521 static int test_command_9 (void)
9522 {
9523   if (test_command_9_skip ()) {
9524     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9525     return 0;
9526   }
9527
9528   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9529   {
9530     char device[] = "/dev/sda";
9531     device[5] = devchar;
9532     int r;
9533     suppress_error = 0;
9534     r = guestfs_blockdev_setrw (g, device);
9535     if (r == -1)
9536       return -1;
9537   }
9538   {
9539     int r;
9540     suppress_error = 0;
9541     r = guestfs_umount_all (g);
9542     if (r == -1)
9543       return -1;
9544   }
9545   {
9546     int r;
9547     suppress_error = 0;
9548     r = guestfs_lvm_remove_all (g);
9549     if (r == -1)
9550       return -1;
9551   }
9552   {
9553     char device[] = "/dev/sda";
9554     device[5] = devchar;
9555     char lines_0[] = ",";
9556     char *lines[] = {
9557       lines_0,
9558       NULL
9559     };
9560     int r;
9561     suppress_error = 0;
9562     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9563     if (r == -1)
9564       return -1;
9565   }
9566   {
9567     char fstype[] = "ext2";
9568     char device[] = "/dev/sda1";
9569     device[5] = devchar;
9570     int r;
9571     suppress_error = 0;
9572     r = guestfs_mkfs (g, fstype, device);
9573     if (r == -1)
9574       return -1;
9575   }
9576   {
9577     char device[] = "/dev/sda1";
9578     device[5] = devchar;
9579     char mountpoint[] = "/";
9580     int r;
9581     suppress_error = 0;
9582     r = guestfs_mount (g, device, mountpoint);
9583     if (r == -1)
9584       return -1;
9585   }
9586   /* TestOutput for command (9) */
9587   char expected[] = "Result10-1\nResult10-2\n";
9588   {
9589     char remotefilename[] = "/test-command";
9590     int r;
9591     suppress_error = 0;
9592     r = guestfs_upload (g, "test-command", remotefilename);
9593     if (r == -1)
9594       return -1;
9595   }
9596   {
9597     char path[] = "/test-command";
9598     int r;
9599     suppress_error = 0;
9600     r = guestfs_chmod (g, 493, path);
9601     if (r == -1)
9602       return -1;
9603   }
9604   {
9605     char arguments_0[] = "/test-command";
9606     char arguments_1[] = "10";
9607     char *arguments[] = {
9608       arguments_0,
9609       arguments_1,
9610       NULL
9611     };
9612     char *r;
9613     suppress_error = 0;
9614     r = guestfs_command (g, arguments);
9615     if (r == NULL)
9616       return -1;
9617     if (strcmp (r, expected) != 0) {
9618       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9619       return -1;
9620     }
9621     free (r);
9622   }
9623   return 0;
9624 }
9625
9626 static int test_command_10_skip (void)
9627 {
9628   const char *str;
9629
9630   str = getenv ("SKIP_TEST_COMMAND_10");
9631   if (str && strcmp (str, "1") == 0) return 1;
9632   str = getenv ("SKIP_TEST_COMMAND");
9633   if (str && strcmp (str, "1") == 0) return 1;
9634   return 0;
9635 }
9636
9637 static int test_command_10 (void)
9638 {
9639   if (test_command_10_skip ()) {
9640     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9641     return 0;
9642   }
9643
9644   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9645   {
9646     char device[] = "/dev/sda";
9647     device[5] = devchar;
9648     int r;
9649     suppress_error = 0;
9650     r = guestfs_blockdev_setrw (g, device);
9651     if (r == -1)
9652       return -1;
9653   }
9654   {
9655     int r;
9656     suppress_error = 0;
9657     r = guestfs_umount_all (g);
9658     if (r == -1)
9659       return -1;
9660   }
9661   {
9662     int r;
9663     suppress_error = 0;
9664     r = guestfs_lvm_remove_all (g);
9665     if (r == -1)
9666       return -1;
9667   }
9668   {
9669     char device[] = "/dev/sda";
9670     device[5] = devchar;
9671     char lines_0[] = ",";
9672     char *lines[] = {
9673       lines_0,
9674       NULL
9675     };
9676     int r;
9677     suppress_error = 0;
9678     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9679     if (r == -1)
9680       return -1;
9681   }
9682   {
9683     char fstype[] = "ext2";
9684     char device[] = "/dev/sda1";
9685     device[5] = devchar;
9686     int r;
9687     suppress_error = 0;
9688     r = guestfs_mkfs (g, fstype, device);
9689     if (r == -1)
9690       return -1;
9691   }
9692   {
9693     char device[] = "/dev/sda1";
9694     device[5] = devchar;
9695     char mountpoint[] = "/";
9696     int r;
9697     suppress_error = 0;
9698     r = guestfs_mount (g, device, mountpoint);
9699     if (r == -1)
9700       return -1;
9701   }
9702   /* TestOutput for command (10) */
9703   char expected[] = "Result11-1\nResult11-2";
9704   {
9705     char remotefilename[] = "/test-command";
9706     int r;
9707     suppress_error = 0;
9708     r = guestfs_upload (g, "test-command", remotefilename);
9709     if (r == -1)
9710       return -1;
9711   }
9712   {
9713     char path[] = "/test-command";
9714     int r;
9715     suppress_error = 0;
9716     r = guestfs_chmod (g, 493, path);
9717     if (r == -1)
9718       return -1;
9719   }
9720   {
9721     char arguments_0[] = "/test-command";
9722     char arguments_1[] = "11";
9723     char *arguments[] = {
9724       arguments_0,
9725       arguments_1,
9726       NULL
9727     };
9728     char *r;
9729     suppress_error = 0;
9730     r = guestfs_command (g, arguments);
9731     if (r == NULL)
9732       return -1;
9733     if (strcmp (r, expected) != 0) {
9734       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9735       return -1;
9736     }
9737     free (r);
9738   }
9739   return 0;
9740 }
9741
9742 static int test_command_11_skip (void)
9743 {
9744   const char *str;
9745
9746   str = getenv ("SKIP_TEST_COMMAND_11");
9747   if (str && strcmp (str, "1") == 0) return 1;
9748   str = getenv ("SKIP_TEST_COMMAND");
9749   if (str && strcmp (str, "1") == 0) return 1;
9750   return 0;
9751 }
9752
9753 static int test_command_11 (void)
9754 {
9755   if (test_command_11_skip ()) {
9756     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9757     return 0;
9758   }
9759
9760   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9761   {
9762     char device[] = "/dev/sda";
9763     device[5] = devchar;
9764     int r;
9765     suppress_error = 0;
9766     r = guestfs_blockdev_setrw (g, device);
9767     if (r == -1)
9768       return -1;
9769   }
9770   {
9771     int r;
9772     suppress_error = 0;
9773     r = guestfs_umount_all (g);
9774     if (r == -1)
9775       return -1;
9776   }
9777   {
9778     int r;
9779     suppress_error = 0;
9780     r = guestfs_lvm_remove_all (g);
9781     if (r == -1)
9782       return -1;
9783   }
9784   {
9785     char device[] = "/dev/sda";
9786     device[5] = devchar;
9787     char lines_0[] = ",";
9788     char *lines[] = {
9789       lines_0,
9790       NULL
9791     };
9792     int r;
9793     suppress_error = 0;
9794     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9795     if (r == -1)
9796       return -1;
9797   }
9798   {
9799     char fstype[] = "ext2";
9800     char device[] = "/dev/sda1";
9801     device[5] = devchar;
9802     int r;
9803     suppress_error = 0;
9804     r = guestfs_mkfs (g, fstype, device);
9805     if (r == -1)
9806       return -1;
9807   }
9808   {
9809     char device[] = "/dev/sda1";
9810     device[5] = devchar;
9811     char mountpoint[] = "/";
9812     int r;
9813     suppress_error = 0;
9814     r = guestfs_mount (g, device, mountpoint);
9815     if (r == -1)
9816       return -1;
9817   }
9818   /* TestLastFail for command (11) */
9819   {
9820     char remotefilename[] = "/test-command";
9821     int r;
9822     suppress_error = 0;
9823     r = guestfs_upload (g, "test-command", remotefilename);
9824     if (r == -1)
9825       return -1;
9826   }
9827   {
9828     char path[] = "/test-command";
9829     int r;
9830     suppress_error = 0;
9831     r = guestfs_chmod (g, 493, path);
9832     if (r == -1)
9833       return -1;
9834   }
9835   {
9836     char arguments_0[] = "/test-command";
9837     char *arguments[] = {
9838       arguments_0,
9839       NULL
9840     };
9841     char *r;
9842     suppress_error = 1;
9843     r = guestfs_command (g, arguments);
9844     if (r != NULL)
9845       return -1;
9846     free (r);
9847   }
9848   return 0;
9849 }
9850
9851 static int test_file_0_skip (void)
9852 {
9853   const char *str;
9854
9855   str = getenv ("SKIP_TEST_FILE_0");
9856   if (str && strcmp (str, "1") == 0) return 1;
9857   str = getenv ("SKIP_TEST_FILE");
9858   if (str && strcmp (str, "1") == 0) return 1;
9859   return 0;
9860 }
9861
9862 static int test_file_0 (void)
9863 {
9864   if (test_file_0_skip ()) {
9865     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9866     return 0;
9867   }
9868
9869   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9870   {
9871     char device[] = "/dev/sda";
9872     device[5] = devchar;
9873     int r;
9874     suppress_error = 0;
9875     r = guestfs_blockdev_setrw (g, device);
9876     if (r == -1)
9877       return -1;
9878   }
9879   {
9880     int r;
9881     suppress_error = 0;
9882     r = guestfs_umount_all (g);
9883     if (r == -1)
9884       return -1;
9885   }
9886   {
9887     int r;
9888     suppress_error = 0;
9889     r = guestfs_lvm_remove_all (g);
9890     if (r == -1)
9891       return -1;
9892   }
9893   {
9894     char device[] = "/dev/sda";
9895     device[5] = devchar;
9896     char lines_0[] = ",";
9897     char *lines[] = {
9898       lines_0,
9899       NULL
9900     };
9901     int r;
9902     suppress_error = 0;
9903     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9904     if (r == -1)
9905       return -1;
9906   }
9907   {
9908     char fstype[] = "ext2";
9909     char device[] = "/dev/sda1";
9910     device[5] = devchar;
9911     int r;
9912     suppress_error = 0;
9913     r = guestfs_mkfs (g, fstype, device);
9914     if (r == -1)
9915       return -1;
9916   }
9917   {
9918     char device[] = "/dev/sda1";
9919     device[5] = devchar;
9920     char mountpoint[] = "/";
9921     int r;
9922     suppress_error = 0;
9923     r = guestfs_mount (g, device, mountpoint);
9924     if (r == -1)
9925       return -1;
9926   }
9927   /* TestOutput for file (0) */
9928   char expected[] = "empty";
9929   {
9930     char path[] = "/new";
9931     int r;
9932     suppress_error = 0;
9933     r = guestfs_touch (g, path);
9934     if (r == -1)
9935       return -1;
9936   }
9937   {
9938     char path[] = "/new";
9939     char *r;
9940     suppress_error = 0;
9941     r = guestfs_file (g, path);
9942     if (r == NULL)
9943       return -1;
9944     if (strcmp (r, expected) != 0) {
9945       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9946       return -1;
9947     }
9948     free (r);
9949   }
9950   return 0;
9951 }
9952
9953 static int test_file_1_skip (void)
9954 {
9955   const char *str;
9956
9957   str = getenv ("SKIP_TEST_FILE_1");
9958   if (str && strcmp (str, "1") == 0) return 1;
9959   str = getenv ("SKIP_TEST_FILE");
9960   if (str && strcmp (str, "1") == 0) return 1;
9961   return 0;
9962 }
9963
9964 static int test_file_1 (void)
9965 {
9966   if (test_file_1_skip ()) {
9967     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9968     return 0;
9969   }
9970
9971   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9972   {
9973     char device[] = "/dev/sda";
9974     device[5] = devchar;
9975     int r;
9976     suppress_error = 0;
9977     r = guestfs_blockdev_setrw (g, device);
9978     if (r == -1)
9979       return -1;
9980   }
9981   {
9982     int r;
9983     suppress_error = 0;
9984     r = guestfs_umount_all (g);
9985     if (r == -1)
9986       return -1;
9987   }
9988   {
9989     int r;
9990     suppress_error = 0;
9991     r = guestfs_lvm_remove_all (g);
9992     if (r == -1)
9993       return -1;
9994   }
9995   {
9996     char device[] = "/dev/sda";
9997     device[5] = devchar;
9998     char lines_0[] = ",";
9999     char *lines[] = {
10000       lines_0,
10001       NULL
10002     };
10003     int r;
10004     suppress_error = 0;
10005     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10006     if (r == -1)
10007       return -1;
10008   }
10009   {
10010     char fstype[] = "ext2";
10011     char device[] = "/dev/sda1";
10012     device[5] = devchar;
10013     int r;
10014     suppress_error = 0;
10015     r = guestfs_mkfs (g, fstype, device);
10016     if (r == -1)
10017       return -1;
10018   }
10019   {
10020     char device[] = "/dev/sda1";
10021     device[5] = devchar;
10022     char mountpoint[] = "/";
10023     int r;
10024     suppress_error = 0;
10025     r = guestfs_mount (g, device, mountpoint);
10026     if (r == -1)
10027       return -1;
10028   }
10029   /* TestOutput for file (1) */
10030   char expected[] = "ASCII text";
10031   {
10032     char path[] = "/new";
10033     char content[] = "some content\n";
10034     int r;
10035     suppress_error = 0;
10036     r = guestfs_write_file (g, path, content, 0);
10037     if (r == -1)
10038       return -1;
10039   }
10040   {
10041     char path[] = "/new";
10042     char *r;
10043     suppress_error = 0;
10044     r = guestfs_file (g, path);
10045     if (r == NULL)
10046       return -1;
10047     if (strcmp (r, expected) != 0) {
10048       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10049       return -1;
10050     }
10051     free (r);
10052   }
10053   return 0;
10054 }
10055
10056 static int test_file_2_skip (void)
10057 {
10058   const char *str;
10059
10060   str = getenv ("SKIP_TEST_FILE_2");
10061   if (str && strcmp (str, "1") == 0) return 1;
10062   str = getenv ("SKIP_TEST_FILE");
10063   if (str && strcmp (str, "1") == 0) return 1;
10064   return 0;
10065 }
10066
10067 static int test_file_2 (void)
10068 {
10069   if (test_file_2_skip ()) {
10070     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10071     return 0;
10072   }
10073
10074   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10075   {
10076     char device[] = "/dev/sda";
10077     device[5] = devchar;
10078     int r;
10079     suppress_error = 0;
10080     r = guestfs_blockdev_setrw (g, device);
10081     if (r == -1)
10082       return -1;
10083   }
10084   {
10085     int r;
10086     suppress_error = 0;
10087     r = guestfs_umount_all (g);
10088     if (r == -1)
10089       return -1;
10090   }
10091   {
10092     int r;
10093     suppress_error = 0;
10094     r = guestfs_lvm_remove_all (g);
10095     if (r == -1)
10096       return -1;
10097   }
10098   {
10099     char device[] = "/dev/sda";
10100     device[5] = devchar;
10101     char lines_0[] = ",";
10102     char *lines[] = {
10103       lines_0,
10104       NULL
10105     };
10106     int r;
10107     suppress_error = 0;
10108     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10109     if (r == -1)
10110       return -1;
10111   }
10112   {
10113     char fstype[] = "ext2";
10114     char device[] = "/dev/sda1";
10115     device[5] = devchar;
10116     int r;
10117     suppress_error = 0;
10118     r = guestfs_mkfs (g, fstype, device);
10119     if (r == -1)
10120       return -1;
10121   }
10122   {
10123     char device[] = "/dev/sda1";
10124     device[5] = devchar;
10125     char mountpoint[] = "/";
10126     int r;
10127     suppress_error = 0;
10128     r = guestfs_mount (g, device, mountpoint);
10129     if (r == -1)
10130       return -1;
10131   }
10132   /* TestLastFail for file (2) */
10133   {
10134     char path[] = "/nofile";
10135     char *r;
10136     suppress_error = 1;
10137     r = guestfs_file (g, path);
10138     if (r != NULL)
10139       return -1;
10140     free (r);
10141   }
10142   return 0;
10143 }
10144
10145 static int test_umount_all_0_skip (void)
10146 {
10147   const char *str;
10148
10149   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10150   if (str && strcmp (str, "1") == 0) return 1;
10151   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10152   if (str && strcmp (str, "1") == 0) return 1;
10153   return 0;
10154 }
10155
10156 static int test_umount_all_0 (void)
10157 {
10158   if (test_umount_all_0_skip ()) {
10159     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10160     return 0;
10161   }
10162
10163   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10164   {
10165     char device[] = "/dev/sda";
10166     device[5] = devchar;
10167     int r;
10168     suppress_error = 0;
10169     r = guestfs_blockdev_setrw (g, device);
10170     if (r == -1)
10171       return -1;
10172   }
10173   {
10174     int r;
10175     suppress_error = 0;
10176     r = guestfs_umount_all (g);
10177     if (r == -1)
10178       return -1;
10179   }
10180   {
10181     int r;
10182     suppress_error = 0;
10183     r = guestfs_lvm_remove_all (g);
10184     if (r == -1)
10185       return -1;
10186   }
10187   {
10188     char device[] = "/dev/sda";
10189     device[5] = devchar;
10190     char lines_0[] = ",";
10191     char *lines[] = {
10192       lines_0,
10193       NULL
10194     };
10195     int r;
10196     suppress_error = 0;
10197     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10198     if (r == -1)
10199       return -1;
10200   }
10201   {
10202     char fstype[] = "ext2";
10203     char device[] = "/dev/sda1";
10204     device[5] = devchar;
10205     int r;
10206     suppress_error = 0;
10207     r = guestfs_mkfs (g, fstype, device);
10208     if (r == -1)
10209       return -1;
10210   }
10211   {
10212     char device[] = "/dev/sda1";
10213     device[5] = devchar;
10214     char mountpoint[] = "/";
10215     int r;
10216     suppress_error = 0;
10217     r = guestfs_mount (g, device, mountpoint);
10218     if (r == -1)
10219       return -1;
10220   }
10221   /* TestOutputList for umount_all (0) */
10222   {
10223     int r;
10224     suppress_error = 0;
10225     r = guestfs_umount_all (g);
10226     if (r == -1)
10227       return -1;
10228   }
10229   {
10230     char **r;
10231     int i;
10232     suppress_error = 0;
10233     r = guestfs_mounts (g);
10234     if (r == NULL)
10235       return -1;
10236     if (r[0] != NULL) {
10237       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10238       print_strings (r);
10239       return -1;
10240     }
10241     for (i = 0; r[i] != NULL; ++i)
10242       free (r[i]);
10243     free (r);
10244   }
10245   return 0;
10246 }
10247
10248 static int test_umount_all_1_skip (void)
10249 {
10250   const char *str;
10251
10252   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10253   if (str && strcmp (str, "1") == 0) return 1;
10254   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10255   if (str && strcmp (str, "1") == 0) return 1;
10256   return 0;
10257 }
10258
10259 static int test_umount_all_1 (void)
10260 {
10261   if (test_umount_all_1_skip ()) {
10262     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10263     return 0;
10264   }
10265
10266   /* InitNone|InitEmpty for test_umount_all_1 */
10267   {
10268     char device[] = "/dev/sda";
10269     device[5] = devchar;
10270     int r;
10271     suppress_error = 0;
10272     r = guestfs_blockdev_setrw (g, device);
10273     if (r == -1)
10274       return -1;
10275   }
10276   {
10277     int r;
10278     suppress_error = 0;
10279     r = guestfs_umount_all (g);
10280     if (r == -1)
10281       return -1;
10282   }
10283   {
10284     int r;
10285     suppress_error = 0;
10286     r = guestfs_lvm_remove_all (g);
10287     if (r == -1)
10288       return -1;
10289   }
10290   /* TestOutputList for umount_all (1) */
10291   {
10292     char device[] = "/dev/sda";
10293     device[5] = devchar;
10294     char lines_0[] = ",10";
10295     char lines_1[] = ",20";
10296     char lines_2[] = ",";
10297     char *lines[] = {
10298       lines_0,
10299       lines_1,
10300       lines_2,
10301       NULL
10302     };
10303     int r;
10304     suppress_error = 0;
10305     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10306     if (r == -1)
10307       return -1;
10308   }
10309   {
10310     char fstype[] = "ext2";
10311     char device[] = "/dev/sda1";
10312     device[5] = devchar;
10313     int r;
10314     suppress_error = 0;
10315     r = guestfs_mkfs (g, fstype, device);
10316     if (r == -1)
10317       return -1;
10318   }
10319   {
10320     char fstype[] = "ext2";
10321     char device[] = "/dev/sda2";
10322     device[5] = devchar;
10323     int r;
10324     suppress_error = 0;
10325     r = guestfs_mkfs (g, fstype, device);
10326     if (r == -1)
10327       return -1;
10328   }
10329   {
10330     char fstype[] = "ext2";
10331     char device[] = "/dev/sda3";
10332     device[5] = devchar;
10333     int r;
10334     suppress_error = 0;
10335     r = guestfs_mkfs (g, fstype, device);
10336     if (r == -1)
10337       return -1;
10338   }
10339   {
10340     char device[] = "/dev/sda1";
10341     device[5] = devchar;
10342     char mountpoint[] = "/";
10343     int r;
10344     suppress_error = 0;
10345     r = guestfs_mount (g, device, mountpoint);
10346     if (r == -1)
10347       return -1;
10348   }
10349   {
10350     char path[] = "/mp1";
10351     int r;
10352     suppress_error = 0;
10353     r = guestfs_mkdir (g, path);
10354     if (r == -1)
10355       return -1;
10356   }
10357   {
10358     char device[] = "/dev/sda2";
10359     device[5] = devchar;
10360     char mountpoint[] = "/mp1";
10361     int r;
10362     suppress_error = 0;
10363     r = guestfs_mount (g, device, mountpoint);
10364     if (r == -1)
10365       return -1;
10366   }
10367   {
10368     char path[] = "/mp1/mp2";
10369     int r;
10370     suppress_error = 0;
10371     r = guestfs_mkdir (g, path);
10372     if (r == -1)
10373       return -1;
10374   }
10375   {
10376     char device[] = "/dev/sda3";
10377     device[5] = devchar;
10378     char mountpoint[] = "/mp1/mp2";
10379     int r;
10380     suppress_error = 0;
10381     r = guestfs_mount (g, device, mountpoint);
10382     if (r == -1)
10383       return -1;
10384   }
10385   {
10386     char path[] = "/mp1/mp2/mp3";
10387     int r;
10388     suppress_error = 0;
10389     r = guestfs_mkdir (g, path);
10390     if (r == -1)
10391       return -1;
10392   }
10393   {
10394     int r;
10395     suppress_error = 0;
10396     r = guestfs_umount_all (g);
10397     if (r == -1)
10398       return -1;
10399   }
10400   {
10401     char **r;
10402     int i;
10403     suppress_error = 0;
10404     r = guestfs_mounts (g);
10405     if (r == NULL)
10406       return -1;
10407     if (r[0] != NULL) {
10408       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10409       print_strings (r);
10410       return -1;
10411     }
10412     for (i = 0; r[i] != NULL; ++i)
10413       free (r[i]);
10414     free (r);
10415   }
10416   return 0;
10417 }
10418
10419 static int test_mounts_0_skip (void)
10420 {
10421   const char *str;
10422
10423   str = getenv ("SKIP_TEST_MOUNTS_0");
10424   if (str && strcmp (str, "1") == 0) return 1;
10425   str = getenv ("SKIP_TEST_MOUNTS");
10426   if (str && strcmp (str, "1") == 0) return 1;
10427   return 0;
10428 }
10429
10430 static int test_mounts_0 (void)
10431 {
10432   if (test_mounts_0_skip ()) {
10433     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10434     return 0;
10435   }
10436
10437   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10438   {
10439     char device[] = "/dev/sda";
10440     device[5] = devchar;
10441     int r;
10442     suppress_error = 0;
10443     r = guestfs_blockdev_setrw (g, device);
10444     if (r == -1)
10445       return -1;
10446   }
10447   {
10448     int r;
10449     suppress_error = 0;
10450     r = guestfs_umount_all (g);
10451     if (r == -1)
10452       return -1;
10453   }
10454   {
10455     int r;
10456     suppress_error = 0;
10457     r = guestfs_lvm_remove_all (g);
10458     if (r == -1)
10459       return -1;
10460   }
10461   {
10462     char device[] = "/dev/sda";
10463     device[5] = devchar;
10464     char lines_0[] = ",";
10465     char *lines[] = {
10466       lines_0,
10467       NULL
10468     };
10469     int r;
10470     suppress_error = 0;
10471     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10472     if (r == -1)
10473       return -1;
10474   }
10475   {
10476     char fstype[] = "ext2";
10477     char device[] = "/dev/sda1";
10478     device[5] = devchar;
10479     int r;
10480     suppress_error = 0;
10481     r = guestfs_mkfs (g, fstype, device);
10482     if (r == -1)
10483       return -1;
10484   }
10485   {
10486     char device[] = "/dev/sda1";
10487     device[5] = devchar;
10488     char mountpoint[] = "/";
10489     int r;
10490     suppress_error = 0;
10491     r = guestfs_mount (g, device, mountpoint);
10492     if (r == -1)
10493       return -1;
10494   }
10495   /* TestOutputList for mounts (0) */
10496   {
10497     char **r;
10498     int i;
10499     suppress_error = 0;
10500     r = guestfs_mounts (g);
10501     if (r == NULL)
10502       return -1;
10503     if (!r[0]) {
10504       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10505       print_strings (r);
10506       return -1;
10507     }
10508     {
10509       char expected[] = "/dev/sda1";
10510       expected[5] = devchar;
10511       if (strcmp (r[0], expected) != 0) {
10512         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10513         return -1;
10514       }
10515     }
10516     if (r[1] != NULL) {
10517       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10518       print_strings (r);
10519       return -1;
10520     }
10521     for (i = 0; r[i] != NULL; ++i)
10522       free (r[i]);
10523     free (r);
10524   }
10525   return 0;
10526 }
10527
10528 static int test_umount_0_skip (void)
10529 {
10530   const char *str;
10531
10532   str = getenv ("SKIP_TEST_UMOUNT_0");
10533   if (str && strcmp (str, "1") == 0) return 1;
10534   str = getenv ("SKIP_TEST_UMOUNT");
10535   if (str && strcmp (str, "1") == 0) return 1;
10536   return 0;
10537 }
10538
10539 static int test_umount_0 (void)
10540 {
10541   if (test_umount_0_skip ()) {
10542     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10543     return 0;
10544   }
10545
10546   /* InitNone|InitEmpty for test_umount_0 */
10547   {
10548     char device[] = "/dev/sda";
10549     device[5] = devchar;
10550     int r;
10551     suppress_error = 0;
10552     r = guestfs_blockdev_setrw (g, device);
10553     if (r == -1)
10554       return -1;
10555   }
10556   {
10557     int r;
10558     suppress_error = 0;
10559     r = guestfs_umount_all (g);
10560     if (r == -1)
10561       return -1;
10562   }
10563   {
10564     int r;
10565     suppress_error = 0;
10566     r = guestfs_lvm_remove_all (g);
10567     if (r == -1)
10568       return -1;
10569   }
10570   /* TestOutputList for umount (0) */
10571   {
10572     char device[] = "/dev/sda";
10573     device[5] = devchar;
10574     char lines_0[] = ",";
10575     char *lines[] = {
10576       lines_0,
10577       NULL
10578     };
10579     int r;
10580     suppress_error = 0;
10581     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10582     if (r == -1)
10583       return -1;
10584   }
10585   {
10586     char fstype[] = "ext2";
10587     char device[] = "/dev/sda1";
10588     device[5] = devchar;
10589     int r;
10590     suppress_error = 0;
10591     r = guestfs_mkfs (g, fstype, device);
10592     if (r == -1)
10593       return -1;
10594   }
10595   {
10596     char device[] = "/dev/sda1";
10597     device[5] = devchar;
10598     char mountpoint[] = "/";
10599     int r;
10600     suppress_error = 0;
10601     r = guestfs_mount (g, device, mountpoint);
10602     if (r == -1)
10603       return -1;
10604   }
10605   {
10606     char **r;
10607     int i;
10608     suppress_error = 0;
10609     r = guestfs_mounts (g);
10610     if (r == NULL)
10611       return -1;
10612     if (!r[0]) {
10613       fprintf (stderr, "test_umount_0: short list returned from command\n");
10614       print_strings (r);
10615       return -1;
10616     }
10617     {
10618       char expected[] = "/dev/sda1";
10619       expected[5] = devchar;
10620       if (strcmp (r[0], expected) != 0) {
10621         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10622         return -1;
10623       }
10624     }
10625     if (r[1] != NULL) {
10626       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10627       print_strings (r);
10628       return -1;
10629     }
10630     for (i = 0; r[i] != NULL; ++i)
10631       free (r[i]);
10632     free (r);
10633   }
10634   return 0;
10635 }
10636
10637 static int test_umount_1_skip (void)
10638 {
10639   const char *str;
10640
10641   str = getenv ("SKIP_TEST_UMOUNT_1");
10642   if (str && strcmp (str, "1") == 0) return 1;
10643   str = getenv ("SKIP_TEST_UMOUNT");
10644   if (str && strcmp (str, "1") == 0) return 1;
10645   return 0;
10646 }
10647
10648 static int test_umount_1 (void)
10649 {
10650   if (test_umount_1_skip ()) {
10651     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10652     return 0;
10653   }
10654
10655   /* InitNone|InitEmpty for test_umount_1 */
10656   {
10657     char device[] = "/dev/sda";
10658     device[5] = devchar;
10659     int r;
10660     suppress_error = 0;
10661     r = guestfs_blockdev_setrw (g, device);
10662     if (r == -1)
10663       return -1;
10664   }
10665   {
10666     int r;
10667     suppress_error = 0;
10668     r = guestfs_umount_all (g);
10669     if (r == -1)
10670       return -1;
10671   }
10672   {
10673     int r;
10674     suppress_error = 0;
10675     r = guestfs_lvm_remove_all (g);
10676     if (r == -1)
10677       return -1;
10678   }
10679   /* TestOutputList for umount (1) */
10680   {
10681     char device[] = "/dev/sda";
10682     device[5] = devchar;
10683     char lines_0[] = ",";
10684     char *lines[] = {
10685       lines_0,
10686       NULL
10687     };
10688     int r;
10689     suppress_error = 0;
10690     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10691     if (r == -1)
10692       return -1;
10693   }
10694   {
10695     char fstype[] = "ext2";
10696     char device[] = "/dev/sda1";
10697     device[5] = devchar;
10698     int r;
10699     suppress_error = 0;
10700     r = guestfs_mkfs (g, fstype, device);
10701     if (r == -1)
10702       return -1;
10703   }
10704   {
10705     char device[] = "/dev/sda1";
10706     device[5] = devchar;
10707     char mountpoint[] = "/";
10708     int r;
10709     suppress_error = 0;
10710     r = guestfs_mount (g, device, mountpoint);
10711     if (r == -1)
10712       return -1;
10713   }
10714   {
10715     char pathordevice[] = "/";
10716     int r;
10717     suppress_error = 0;
10718     r = guestfs_umount (g, pathordevice);
10719     if (r == -1)
10720       return -1;
10721   }
10722   {
10723     char **r;
10724     int i;
10725     suppress_error = 0;
10726     r = guestfs_mounts (g);
10727     if (r == NULL)
10728       return -1;
10729     if (r[0] != NULL) {
10730       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10731       print_strings (r);
10732       return -1;
10733     }
10734     for (i = 0; r[i] != NULL; ++i)
10735       free (r[i]);
10736     free (r);
10737   }
10738   return 0;
10739 }
10740
10741 static int test_write_file_0_skip (void)
10742 {
10743   const char *str;
10744
10745   str = getenv ("SKIP_TEST_WRITE_FILE_0");
10746   if (str && strcmp (str, "1") == 0) return 1;
10747   str = getenv ("SKIP_TEST_WRITE_FILE");
10748   if (str && strcmp (str, "1") == 0) return 1;
10749   return 0;
10750 }
10751
10752 static int test_write_file_0 (void)
10753 {
10754   if (test_write_file_0_skip ()) {
10755     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10756     return 0;
10757   }
10758
10759   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10760   {
10761     char device[] = "/dev/sda";
10762     device[5] = devchar;
10763     int r;
10764     suppress_error = 0;
10765     r = guestfs_blockdev_setrw (g, device);
10766     if (r == -1)
10767       return -1;
10768   }
10769   {
10770     int r;
10771     suppress_error = 0;
10772     r = guestfs_umount_all (g);
10773     if (r == -1)
10774       return -1;
10775   }
10776   {
10777     int r;
10778     suppress_error = 0;
10779     r = guestfs_lvm_remove_all (g);
10780     if (r == -1)
10781       return -1;
10782   }
10783   {
10784     char device[] = "/dev/sda";
10785     device[5] = devchar;
10786     char lines_0[] = ",";
10787     char *lines[] = {
10788       lines_0,
10789       NULL
10790     };
10791     int r;
10792     suppress_error = 0;
10793     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10794     if (r == -1)
10795       return -1;
10796   }
10797   {
10798     char fstype[] = "ext2";
10799     char device[] = "/dev/sda1";
10800     device[5] = devchar;
10801     int r;
10802     suppress_error = 0;
10803     r = guestfs_mkfs (g, fstype, device);
10804     if (r == -1)
10805       return -1;
10806   }
10807   {
10808     char device[] = "/dev/sda1";
10809     device[5] = devchar;
10810     char mountpoint[] = "/";
10811     int r;
10812     suppress_error = 0;
10813     r = guestfs_mount (g, device, mountpoint);
10814     if (r == -1)
10815       return -1;
10816   }
10817   /* TestOutput for write_file (0) */
10818   char expected[] = "new file contents";
10819   {
10820     char path[] = "/new";
10821     char content[] = "new file contents";
10822     int r;
10823     suppress_error = 0;
10824     r = guestfs_write_file (g, path, content, 0);
10825     if (r == -1)
10826       return -1;
10827   }
10828   {
10829     char path[] = "/new";
10830     char *r;
10831     suppress_error = 0;
10832     r = guestfs_cat (g, path);
10833     if (r == NULL)
10834       return -1;
10835     if (strcmp (r, expected) != 0) {
10836       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10837       return -1;
10838     }
10839     free (r);
10840   }
10841   return 0;
10842 }
10843
10844 static int test_write_file_1_skip (void)
10845 {
10846   const char *str;
10847
10848   str = getenv ("SKIP_TEST_WRITE_FILE_1");
10849   if (str && strcmp (str, "1") == 0) return 1;
10850   str = getenv ("SKIP_TEST_WRITE_FILE");
10851   if (str && strcmp (str, "1") == 0) return 1;
10852   return 0;
10853 }
10854
10855 static int test_write_file_1 (void)
10856 {
10857   if (test_write_file_1_skip ()) {
10858     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10859     return 0;
10860   }
10861
10862   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10863   {
10864     char device[] = "/dev/sda";
10865     device[5] = devchar;
10866     int r;
10867     suppress_error = 0;
10868     r = guestfs_blockdev_setrw (g, device);
10869     if (r == -1)
10870       return -1;
10871   }
10872   {
10873     int r;
10874     suppress_error = 0;
10875     r = guestfs_umount_all (g);
10876     if (r == -1)
10877       return -1;
10878   }
10879   {
10880     int r;
10881     suppress_error = 0;
10882     r = guestfs_lvm_remove_all (g);
10883     if (r == -1)
10884       return -1;
10885   }
10886   {
10887     char device[] = "/dev/sda";
10888     device[5] = devchar;
10889     char lines_0[] = ",";
10890     char *lines[] = {
10891       lines_0,
10892       NULL
10893     };
10894     int r;
10895     suppress_error = 0;
10896     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10897     if (r == -1)
10898       return -1;
10899   }
10900   {
10901     char fstype[] = "ext2";
10902     char device[] = "/dev/sda1";
10903     device[5] = devchar;
10904     int r;
10905     suppress_error = 0;
10906     r = guestfs_mkfs (g, fstype, device);
10907     if (r == -1)
10908       return -1;
10909   }
10910   {
10911     char device[] = "/dev/sda1";
10912     device[5] = devchar;
10913     char mountpoint[] = "/";
10914     int r;
10915     suppress_error = 0;
10916     r = guestfs_mount (g, device, mountpoint);
10917     if (r == -1)
10918       return -1;
10919   }
10920   /* TestOutput for write_file (1) */
10921   char expected[] = "\nnew file contents\n";
10922   {
10923     char path[] = "/new";
10924     char content[] = "\nnew file contents\n";
10925     int r;
10926     suppress_error = 0;
10927     r = guestfs_write_file (g, path, content, 0);
10928     if (r == -1)
10929       return -1;
10930   }
10931   {
10932     char path[] = "/new";
10933     char *r;
10934     suppress_error = 0;
10935     r = guestfs_cat (g, path);
10936     if (r == NULL)
10937       return -1;
10938     if (strcmp (r, expected) != 0) {
10939       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10940       return -1;
10941     }
10942     free (r);
10943   }
10944   return 0;
10945 }
10946
10947 static int test_write_file_2_skip (void)
10948 {
10949   const char *str;
10950
10951   str = getenv ("SKIP_TEST_WRITE_FILE_2");
10952   if (str && strcmp (str, "1") == 0) return 1;
10953   str = getenv ("SKIP_TEST_WRITE_FILE");
10954   if (str && strcmp (str, "1") == 0) return 1;
10955   return 0;
10956 }
10957
10958 static int test_write_file_2 (void)
10959 {
10960   if (test_write_file_2_skip ()) {
10961     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10962     return 0;
10963   }
10964
10965   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10966   {
10967     char device[] = "/dev/sda";
10968     device[5] = devchar;
10969     int r;
10970     suppress_error = 0;
10971     r = guestfs_blockdev_setrw (g, device);
10972     if (r == -1)
10973       return -1;
10974   }
10975   {
10976     int r;
10977     suppress_error = 0;
10978     r = guestfs_umount_all (g);
10979     if (r == -1)
10980       return -1;
10981   }
10982   {
10983     int r;
10984     suppress_error = 0;
10985     r = guestfs_lvm_remove_all (g);
10986     if (r == -1)
10987       return -1;
10988   }
10989   {
10990     char device[] = "/dev/sda";
10991     device[5] = devchar;
10992     char lines_0[] = ",";
10993     char *lines[] = {
10994       lines_0,
10995       NULL
10996     };
10997     int r;
10998     suppress_error = 0;
10999     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11000     if (r == -1)
11001       return -1;
11002   }
11003   {
11004     char fstype[] = "ext2";
11005     char device[] = "/dev/sda1";
11006     device[5] = devchar;
11007     int r;
11008     suppress_error = 0;
11009     r = guestfs_mkfs (g, fstype, device);
11010     if (r == -1)
11011       return -1;
11012   }
11013   {
11014     char device[] = "/dev/sda1";
11015     device[5] = devchar;
11016     char mountpoint[] = "/";
11017     int r;
11018     suppress_error = 0;
11019     r = guestfs_mount (g, device, mountpoint);
11020     if (r == -1)
11021       return -1;
11022   }
11023   /* TestOutput for write_file (2) */
11024   char expected[] = "\n\n";
11025   {
11026     char path[] = "/new";
11027     char content[] = "\n\n";
11028     int r;
11029     suppress_error = 0;
11030     r = guestfs_write_file (g, path, content, 0);
11031     if (r == -1)
11032       return -1;
11033   }
11034   {
11035     char path[] = "/new";
11036     char *r;
11037     suppress_error = 0;
11038     r = guestfs_cat (g, path);
11039     if (r == NULL)
11040       return -1;
11041     if (strcmp (r, expected) != 0) {
11042       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11043       return -1;
11044     }
11045     free (r);
11046   }
11047   return 0;
11048 }
11049
11050 static int test_write_file_3_skip (void)
11051 {
11052   const char *str;
11053
11054   str = getenv ("SKIP_TEST_WRITE_FILE_3");
11055   if (str && strcmp (str, "1") == 0) return 1;
11056   str = getenv ("SKIP_TEST_WRITE_FILE");
11057   if (str && strcmp (str, "1") == 0) return 1;
11058   return 0;
11059 }
11060
11061 static int test_write_file_3 (void)
11062 {
11063   if (test_write_file_3_skip ()) {
11064     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11065     return 0;
11066   }
11067
11068   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11069   {
11070     char device[] = "/dev/sda";
11071     device[5] = devchar;
11072     int r;
11073     suppress_error = 0;
11074     r = guestfs_blockdev_setrw (g, device);
11075     if (r == -1)
11076       return -1;
11077   }
11078   {
11079     int r;
11080     suppress_error = 0;
11081     r = guestfs_umount_all (g);
11082     if (r == -1)
11083       return -1;
11084   }
11085   {
11086     int r;
11087     suppress_error = 0;
11088     r = guestfs_lvm_remove_all (g);
11089     if (r == -1)
11090       return -1;
11091   }
11092   {
11093     char device[] = "/dev/sda";
11094     device[5] = devchar;
11095     char lines_0[] = ",";
11096     char *lines[] = {
11097       lines_0,
11098       NULL
11099     };
11100     int r;
11101     suppress_error = 0;
11102     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11103     if (r == -1)
11104       return -1;
11105   }
11106   {
11107     char fstype[] = "ext2";
11108     char device[] = "/dev/sda1";
11109     device[5] = devchar;
11110     int r;
11111     suppress_error = 0;
11112     r = guestfs_mkfs (g, fstype, device);
11113     if (r == -1)
11114       return -1;
11115   }
11116   {
11117     char device[] = "/dev/sda1";
11118     device[5] = devchar;
11119     char mountpoint[] = "/";
11120     int r;
11121     suppress_error = 0;
11122     r = guestfs_mount (g, device, mountpoint);
11123     if (r == -1)
11124       return -1;
11125   }
11126   /* TestOutput for write_file (3) */
11127   char expected[] = "";
11128   {
11129     char path[] = "/new";
11130     char content[] = "";
11131     int r;
11132     suppress_error = 0;
11133     r = guestfs_write_file (g, path, content, 0);
11134     if (r == -1)
11135       return -1;
11136   }
11137   {
11138     char path[] = "/new";
11139     char *r;
11140     suppress_error = 0;
11141     r = guestfs_cat (g, path);
11142     if (r == NULL)
11143       return -1;
11144     if (strcmp (r, expected) != 0) {
11145       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11146       return -1;
11147     }
11148     free (r);
11149   }
11150   return 0;
11151 }
11152
11153 static int test_write_file_4_skip (void)
11154 {
11155   const char *str;
11156
11157   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11158   if (str && strcmp (str, "1") == 0) return 1;
11159   str = getenv ("SKIP_TEST_WRITE_FILE");
11160   if (str && strcmp (str, "1") == 0) return 1;
11161   return 0;
11162 }
11163
11164 static int test_write_file_4 (void)
11165 {
11166   if (test_write_file_4_skip ()) {
11167     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11168     return 0;
11169   }
11170
11171   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11172   {
11173     char device[] = "/dev/sda";
11174     device[5] = devchar;
11175     int r;
11176     suppress_error = 0;
11177     r = guestfs_blockdev_setrw (g, device);
11178     if (r == -1)
11179       return -1;
11180   }
11181   {
11182     int r;
11183     suppress_error = 0;
11184     r = guestfs_umount_all (g);
11185     if (r == -1)
11186       return -1;
11187   }
11188   {
11189     int r;
11190     suppress_error = 0;
11191     r = guestfs_lvm_remove_all (g);
11192     if (r == -1)
11193       return -1;
11194   }
11195   {
11196     char device[] = "/dev/sda";
11197     device[5] = devchar;
11198     char lines_0[] = ",";
11199     char *lines[] = {
11200       lines_0,
11201       NULL
11202     };
11203     int r;
11204     suppress_error = 0;
11205     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11206     if (r == -1)
11207       return -1;
11208   }
11209   {
11210     char fstype[] = "ext2";
11211     char device[] = "/dev/sda1";
11212     device[5] = devchar;
11213     int r;
11214     suppress_error = 0;
11215     r = guestfs_mkfs (g, fstype, device);
11216     if (r == -1)
11217       return -1;
11218   }
11219   {
11220     char device[] = "/dev/sda1";
11221     device[5] = devchar;
11222     char mountpoint[] = "/";
11223     int r;
11224     suppress_error = 0;
11225     r = guestfs_mount (g, device, mountpoint);
11226     if (r == -1)
11227       return -1;
11228   }
11229   /* TestOutput for write_file (4) */
11230   char expected[] = "\n\n\n";
11231   {
11232     char path[] = "/new";
11233     char content[] = "\n\n\n";
11234     int r;
11235     suppress_error = 0;
11236     r = guestfs_write_file (g, path, content, 0);
11237     if (r == -1)
11238       return -1;
11239   }
11240   {
11241     char path[] = "/new";
11242     char *r;
11243     suppress_error = 0;
11244     r = guestfs_cat (g, path);
11245     if (r == NULL)
11246       return -1;
11247     if (strcmp (r, expected) != 0) {
11248       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11249       return -1;
11250     }
11251     free (r);
11252   }
11253   return 0;
11254 }
11255
11256 static int test_write_file_5_skip (void)
11257 {
11258   const char *str;
11259
11260   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11261   if (str && strcmp (str, "1") == 0) return 1;
11262   str = getenv ("SKIP_TEST_WRITE_FILE");
11263   if (str && strcmp (str, "1") == 0) return 1;
11264   return 0;
11265 }
11266
11267 static int test_write_file_5 (void)
11268 {
11269   if (test_write_file_5_skip ()) {
11270     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11271     return 0;
11272   }
11273
11274   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11275   {
11276     char device[] = "/dev/sda";
11277     device[5] = devchar;
11278     int r;
11279     suppress_error = 0;
11280     r = guestfs_blockdev_setrw (g, device);
11281     if (r == -1)
11282       return -1;
11283   }
11284   {
11285     int r;
11286     suppress_error = 0;
11287     r = guestfs_umount_all (g);
11288     if (r == -1)
11289       return -1;
11290   }
11291   {
11292     int r;
11293     suppress_error = 0;
11294     r = guestfs_lvm_remove_all (g);
11295     if (r == -1)
11296       return -1;
11297   }
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   /* TestOutput for write_file (5) */
11333   char expected[] = "\n";
11334   {
11335     char path[] = "/new";
11336     char content[] = "\n";
11337     int r;
11338     suppress_error = 0;
11339     r = guestfs_write_file (g, path, content, 0);
11340     if (r == -1)
11341       return -1;
11342   }
11343   {
11344     char path[] = "/new";
11345     char *r;
11346     suppress_error = 0;
11347     r = guestfs_cat (g, path);
11348     if (r == NULL)
11349       return -1;
11350     if (strcmp (r, expected) != 0) {
11351       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11352       return -1;
11353     }
11354     free (r);
11355   }
11356   return 0;
11357 }
11358
11359 static int test_mkfs_0_skip (void)
11360 {
11361   const char *str;
11362
11363   str = getenv ("SKIP_TEST_MKFS_0");
11364   if (str && strcmp (str, "1") == 0) return 1;
11365   str = getenv ("SKIP_TEST_MKFS");
11366   if (str && strcmp (str, "1") == 0) return 1;
11367   return 0;
11368 }
11369
11370 static int test_mkfs_0 (void)
11371 {
11372   if (test_mkfs_0_skip ()) {
11373     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11374     return 0;
11375   }
11376
11377   /* InitNone|InitEmpty for test_mkfs_0 */
11378   {
11379     char device[] = "/dev/sda";
11380     device[5] = devchar;
11381     int r;
11382     suppress_error = 0;
11383     r = guestfs_blockdev_setrw (g, device);
11384     if (r == -1)
11385       return -1;
11386   }
11387   {
11388     int r;
11389     suppress_error = 0;
11390     r = guestfs_umount_all (g);
11391     if (r == -1)
11392       return -1;
11393   }
11394   {
11395     int r;
11396     suppress_error = 0;
11397     r = guestfs_lvm_remove_all (g);
11398     if (r == -1)
11399       return -1;
11400   }
11401   /* TestOutput for mkfs (0) */
11402   char expected[] = "new file contents";
11403   {
11404     char device[] = "/dev/sda";
11405     device[5] = devchar;
11406     char lines_0[] = ",";
11407     char *lines[] = {
11408       lines_0,
11409       NULL
11410     };
11411     int r;
11412     suppress_error = 0;
11413     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11414     if (r == -1)
11415       return -1;
11416   }
11417   {
11418     char fstype[] = "ext2";
11419     char device[] = "/dev/sda1";
11420     device[5] = devchar;
11421     int r;
11422     suppress_error = 0;
11423     r = guestfs_mkfs (g, fstype, device);
11424     if (r == -1)
11425       return -1;
11426   }
11427   {
11428     char device[] = "/dev/sda1";
11429     device[5] = devchar;
11430     char mountpoint[] = "/";
11431     int r;
11432     suppress_error = 0;
11433     r = guestfs_mount (g, device, mountpoint);
11434     if (r == -1)
11435       return -1;
11436   }
11437   {
11438     char path[] = "/new";
11439     char content[] = "new file contents";
11440     int r;
11441     suppress_error = 0;
11442     r = guestfs_write_file (g, path, content, 0);
11443     if (r == -1)
11444       return -1;
11445   }
11446   {
11447     char path[] = "/new";
11448     char *r;
11449     suppress_error = 0;
11450     r = guestfs_cat (g, path);
11451     if (r == NULL)
11452       return -1;
11453     if (strcmp (r, expected) != 0) {
11454       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11455       return -1;
11456     }
11457     free (r);
11458   }
11459   return 0;
11460 }
11461
11462 static int test_lvcreate_0_skip (void)
11463 {
11464   const char *str;
11465
11466   str = getenv ("SKIP_TEST_LVCREATE_0");
11467   if (str && strcmp (str, "1") == 0) return 1;
11468   str = getenv ("SKIP_TEST_LVCREATE");
11469   if (str && strcmp (str, "1") == 0) return 1;
11470   return 0;
11471 }
11472
11473 static int test_lvcreate_0 (void)
11474 {
11475   if (test_lvcreate_0_skip ()) {
11476     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11477     return 0;
11478   }
11479
11480   /* InitNone|InitEmpty for test_lvcreate_0 */
11481   {
11482     char device[] = "/dev/sda";
11483     device[5] = devchar;
11484     int r;
11485     suppress_error = 0;
11486     r = guestfs_blockdev_setrw (g, device);
11487     if (r == -1)
11488       return -1;
11489   }
11490   {
11491     int r;
11492     suppress_error = 0;
11493     r = guestfs_umount_all (g);
11494     if (r == -1)
11495       return -1;
11496   }
11497   {
11498     int r;
11499     suppress_error = 0;
11500     r = guestfs_lvm_remove_all (g);
11501     if (r == -1)
11502       return -1;
11503   }
11504   /* TestOutputList for lvcreate (0) */
11505   {
11506     char device[] = "/dev/sda";
11507     device[5] = devchar;
11508     char lines_0[] = ",10";
11509     char lines_1[] = ",20";
11510     char lines_2[] = ",";
11511     char *lines[] = {
11512       lines_0,
11513       lines_1,
11514       lines_2,
11515       NULL
11516     };
11517     int r;
11518     suppress_error = 0;
11519     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11520     if (r == -1)
11521       return -1;
11522   }
11523   {
11524     char device[] = "/dev/sda1";
11525     device[5] = devchar;
11526     int r;
11527     suppress_error = 0;
11528     r = guestfs_pvcreate (g, device);
11529     if (r == -1)
11530       return -1;
11531   }
11532   {
11533     char device[] = "/dev/sda2";
11534     device[5] = devchar;
11535     int r;
11536     suppress_error = 0;
11537     r = guestfs_pvcreate (g, device);
11538     if (r == -1)
11539       return -1;
11540   }
11541   {
11542     char device[] = "/dev/sda3";
11543     device[5] = devchar;
11544     int r;
11545     suppress_error = 0;
11546     r = guestfs_pvcreate (g, device);
11547     if (r == -1)
11548       return -1;
11549   }
11550   {
11551     char volgroup[] = "VG1";
11552     char physvols_0[] = "/dev/sda1";
11553     physvols_0[5] = devchar;
11554     char physvols_1[] = "/dev/sda2";
11555     physvols_1[5] = devchar;
11556     char *physvols[] = {
11557       physvols_0,
11558       physvols_1,
11559       NULL
11560     };
11561     int r;
11562     suppress_error = 0;
11563     r = guestfs_vgcreate (g, volgroup, physvols);
11564     if (r == -1)
11565       return -1;
11566   }
11567   {
11568     char volgroup[] = "VG2";
11569     char physvols_0[] = "/dev/sda3";
11570     physvols_0[5] = devchar;
11571     char *physvols[] = {
11572       physvols_0,
11573       NULL
11574     };
11575     int r;
11576     suppress_error = 0;
11577     r = guestfs_vgcreate (g, volgroup, physvols);
11578     if (r == -1)
11579       return -1;
11580   }
11581   {
11582     char logvol[] = "LV1";
11583     char volgroup[] = "VG1";
11584     int r;
11585     suppress_error = 0;
11586     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11587     if (r == -1)
11588       return -1;
11589   }
11590   {
11591     char logvol[] = "LV2";
11592     char volgroup[] = "VG1";
11593     int r;
11594     suppress_error = 0;
11595     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11596     if (r == -1)
11597       return -1;
11598   }
11599   {
11600     char logvol[] = "LV3";
11601     char volgroup[] = "VG2";
11602     int r;
11603     suppress_error = 0;
11604     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11605     if (r == -1)
11606       return -1;
11607   }
11608   {
11609     char logvol[] = "LV4";
11610     char volgroup[] = "VG2";
11611     int r;
11612     suppress_error = 0;
11613     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11614     if (r == -1)
11615       return -1;
11616   }
11617   {
11618     char logvol[] = "LV5";
11619     char volgroup[] = "VG2";
11620     int r;
11621     suppress_error = 0;
11622     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11623     if (r == -1)
11624       return -1;
11625   }
11626   {
11627     char **r;
11628     int i;
11629     suppress_error = 0;
11630     r = guestfs_lvs (g);
11631     if (r == NULL)
11632       return -1;
11633     if (!r[0]) {
11634       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11635       print_strings (r);
11636       return -1;
11637     }
11638     {
11639       char expected[] = "/dev/VG1/LV1";
11640       if (strcmp (r[0], expected) != 0) {
11641         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11642         return -1;
11643       }
11644     }
11645     if (!r[1]) {
11646       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11647       print_strings (r);
11648       return -1;
11649     }
11650     {
11651       char expected[] = "/dev/VG1/LV2";
11652       if (strcmp (r[1], expected) != 0) {
11653         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11654         return -1;
11655       }
11656     }
11657     if (!r[2]) {
11658       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11659       print_strings (r);
11660       return -1;
11661     }
11662     {
11663       char expected[] = "/dev/VG2/LV3";
11664       if (strcmp (r[2], expected) != 0) {
11665         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11666         return -1;
11667       }
11668     }
11669     if (!r[3]) {
11670       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11671       print_strings (r);
11672       return -1;
11673     }
11674     {
11675       char expected[] = "/dev/VG2/LV4";
11676       if (strcmp (r[3], expected) != 0) {
11677         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11678         return -1;
11679       }
11680     }
11681     if (!r[4]) {
11682       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11683       print_strings (r);
11684       return -1;
11685     }
11686     {
11687       char expected[] = "/dev/VG2/LV5";
11688       if (strcmp (r[4], expected) != 0) {
11689         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11690         return -1;
11691       }
11692     }
11693     if (r[5] != NULL) {
11694       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11695       print_strings (r);
11696       return -1;
11697     }
11698     for (i = 0; r[i] != NULL; ++i)
11699       free (r[i]);
11700     free (r);
11701   }
11702   return 0;
11703 }
11704
11705 static int test_vgcreate_0_skip (void)
11706 {
11707   const char *str;
11708
11709   str = getenv ("SKIP_TEST_VGCREATE_0");
11710   if (str && strcmp (str, "1") == 0) return 1;
11711   str = getenv ("SKIP_TEST_VGCREATE");
11712   if (str && strcmp (str, "1") == 0) return 1;
11713   return 0;
11714 }
11715
11716 static int test_vgcreate_0 (void)
11717 {
11718   if (test_vgcreate_0_skip ()) {
11719     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11720     return 0;
11721   }
11722
11723   /* InitNone|InitEmpty for test_vgcreate_0 */
11724   {
11725     char device[] = "/dev/sda";
11726     device[5] = devchar;
11727     int r;
11728     suppress_error = 0;
11729     r = guestfs_blockdev_setrw (g, device);
11730     if (r == -1)
11731       return -1;
11732   }
11733   {
11734     int r;
11735     suppress_error = 0;
11736     r = guestfs_umount_all (g);
11737     if (r == -1)
11738       return -1;
11739   }
11740   {
11741     int r;
11742     suppress_error = 0;
11743     r = guestfs_lvm_remove_all (g);
11744     if (r == -1)
11745       return -1;
11746   }
11747   /* TestOutputList for vgcreate (0) */
11748   {
11749     char device[] = "/dev/sda";
11750     device[5] = devchar;
11751     char lines_0[] = ",10";
11752     char lines_1[] = ",20";
11753     char lines_2[] = ",";
11754     char *lines[] = {
11755       lines_0,
11756       lines_1,
11757       lines_2,
11758       NULL
11759     };
11760     int r;
11761     suppress_error = 0;
11762     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11763     if (r == -1)
11764       return -1;
11765   }
11766   {
11767     char device[] = "/dev/sda1";
11768     device[5] = devchar;
11769     int r;
11770     suppress_error = 0;
11771     r = guestfs_pvcreate (g, device);
11772     if (r == -1)
11773       return -1;
11774   }
11775   {
11776     char device[] = "/dev/sda2";
11777     device[5] = devchar;
11778     int r;
11779     suppress_error = 0;
11780     r = guestfs_pvcreate (g, device);
11781     if (r == -1)
11782       return -1;
11783   }
11784   {
11785     char device[] = "/dev/sda3";
11786     device[5] = devchar;
11787     int r;
11788     suppress_error = 0;
11789     r = guestfs_pvcreate (g, device);
11790     if (r == -1)
11791       return -1;
11792   }
11793   {
11794     char volgroup[] = "VG1";
11795     char physvols_0[] = "/dev/sda1";
11796     physvols_0[5] = devchar;
11797     char physvols_1[] = "/dev/sda2";
11798     physvols_1[5] = devchar;
11799     char *physvols[] = {
11800       physvols_0,
11801       physvols_1,
11802       NULL
11803     };
11804     int r;
11805     suppress_error = 0;
11806     r = guestfs_vgcreate (g, volgroup, physvols);
11807     if (r == -1)
11808       return -1;
11809   }
11810   {
11811     char volgroup[] = "VG2";
11812     char physvols_0[] = "/dev/sda3";
11813     physvols_0[5] = devchar;
11814     char *physvols[] = {
11815       physvols_0,
11816       NULL
11817     };
11818     int r;
11819     suppress_error = 0;
11820     r = guestfs_vgcreate (g, volgroup, physvols);
11821     if (r == -1)
11822       return -1;
11823   }
11824   {
11825     char **r;
11826     int i;
11827     suppress_error = 0;
11828     r = guestfs_vgs (g);
11829     if (r == NULL)
11830       return -1;
11831     if (!r[0]) {
11832       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11833       print_strings (r);
11834       return -1;
11835     }
11836     {
11837       char expected[] = "VG1";
11838       if (strcmp (r[0], expected) != 0) {
11839         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11840         return -1;
11841       }
11842     }
11843     if (!r[1]) {
11844       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11845       print_strings (r);
11846       return -1;
11847     }
11848     {
11849       char expected[] = "VG2";
11850       if (strcmp (r[1], expected) != 0) {
11851         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11852         return -1;
11853       }
11854     }
11855     if (r[2] != NULL) {
11856       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11857       print_strings (r);
11858       return -1;
11859     }
11860     for (i = 0; r[i] != NULL; ++i)
11861       free (r[i]);
11862     free (r);
11863   }
11864   return 0;
11865 }
11866
11867 static int test_pvcreate_0_skip (void)
11868 {
11869   const char *str;
11870
11871   str = getenv ("SKIP_TEST_PVCREATE_0");
11872   if (str && strcmp (str, "1") == 0) return 1;
11873   str = getenv ("SKIP_TEST_PVCREATE");
11874   if (str && strcmp (str, "1") == 0) return 1;
11875   return 0;
11876 }
11877
11878 static int test_pvcreate_0 (void)
11879 {
11880   if (test_pvcreate_0_skip ()) {
11881     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11882     return 0;
11883   }
11884
11885   /* InitNone|InitEmpty for test_pvcreate_0 */
11886   {
11887     char device[] = "/dev/sda";
11888     device[5] = devchar;
11889     int r;
11890     suppress_error = 0;
11891     r = guestfs_blockdev_setrw (g, device);
11892     if (r == -1)
11893       return -1;
11894   }
11895   {
11896     int r;
11897     suppress_error = 0;
11898     r = guestfs_umount_all (g);
11899     if (r == -1)
11900       return -1;
11901   }
11902   {
11903     int r;
11904     suppress_error = 0;
11905     r = guestfs_lvm_remove_all (g);
11906     if (r == -1)
11907       return -1;
11908   }
11909   /* TestOutputList for pvcreate (0) */
11910   {
11911     char device[] = "/dev/sda";
11912     device[5] = devchar;
11913     char lines_0[] = ",10";
11914     char lines_1[] = ",20";
11915     char lines_2[] = ",";
11916     char *lines[] = {
11917       lines_0,
11918       lines_1,
11919       lines_2,
11920       NULL
11921     };
11922     int r;
11923     suppress_error = 0;
11924     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11925     if (r == -1)
11926       return -1;
11927   }
11928   {
11929     char device[] = "/dev/sda1";
11930     device[5] = devchar;
11931     int r;
11932     suppress_error = 0;
11933     r = guestfs_pvcreate (g, device);
11934     if (r == -1)
11935       return -1;
11936   }
11937   {
11938     char device[] = "/dev/sda2";
11939     device[5] = devchar;
11940     int r;
11941     suppress_error = 0;
11942     r = guestfs_pvcreate (g, device);
11943     if (r == -1)
11944       return -1;
11945   }
11946   {
11947     char device[] = "/dev/sda3";
11948     device[5] = devchar;
11949     int r;
11950     suppress_error = 0;
11951     r = guestfs_pvcreate (g, device);
11952     if (r == -1)
11953       return -1;
11954   }
11955   {
11956     char **r;
11957     int i;
11958     suppress_error = 0;
11959     r = guestfs_pvs (g);
11960     if (r == NULL)
11961       return -1;
11962     if (!r[0]) {
11963       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11964       print_strings (r);
11965       return -1;
11966     }
11967     {
11968       char expected[] = "/dev/sda1";
11969       expected[5] = devchar;
11970       if (strcmp (r[0], expected) != 0) {
11971         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11972         return -1;
11973       }
11974     }
11975     if (!r[1]) {
11976       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11977       print_strings (r);
11978       return -1;
11979     }
11980     {
11981       char expected[] = "/dev/sda2";
11982       expected[5] = devchar;
11983       if (strcmp (r[1], expected) != 0) {
11984         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11985         return -1;
11986       }
11987     }
11988     if (!r[2]) {
11989       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11990       print_strings (r);
11991       return -1;
11992     }
11993     {
11994       char expected[] = "/dev/sda3";
11995       expected[5] = devchar;
11996       if (strcmp (r[2], expected) != 0) {
11997         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11998         return -1;
11999       }
12000     }
12001     if (r[3] != NULL) {
12002       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12003       print_strings (r);
12004       return -1;
12005     }
12006     for (i = 0; r[i] != NULL; ++i)
12007       free (r[i]);
12008     free (r);
12009   }
12010   return 0;
12011 }
12012
12013 static int test_is_dir_0_skip (void)
12014 {
12015   const char *str;
12016
12017   str = getenv ("SKIP_TEST_IS_DIR_0");
12018   if (str && strcmp (str, "1") == 0) return 1;
12019   str = getenv ("SKIP_TEST_IS_DIR");
12020   if (str && strcmp (str, "1") == 0) return 1;
12021   return 0;
12022 }
12023
12024 static int test_is_dir_0 (void)
12025 {
12026   if (test_is_dir_0_skip ()) {
12027     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12028     return 0;
12029   }
12030
12031   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12032   {
12033     char device[] = "/dev/sda";
12034     device[5] = devchar;
12035     int r;
12036     suppress_error = 0;
12037     r = guestfs_blockdev_setrw (g, device);
12038     if (r == -1)
12039       return -1;
12040   }
12041   {
12042     int r;
12043     suppress_error = 0;
12044     r = guestfs_umount_all (g);
12045     if (r == -1)
12046       return -1;
12047   }
12048   {
12049     int r;
12050     suppress_error = 0;
12051     r = guestfs_lvm_remove_all (g);
12052     if (r == -1)
12053       return -1;
12054   }
12055   {
12056     char device[] = "/dev/sda";
12057     device[5] = devchar;
12058     char lines_0[] = ",";
12059     char *lines[] = {
12060       lines_0,
12061       NULL
12062     };
12063     int r;
12064     suppress_error = 0;
12065     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12066     if (r == -1)
12067       return -1;
12068   }
12069   {
12070     char fstype[] = "ext2";
12071     char device[] = "/dev/sda1";
12072     device[5] = devchar;
12073     int r;
12074     suppress_error = 0;
12075     r = guestfs_mkfs (g, fstype, device);
12076     if (r == -1)
12077       return -1;
12078   }
12079   {
12080     char device[] = "/dev/sda1";
12081     device[5] = devchar;
12082     char mountpoint[] = "/";
12083     int r;
12084     suppress_error = 0;
12085     r = guestfs_mount (g, device, mountpoint);
12086     if (r == -1)
12087       return -1;
12088   }
12089   /* TestOutputFalse for is_dir (0) */
12090   {
12091     char path[] = "/new";
12092     int r;
12093     suppress_error = 0;
12094     r = guestfs_touch (g, path);
12095     if (r == -1)
12096       return -1;
12097   }
12098   {
12099     char path[] = "/new";
12100     int r;
12101     suppress_error = 0;
12102     r = guestfs_is_dir (g, path);
12103     if (r == -1)
12104       return -1;
12105     if (r) {
12106       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12107       return -1;
12108     }
12109   }
12110   return 0;
12111 }
12112
12113 static int test_is_dir_1_skip (void)
12114 {
12115   const char *str;
12116
12117   str = getenv ("SKIP_TEST_IS_DIR_1");
12118   if (str && strcmp (str, "1") == 0) return 1;
12119   str = getenv ("SKIP_TEST_IS_DIR");
12120   if (str && strcmp (str, "1") == 0) return 1;
12121   return 0;
12122 }
12123
12124 static int test_is_dir_1 (void)
12125 {
12126   if (test_is_dir_1_skip ()) {
12127     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12128     return 0;
12129   }
12130
12131   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12132   {
12133     char device[] = "/dev/sda";
12134     device[5] = devchar;
12135     int r;
12136     suppress_error = 0;
12137     r = guestfs_blockdev_setrw (g, device);
12138     if (r == -1)
12139       return -1;
12140   }
12141   {
12142     int r;
12143     suppress_error = 0;
12144     r = guestfs_umount_all (g);
12145     if (r == -1)
12146       return -1;
12147   }
12148   {
12149     int r;
12150     suppress_error = 0;
12151     r = guestfs_lvm_remove_all (g);
12152     if (r == -1)
12153       return -1;
12154   }
12155   {
12156     char device[] = "/dev/sda";
12157     device[5] = devchar;
12158     char lines_0[] = ",";
12159     char *lines[] = {
12160       lines_0,
12161       NULL
12162     };
12163     int r;
12164     suppress_error = 0;
12165     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12166     if (r == -1)
12167       return -1;
12168   }
12169   {
12170     char fstype[] = "ext2";
12171     char device[] = "/dev/sda1";
12172     device[5] = devchar;
12173     int r;
12174     suppress_error = 0;
12175     r = guestfs_mkfs (g, fstype, device);
12176     if (r == -1)
12177       return -1;
12178   }
12179   {
12180     char device[] = "/dev/sda1";
12181     device[5] = devchar;
12182     char mountpoint[] = "/";
12183     int r;
12184     suppress_error = 0;
12185     r = guestfs_mount (g, device, mountpoint);
12186     if (r == -1)
12187       return -1;
12188   }
12189   /* TestOutputTrue for is_dir (1) */
12190   {
12191     char path[] = "/new";
12192     int r;
12193     suppress_error = 0;
12194     r = guestfs_mkdir (g, path);
12195     if (r == -1)
12196       return -1;
12197   }
12198   {
12199     char path[] = "/new";
12200     int r;
12201     suppress_error = 0;
12202     r = guestfs_is_dir (g, path);
12203     if (r == -1)
12204       return -1;
12205     if (!r) {
12206       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12207       return -1;
12208     }
12209   }
12210   return 0;
12211 }
12212
12213 static int test_is_file_0_skip (void)
12214 {
12215   const char *str;
12216
12217   str = getenv ("SKIP_TEST_IS_FILE_0");
12218   if (str && strcmp (str, "1") == 0) return 1;
12219   str = getenv ("SKIP_TEST_IS_FILE");
12220   if (str && strcmp (str, "1") == 0) return 1;
12221   return 0;
12222 }
12223
12224 static int test_is_file_0 (void)
12225 {
12226   if (test_is_file_0_skip ()) {
12227     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12228     return 0;
12229   }
12230
12231   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12232   {
12233     char device[] = "/dev/sda";
12234     device[5] = devchar;
12235     int r;
12236     suppress_error = 0;
12237     r = guestfs_blockdev_setrw (g, device);
12238     if (r == -1)
12239       return -1;
12240   }
12241   {
12242     int r;
12243     suppress_error = 0;
12244     r = guestfs_umount_all (g);
12245     if (r == -1)
12246       return -1;
12247   }
12248   {
12249     int r;
12250     suppress_error = 0;
12251     r = guestfs_lvm_remove_all (g);
12252     if (r == -1)
12253       return -1;
12254   }
12255   {
12256     char device[] = "/dev/sda";
12257     device[5] = devchar;
12258     char lines_0[] = ",";
12259     char *lines[] = {
12260       lines_0,
12261       NULL
12262     };
12263     int r;
12264     suppress_error = 0;
12265     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12266     if (r == -1)
12267       return -1;
12268   }
12269   {
12270     char fstype[] = "ext2";
12271     char device[] = "/dev/sda1";
12272     device[5] = devchar;
12273     int r;
12274     suppress_error = 0;
12275     r = guestfs_mkfs (g, fstype, device);
12276     if (r == -1)
12277       return -1;
12278   }
12279   {
12280     char device[] = "/dev/sda1";
12281     device[5] = devchar;
12282     char mountpoint[] = "/";
12283     int r;
12284     suppress_error = 0;
12285     r = guestfs_mount (g, device, mountpoint);
12286     if (r == -1)
12287       return -1;
12288   }
12289   /* TestOutputTrue for is_file (0) */
12290   {
12291     char path[] = "/new";
12292     int r;
12293     suppress_error = 0;
12294     r = guestfs_touch (g, path);
12295     if (r == -1)
12296       return -1;
12297   }
12298   {
12299     char path[] = "/new";
12300     int r;
12301     suppress_error = 0;
12302     r = guestfs_is_file (g, path);
12303     if (r == -1)
12304       return -1;
12305     if (!r) {
12306       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12307       return -1;
12308     }
12309   }
12310   return 0;
12311 }
12312
12313 static int test_is_file_1_skip (void)
12314 {
12315   const char *str;
12316
12317   str = getenv ("SKIP_TEST_IS_FILE_1");
12318   if (str && strcmp (str, "1") == 0) return 1;
12319   str = getenv ("SKIP_TEST_IS_FILE");
12320   if (str && strcmp (str, "1") == 0) return 1;
12321   return 0;
12322 }
12323
12324 static int test_is_file_1 (void)
12325 {
12326   if (test_is_file_1_skip ()) {
12327     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12328     return 0;
12329   }
12330
12331   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12332   {
12333     char device[] = "/dev/sda";
12334     device[5] = devchar;
12335     int r;
12336     suppress_error = 0;
12337     r = guestfs_blockdev_setrw (g, device);
12338     if (r == -1)
12339       return -1;
12340   }
12341   {
12342     int r;
12343     suppress_error = 0;
12344     r = guestfs_umount_all (g);
12345     if (r == -1)
12346       return -1;
12347   }
12348   {
12349     int r;
12350     suppress_error = 0;
12351     r = guestfs_lvm_remove_all (g);
12352     if (r == -1)
12353       return -1;
12354   }
12355   {
12356     char device[] = "/dev/sda";
12357     device[5] = devchar;
12358     char lines_0[] = ",";
12359     char *lines[] = {
12360       lines_0,
12361       NULL
12362     };
12363     int r;
12364     suppress_error = 0;
12365     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12366     if (r == -1)
12367       return -1;
12368   }
12369   {
12370     char fstype[] = "ext2";
12371     char device[] = "/dev/sda1";
12372     device[5] = devchar;
12373     int r;
12374     suppress_error = 0;
12375     r = guestfs_mkfs (g, fstype, device);
12376     if (r == -1)
12377       return -1;
12378   }
12379   {
12380     char device[] = "/dev/sda1";
12381     device[5] = devchar;
12382     char mountpoint[] = "/";
12383     int r;
12384     suppress_error = 0;
12385     r = guestfs_mount (g, device, mountpoint);
12386     if (r == -1)
12387       return -1;
12388   }
12389   /* TestOutputFalse for is_file (1) */
12390   {
12391     char path[] = "/new";
12392     int r;
12393     suppress_error = 0;
12394     r = guestfs_mkdir (g, path);
12395     if (r == -1)
12396       return -1;
12397   }
12398   {
12399     char path[] = "/new";
12400     int r;
12401     suppress_error = 0;
12402     r = guestfs_is_file (g, path);
12403     if (r == -1)
12404       return -1;
12405     if (r) {
12406       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12407       return -1;
12408     }
12409   }
12410   return 0;
12411 }
12412
12413 static int test_exists_0_skip (void)
12414 {
12415   const char *str;
12416
12417   str = getenv ("SKIP_TEST_EXISTS_0");
12418   if (str && strcmp (str, "1") == 0) return 1;
12419   str = getenv ("SKIP_TEST_EXISTS");
12420   if (str && strcmp (str, "1") == 0) return 1;
12421   return 0;
12422 }
12423
12424 static int test_exists_0 (void)
12425 {
12426   if (test_exists_0_skip ()) {
12427     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12428     return 0;
12429   }
12430
12431   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12432   {
12433     char device[] = "/dev/sda";
12434     device[5] = devchar;
12435     int r;
12436     suppress_error = 0;
12437     r = guestfs_blockdev_setrw (g, device);
12438     if (r == -1)
12439       return -1;
12440   }
12441   {
12442     int r;
12443     suppress_error = 0;
12444     r = guestfs_umount_all (g);
12445     if (r == -1)
12446       return -1;
12447   }
12448   {
12449     int r;
12450     suppress_error = 0;
12451     r = guestfs_lvm_remove_all (g);
12452     if (r == -1)
12453       return -1;
12454   }
12455   {
12456     char device[] = "/dev/sda";
12457     device[5] = devchar;
12458     char lines_0[] = ",";
12459     char *lines[] = {
12460       lines_0,
12461       NULL
12462     };
12463     int r;
12464     suppress_error = 0;
12465     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12466     if (r == -1)
12467       return -1;
12468   }
12469   {
12470     char fstype[] = "ext2";
12471     char device[] = "/dev/sda1";
12472     device[5] = devchar;
12473     int r;
12474     suppress_error = 0;
12475     r = guestfs_mkfs (g, fstype, device);
12476     if (r == -1)
12477       return -1;
12478   }
12479   {
12480     char device[] = "/dev/sda1";
12481     device[5] = devchar;
12482     char mountpoint[] = "/";
12483     int r;
12484     suppress_error = 0;
12485     r = guestfs_mount (g, device, mountpoint);
12486     if (r == -1)
12487       return -1;
12488   }
12489   /* TestOutputTrue for exists (0) */
12490   {
12491     char path[] = "/new";
12492     int r;
12493     suppress_error = 0;
12494     r = guestfs_touch (g, path);
12495     if (r == -1)
12496       return -1;
12497   }
12498   {
12499     char path[] = "/new";
12500     int r;
12501     suppress_error = 0;
12502     r = guestfs_exists (g, path);
12503     if (r == -1)
12504       return -1;
12505     if (!r) {
12506       fprintf (stderr, "test_exists_0: expected true, got false\n");
12507       return -1;
12508     }
12509   }
12510   return 0;
12511 }
12512
12513 static int test_exists_1_skip (void)
12514 {
12515   const char *str;
12516
12517   str = getenv ("SKIP_TEST_EXISTS_1");
12518   if (str && strcmp (str, "1") == 0) return 1;
12519   str = getenv ("SKIP_TEST_EXISTS");
12520   if (str && strcmp (str, "1") == 0) return 1;
12521   return 0;
12522 }
12523
12524 static int test_exists_1 (void)
12525 {
12526   if (test_exists_1_skip ()) {
12527     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12528     return 0;
12529   }
12530
12531   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12532   {
12533     char device[] = "/dev/sda";
12534     device[5] = devchar;
12535     int r;
12536     suppress_error = 0;
12537     r = guestfs_blockdev_setrw (g, device);
12538     if (r == -1)
12539       return -1;
12540   }
12541   {
12542     int r;
12543     suppress_error = 0;
12544     r = guestfs_umount_all (g);
12545     if (r == -1)
12546       return -1;
12547   }
12548   {
12549     int r;
12550     suppress_error = 0;
12551     r = guestfs_lvm_remove_all (g);
12552     if (r == -1)
12553       return -1;
12554   }
12555   {
12556     char device[] = "/dev/sda";
12557     device[5] = devchar;
12558     char lines_0[] = ",";
12559     char *lines[] = {
12560       lines_0,
12561       NULL
12562     };
12563     int r;
12564     suppress_error = 0;
12565     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12566     if (r == -1)
12567       return -1;
12568   }
12569   {
12570     char fstype[] = "ext2";
12571     char device[] = "/dev/sda1";
12572     device[5] = devchar;
12573     int r;
12574     suppress_error = 0;
12575     r = guestfs_mkfs (g, fstype, device);
12576     if (r == -1)
12577       return -1;
12578   }
12579   {
12580     char device[] = "/dev/sda1";
12581     device[5] = devchar;
12582     char mountpoint[] = "/";
12583     int r;
12584     suppress_error = 0;
12585     r = guestfs_mount (g, device, mountpoint);
12586     if (r == -1)
12587       return -1;
12588   }
12589   /* TestOutputTrue for exists (1) */
12590   {
12591     char path[] = "/new";
12592     int r;
12593     suppress_error = 0;
12594     r = guestfs_mkdir (g, path);
12595     if (r == -1)
12596       return -1;
12597   }
12598   {
12599     char path[] = "/new";
12600     int r;
12601     suppress_error = 0;
12602     r = guestfs_exists (g, path);
12603     if (r == -1)
12604       return -1;
12605     if (!r) {
12606       fprintf (stderr, "test_exists_1: expected true, got false\n");
12607       return -1;
12608     }
12609   }
12610   return 0;
12611 }
12612
12613 static int test_mkdir_p_0_skip (void)
12614 {
12615   const char *str;
12616
12617   str = getenv ("SKIP_TEST_MKDIR_P_0");
12618   if (str && strcmp (str, "1") == 0) return 1;
12619   str = getenv ("SKIP_TEST_MKDIR_P");
12620   if (str && strcmp (str, "1") == 0) return 1;
12621   return 0;
12622 }
12623
12624 static int test_mkdir_p_0 (void)
12625 {
12626   if (test_mkdir_p_0_skip ()) {
12627     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12628     return 0;
12629   }
12630
12631   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12632   {
12633     char device[] = "/dev/sda";
12634     device[5] = devchar;
12635     int r;
12636     suppress_error = 0;
12637     r = guestfs_blockdev_setrw (g, device);
12638     if (r == -1)
12639       return -1;
12640   }
12641   {
12642     int r;
12643     suppress_error = 0;
12644     r = guestfs_umount_all (g);
12645     if (r == -1)
12646       return -1;
12647   }
12648   {
12649     int r;
12650     suppress_error = 0;
12651     r = guestfs_lvm_remove_all (g);
12652     if (r == -1)
12653       return -1;
12654   }
12655   {
12656     char device[] = "/dev/sda";
12657     device[5] = devchar;
12658     char lines_0[] = ",";
12659     char *lines[] = {
12660       lines_0,
12661       NULL
12662     };
12663     int r;
12664     suppress_error = 0;
12665     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12666     if (r == -1)
12667       return -1;
12668   }
12669   {
12670     char fstype[] = "ext2";
12671     char device[] = "/dev/sda1";
12672     device[5] = devchar;
12673     int r;
12674     suppress_error = 0;
12675     r = guestfs_mkfs (g, fstype, device);
12676     if (r == -1)
12677       return -1;
12678   }
12679   {
12680     char device[] = "/dev/sda1";
12681     device[5] = devchar;
12682     char mountpoint[] = "/";
12683     int r;
12684     suppress_error = 0;
12685     r = guestfs_mount (g, device, mountpoint);
12686     if (r == -1)
12687       return -1;
12688   }
12689   /* TestOutputTrue for mkdir_p (0) */
12690   {
12691     char path[] = "/new/foo/bar";
12692     int r;
12693     suppress_error = 0;
12694     r = guestfs_mkdir_p (g, path);
12695     if (r == -1)
12696       return -1;
12697   }
12698   {
12699     char path[] = "/new/foo/bar";
12700     int r;
12701     suppress_error = 0;
12702     r = guestfs_is_dir (g, path);
12703     if (r == -1)
12704       return -1;
12705     if (!r) {
12706       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12707       return -1;
12708     }
12709   }
12710   return 0;
12711 }
12712
12713 static int test_mkdir_p_1_skip (void)
12714 {
12715   const char *str;
12716
12717   str = getenv ("SKIP_TEST_MKDIR_P_1");
12718   if (str && strcmp (str, "1") == 0) return 1;
12719   str = getenv ("SKIP_TEST_MKDIR_P");
12720   if (str && strcmp (str, "1") == 0) return 1;
12721   return 0;
12722 }
12723
12724 static int test_mkdir_p_1 (void)
12725 {
12726   if (test_mkdir_p_1_skip ()) {
12727     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12728     return 0;
12729   }
12730
12731   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12732   {
12733     char device[] = "/dev/sda";
12734     device[5] = devchar;
12735     int r;
12736     suppress_error = 0;
12737     r = guestfs_blockdev_setrw (g, device);
12738     if (r == -1)
12739       return -1;
12740   }
12741   {
12742     int r;
12743     suppress_error = 0;
12744     r = guestfs_umount_all (g);
12745     if (r == -1)
12746       return -1;
12747   }
12748   {
12749     int r;
12750     suppress_error = 0;
12751     r = guestfs_lvm_remove_all (g);
12752     if (r == -1)
12753       return -1;
12754   }
12755   {
12756     char device[] = "/dev/sda";
12757     device[5] = devchar;
12758     char lines_0[] = ",";
12759     char *lines[] = {
12760       lines_0,
12761       NULL
12762     };
12763     int r;
12764     suppress_error = 0;
12765     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12766     if (r == -1)
12767       return -1;
12768   }
12769   {
12770     char fstype[] = "ext2";
12771     char device[] = "/dev/sda1";
12772     device[5] = devchar;
12773     int r;
12774     suppress_error = 0;
12775     r = guestfs_mkfs (g, fstype, device);
12776     if (r == -1)
12777       return -1;
12778   }
12779   {
12780     char device[] = "/dev/sda1";
12781     device[5] = devchar;
12782     char mountpoint[] = "/";
12783     int r;
12784     suppress_error = 0;
12785     r = guestfs_mount (g, device, mountpoint);
12786     if (r == -1)
12787       return -1;
12788   }
12789   /* TestOutputTrue for mkdir_p (1) */
12790   {
12791     char path[] = "/new/foo/bar";
12792     int r;
12793     suppress_error = 0;
12794     r = guestfs_mkdir_p (g, path);
12795     if (r == -1)
12796       return -1;
12797   }
12798   {
12799     char path[] = "/new/foo";
12800     int r;
12801     suppress_error = 0;
12802     r = guestfs_is_dir (g, path);
12803     if (r == -1)
12804       return -1;
12805     if (!r) {
12806       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12807       return -1;
12808     }
12809   }
12810   return 0;
12811 }
12812
12813 static int test_mkdir_p_2_skip (void)
12814 {
12815   const char *str;
12816
12817   str = getenv ("SKIP_TEST_MKDIR_P_2");
12818   if (str && strcmp (str, "1") == 0) return 1;
12819   str = getenv ("SKIP_TEST_MKDIR_P");
12820   if (str && strcmp (str, "1") == 0) return 1;
12821   return 0;
12822 }
12823
12824 static int test_mkdir_p_2 (void)
12825 {
12826   if (test_mkdir_p_2_skip ()) {
12827     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12828     return 0;
12829   }
12830
12831   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12832   {
12833     char device[] = "/dev/sda";
12834     device[5] = devchar;
12835     int r;
12836     suppress_error = 0;
12837     r = guestfs_blockdev_setrw (g, device);
12838     if (r == -1)
12839       return -1;
12840   }
12841   {
12842     int r;
12843     suppress_error = 0;
12844     r = guestfs_umount_all (g);
12845     if (r == -1)
12846       return -1;
12847   }
12848   {
12849     int r;
12850     suppress_error = 0;
12851     r = guestfs_lvm_remove_all (g);
12852     if (r == -1)
12853       return -1;
12854   }
12855   {
12856     char device[] = "/dev/sda";
12857     device[5] = devchar;
12858     char lines_0[] = ",";
12859     char *lines[] = {
12860       lines_0,
12861       NULL
12862     };
12863     int r;
12864     suppress_error = 0;
12865     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12866     if (r == -1)
12867       return -1;
12868   }
12869   {
12870     char fstype[] = "ext2";
12871     char device[] = "/dev/sda1";
12872     device[5] = devchar;
12873     int r;
12874     suppress_error = 0;
12875     r = guestfs_mkfs (g, fstype, device);
12876     if (r == -1)
12877       return -1;
12878   }
12879   {
12880     char device[] = "/dev/sda1";
12881     device[5] = devchar;
12882     char mountpoint[] = "/";
12883     int r;
12884     suppress_error = 0;
12885     r = guestfs_mount (g, device, mountpoint);
12886     if (r == -1)
12887       return -1;
12888   }
12889   /* TestOutputTrue for mkdir_p (2) */
12890   {
12891     char path[] = "/new/foo/bar";
12892     int r;
12893     suppress_error = 0;
12894     r = guestfs_mkdir_p (g, path);
12895     if (r == -1)
12896       return -1;
12897   }
12898   {
12899     char path[] = "/new";
12900     int r;
12901     suppress_error = 0;
12902     r = guestfs_is_dir (g, path);
12903     if (r == -1)
12904       return -1;
12905     if (!r) {
12906       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12907       return -1;
12908     }
12909   }
12910   return 0;
12911 }
12912
12913 static int test_mkdir_p_3_skip (void)
12914 {
12915   const char *str;
12916
12917   str = getenv ("SKIP_TEST_MKDIR_P_3");
12918   if (str && strcmp (str, "1") == 0) return 1;
12919   str = getenv ("SKIP_TEST_MKDIR_P");
12920   if (str && strcmp (str, "1") == 0) return 1;
12921   return 0;
12922 }
12923
12924 static int test_mkdir_p_3 (void)
12925 {
12926   if (test_mkdir_p_3_skip ()) {
12927     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12928     return 0;
12929   }
12930
12931   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12932   {
12933     char device[] = "/dev/sda";
12934     device[5] = devchar;
12935     int r;
12936     suppress_error = 0;
12937     r = guestfs_blockdev_setrw (g, device);
12938     if (r == -1)
12939       return -1;
12940   }
12941   {
12942     int r;
12943     suppress_error = 0;
12944     r = guestfs_umount_all (g);
12945     if (r == -1)
12946       return -1;
12947   }
12948   {
12949     int r;
12950     suppress_error = 0;
12951     r = guestfs_lvm_remove_all (g);
12952     if (r == -1)
12953       return -1;
12954   }
12955   {
12956     char device[] = "/dev/sda";
12957     device[5] = devchar;
12958     char lines_0[] = ",";
12959     char *lines[] = {
12960       lines_0,
12961       NULL
12962     };
12963     int r;
12964     suppress_error = 0;
12965     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12966     if (r == -1)
12967       return -1;
12968   }
12969   {
12970     char fstype[] = "ext2";
12971     char device[] = "/dev/sda1";
12972     device[5] = devchar;
12973     int r;
12974     suppress_error = 0;
12975     r = guestfs_mkfs (g, fstype, device);
12976     if (r == -1)
12977       return -1;
12978   }
12979   {
12980     char device[] = "/dev/sda1";
12981     device[5] = devchar;
12982     char mountpoint[] = "/";
12983     int r;
12984     suppress_error = 0;
12985     r = guestfs_mount (g, device, mountpoint);
12986     if (r == -1)
12987       return -1;
12988   }
12989   /* TestRun for mkdir_p (3) */
12990   {
12991     char path[] = "/new";
12992     int r;
12993     suppress_error = 0;
12994     r = guestfs_mkdir (g, path);
12995     if (r == -1)
12996       return -1;
12997   }
12998   {
12999     char path[] = "/new";
13000     int r;
13001     suppress_error = 0;
13002     r = guestfs_mkdir_p (g, path);
13003     if (r == -1)
13004       return -1;
13005   }
13006   return 0;
13007 }
13008
13009 static int test_mkdir_p_4_skip (void)
13010 {
13011   const char *str;
13012
13013   str = getenv ("SKIP_TEST_MKDIR_P_4");
13014   if (str && strcmp (str, "1") == 0) return 1;
13015   str = getenv ("SKIP_TEST_MKDIR_P");
13016   if (str && strcmp (str, "1") == 0) return 1;
13017   return 0;
13018 }
13019
13020 static int test_mkdir_p_4 (void)
13021 {
13022   if (test_mkdir_p_4_skip ()) {
13023     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13024     return 0;
13025   }
13026
13027   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13028   {
13029     char device[] = "/dev/sda";
13030     device[5] = devchar;
13031     int r;
13032     suppress_error = 0;
13033     r = guestfs_blockdev_setrw (g, device);
13034     if (r == -1)
13035       return -1;
13036   }
13037   {
13038     int r;
13039     suppress_error = 0;
13040     r = guestfs_umount_all (g);
13041     if (r == -1)
13042       return -1;
13043   }
13044   {
13045     int r;
13046     suppress_error = 0;
13047     r = guestfs_lvm_remove_all (g);
13048     if (r == -1)
13049       return -1;
13050   }
13051   {
13052     char device[] = "/dev/sda";
13053     device[5] = devchar;
13054     char lines_0[] = ",";
13055     char *lines[] = {
13056       lines_0,
13057       NULL
13058     };
13059     int r;
13060     suppress_error = 0;
13061     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13062     if (r == -1)
13063       return -1;
13064   }
13065   {
13066     char fstype[] = "ext2";
13067     char device[] = "/dev/sda1";
13068     device[5] = devchar;
13069     int r;
13070     suppress_error = 0;
13071     r = guestfs_mkfs (g, fstype, device);
13072     if (r == -1)
13073       return -1;
13074   }
13075   {
13076     char device[] = "/dev/sda1";
13077     device[5] = devchar;
13078     char mountpoint[] = "/";
13079     int r;
13080     suppress_error = 0;
13081     r = guestfs_mount (g, device, mountpoint);
13082     if (r == -1)
13083       return -1;
13084   }
13085   /* TestLastFail for mkdir_p (4) */
13086   {
13087     char path[] = "/new";
13088     int r;
13089     suppress_error = 0;
13090     r = guestfs_touch (g, path);
13091     if (r == -1)
13092       return -1;
13093   }
13094   {
13095     char path[] = "/new";
13096     int r;
13097     suppress_error = 1;
13098     r = guestfs_mkdir_p (g, path);
13099     if (r != -1)
13100       return -1;
13101   }
13102   return 0;
13103 }
13104
13105 static int test_mkdir_0_skip (void)
13106 {
13107   const char *str;
13108
13109   str = getenv ("SKIP_TEST_MKDIR_0");
13110   if (str && strcmp (str, "1") == 0) return 1;
13111   str = getenv ("SKIP_TEST_MKDIR");
13112   if (str && strcmp (str, "1") == 0) return 1;
13113   return 0;
13114 }
13115
13116 static int test_mkdir_0 (void)
13117 {
13118   if (test_mkdir_0_skip ()) {
13119     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13120     return 0;
13121   }
13122
13123   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13124   {
13125     char device[] = "/dev/sda";
13126     device[5] = devchar;
13127     int r;
13128     suppress_error = 0;
13129     r = guestfs_blockdev_setrw (g, device);
13130     if (r == -1)
13131       return -1;
13132   }
13133   {
13134     int r;
13135     suppress_error = 0;
13136     r = guestfs_umount_all (g);
13137     if (r == -1)
13138       return -1;
13139   }
13140   {
13141     int r;
13142     suppress_error = 0;
13143     r = guestfs_lvm_remove_all (g);
13144     if (r == -1)
13145       return -1;
13146   }
13147   {
13148     char device[] = "/dev/sda";
13149     device[5] = devchar;
13150     char lines_0[] = ",";
13151     char *lines[] = {
13152       lines_0,
13153       NULL
13154     };
13155     int r;
13156     suppress_error = 0;
13157     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13158     if (r == -1)
13159       return -1;
13160   }
13161   {
13162     char fstype[] = "ext2";
13163     char device[] = "/dev/sda1";
13164     device[5] = devchar;
13165     int r;
13166     suppress_error = 0;
13167     r = guestfs_mkfs (g, fstype, device);
13168     if (r == -1)
13169       return -1;
13170   }
13171   {
13172     char device[] = "/dev/sda1";
13173     device[5] = devchar;
13174     char mountpoint[] = "/";
13175     int r;
13176     suppress_error = 0;
13177     r = guestfs_mount (g, device, mountpoint);
13178     if (r == -1)
13179       return -1;
13180   }
13181   /* TestOutputTrue for mkdir (0) */
13182   {
13183     char path[] = "/new";
13184     int r;
13185     suppress_error = 0;
13186     r = guestfs_mkdir (g, path);
13187     if (r == -1)
13188       return -1;
13189   }
13190   {
13191     char path[] = "/new";
13192     int r;
13193     suppress_error = 0;
13194     r = guestfs_is_dir (g, path);
13195     if (r == -1)
13196       return -1;
13197     if (!r) {
13198       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13199       return -1;
13200     }
13201   }
13202   return 0;
13203 }
13204
13205 static int test_mkdir_1_skip (void)
13206 {
13207   const char *str;
13208
13209   str = getenv ("SKIP_TEST_MKDIR_1");
13210   if (str && strcmp (str, "1") == 0) return 1;
13211   str = getenv ("SKIP_TEST_MKDIR");
13212   if (str && strcmp (str, "1") == 0) return 1;
13213   return 0;
13214 }
13215
13216 static int test_mkdir_1 (void)
13217 {
13218   if (test_mkdir_1_skip ()) {
13219     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13220     return 0;
13221   }
13222
13223   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13224   {
13225     char device[] = "/dev/sda";
13226     device[5] = devchar;
13227     int r;
13228     suppress_error = 0;
13229     r = guestfs_blockdev_setrw (g, device);
13230     if (r == -1)
13231       return -1;
13232   }
13233   {
13234     int r;
13235     suppress_error = 0;
13236     r = guestfs_umount_all (g);
13237     if (r == -1)
13238       return -1;
13239   }
13240   {
13241     int r;
13242     suppress_error = 0;
13243     r = guestfs_lvm_remove_all (g);
13244     if (r == -1)
13245       return -1;
13246   }
13247   {
13248     char device[] = "/dev/sda";
13249     device[5] = devchar;
13250     char lines_0[] = ",";
13251     char *lines[] = {
13252       lines_0,
13253       NULL
13254     };
13255     int r;
13256     suppress_error = 0;
13257     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13258     if (r == -1)
13259       return -1;
13260   }
13261   {
13262     char fstype[] = "ext2";
13263     char device[] = "/dev/sda1";
13264     device[5] = devchar;
13265     int r;
13266     suppress_error = 0;
13267     r = guestfs_mkfs (g, fstype, device);
13268     if (r == -1)
13269       return -1;
13270   }
13271   {
13272     char device[] = "/dev/sda1";
13273     device[5] = devchar;
13274     char mountpoint[] = "/";
13275     int r;
13276     suppress_error = 0;
13277     r = guestfs_mount (g, device, mountpoint);
13278     if (r == -1)
13279       return -1;
13280   }
13281   /* TestLastFail for mkdir (1) */
13282   {
13283     char path[] = "/new/foo/bar";
13284     int r;
13285     suppress_error = 1;
13286     r = guestfs_mkdir (g, path);
13287     if (r != -1)
13288       return -1;
13289   }
13290   return 0;
13291 }
13292
13293 static int test_rm_rf_0_skip (void)
13294 {
13295   const char *str;
13296
13297   str = getenv ("SKIP_TEST_RM_RF_0");
13298   if (str && strcmp (str, "1") == 0) return 1;
13299   str = getenv ("SKIP_TEST_RM_RF");
13300   if (str && strcmp (str, "1") == 0) return 1;
13301   return 0;
13302 }
13303
13304 static int test_rm_rf_0 (void)
13305 {
13306   if (test_rm_rf_0_skip ()) {
13307     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13308     return 0;
13309   }
13310
13311   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13312   {
13313     char device[] = "/dev/sda";
13314     device[5] = devchar;
13315     int r;
13316     suppress_error = 0;
13317     r = guestfs_blockdev_setrw (g, device);
13318     if (r == -1)
13319       return -1;
13320   }
13321   {
13322     int r;
13323     suppress_error = 0;
13324     r = guestfs_umount_all (g);
13325     if (r == -1)
13326       return -1;
13327   }
13328   {
13329     int r;
13330     suppress_error = 0;
13331     r = guestfs_lvm_remove_all (g);
13332     if (r == -1)
13333       return -1;
13334   }
13335   {
13336     char device[] = "/dev/sda";
13337     device[5] = devchar;
13338     char lines_0[] = ",";
13339     char *lines[] = {
13340       lines_0,
13341       NULL
13342     };
13343     int r;
13344     suppress_error = 0;
13345     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13346     if (r == -1)
13347       return -1;
13348   }
13349   {
13350     char fstype[] = "ext2";
13351     char device[] = "/dev/sda1";
13352     device[5] = devchar;
13353     int r;
13354     suppress_error = 0;
13355     r = guestfs_mkfs (g, fstype, device);
13356     if (r == -1)
13357       return -1;
13358   }
13359   {
13360     char device[] = "/dev/sda1";
13361     device[5] = devchar;
13362     char mountpoint[] = "/";
13363     int r;
13364     suppress_error = 0;
13365     r = guestfs_mount (g, device, mountpoint);
13366     if (r == -1)
13367       return -1;
13368   }
13369   /* TestOutputFalse for rm_rf (0) */
13370   {
13371     char path[] = "/new";
13372     int r;
13373     suppress_error = 0;
13374     r = guestfs_mkdir (g, path);
13375     if (r == -1)
13376       return -1;
13377   }
13378   {
13379     char path[] = "/new/foo";
13380     int r;
13381     suppress_error = 0;
13382     r = guestfs_mkdir (g, path);
13383     if (r == -1)
13384       return -1;
13385   }
13386   {
13387     char path[] = "/new/foo/bar";
13388     int r;
13389     suppress_error = 0;
13390     r = guestfs_touch (g, path);
13391     if (r == -1)
13392       return -1;
13393   }
13394   {
13395     char path[] = "/new";
13396     int r;
13397     suppress_error = 0;
13398     r = guestfs_rm_rf (g, path);
13399     if (r == -1)
13400       return -1;
13401   }
13402   {
13403     char path[] = "/new";
13404     int r;
13405     suppress_error = 0;
13406     r = guestfs_exists (g, path);
13407     if (r == -1)
13408       return -1;
13409     if (r) {
13410       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13411       return -1;
13412     }
13413   }
13414   return 0;
13415 }
13416
13417 static int test_rmdir_0_skip (void)
13418 {
13419   const char *str;
13420
13421   str = getenv ("SKIP_TEST_RMDIR_0");
13422   if (str && strcmp (str, "1") == 0) return 1;
13423   str = getenv ("SKIP_TEST_RMDIR");
13424   if (str && strcmp (str, "1") == 0) return 1;
13425   return 0;
13426 }
13427
13428 static int test_rmdir_0 (void)
13429 {
13430   if (test_rmdir_0_skip ()) {
13431     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13432     return 0;
13433   }
13434
13435   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13436   {
13437     char device[] = "/dev/sda";
13438     device[5] = devchar;
13439     int r;
13440     suppress_error = 0;
13441     r = guestfs_blockdev_setrw (g, device);
13442     if (r == -1)
13443       return -1;
13444   }
13445   {
13446     int r;
13447     suppress_error = 0;
13448     r = guestfs_umount_all (g);
13449     if (r == -1)
13450       return -1;
13451   }
13452   {
13453     int r;
13454     suppress_error = 0;
13455     r = guestfs_lvm_remove_all (g);
13456     if (r == -1)
13457       return -1;
13458   }
13459   {
13460     char device[] = "/dev/sda";
13461     device[5] = devchar;
13462     char lines_0[] = ",";
13463     char *lines[] = {
13464       lines_0,
13465       NULL
13466     };
13467     int r;
13468     suppress_error = 0;
13469     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13470     if (r == -1)
13471       return -1;
13472   }
13473   {
13474     char fstype[] = "ext2";
13475     char device[] = "/dev/sda1";
13476     device[5] = devchar;
13477     int r;
13478     suppress_error = 0;
13479     r = guestfs_mkfs (g, fstype, device);
13480     if (r == -1)
13481       return -1;
13482   }
13483   {
13484     char device[] = "/dev/sda1";
13485     device[5] = devchar;
13486     char mountpoint[] = "/";
13487     int r;
13488     suppress_error = 0;
13489     r = guestfs_mount (g, device, mountpoint);
13490     if (r == -1)
13491       return -1;
13492   }
13493   /* TestRun for rmdir (0) */
13494   {
13495     char path[] = "/new";
13496     int r;
13497     suppress_error = 0;
13498     r = guestfs_mkdir (g, path);
13499     if (r == -1)
13500       return -1;
13501   }
13502   {
13503     char path[] = "/new";
13504     int r;
13505     suppress_error = 0;
13506     r = guestfs_rmdir (g, path);
13507     if (r == -1)
13508       return -1;
13509   }
13510   return 0;
13511 }
13512
13513 static int test_rmdir_1_skip (void)
13514 {
13515   const char *str;
13516
13517   str = getenv ("SKIP_TEST_RMDIR_1");
13518   if (str && strcmp (str, "1") == 0) return 1;
13519   str = getenv ("SKIP_TEST_RMDIR");
13520   if (str && strcmp (str, "1") == 0) return 1;
13521   return 0;
13522 }
13523
13524 static int test_rmdir_1 (void)
13525 {
13526   if (test_rmdir_1_skip ()) {
13527     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13528     return 0;
13529   }
13530
13531   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13532   {
13533     char device[] = "/dev/sda";
13534     device[5] = devchar;
13535     int r;
13536     suppress_error = 0;
13537     r = guestfs_blockdev_setrw (g, device);
13538     if (r == -1)
13539       return -1;
13540   }
13541   {
13542     int r;
13543     suppress_error = 0;
13544     r = guestfs_umount_all (g);
13545     if (r == -1)
13546       return -1;
13547   }
13548   {
13549     int r;
13550     suppress_error = 0;
13551     r = guestfs_lvm_remove_all (g);
13552     if (r == -1)
13553       return -1;
13554   }
13555   {
13556     char device[] = "/dev/sda";
13557     device[5] = devchar;
13558     char lines_0[] = ",";
13559     char *lines[] = {
13560       lines_0,
13561       NULL
13562     };
13563     int r;
13564     suppress_error = 0;
13565     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13566     if (r == -1)
13567       return -1;
13568   }
13569   {
13570     char fstype[] = "ext2";
13571     char device[] = "/dev/sda1";
13572     device[5] = devchar;
13573     int r;
13574     suppress_error = 0;
13575     r = guestfs_mkfs (g, fstype, device);
13576     if (r == -1)
13577       return -1;
13578   }
13579   {
13580     char device[] = "/dev/sda1";
13581     device[5] = devchar;
13582     char mountpoint[] = "/";
13583     int r;
13584     suppress_error = 0;
13585     r = guestfs_mount (g, device, mountpoint);
13586     if (r == -1)
13587       return -1;
13588   }
13589   /* TestLastFail for rmdir (1) */
13590   {
13591     char path[] = "/new";
13592     int r;
13593     suppress_error = 1;
13594     r = guestfs_rmdir (g, path);
13595     if (r != -1)
13596       return -1;
13597   }
13598   return 0;
13599 }
13600
13601 static int test_rmdir_2_skip (void)
13602 {
13603   const char *str;
13604
13605   str = getenv ("SKIP_TEST_RMDIR_2");
13606   if (str && strcmp (str, "1") == 0) return 1;
13607   str = getenv ("SKIP_TEST_RMDIR");
13608   if (str && strcmp (str, "1") == 0) return 1;
13609   return 0;
13610 }
13611
13612 static int test_rmdir_2 (void)
13613 {
13614   if (test_rmdir_2_skip ()) {
13615     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13616     return 0;
13617   }
13618
13619   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13620   {
13621     char device[] = "/dev/sda";
13622     device[5] = devchar;
13623     int r;
13624     suppress_error = 0;
13625     r = guestfs_blockdev_setrw (g, device);
13626     if (r == -1)
13627       return -1;
13628   }
13629   {
13630     int r;
13631     suppress_error = 0;
13632     r = guestfs_umount_all (g);
13633     if (r == -1)
13634       return -1;
13635   }
13636   {
13637     int r;
13638     suppress_error = 0;
13639     r = guestfs_lvm_remove_all (g);
13640     if (r == -1)
13641       return -1;
13642   }
13643   {
13644     char device[] = "/dev/sda";
13645     device[5] = devchar;
13646     char lines_0[] = ",";
13647     char *lines[] = {
13648       lines_0,
13649       NULL
13650     };
13651     int r;
13652     suppress_error = 0;
13653     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13654     if (r == -1)
13655       return -1;
13656   }
13657   {
13658     char fstype[] = "ext2";
13659     char device[] = "/dev/sda1";
13660     device[5] = devchar;
13661     int r;
13662     suppress_error = 0;
13663     r = guestfs_mkfs (g, fstype, device);
13664     if (r == -1)
13665       return -1;
13666   }
13667   {
13668     char device[] = "/dev/sda1";
13669     device[5] = devchar;
13670     char mountpoint[] = "/";
13671     int r;
13672     suppress_error = 0;
13673     r = guestfs_mount (g, device, mountpoint);
13674     if (r == -1)
13675       return -1;
13676   }
13677   /* TestLastFail for rmdir (2) */
13678   {
13679     char path[] = "/new";
13680     int r;
13681     suppress_error = 0;
13682     r = guestfs_touch (g, path);
13683     if (r == -1)
13684       return -1;
13685   }
13686   {
13687     char path[] = "/new";
13688     int r;
13689     suppress_error = 1;
13690     r = guestfs_rmdir (g, path);
13691     if (r != -1)
13692       return -1;
13693   }
13694   return 0;
13695 }
13696
13697 static int test_rm_0_skip (void)
13698 {
13699   const char *str;
13700
13701   str = getenv ("SKIP_TEST_RM_0");
13702   if (str && strcmp (str, "1") == 0) return 1;
13703   str = getenv ("SKIP_TEST_RM");
13704   if (str && strcmp (str, "1") == 0) return 1;
13705   return 0;
13706 }
13707
13708 static int test_rm_0 (void)
13709 {
13710   if (test_rm_0_skip ()) {
13711     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13712     return 0;
13713   }
13714
13715   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13716   {
13717     char device[] = "/dev/sda";
13718     device[5] = devchar;
13719     int r;
13720     suppress_error = 0;
13721     r = guestfs_blockdev_setrw (g, device);
13722     if (r == -1)
13723       return -1;
13724   }
13725   {
13726     int r;
13727     suppress_error = 0;
13728     r = guestfs_umount_all (g);
13729     if (r == -1)
13730       return -1;
13731   }
13732   {
13733     int r;
13734     suppress_error = 0;
13735     r = guestfs_lvm_remove_all (g);
13736     if (r == -1)
13737       return -1;
13738   }
13739   {
13740     char device[] = "/dev/sda";
13741     device[5] = devchar;
13742     char lines_0[] = ",";
13743     char *lines[] = {
13744       lines_0,
13745       NULL
13746     };
13747     int r;
13748     suppress_error = 0;
13749     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13750     if (r == -1)
13751       return -1;
13752   }
13753   {
13754     char fstype[] = "ext2";
13755     char device[] = "/dev/sda1";
13756     device[5] = devchar;
13757     int r;
13758     suppress_error = 0;
13759     r = guestfs_mkfs (g, fstype, device);
13760     if (r == -1)
13761       return -1;
13762   }
13763   {
13764     char device[] = "/dev/sda1";
13765     device[5] = devchar;
13766     char mountpoint[] = "/";
13767     int r;
13768     suppress_error = 0;
13769     r = guestfs_mount (g, device, mountpoint);
13770     if (r == -1)
13771       return -1;
13772   }
13773   /* TestRun for rm (0) */
13774   {
13775     char path[] = "/new";
13776     int r;
13777     suppress_error = 0;
13778     r = guestfs_touch (g, path);
13779     if (r == -1)
13780       return -1;
13781   }
13782   {
13783     char path[] = "/new";
13784     int r;
13785     suppress_error = 0;
13786     r = guestfs_rm (g, path);
13787     if (r == -1)
13788       return -1;
13789   }
13790   return 0;
13791 }
13792
13793 static int test_rm_1_skip (void)
13794 {
13795   const char *str;
13796
13797   str = getenv ("SKIP_TEST_RM_1");
13798   if (str && strcmp (str, "1") == 0) return 1;
13799   str = getenv ("SKIP_TEST_RM");
13800   if (str && strcmp (str, "1") == 0) return 1;
13801   return 0;
13802 }
13803
13804 static int test_rm_1 (void)
13805 {
13806   if (test_rm_1_skip ()) {
13807     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13808     return 0;
13809   }
13810
13811   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13812   {
13813     char device[] = "/dev/sda";
13814     device[5] = devchar;
13815     int r;
13816     suppress_error = 0;
13817     r = guestfs_blockdev_setrw (g, device);
13818     if (r == -1)
13819       return -1;
13820   }
13821   {
13822     int r;
13823     suppress_error = 0;
13824     r = guestfs_umount_all (g);
13825     if (r == -1)
13826       return -1;
13827   }
13828   {
13829     int r;
13830     suppress_error = 0;
13831     r = guestfs_lvm_remove_all (g);
13832     if (r == -1)
13833       return -1;
13834   }
13835   {
13836     char device[] = "/dev/sda";
13837     device[5] = devchar;
13838     char lines_0[] = ",";
13839     char *lines[] = {
13840       lines_0,
13841       NULL
13842     };
13843     int r;
13844     suppress_error = 0;
13845     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13846     if (r == -1)
13847       return -1;
13848   }
13849   {
13850     char fstype[] = "ext2";
13851     char device[] = "/dev/sda1";
13852     device[5] = devchar;
13853     int r;
13854     suppress_error = 0;
13855     r = guestfs_mkfs (g, fstype, device);
13856     if (r == -1)
13857       return -1;
13858   }
13859   {
13860     char device[] = "/dev/sda1";
13861     device[5] = devchar;
13862     char mountpoint[] = "/";
13863     int r;
13864     suppress_error = 0;
13865     r = guestfs_mount (g, device, mountpoint);
13866     if (r == -1)
13867       return -1;
13868   }
13869   /* TestLastFail for rm (1) */
13870   {
13871     char path[] = "/new";
13872     int r;
13873     suppress_error = 1;
13874     r = guestfs_rm (g, path);
13875     if (r != -1)
13876       return -1;
13877   }
13878   return 0;
13879 }
13880
13881 static int test_rm_2_skip (void)
13882 {
13883   const char *str;
13884
13885   str = getenv ("SKIP_TEST_RM_2");
13886   if (str && strcmp (str, "1") == 0) return 1;
13887   str = getenv ("SKIP_TEST_RM");
13888   if (str && strcmp (str, "1") == 0) return 1;
13889   return 0;
13890 }
13891
13892 static int test_rm_2 (void)
13893 {
13894   if (test_rm_2_skip ()) {
13895     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13896     return 0;
13897   }
13898
13899   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13900   {
13901     char device[] = "/dev/sda";
13902     device[5] = devchar;
13903     int r;
13904     suppress_error = 0;
13905     r = guestfs_blockdev_setrw (g, device);
13906     if (r == -1)
13907       return -1;
13908   }
13909   {
13910     int r;
13911     suppress_error = 0;
13912     r = guestfs_umount_all (g);
13913     if (r == -1)
13914       return -1;
13915   }
13916   {
13917     int r;
13918     suppress_error = 0;
13919     r = guestfs_lvm_remove_all (g);
13920     if (r == -1)
13921       return -1;
13922   }
13923   {
13924     char device[] = "/dev/sda";
13925     device[5] = devchar;
13926     char lines_0[] = ",";
13927     char *lines[] = {
13928       lines_0,
13929       NULL
13930     };
13931     int r;
13932     suppress_error = 0;
13933     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13934     if (r == -1)
13935       return -1;
13936   }
13937   {
13938     char fstype[] = "ext2";
13939     char device[] = "/dev/sda1";
13940     device[5] = devchar;
13941     int r;
13942     suppress_error = 0;
13943     r = guestfs_mkfs (g, fstype, device);
13944     if (r == -1)
13945       return -1;
13946   }
13947   {
13948     char device[] = "/dev/sda1";
13949     device[5] = devchar;
13950     char mountpoint[] = "/";
13951     int r;
13952     suppress_error = 0;
13953     r = guestfs_mount (g, device, mountpoint);
13954     if (r == -1)
13955       return -1;
13956   }
13957   /* TestLastFail for rm (2) */
13958   {
13959     char path[] = "/new";
13960     int r;
13961     suppress_error = 0;
13962     r = guestfs_mkdir (g, path);
13963     if (r == -1)
13964       return -1;
13965   }
13966   {
13967     char path[] = "/new";
13968     int r;
13969     suppress_error = 1;
13970     r = guestfs_rm (g, path);
13971     if (r != -1)
13972       return -1;
13973   }
13974   return 0;
13975 }
13976
13977 static int test_read_lines_0_skip (void)
13978 {
13979   const char *str;
13980
13981   str = getenv ("SKIP_TEST_READ_LINES_0");
13982   if (str && strcmp (str, "1") == 0) return 1;
13983   str = getenv ("SKIP_TEST_READ_LINES");
13984   if (str && strcmp (str, "1") == 0) return 1;
13985   return 0;
13986 }
13987
13988 static int test_read_lines_0 (void)
13989 {
13990   if (test_read_lines_0_skip ()) {
13991     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13992     return 0;
13993   }
13994
13995   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13996   {
13997     char device[] = "/dev/sda";
13998     device[5] = devchar;
13999     int r;
14000     suppress_error = 0;
14001     r = guestfs_blockdev_setrw (g, device);
14002     if (r == -1)
14003       return -1;
14004   }
14005   {
14006     int r;
14007     suppress_error = 0;
14008     r = guestfs_umount_all (g);
14009     if (r == -1)
14010       return -1;
14011   }
14012   {
14013     int r;
14014     suppress_error = 0;
14015     r = guestfs_lvm_remove_all (g);
14016     if (r == -1)
14017       return -1;
14018   }
14019   {
14020     char device[] = "/dev/sda";
14021     device[5] = devchar;
14022     char lines_0[] = ",";
14023     char *lines[] = {
14024       lines_0,
14025       NULL
14026     };
14027     int r;
14028     suppress_error = 0;
14029     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14030     if (r == -1)
14031       return -1;
14032   }
14033   {
14034     char fstype[] = "ext2";
14035     char device[] = "/dev/sda1";
14036     device[5] = devchar;
14037     int r;
14038     suppress_error = 0;
14039     r = guestfs_mkfs (g, fstype, device);
14040     if (r == -1)
14041       return -1;
14042   }
14043   {
14044     char device[] = "/dev/sda1";
14045     device[5] = devchar;
14046     char mountpoint[] = "/";
14047     int r;
14048     suppress_error = 0;
14049     r = guestfs_mount (g, device, mountpoint);
14050     if (r == -1)
14051       return -1;
14052   }
14053   /* TestOutputList for read_lines (0) */
14054   {
14055     char path[] = "/new";
14056     char content[] = "line1\r\nline2\nline3";
14057     int r;
14058     suppress_error = 0;
14059     r = guestfs_write_file (g, path, content, 0);
14060     if (r == -1)
14061       return -1;
14062   }
14063   {
14064     char path[] = "/new";
14065     char **r;
14066     int i;
14067     suppress_error = 0;
14068     r = guestfs_read_lines (g, path);
14069     if (r == NULL)
14070       return -1;
14071     if (!r[0]) {
14072       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14073       print_strings (r);
14074       return -1;
14075     }
14076     {
14077       char expected[] = "line1";
14078       if (strcmp (r[0], expected) != 0) {
14079         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14080         return -1;
14081       }
14082     }
14083     if (!r[1]) {
14084       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14085       print_strings (r);
14086       return -1;
14087     }
14088     {
14089       char expected[] = "line2";
14090       if (strcmp (r[1], expected) != 0) {
14091         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14092         return -1;
14093       }
14094     }
14095     if (!r[2]) {
14096       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14097       print_strings (r);
14098       return -1;
14099     }
14100     {
14101       char expected[] = "line3";
14102       if (strcmp (r[2], expected) != 0) {
14103         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14104         return -1;
14105       }
14106     }
14107     if (r[3] != NULL) {
14108       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14109       print_strings (r);
14110       return -1;
14111     }
14112     for (i = 0; r[i] != NULL; ++i)
14113       free (r[i]);
14114     free (r);
14115   }
14116   return 0;
14117 }
14118
14119 static int test_read_lines_1_skip (void)
14120 {
14121   const char *str;
14122
14123   str = getenv ("SKIP_TEST_READ_LINES_1");
14124   if (str && strcmp (str, "1") == 0) return 1;
14125   str = getenv ("SKIP_TEST_READ_LINES");
14126   if (str && strcmp (str, "1") == 0) return 1;
14127   return 0;
14128 }
14129
14130 static int test_read_lines_1 (void)
14131 {
14132   if (test_read_lines_1_skip ()) {
14133     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14134     return 0;
14135   }
14136
14137   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14138   {
14139     char device[] = "/dev/sda";
14140     device[5] = devchar;
14141     int r;
14142     suppress_error = 0;
14143     r = guestfs_blockdev_setrw (g, device);
14144     if (r == -1)
14145       return -1;
14146   }
14147   {
14148     int r;
14149     suppress_error = 0;
14150     r = guestfs_umount_all (g);
14151     if (r == -1)
14152       return -1;
14153   }
14154   {
14155     int r;
14156     suppress_error = 0;
14157     r = guestfs_lvm_remove_all (g);
14158     if (r == -1)
14159       return -1;
14160   }
14161   {
14162     char device[] = "/dev/sda";
14163     device[5] = devchar;
14164     char lines_0[] = ",";
14165     char *lines[] = {
14166       lines_0,
14167       NULL
14168     };
14169     int r;
14170     suppress_error = 0;
14171     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14172     if (r == -1)
14173       return -1;
14174   }
14175   {
14176     char fstype[] = "ext2";
14177     char device[] = "/dev/sda1";
14178     device[5] = devchar;
14179     int r;
14180     suppress_error = 0;
14181     r = guestfs_mkfs (g, fstype, device);
14182     if (r == -1)
14183       return -1;
14184   }
14185   {
14186     char device[] = "/dev/sda1";
14187     device[5] = devchar;
14188     char mountpoint[] = "/";
14189     int r;
14190     suppress_error = 0;
14191     r = guestfs_mount (g, device, mountpoint);
14192     if (r == -1)
14193       return -1;
14194   }
14195   /* TestOutputList for read_lines (1) */
14196   {
14197     char path[] = "/new";
14198     char content[] = "";
14199     int r;
14200     suppress_error = 0;
14201     r = guestfs_write_file (g, path, content, 0);
14202     if (r == -1)
14203       return -1;
14204   }
14205   {
14206     char path[] = "/new";
14207     char **r;
14208     int i;
14209     suppress_error = 0;
14210     r = guestfs_read_lines (g, path);
14211     if (r == NULL)
14212       return -1;
14213     if (r[0] != NULL) {
14214       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14215       print_strings (r);
14216       return -1;
14217     }
14218     for (i = 0; r[i] != NULL; ++i)
14219       free (r[i]);
14220     free (r);
14221   }
14222   return 0;
14223 }
14224
14225 static int test_lvs_0_skip (void)
14226 {
14227   const char *str;
14228
14229   str = getenv ("SKIP_TEST_LVS_0");
14230   if (str && strcmp (str, "1") == 0) return 1;
14231   str = getenv ("SKIP_TEST_LVS");
14232   if (str && strcmp (str, "1") == 0) return 1;
14233   return 0;
14234 }
14235
14236 static int test_lvs_0 (void)
14237 {
14238   if (test_lvs_0_skip ()) {
14239     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14240     return 0;
14241   }
14242
14243   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14244   {
14245     char device[] = "/dev/sda";
14246     device[5] = devchar;
14247     int r;
14248     suppress_error = 0;
14249     r = guestfs_blockdev_setrw (g, device);
14250     if (r == -1)
14251       return -1;
14252   }
14253   {
14254     int r;
14255     suppress_error = 0;
14256     r = guestfs_umount_all (g);
14257     if (r == -1)
14258       return -1;
14259   }
14260   {
14261     int r;
14262     suppress_error = 0;
14263     r = guestfs_lvm_remove_all (g);
14264     if (r == -1)
14265       return -1;
14266   }
14267   {
14268     char device[] = "/dev/sda";
14269     device[5] = devchar;
14270     char lines_0[] = ",";
14271     char *lines[] = {
14272       lines_0,
14273       NULL
14274     };
14275     int r;
14276     suppress_error = 0;
14277     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14278     if (r == -1)
14279       return -1;
14280   }
14281   {
14282     char device[] = "/dev/sda1";
14283     device[5] = devchar;
14284     int r;
14285     suppress_error = 0;
14286     r = guestfs_pvcreate (g, device);
14287     if (r == -1)
14288       return -1;
14289   }
14290   {
14291     char volgroup[] = "VG";
14292     char physvols_0[] = "/dev/sda1";
14293     physvols_0[5] = devchar;
14294     char *physvols[] = {
14295       physvols_0,
14296       NULL
14297     };
14298     int r;
14299     suppress_error = 0;
14300     r = guestfs_vgcreate (g, volgroup, physvols);
14301     if (r == -1)
14302       return -1;
14303   }
14304   {
14305     char logvol[] = "LV";
14306     char volgroup[] = "VG";
14307     int r;
14308     suppress_error = 0;
14309     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14310     if (r == -1)
14311       return -1;
14312   }
14313   {
14314     char fstype[] = "ext2";
14315     char device[] = "/dev/VG/LV";
14316     int r;
14317     suppress_error = 0;
14318     r = guestfs_mkfs (g, fstype, device);
14319     if (r == -1)
14320       return -1;
14321   }
14322   {
14323     char device[] = "/dev/VG/LV";
14324     char mountpoint[] = "/";
14325     int r;
14326     suppress_error = 0;
14327     r = guestfs_mount (g, device, mountpoint);
14328     if (r == -1)
14329       return -1;
14330   }
14331   /* TestOutputList for lvs (0) */
14332   {
14333     char **r;
14334     int i;
14335     suppress_error = 0;
14336     r = guestfs_lvs (g);
14337     if (r == NULL)
14338       return -1;
14339     if (!r[0]) {
14340       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14341       print_strings (r);
14342       return -1;
14343     }
14344     {
14345       char expected[] = "/dev/VG/LV";
14346       if (strcmp (r[0], expected) != 0) {
14347         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14348         return -1;
14349       }
14350     }
14351     if (r[1] != NULL) {
14352       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14353       print_strings (r);
14354       return -1;
14355     }
14356     for (i = 0; r[i] != NULL; ++i)
14357       free (r[i]);
14358     free (r);
14359   }
14360   return 0;
14361 }
14362
14363 static int test_lvs_1_skip (void)
14364 {
14365   const char *str;
14366
14367   str = getenv ("SKIP_TEST_LVS_1");
14368   if (str && strcmp (str, "1") == 0) return 1;
14369   str = getenv ("SKIP_TEST_LVS");
14370   if (str && strcmp (str, "1") == 0) return 1;
14371   return 0;
14372 }
14373
14374 static int test_lvs_1 (void)
14375 {
14376   if (test_lvs_1_skip ()) {
14377     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14378     return 0;
14379   }
14380
14381   /* InitNone|InitEmpty for test_lvs_1 */
14382   {
14383     char device[] = "/dev/sda";
14384     device[5] = devchar;
14385     int r;
14386     suppress_error = 0;
14387     r = guestfs_blockdev_setrw (g, device);
14388     if (r == -1)
14389       return -1;
14390   }
14391   {
14392     int r;
14393     suppress_error = 0;
14394     r = guestfs_umount_all (g);
14395     if (r == -1)
14396       return -1;
14397   }
14398   {
14399     int r;
14400     suppress_error = 0;
14401     r = guestfs_lvm_remove_all (g);
14402     if (r == -1)
14403       return -1;
14404   }
14405   /* TestOutputList for lvs (1) */
14406   {
14407     char device[] = "/dev/sda";
14408     device[5] = devchar;
14409     char lines_0[] = ",10";
14410     char lines_1[] = ",20";
14411     char lines_2[] = ",";
14412     char *lines[] = {
14413       lines_0,
14414       lines_1,
14415       lines_2,
14416       NULL
14417     };
14418     int r;
14419     suppress_error = 0;
14420     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14421     if (r == -1)
14422       return -1;
14423   }
14424   {
14425     char device[] = "/dev/sda1";
14426     device[5] = devchar;
14427     int r;
14428     suppress_error = 0;
14429     r = guestfs_pvcreate (g, device);
14430     if (r == -1)
14431       return -1;
14432   }
14433   {
14434     char device[] = "/dev/sda2";
14435     device[5] = devchar;
14436     int r;
14437     suppress_error = 0;
14438     r = guestfs_pvcreate (g, device);
14439     if (r == -1)
14440       return -1;
14441   }
14442   {
14443     char device[] = "/dev/sda3";
14444     device[5] = devchar;
14445     int r;
14446     suppress_error = 0;
14447     r = guestfs_pvcreate (g, device);
14448     if (r == -1)
14449       return -1;
14450   }
14451   {
14452     char volgroup[] = "VG1";
14453     char physvols_0[] = "/dev/sda1";
14454     physvols_0[5] = devchar;
14455     char physvols_1[] = "/dev/sda2";
14456     physvols_1[5] = devchar;
14457     char *physvols[] = {
14458       physvols_0,
14459       physvols_1,
14460       NULL
14461     };
14462     int r;
14463     suppress_error = 0;
14464     r = guestfs_vgcreate (g, volgroup, physvols);
14465     if (r == -1)
14466       return -1;
14467   }
14468   {
14469     char volgroup[] = "VG2";
14470     char physvols_0[] = "/dev/sda3";
14471     physvols_0[5] = devchar;
14472     char *physvols[] = {
14473       physvols_0,
14474       NULL
14475     };
14476     int r;
14477     suppress_error = 0;
14478     r = guestfs_vgcreate (g, volgroup, physvols);
14479     if (r == -1)
14480       return -1;
14481   }
14482   {
14483     char logvol[] = "LV1";
14484     char volgroup[] = "VG1";
14485     int r;
14486     suppress_error = 0;
14487     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14488     if (r == -1)
14489       return -1;
14490   }
14491   {
14492     char logvol[] = "LV2";
14493     char volgroup[] = "VG1";
14494     int r;
14495     suppress_error = 0;
14496     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14497     if (r == -1)
14498       return -1;
14499   }
14500   {
14501     char logvol[] = "LV3";
14502     char volgroup[] = "VG2";
14503     int r;
14504     suppress_error = 0;
14505     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14506     if (r == -1)
14507       return -1;
14508   }
14509   {
14510     char **r;
14511     int i;
14512     suppress_error = 0;
14513     r = guestfs_lvs (g);
14514     if (r == NULL)
14515       return -1;
14516     if (!r[0]) {
14517       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14518       print_strings (r);
14519       return -1;
14520     }
14521     {
14522       char expected[] = "/dev/VG1/LV1";
14523       if (strcmp (r[0], expected) != 0) {
14524         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14525         return -1;
14526       }
14527     }
14528     if (!r[1]) {
14529       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14530       print_strings (r);
14531       return -1;
14532     }
14533     {
14534       char expected[] = "/dev/VG1/LV2";
14535       if (strcmp (r[1], expected) != 0) {
14536         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14537         return -1;
14538       }
14539     }
14540     if (!r[2]) {
14541       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14542       print_strings (r);
14543       return -1;
14544     }
14545     {
14546       char expected[] = "/dev/VG2/LV3";
14547       if (strcmp (r[2], expected) != 0) {
14548         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14549         return -1;
14550       }
14551     }
14552     if (r[3] != NULL) {
14553       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14554       print_strings (r);
14555       return -1;
14556     }
14557     for (i = 0; r[i] != NULL; ++i)
14558       free (r[i]);
14559     free (r);
14560   }
14561   return 0;
14562 }
14563
14564 static int test_vgs_0_skip (void)
14565 {
14566   const char *str;
14567
14568   str = getenv ("SKIP_TEST_VGS_0");
14569   if (str && strcmp (str, "1") == 0) return 1;
14570   str = getenv ("SKIP_TEST_VGS");
14571   if (str && strcmp (str, "1") == 0) return 1;
14572   return 0;
14573 }
14574
14575 static int test_vgs_0 (void)
14576 {
14577   if (test_vgs_0_skip ()) {
14578     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14579     return 0;
14580   }
14581
14582   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14583   {
14584     char device[] = "/dev/sda";
14585     device[5] = devchar;
14586     int r;
14587     suppress_error = 0;
14588     r = guestfs_blockdev_setrw (g, device);
14589     if (r == -1)
14590       return -1;
14591   }
14592   {
14593     int r;
14594     suppress_error = 0;
14595     r = guestfs_umount_all (g);
14596     if (r == -1)
14597       return -1;
14598   }
14599   {
14600     int r;
14601     suppress_error = 0;
14602     r = guestfs_lvm_remove_all (g);
14603     if (r == -1)
14604       return -1;
14605   }
14606   {
14607     char device[] = "/dev/sda";
14608     device[5] = devchar;
14609     char lines_0[] = ",";
14610     char *lines[] = {
14611       lines_0,
14612       NULL
14613     };
14614     int r;
14615     suppress_error = 0;
14616     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14617     if (r == -1)
14618       return -1;
14619   }
14620   {
14621     char device[] = "/dev/sda1";
14622     device[5] = devchar;
14623     int r;
14624     suppress_error = 0;
14625     r = guestfs_pvcreate (g, device);
14626     if (r == -1)
14627       return -1;
14628   }
14629   {
14630     char volgroup[] = "VG";
14631     char physvols_0[] = "/dev/sda1";
14632     physvols_0[5] = devchar;
14633     char *physvols[] = {
14634       physvols_0,
14635       NULL
14636     };
14637     int r;
14638     suppress_error = 0;
14639     r = guestfs_vgcreate (g, volgroup, physvols);
14640     if (r == -1)
14641       return -1;
14642   }
14643   {
14644     char logvol[] = "LV";
14645     char volgroup[] = "VG";
14646     int r;
14647     suppress_error = 0;
14648     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14649     if (r == -1)
14650       return -1;
14651   }
14652   {
14653     char fstype[] = "ext2";
14654     char device[] = "/dev/VG/LV";
14655     int r;
14656     suppress_error = 0;
14657     r = guestfs_mkfs (g, fstype, device);
14658     if (r == -1)
14659       return -1;
14660   }
14661   {
14662     char device[] = "/dev/VG/LV";
14663     char mountpoint[] = "/";
14664     int r;
14665     suppress_error = 0;
14666     r = guestfs_mount (g, device, mountpoint);
14667     if (r == -1)
14668       return -1;
14669   }
14670   /* TestOutputList for vgs (0) */
14671   {
14672     char **r;
14673     int i;
14674     suppress_error = 0;
14675     r = guestfs_vgs (g);
14676     if (r == NULL)
14677       return -1;
14678     if (!r[0]) {
14679       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14680       print_strings (r);
14681       return -1;
14682     }
14683     {
14684       char expected[] = "VG";
14685       if (strcmp (r[0], expected) != 0) {
14686         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14687         return -1;
14688       }
14689     }
14690     if (r[1] != NULL) {
14691       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14692       print_strings (r);
14693       return -1;
14694     }
14695     for (i = 0; r[i] != NULL; ++i)
14696       free (r[i]);
14697     free (r);
14698   }
14699   return 0;
14700 }
14701
14702 static int test_vgs_1_skip (void)
14703 {
14704   const char *str;
14705
14706   str = getenv ("SKIP_TEST_VGS_1");
14707   if (str && strcmp (str, "1") == 0) return 1;
14708   str = getenv ("SKIP_TEST_VGS");
14709   if (str && strcmp (str, "1") == 0) return 1;
14710   return 0;
14711 }
14712
14713 static int test_vgs_1 (void)
14714 {
14715   if (test_vgs_1_skip ()) {
14716     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14717     return 0;
14718   }
14719
14720   /* InitNone|InitEmpty for test_vgs_1 */
14721   {
14722     char device[] = "/dev/sda";
14723     device[5] = devchar;
14724     int r;
14725     suppress_error = 0;
14726     r = guestfs_blockdev_setrw (g, device);
14727     if (r == -1)
14728       return -1;
14729   }
14730   {
14731     int r;
14732     suppress_error = 0;
14733     r = guestfs_umount_all (g);
14734     if (r == -1)
14735       return -1;
14736   }
14737   {
14738     int r;
14739     suppress_error = 0;
14740     r = guestfs_lvm_remove_all (g);
14741     if (r == -1)
14742       return -1;
14743   }
14744   /* TestOutputList for vgs (1) */
14745   {
14746     char device[] = "/dev/sda";
14747     device[5] = devchar;
14748     char lines_0[] = ",10";
14749     char lines_1[] = ",20";
14750     char lines_2[] = ",";
14751     char *lines[] = {
14752       lines_0,
14753       lines_1,
14754       lines_2,
14755       NULL
14756     };
14757     int r;
14758     suppress_error = 0;
14759     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14760     if (r == -1)
14761       return -1;
14762   }
14763   {
14764     char device[] = "/dev/sda1";
14765     device[5] = devchar;
14766     int r;
14767     suppress_error = 0;
14768     r = guestfs_pvcreate (g, device);
14769     if (r == -1)
14770       return -1;
14771   }
14772   {
14773     char device[] = "/dev/sda2";
14774     device[5] = devchar;
14775     int r;
14776     suppress_error = 0;
14777     r = guestfs_pvcreate (g, device);
14778     if (r == -1)
14779       return -1;
14780   }
14781   {
14782     char device[] = "/dev/sda3";
14783     device[5] = devchar;
14784     int r;
14785     suppress_error = 0;
14786     r = guestfs_pvcreate (g, device);
14787     if (r == -1)
14788       return -1;
14789   }
14790   {
14791     char volgroup[] = "VG1";
14792     char physvols_0[] = "/dev/sda1";
14793     physvols_0[5] = devchar;
14794     char physvols_1[] = "/dev/sda2";
14795     physvols_1[5] = devchar;
14796     char *physvols[] = {
14797       physvols_0,
14798       physvols_1,
14799       NULL
14800     };
14801     int r;
14802     suppress_error = 0;
14803     r = guestfs_vgcreate (g, volgroup, physvols);
14804     if (r == -1)
14805       return -1;
14806   }
14807   {
14808     char volgroup[] = "VG2";
14809     char physvols_0[] = "/dev/sda3";
14810     physvols_0[5] = devchar;
14811     char *physvols[] = {
14812       physvols_0,
14813       NULL
14814     };
14815     int r;
14816     suppress_error = 0;
14817     r = guestfs_vgcreate (g, volgroup, physvols);
14818     if (r == -1)
14819       return -1;
14820   }
14821   {
14822     char **r;
14823     int i;
14824     suppress_error = 0;
14825     r = guestfs_vgs (g);
14826     if (r == NULL)
14827       return -1;
14828     if (!r[0]) {
14829       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14830       print_strings (r);
14831       return -1;
14832     }
14833     {
14834       char expected[] = "VG1";
14835       if (strcmp (r[0], expected) != 0) {
14836         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14837         return -1;
14838       }
14839     }
14840     if (!r[1]) {
14841       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14842       print_strings (r);
14843       return -1;
14844     }
14845     {
14846       char expected[] = "VG2";
14847       if (strcmp (r[1], expected) != 0) {
14848         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14849         return -1;
14850       }
14851     }
14852     if (r[2] != NULL) {
14853       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14854       print_strings (r);
14855       return -1;
14856     }
14857     for (i = 0; r[i] != NULL; ++i)
14858       free (r[i]);
14859     free (r);
14860   }
14861   return 0;
14862 }
14863
14864 static int test_pvs_0_skip (void)
14865 {
14866   const char *str;
14867
14868   str = getenv ("SKIP_TEST_PVS_0");
14869   if (str && strcmp (str, "1") == 0) return 1;
14870   str = getenv ("SKIP_TEST_PVS");
14871   if (str && strcmp (str, "1") == 0) return 1;
14872   return 0;
14873 }
14874
14875 static int test_pvs_0 (void)
14876 {
14877   if (test_pvs_0_skip ()) {
14878     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14879     return 0;
14880   }
14881
14882   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14883   {
14884     char device[] = "/dev/sda";
14885     device[5] = devchar;
14886     int r;
14887     suppress_error = 0;
14888     r = guestfs_blockdev_setrw (g, device);
14889     if (r == -1)
14890       return -1;
14891   }
14892   {
14893     int r;
14894     suppress_error = 0;
14895     r = guestfs_umount_all (g);
14896     if (r == -1)
14897       return -1;
14898   }
14899   {
14900     int r;
14901     suppress_error = 0;
14902     r = guestfs_lvm_remove_all (g);
14903     if (r == -1)
14904       return -1;
14905   }
14906   {
14907     char device[] = "/dev/sda";
14908     device[5] = devchar;
14909     char lines_0[] = ",";
14910     char *lines[] = {
14911       lines_0,
14912       NULL
14913     };
14914     int r;
14915     suppress_error = 0;
14916     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14917     if (r == -1)
14918       return -1;
14919   }
14920   {
14921     char device[] = "/dev/sda1";
14922     device[5] = devchar;
14923     int r;
14924     suppress_error = 0;
14925     r = guestfs_pvcreate (g, device);
14926     if (r == -1)
14927       return -1;
14928   }
14929   {
14930     char volgroup[] = "VG";
14931     char physvols_0[] = "/dev/sda1";
14932     physvols_0[5] = devchar;
14933     char *physvols[] = {
14934       physvols_0,
14935       NULL
14936     };
14937     int r;
14938     suppress_error = 0;
14939     r = guestfs_vgcreate (g, volgroup, physvols);
14940     if (r == -1)
14941       return -1;
14942   }
14943   {
14944     char logvol[] = "LV";
14945     char volgroup[] = "VG";
14946     int r;
14947     suppress_error = 0;
14948     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14949     if (r == -1)
14950       return -1;
14951   }
14952   {
14953     char fstype[] = "ext2";
14954     char device[] = "/dev/VG/LV";
14955     int r;
14956     suppress_error = 0;
14957     r = guestfs_mkfs (g, fstype, device);
14958     if (r == -1)
14959       return -1;
14960   }
14961   {
14962     char device[] = "/dev/VG/LV";
14963     char mountpoint[] = "/";
14964     int r;
14965     suppress_error = 0;
14966     r = guestfs_mount (g, device, mountpoint);
14967     if (r == -1)
14968       return -1;
14969   }
14970   /* TestOutputList for pvs (0) */
14971   {
14972     char **r;
14973     int i;
14974     suppress_error = 0;
14975     r = guestfs_pvs (g);
14976     if (r == NULL)
14977       return -1;
14978     if (!r[0]) {
14979       fprintf (stderr, "test_pvs_0: short list returned from command\n");
14980       print_strings (r);
14981       return -1;
14982     }
14983     {
14984       char expected[] = "/dev/sda1";
14985       expected[5] = devchar;
14986       if (strcmp (r[0], expected) != 0) {
14987         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14988         return -1;
14989       }
14990     }
14991     if (r[1] != NULL) {
14992       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14993       print_strings (r);
14994       return -1;
14995     }
14996     for (i = 0; r[i] != NULL; ++i)
14997       free (r[i]);
14998     free (r);
14999   }
15000   return 0;
15001 }
15002
15003 static int test_pvs_1_skip (void)
15004 {
15005   const char *str;
15006
15007   str = getenv ("SKIP_TEST_PVS_1");
15008   if (str && strcmp (str, "1") == 0) return 1;
15009   str = getenv ("SKIP_TEST_PVS");
15010   if (str && strcmp (str, "1") == 0) return 1;
15011   return 0;
15012 }
15013
15014 static int test_pvs_1 (void)
15015 {
15016   if (test_pvs_1_skip ()) {
15017     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15018     return 0;
15019   }
15020
15021   /* InitNone|InitEmpty for test_pvs_1 */
15022   {
15023     char device[] = "/dev/sda";
15024     device[5] = devchar;
15025     int r;
15026     suppress_error = 0;
15027     r = guestfs_blockdev_setrw (g, device);
15028     if (r == -1)
15029       return -1;
15030   }
15031   {
15032     int r;
15033     suppress_error = 0;
15034     r = guestfs_umount_all (g);
15035     if (r == -1)
15036       return -1;
15037   }
15038   {
15039     int r;
15040     suppress_error = 0;
15041     r = guestfs_lvm_remove_all (g);
15042     if (r == -1)
15043       return -1;
15044   }
15045   /* TestOutputList for pvs (1) */
15046   {
15047     char device[] = "/dev/sda";
15048     device[5] = devchar;
15049     char lines_0[] = ",10";
15050     char lines_1[] = ",20";
15051     char lines_2[] = ",";
15052     char *lines[] = {
15053       lines_0,
15054       lines_1,
15055       lines_2,
15056       NULL
15057     };
15058     int r;
15059     suppress_error = 0;
15060     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15061     if (r == -1)
15062       return -1;
15063   }
15064   {
15065     char device[] = "/dev/sda1";
15066     device[5] = devchar;
15067     int r;
15068     suppress_error = 0;
15069     r = guestfs_pvcreate (g, device);
15070     if (r == -1)
15071       return -1;
15072   }
15073   {
15074     char device[] = "/dev/sda2";
15075     device[5] = devchar;
15076     int r;
15077     suppress_error = 0;
15078     r = guestfs_pvcreate (g, device);
15079     if (r == -1)
15080       return -1;
15081   }
15082   {
15083     char device[] = "/dev/sda3";
15084     device[5] = devchar;
15085     int r;
15086     suppress_error = 0;
15087     r = guestfs_pvcreate (g, device);
15088     if (r == -1)
15089       return -1;
15090   }
15091   {
15092     char **r;
15093     int i;
15094     suppress_error = 0;
15095     r = guestfs_pvs (g);
15096     if (r == NULL)
15097       return -1;
15098     if (!r[0]) {
15099       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15100       print_strings (r);
15101       return -1;
15102     }
15103     {
15104       char expected[] = "/dev/sda1";
15105       expected[5] = devchar;
15106       if (strcmp (r[0], expected) != 0) {
15107         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15108         return -1;
15109       }
15110     }
15111     if (!r[1]) {
15112       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15113       print_strings (r);
15114       return -1;
15115     }
15116     {
15117       char expected[] = "/dev/sda2";
15118       expected[5] = devchar;
15119       if (strcmp (r[1], expected) != 0) {
15120         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15121         return -1;
15122       }
15123     }
15124     if (!r[2]) {
15125       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15126       print_strings (r);
15127       return -1;
15128     }
15129     {
15130       char expected[] = "/dev/sda3";
15131       expected[5] = devchar;
15132       if (strcmp (r[2], expected) != 0) {
15133         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15134         return -1;
15135       }
15136     }
15137     if (r[3] != NULL) {
15138       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15139       print_strings (r);
15140       return -1;
15141     }
15142     for (i = 0; r[i] != NULL; ++i)
15143       free (r[i]);
15144     free (r);
15145   }
15146   return 0;
15147 }
15148
15149 static int test_list_partitions_0_skip (void)
15150 {
15151   const char *str;
15152
15153   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15154   if (str && strcmp (str, "1") == 0) return 1;
15155   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15156   if (str && strcmp (str, "1") == 0) return 1;
15157   return 0;
15158 }
15159
15160 static int test_list_partitions_0 (void)
15161 {
15162   if (test_list_partitions_0_skip ()) {
15163     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15164     return 0;
15165   }
15166
15167   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15168   {
15169     char device[] = "/dev/sda";
15170     device[5] = devchar;
15171     int r;
15172     suppress_error = 0;
15173     r = guestfs_blockdev_setrw (g, device);
15174     if (r == -1)
15175       return -1;
15176   }
15177   {
15178     int r;
15179     suppress_error = 0;
15180     r = guestfs_umount_all (g);
15181     if (r == -1)
15182       return -1;
15183   }
15184   {
15185     int r;
15186     suppress_error = 0;
15187     r = guestfs_lvm_remove_all (g);
15188     if (r == -1)
15189       return -1;
15190   }
15191   {
15192     char device[] = "/dev/sda";
15193     device[5] = devchar;
15194     char lines_0[] = ",";
15195     char *lines[] = {
15196       lines_0,
15197       NULL
15198     };
15199     int r;
15200     suppress_error = 0;
15201     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15202     if (r == -1)
15203       return -1;
15204   }
15205   {
15206     char fstype[] = "ext2";
15207     char device[] = "/dev/sda1";
15208     device[5] = devchar;
15209     int r;
15210     suppress_error = 0;
15211     r = guestfs_mkfs (g, fstype, device);
15212     if (r == -1)
15213       return -1;
15214   }
15215   {
15216     char device[] = "/dev/sda1";
15217     device[5] = devchar;
15218     char mountpoint[] = "/";
15219     int r;
15220     suppress_error = 0;
15221     r = guestfs_mount (g, device, mountpoint);
15222     if (r == -1)
15223       return -1;
15224   }
15225   /* TestOutputList for list_partitions (0) */
15226   {
15227     char **r;
15228     int i;
15229     suppress_error = 0;
15230     r = guestfs_list_partitions (g);
15231     if (r == NULL)
15232       return -1;
15233     if (!r[0]) {
15234       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15235       print_strings (r);
15236       return -1;
15237     }
15238     {
15239       char expected[] = "/dev/sda1";
15240       expected[5] = devchar;
15241       if (strcmp (r[0], expected) != 0) {
15242         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15243         return -1;
15244       }
15245     }
15246     if (r[1] != NULL) {
15247       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15248       print_strings (r);
15249       return -1;
15250     }
15251     for (i = 0; r[i] != NULL; ++i)
15252       free (r[i]);
15253     free (r);
15254   }
15255   return 0;
15256 }
15257
15258 static int test_list_partitions_1_skip (void)
15259 {
15260   const char *str;
15261
15262   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15263   if (str && strcmp (str, "1") == 0) return 1;
15264   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15265   if (str && strcmp (str, "1") == 0) return 1;
15266   return 0;
15267 }
15268
15269 static int test_list_partitions_1 (void)
15270 {
15271   if (test_list_partitions_1_skip ()) {
15272     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15273     return 0;
15274   }
15275
15276   /* InitNone|InitEmpty for test_list_partitions_1 */
15277   {
15278     char device[] = "/dev/sda";
15279     device[5] = devchar;
15280     int r;
15281     suppress_error = 0;
15282     r = guestfs_blockdev_setrw (g, device);
15283     if (r == -1)
15284       return -1;
15285   }
15286   {
15287     int r;
15288     suppress_error = 0;
15289     r = guestfs_umount_all (g);
15290     if (r == -1)
15291       return -1;
15292   }
15293   {
15294     int r;
15295     suppress_error = 0;
15296     r = guestfs_lvm_remove_all (g);
15297     if (r == -1)
15298       return -1;
15299   }
15300   /* TestOutputList for list_partitions (1) */
15301   {
15302     char device[] = "/dev/sda";
15303     device[5] = devchar;
15304     char lines_0[] = ",10";
15305     char lines_1[] = ",20";
15306     char lines_2[] = ",";
15307     char *lines[] = {
15308       lines_0,
15309       lines_1,
15310       lines_2,
15311       NULL
15312     };
15313     int r;
15314     suppress_error = 0;
15315     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15316     if (r == -1)
15317       return -1;
15318   }
15319   {
15320     char **r;
15321     int i;
15322     suppress_error = 0;
15323     r = guestfs_list_partitions (g);
15324     if (r == NULL)
15325       return -1;
15326     if (!r[0]) {
15327       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15328       print_strings (r);
15329       return -1;
15330     }
15331     {
15332       char expected[] = "/dev/sda1";
15333       expected[5] = devchar;
15334       if (strcmp (r[0], expected) != 0) {
15335         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15336         return -1;
15337       }
15338     }
15339     if (!r[1]) {
15340       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15341       print_strings (r);
15342       return -1;
15343     }
15344     {
15345       char expected[] = "/dev/sda2";
15346       expected[5] = devchar;
15347       if (strcmp (r[1], expected) != 0) {
15348         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15349         return -1;
15350       }
15351     }
15352     if (!r[2]) {
15353       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15354       print_strings (r);
15355       return -1;
15356     }
15357     {
15358       char expected[] = "/dev/sda3";
15359       expected[5] = devchar;
15360       if (strcmp (r[2], expected) != 0) {
15361         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15362         return -1;
15363       }
15364     }
15365     if (r[3] != NULL) {
15366       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15367       print_strings (r);
15368       return -1;
15369     }
15370     for (i = 0; r[i] != NULL; ++i)
15371       free (r[i]);
15372     free (r);
15373   }
15374   return 0;
15375 }
15376
15377 static int test_list_devices_0_skip (void)
15378 {
15379   const char *str;
15380
15381   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15382   if (str && strcmp (str, "1") == 0) return 1;
15383   str = getenv ("SKIP_TEST_LIST_DEVICES");
15384   if (str && strcmp (str, "1") == 0) return 1;
15385   return 0;
15386 }
15387
15388 static int test_list_devices_0 (void)
15389 {
15390   if (test_list_devices_0_skip ()) {
15391     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15392     return 0;
15393   }
15394
15395   /* InitNone|InitEmpty for test_list_devices_0 */
15396   {
15397     char device[] = "/dev/sda";
15398     device[5] = devchar;
15399     int r;
15400     suppress_error = 0;
15401     r = guestfs_blockdev_setrw (g, device);
15402     if (r == -1)
15403       return -1;
15404   }
15405   {
15406     int r;
15407     suppress_error = 0;
15408     r = guestfs_umount_all (g);
15409     if (r == -1)
15410       return -1;
15411   }
15412   {
15413     int r;
15414     suppress_error = 0;
15415     r = guestfs_lvm_remove_all (g);
15416     if (r == -1)
15417       return -1;
15418   }
15419   /* TestOutputList for list_devices (0) */
15420   {
15421     char **r;
15422     int i;
15423     suppress_error = 0;
15424     r = guestfs_list_devices (g);
15425     if (r == NULL)
15426       return -1;
15427     if (!r[0]) {
15428       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15429       print_strings (r);
15430       return -1;
15431     }
15432     {
15433       char expected[] = "/dev/sda";
15434       expected[5] = devchar;
15435       if (strcmp (r[0], expected) != 0) {
15436         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15437         return -1;
15438       }
15439     }
15440     if (!r[1]) {
15441       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15442       print_strings (r);
15443       return -1;
15444     }
15445     {
15446       char expected[] = "/dev/sdb";
15447       expected[5] = devchar;
15448       if (strcmp (r[1], expected) != 0) {
15449         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15450         return -1;
15451       }
15452     }
15453     if (!r[2]) {
15454       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15455       print_strings (r);
15456       return -1;
15457     }
15458     {
15459       char expected[] = "/dev/sdc";
15460       expected[5] = devchar;
15461       if (strcmp (r[2], expected) != 0) {
15462         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15463         return -1;
15464       }
15465     }
15466     if (!r[3]) {
15467       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15468       print_strings (r);
15469       return -1;
15470     }
15471     {
15472       char expected[] = "/dev/sdd";
15473       expected[5] = devchar;
15474       if (strcmp (r[3], expected) != 0) {
15475         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15476         return -1;
15477       }
15478     }
15479     if (r[4] != NULL) {
15480       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15481       print_strings (r);
15482       return -1;
15483     }
15484     for (i = 0; r[i] != NULL; ++i)
15485       free (r[i]);
15486     free (r);
15487   }
15488   return 0;
15489 }
15490
15491 static int test_ls_0_skip (void)
15492 {
15493   const char *str;
15494
15495   str = getenv ("SKIP_TEST_LS_0");
15496   if (str && strcmp (str, "1") == 0) return 1;
15497   str = getenv ("SKIP_TEST_LS");
15498   if (str && strcmp (str, "1") == 0) return 1;
15499   return 0;
15500 }
15501
15502 static int test_ls_0 (void)
15503 {
15504   if (test_ls_0_skip ()) {
15505     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15506     return 0;
15507   }
15508
15509   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15510   {
15511     char device[] = "/dev/sda";
15512     device[5] = devchar;
15513     int r;
15514     suppress_error = 0;
15515     r = guestfs_blockdev_setrw (g, device);
15516     if (r == -1)
15517       return -1;
15518   }
15519   {
15520     int r;
15521     suppress_error = 0;
15522     r = guestfs_umount_all (g);
15523     if (r == -1)
15524       return -1;
15525   }
15526   {
15527     int r;
15528     suppress_error = 0;
15529     r = guestfs_lvm_remove_all (g);
15530     if (r == -1)
15531       return -1;
15532   }
15533   {
15534     char device[] = "/dev/sda";
15535     device[5] = devchar;
15536     char lines_0[] = ",";
15537     char *lines[] = {
15538       lines_0,
15539       NULL
15540     };
15541     int r;
15542     suppress_error = 0;
15543     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15544     if (r == -1)
15545       return -1;
15546   }
15547   {
15548     char fstype[] = "ext2";
15549     char device[] = "/dev/sda1";
15550     device[5] = devchar;
15551     int r;
15552     suppress_error = 0;
15553     r = guestfs_mkfs (g, fstype, device);
15554     if (r == -1)
15555       return -1;
15556   }
15557   {
15558     char device[] = "/dev/sda1";
15559     device[5] = devchar;
15560     char mountpoint[] = "/";
15561     int r;
15562     suppress_error = 0;
15563     r = guestfs_mount (g, device, mountpoint);
15564     if (r == -1)
15565       return -1;
15566   }
15567   /* TestOutputList for ls (0) */
15568   {
15569     char path[] = "/new";
15570     int r;
15571     suppress_error = 0;
15572     r = guestfs_touch (g, path);
15573     if (r == -1)
15574       return -1;
15575   }
15576   {
15577     char path[] = "/newer";
15578     int r;
15579     suppress_error = 0;
15580     r = guestfs_touch (g, path);
15581     if (r == -1)
15582       return -1;
15583   }
15584   {
15585     char path[] = "/newest";
15586     int r;
15587     suppress_error = 0;
15588     r = guestfs_touch (g, path);
15589     if (r == -1)
15590       return -1;
15591   }
15592   {
15593     char directory[] = "/";
15594     char **r;
15595     int i;
15596     suppress_error = 0;
15597     r = guestfs_ls (g, directory);
15598     if (r == NULL)
15599       return -1;
15600     if (!r[0]) {
15601       fprintf (stderr, "test_ls_0: short list returned from command\n");
15602       print_strings (r);
15603       return -1;
15604     }
15605     {
15606       char expected[] = "lost+found";
15607       if (strcmp (r[0], expected) != 0) {
15608         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15609         return -1;
15610       }
15611     }
15612     if (!r[1]) {
15613       fprintf (stderr, "test_ls_0: short list returned from command\n");
15614       print_strings (r);
15615       return -1;
15616     }
15617     {
15618       char expected[] = "new";
15619       if (strcmp (r[1], expected) != 0) {
15620         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15621         return -1;
15622       }
15623     }
15624     if (!r[2]) {
15625       fprintf (stderr, "test_ls_0: short list returned from command\n");
15626       print_strings (r);
15627       return -1;
15628     }
15629     {
15630       char expected[] = "newer";
15631       if (strcmp (r[2], expected) != 0) {
15632         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15633         return -1;
15634       }
15635     }
15636     if (!r[3]) {
15637       fprintf (stderr, "test_ls_0: short list returned from command\n");
15638       print_strings (r);
15639       return -1;
15640     }
15641     {
15642       char expected[] = "newest";
15643       if (strcmp (r[3], expected) != 0) {
15644         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15645         return -1;
15646       }
15647     }
15648     if (r[4] != NULL) {
15649       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15650       print_strings (r);
15651       return -1;
15652     }
15653     for (i = 0; r[i] != NULL; ++i)
15654       free (r[i]);
15655     free (r);
15656   }
15657   return 0;
15658 }
15659
15660 static int test_cat_0_skip (void)
15661 {
15662   const char *str;
15663
15664   str = getenv ("SKIP_TEST_CAT_0");
15665   if (str && strcmp (str, "1") == 0) return 1;
15666   str = getenv ("SKIP_TEST_CAT");
15667   if (str && strcmp (str, "1") == 0) return 1;
15668   return 0;
15669 }
15670
15671 static int test_cat_0 (void)
15672 {
15673   if (test_cat_0_skip ()) {
15674     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15675     return 0;
15676   }
15677
15678   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15679   {
15680     char device[] = "/dev/sda";
15681     device[5] = devchar;
15682     int r;
15683     suppress_error = 0;
15684     r = guestfs_blockdev_setrw (g, device);
15685     if (r == -1)
15686       return -1;
15687   }
15688   {
15689     int r;
15690     suppress_error = 0;
15691     r = guestfs_umount_all (g);
15692     if (r == -1)
15693       return -1;
15694   }
15695   {
15696     int r;
15697     suppress_error = 0;
15698     r = guestfs_lvm_remove_all (g);
15699     if (r == -1)
15700       return -1;
15701   }
15702   {
15703     char device[] = "/dev/sda";
15704     device[5] = devchar;
15705     char lines_0[] = ",";
15706     char *lines[] = {
15707       lines_0,
15708       NULL
15709     };
15710     int r;
15711     suppress_error = 0;
15712     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15713     if (r == -1)
15714       return -1;
15715   }
15716   {
15717     char fstype[] = "ext2";
15718     char device[] = "/dev/sda1";
15719     device[5] = devchar;
15720     int r;
15721     suppress_error = 0;
15722     r = guestfs_mkfs (g, fstype, device);
15723     if (r == -1)
15724       return -1;
15725   }
15726   {
15727     char device[] = "/dev/sda1";
15728     device[5] = devchar;
15729     char mountpoint[] = "/";
15730     int r;
15731     suppress_error = 0;
15732     r = guestfs_mount (g, device, mountpoint);
15733     if (r == -1)
15734       return -1;
15735   }
15736   /* TestOutput for cat (0) */
15737   char expected[] = "new file contents";
15738   {
15739     char path[] = "/new";
15740     char content[] = "new file contents";
15741     int r;
15742     suppress_error = 0;
15743     r = guestfs_write_file (g, path, content, 0);
15744     if (r == -1)
15745       return -1;
15746   }
15747   {
15748     char path[] = "/new";
15749     char *r;
15750     suppress_error = 0;
15751     r = guestfs_cat (g, path);
15752     if (r == NULL)
15753       return -1;
15754     if (strcmp (r, expected) != 0) {
15755       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15756       return -1;
15757     }
15758     free (r);
15759   }
15760   return 0;
15761 }
15762
15763 static int test_touch_0_skip (void)
15764 {
15765   const char *str;
15766
15767   str = getenv ("SKIP_TEST_TOUCH_0");
15768   if (str && strcmp (str, "1") == 0) return 1;
15769   str = getenv ("SKIP_TEST_TOUCH");
15770   if (str && strcmp (str, "1") == 0) return 1;
15771   return 0;
15772 }
15773
15774 static int test_touch_0 (void)
15775 {
15776   if (test_touch_0_skip ()) {
15777     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15778     return 0;
15779   }
15780
15781   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15782   {
15783     char device[] = "/dev/sda";
15784     device[5] = devchar;
15785     int r;
15786     suppress_error = 0;
15787     r = guestfs_blockdev_setrw (g, device);
15788     if (r == -1)
15789       return -1;
15790   }
15791   {
15792     int r;
15793     suppress_error = 0;
15794     r = guestfs_umount_all (g);
15795     if (r == -1)
15796       return -1;
15797   }
15798   {
15799     int r;
15800     suppress_error = 0;
15801     r = guestfs_lvm_remove_all (g);
15802     if (r == -1)
15803       return -1;
15804   }
15805   {
15806     char device[] = "/dev/sda";
15807     device[5] = devchar;
15808     char lines_0[] = ",";
15809     char *lines[] = {
15810       lines_0,
15811       NULL
15812     };
15813     int r;
15814     suppress_error = 0;
15815     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15816     if (r == -1)
15817       return -1;
15818   }
15819   {
15820     char fstype[] = "ext2";
15821     char device[] = "/dev/sda1";
15822     device[5] = devchar;
15823     int r;
15824     suppress_error = 0;
15825     r = guestfs_mkfs (g, fstype, device);
15826     if (r == -1)
15827       return -1;
15828   }
15829   {
15830     char device[] = "/dev/sda1";
15831     device[5] = devchar;
15832     char mountpoint[] = "/";
15833     int r;
15834     suppress_error = 0;
15835     r = guestfs_mount (g, device, mountpoint);
15836     if (r == -1)
15837       return -1;
15838   }
15839   /* TestOutputTrue for touch (0) */
15840   {
15841     char path[] = "/new";
15842     int r;
15843     suppress_error = 0;
15844     r = guestfs_touch (g, path);
15845     if (r == -1)
15846       return -1;
15847   }
15848   {
15849     char path[] = "/new";
15850     int r;
15851     suppress_error = 0;
15852     r = guestfs_exists (g, path);
15853     if (r == -1)
15854       return -1;
15855     if (!r) {
15856       fprintf (stderr, "test_touch_0: expected true, got false\n");
15857       return -1;
15858     }
15859   }
15860   return 0;
15861 }
15862
15863 static int test_sync_0_skip (void)
15864 {
15865   const char *str;
15866
15867   str = getenv ("SKIP_TEST_SYNC_0");
15868   if (str && strcmp (str, "1") == 0) return 1;
15869   str = getenv ("SKIP_TEST_SYNC");
15870   if (str && strcmp (str, "1") == 0) return 1;
15871   return 0;
15872 }
15873
15874 static int test_sync_0 (void)
15875 {
15876   if (test_sync_0_skip ()) {
15877     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15878     return 0;
15879   }
15880
15881   /* InitNone|InitEmpty for test_sync_0 */
15882   {
15883     char device[] = "/dev/sda";
15884     device[5] = devchar;
15885     int r;
15886     suppress_error = 0;
15887     r = guestfs_blockdev_setrw (g, device);
15888     if (r == -1)
15889       return -1;
15890   }
15891   {
15892     int r;
15893     suppress_error = 0;
15894     r = guestfs_umount_all (g);
15895     if (r == -1)
15896       return -1;
15897   }
15898   {
15899     int r;
15900     suppress_error = 0;
15901     r = guestfs_lvm_remove_all (g);
15902     if (r == -1)
15903       return -1;
15904   }
15905   /* TestRun for sync (0) */
15906   {
15907     int r;
15908     suppress_error = 0;
15909     r = guestfs_sync (g);
15910     if (r == -1)
15911       return -1;
15912   }
15913   return 0;
15914 }
15915
15916 static int test_mount_0_skip (void)
15917 {
15918   const char *str;
15919
15920   str = getenv ("SKIP_TEST_MOUNT_0");
15921   if (str && strcmp (str, "1") == 0) return 1;
15922   str = getenv ("SKIP_TEST_MOUNT");
15923   if (str && strcmp (str, "1") == 0) return 1;
15924   return 0;
15925 }
15926
15927 static int test_mount_0 (void)
15928 {
15929   if (test_mount_0_skip ()) {
15930     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15931     return 0;
15932   }
15933
15934   /* InitNone|InitEmpty for test_mount_0 */
15935   {
15936     char device[] = "/dev/sda";
15937     device[5] = devchar;
15938     int r;
15939     suppress_error = 0;
15940     r = guestfs_blockdev_setrw (g, device);
15941     if (r == -1)
15942       return -1;
15943   }
15944   {
15945     int r;
15946     suppress_error = 0;
15947     r = guestfs_umount_all (g);
15948     if (r == -1)
15949       return -1;
15950   }
15951   {
15952     int r;
15953     suppress_error = 0;
15954     r = guestfs_lvm_remove_all (g);
15955     if (r == -1)
15956       return -1;
15957   }
15958   /* TestOutput for mount (0) */
15959   char expected[] = "new file contents";
15960   {
15961     char device[] = "/dev/sda";
15962     device[5] = devchar;
15963     char lines_0[] = ",";
15964     char *lines[] = {
15965       lines_0,
15966       NULL
15967     };
15968     int r;
15969     suppress_error = 0;
15970     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15971     if (r == -1)
15972       return -1;
15973   }
15974   {
15975     char fstype[] = "ext2";
15976     char device[] = "/dev/sda1";
15977     device[5] = devchar;
15978     int r;
15979     suppress_error = 0;
15980     r = guestfs_mkfs (g, fstype, device);
15981     if (r == -1)
15982       return -1;
15983   }
15984   {
15985     char device[] = "/dev/sda1";
15986     device[5] = devchar;
15987     char mountpoint[] = "/";
15988     int r;
15989     suppress_error = 0;
15990     r = guestfs_mount (g, device, mountpoint);
15991     if (r == -1)
15992       return -1;
15993   }
15994   {
15995     char path[] = "/new";
15996     char content[] = "new file contents";
15997     int r;
15998     suppress_error = 0;
15999     r = guestfs_write_file (g, path, content, 0);
16000     if (r == -1)
16001       return -1;
16002   }
16003   {
16004     char path[] = "/new";
16005     char *r;
16006     suppress_error = 0;
16007     r = guestfs_cat (g, path);
16008     if (r == NULL)
16009       return -1;
16010     if (strcmp (r, expected) != 0) {
16011       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16012       return -1;
16013     }
16014     free (r);
16015   }
16016   return 0;
16017 }
16018
16019 int main (int argc, char *argv[])
16020 {
16021   char c = 0;
16022   int failed = 0;
16023   const char *srcdir;
16024   const char *filename;
16025   int fd, i;
16026   int nr_tests, test_num = 0;
16027   char **devs;
16028
16029   no_test_warnings ();
16030
16031   g = guestfs_create ();
16032   if (g == NULL) {
16033     printf ("guestfs_create FAILED\n");
16034     exit (1);
16035   }
16036
16037   guestfs_set_error_handler (g, print_error, NULL);
16038
16039   guestfs_set_path (g, "../appliance");
16040
16041   filename = "test1.img";
16042   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16043   if (fd == -1) {
16044     perror (filename);
16045     exit (1);
16046   }
16047   if (lseek (fd, 524288000, SEEK_SET) == -1) {
16048     perror ("lseek");
16049     close (fd);
16050     unlink (filename);
16051     exit (1);
16052   }
16053   if (write (fd, &c, 1) == -1) {
16054     perror ("write");
16055     close (fd);
16056     unlink (filename);
16057     exit (1);
16058   }
16059   if (close (fd) == -1) {
16060     perror (filename);
16061     unlink (filename);
16062     exit (1);
16063   }
16064   if (guestfs_add_drive (g, filename) == -1) {
16065     printf ("guestfs_add_drive %s FAILED\n", filename);
16066     exit (1);
16067   }
16068
16069   filename = "test2.img";
16070   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16071   if (fd == -1) {
16072     perror (filename);
16073     exit (1);
16074   }
16075   if (lseek (fd, 52428800, SEEK_SET) == -1) {
16076     perror ("lseek");
16077     close (fd);
16078     unlink (filename);
16079     exit (1);
16080   }
16081   if (write (fd, &c, 1) == -1) {
16082     perror ("write");
16083     close (fd);
16084     unlink (filename);
16085     exit (1);
16086   }
16087   if (close (fd) == -1) {
16088     perror (filename);
16089     unlink (filename);
16090     exit (1);
16091   }
16092   if (guestfs_add_drive (g, filename) == -1) {
16093     printf ("guestfs_add_drive %s FAILED\n", filename);
16094     exit (1);
16095   }
16096
16097   filename = "test3.img";
16098   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16099   if (fd == -1) {
16100     perror (filename);
16101     exit (1);
16102   }
16103   if (lseek (fd, 10485760, SEEK_SET) == -1) {
16104     perror ("lseek");
16105     close (fd);
16106     unlink (filename);
16107     exit (1);
16108   }
16109   if (write (fd, &c, 1) == -1) {
16110     perror ("write");
16111     close (fd);
16112     unlink (filename);
16113     exit (1);
16114   }
16115   if (close (fd) == -1) {
16116     perror (filename);
16117     unlink (filename);
16118     exit (1);
16119   }
16120   if (guestfs_add_drive (g, filename) == -1) {
16121     printf ("guestfs_add_drive %s FAILED\n", filename);
16122     exit (1);
16123   }
16124
16125   if (guestfs_add_drive (g, "../images/test.sqsh") == -1) {
16126     printf ("guestfs_add_drive %s FAILED\n", filename);
16127     exit (1);
16128   }
16129
16130   if (guestfs_launch (g) == -1) {
16131     printf ("guestfs_launch FAILED\n");
16132     exit (1);
16133   }
16134   if (guestfs_wait_ready (g) == -1) {
16135     printf ("guestfs_wait_ready FAILED\n");
16136     exit (1);
16137   }
16138
16139   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
16140    * names.  This changed between RHEL 5 and RHEL 6 so we have to
16141    * support both.
16142    */
16143   devs = guestfs_list_devices (g);
16144   if (devs == NULL || devs[0] == NULL) {
16145     printf ("guestfs_list_devices FAILED\n");
16146     exit (1);
16147   }
16148   if (strncmp (devs[0], "/dev/sd", 7) == 0)
16149     devchar = 's';
16150   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
16151     devchar = 'h';
16152   else {
16153     printf ("guestfs_list_devices returned unexpected string '%s'\n",
16154             devs[0]);
16155     exit (1);
16156   }
16157   for (i = 0; devs[i] != NULL; ++i)
16158     free (devs[i]);
16159   free (devs);
16160
16161   nr_tests = 143;
16162
16163   test_num++;
16164   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16165   if (test_find_0 () == -1) {
16166     printf ("test_find_0 FAILED\n");
16167     failed++;
16168   }
16169   test_num++;
16170   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16171   if (test_find_1 () == -1) {
16172     printf ("test_find_1 FAILED\n");
16173     failed++;
16174   }
16175   test_num++;
16176   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16177   if (test_find_2 () == -1) {
16178     printf ("test_find_2 FAILED\n");
16179     failed++;
16180   }
16181   test_num++;
16182   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16183   if (test_lvresize_0 () == -1) {
16184     printf ("test_lvresize_0 FAILED\n");
16185     failed++;
16186   }
16187   test_num++;
16188   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16189   if (test_zerofree_0 () == -1) {
16190     printf ("test_zerofree_0 FAILED\n");
16191     failed++;
16192   }
16193   test_num++;
16194   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16195   if (test_hexdump_0 () == -1) {
16196     printf ("test_hexdump_0 FAILED\n");
16197     failed++;
16198   }
16199   test_num++;
16200   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16201   if (test_strings_e_0 () == -1) {
16202     printf ("test_strings_e_0 FAILED\n");
16203     failed++;
16204   }
16205   test_num++;
16206   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16207   if (test_strings_e_1 () == -1) {
16208     printf ("test_strings_e_1 FAILED\n");
16209     failed++;
16210   }
16211   test_num++;
16212   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16213   if (test_strings_0 () == -1) {
16214     printf ("test_strings_0 FAILED\n");
16215     failed++;
16216   }
16217   test_num++;
16218   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16219   if (test_strings_1 () == -1) {
16220     printf ("test_strings_1 FAILED\n");
16221     failed++;
16222   }
16223   test_num++;
16224   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16225   if (test_equal_0 () == -1) {
16226     printf ("test_equal_0 FAILED\n");
16227     failed++;
16228   }
16229   test_num++;
16230   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16231   if (test_equal_1 () == -1) {
16232     printf ("test_equal_1 FAILED\n");
16233     failed++;
16234   }
16235   test_num++;
16236   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16237   if (test_equal_2 () == -1) {
16238     printf ("test_equal_2 FAILED\n");
16239     failed++;
16240   }
16241   test_num++;
16242   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16243   if (test_ping_daemon_0 () == -1) {
16244     printf ("test_ping_daemon_0 FAILED\n");
16245     failed++;
16246   }
16247   test_num++;
16248   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16249   if (test_dmesg_0 () == -1) {
16250     printf ("test_dmesg_0 FAILED\n");
16251     failed++;
16252   }
16253   test_num++;
16254   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16255   if (test_drop_caches_0 () == -1) {
16256     printf ("test_drop_caches_0 FAILED\n");
16257     failed++;
16258   }
16259   test_num++;
16260   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16261   if (test_mv_0 () == -1) {
16262     printf ("test_mv_0 FAILED\n");
16263     failed++;
16264   }
16265   test_num++;
16266   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16267   if (test_mv_1 () == -1) {
16268     printf ("test_mv_1 FAILED\n");
16269     failed++;
16270   }
16271   test_num++;
16272   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16273   if (test_cp_a_0 () == -1) {
16274     printf ("test_cp_a_0 FAILED\n");
16275     failed++;
16276   }
16277   test_num++;
16278   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16279   if (test_cp_0 () == -1) {
16280     printf ("test_cp_0 FAILED\n");
16281     failed++;
16282   }
16283   test_num++;
16284   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16285   if (test_cp_1 () == -1) {
16286     printf ("test_cp_1 FAILED\n");
16287     failed++;
16288   }
16289   test_num++;
16290   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16291   if (test_cp_2 () == -1) {
16292     printf ("test_cp_2 FAILED\n");
16293     failed++;
16294   }
16295   test_num++;
16296   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16297   if (test_grub_install_0 () == -1) {
16298     printf ("test_grub_install_0 FAILED\n");
16299     failed++;
16300   }
16301   test_num++;
16302   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16303   if (test_zero_0 () == -1) {
16304     printf ("test_zero_0 FAILED\n");
16305     failed++;
16306   }
16307   test_num++;
16308   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16309   if (test_fsck_0 () == -1) {
16310     printf ("test_fsck_0 FAILED\n");
16311     failed++;
16312   }
16313   test_num++;
16314   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16315   if (test_fsck_1 () == -1) {
16316     printf ("test_fsck_1 FAILED\n");
16317     failed++;
16318   }
16319   test_num++;
16320   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16321   if (test_set_e2uuid_0 () == -1) {
16322     printf ("test_set_e2uuid_0 FAILED\n");
16323     failed++;
16324   }
16325   test_num++;
16326   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16327   if (test_set_e2uuid_1 () == -1) {
16328     printf ("test_set_e2uuid_1 FAILED\n");
16329     failed++;
16330   }
16331   test_num++;
16332   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16333   if (test_set_e2uuid_2 () == -1) {
16334     printf ("test_set_e2uuid_2 FAILED\n");
16335     failed++;
16336   }
16337   test_num++;
16338   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16339   if (test_set_e2uuid_3 () == -1) {
16340     printf ("test_set_e2uuid_3 FAILED\n");
16341     failed++;
16342   }
16343   test_num++;
16344   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16345   if (test_set_e2label_0 () == -1) {
16346     printf ("test_set_e2label_0 FAILED\n");
16347     failed++;
16348   }
16349   test_num++;
16350   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16351   if (test_pvremove_0 () == -1) {
16352     printf ("test_pvremove_0 FAILED\n");
16353     failed++;
16354   }
16355   test_num++;
16356   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16357   if (test_pvremove_1 () == -1) {
16358     printf ("test_pvremove_1 FAILED\n");
16359     failed++;
16360   }
16361   test_num++;
16362   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16363   if (test_pvremove_2 () == -1) {
16364     printf ("test_pvremove_2 FAILED\n");
16365     failed++;
16366   }
16367   test_num++;
16368   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16369   if (test_vgremove_0 () == -1) {
16370     printf ("test_vgremove_0 FAILED\n");
16371     failed++;
16372   }
16373   test_num++;
16374   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16375   if (test_vgremove_1 () == -1) {
16376     printf ("test_vgremove_1 FAILED\n");
16377     failed++;
16378   }
16379   test_num++;
16380   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16381   if (test_lvremove_0 () == -1) {
16382     printf ("test_lvremove_0 FAILED\n");
16383     failed++;
16384   }
16385   test_num++;
16386   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16387   if (test_lvremove_1 () == -1) {
16388     printf ("test_lvremove_1 FAILED\n");
16389     failed++;
16390   }
16391   test_num++;
16392   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16393   if (test_lvremove_2 () == -1) {
16394     printf ("test_lvremove_2 FAILED\n");
16395     failed++;
16396   }
16397   test_num++;
16398   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16399   if (test_mount_ro_0 () == -1) {
16400     printf ("test_mount_ro_0 FAILED\n");
16401     failed++;
16402   }
16403   test_num++;
16404   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16405   if (test_mount_ro_1 () == -1) {
16406     printf ("test_mount_ro_1 FAILED\n");
16407     failed++;
16408   }
16409   test_num++;
16410   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16411   if (test_tgz_in_0 () == -1) {
16412     printf ("test_tgz_in_0 FAILED\n");
16413     failed++;
16414   }
16415   test_num++;
16416   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16417   if (test_tar_in_0 () == -1) {
16418     printf ("test_tar_in_0 FAILED\n");
16419     failed++;
16420   }
16421   test_num++;
16422   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16423   if (test_checksum_0 () == -1) {
16424     printf ("test_checksum_0 FAILED\n");
16425     failed++;
16426   }
16427   test_num++;
16428   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16429   if (test_checksum_1 () == -1) {
16430     printf ("test_checksum_1 FAILED\n");
16431     failed++;
16432   }
16433   test_num++;
16434   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16435   if (test_checksum_2 () == -1) {
16436     printf ("test_checksum_2 FAILED\n");
16437     failed++;
16438   }
16439   test_num++;
16440   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16441   if (test_checksum_3 () == -1) {
16442     printf ("test_checksum_3 FAILED\n");
16443     failed++;
16444   }
16445   test_num++;
16446   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16447   if (test_checksum_4 () == -1) {
16448     printf ("test_checksum_4 FAILED\n");
16449     failed++;
16450   }
16451   test_num++;
16452   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16453   if (test_checksum_5 () == -1) {
16454     printf ("test_checksum_5 FAILED\n");
16455     failed++;
16456   }
16457   test_num++;
16458   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16459   if (test_checksum_6 () == -1) {
16460     printf ("test_checksum_6 FAILED\n");
16461     failed++;
16462   }
16463   test_num++;
16464   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16465   if (test_checksum_7 () == -1) {
16466     printf ("test_checksum_7 FAILED\n");
16467     failed++;
16468   }
16469   test_num++;
16470   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16471   if (test_checksum_8 () == -1) {
16472     printf ("test_checksum_8 FAILED\n");
16473     failed++;
16474   }
16475   test_num++;
16476   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16477   if (test_download_0 () == -1) {
16478     printf ("test_download_0 FAILED\n");
16479     failed++;
16480   }
16481   test_num++;
16482   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16483   if (test_upload_0 () == -1) {
16484     printf ("test_upload_0 FAILED\n");
16485     failed++;
16486   }
16487   test_num++;
16488   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16489   if (test_blockdev_rereadpt_0 () == -1) {
16490     printf ("test_blockdev_rereadpt_0 FAILED\n");
16491     failed++;
16492   }
16493   test_num++;
16494   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16495   if (test_blockdev_flushbufs_0 () == -1) {
16496     printf ("test_blockdev_flushbufs_0 FAILED\n");
16497     failed++;
16498   }
16499   test_num++;
16500   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16501   if (test_blockdev_getsize64_0 () == -1) {
16502     printf ("test_blockdev_getsize64_0 FAILED\n");
16503     failed++;
16504   }
16505   test_num++;
16506   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16507   if (test_blockdev_getsz_0 () == -1) {
16508     printf ("test_blockdev_getsz_0 FAILED\n");
16509     failed++;
16510   }
16511   test_num++;
16512   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16513   if (test_blockdev_getbsz_0 () == -1) {
16514     printf ("test_blockdev_getbsz_0 FAILED\n");
16515     failed++;
16516   }
16517   test_num++;
16518   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16519   if (test_blockdev_getss_0 () == -1) {
16520     printf ("test_blockdev_getss_0 FAILED\n");
16521     failed++;
16522   }
16523   test_num++;
16524   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16525   if (test_blockdev_getro_0 () == -1) {
16526     printf ("test_blockdev_getro_0 FAILED\n");
16527     failed++;
16528   }
16529   test_num++;
16530   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16531   if (test_blockdev_setrw_0 () == -1) {
16532     printf ("test_blockdev_setrw_0 FAILED\n");
16533     failed++;
16534   }
16535   test_num++;
16536   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16537   if (test_blockdev_setro_0 () == -1) {
16538     printf ("test_blockdev_setro_0 FAILED\n");
16539     failed++;
16540   }
16541   test_num++;
16542   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16543   if (test_statvfs_0 () == -1) {
16544     printf ("test_statvfs_0 FAILED\n");
16545     failed++;
16546   }
16547   test_num++;
16548   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16549   if (test_lstat_0 () == -1) {
16550     printf ("test_lstat_0 FAILED\n");
16551     failed++;
16552   }
16553   test_num++;
16554   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16555   if (test_stat_0 () == -1) {
16556     printf ("test_stat_0 FAILED\n");
16557     failed++;
16558   }
16559   test_num++;
16560   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16561   if (test_command_lines_0 () == -1) {
16562     printf ("test_command_lines_0 FAILED\n");
16563     failed++;
16564   }
16565   test_num++;
16566   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16567   if (test_command_lines_1 () == -1) {
16568     printf ("test_command_lines_1 FAILED\n");
16569     failed++;
16570   }
16571   test_num++;
16572   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16573   if (test_command_lines_2 () == -1) {
16574     printf ("test_command_lines_2 FAILED\n");
16575     failed++;
16576   }
16577   test_num++;
16578   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16579   if (test_command_lines_3 () == -1) {
16580     printf ("test_command_lines_3 FAILED\n");
16581     failed++;
16582   }
16583   test_num++;
16584   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16585   if (test_command_lines_4 () == -1) {
16586     printf ("test_command_lines_4 FAILED\n");
16587     failed++;
16588   }
16589   test_num++;
16590   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16591   if (test_command_lines_5 () == -1) {
16592     printf ("test_command_lines_5 FAILED\n");
16593     failed++;
16594   }
16595   test_num++;
16596   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16597   if (test_command_lines_6 () == -1) {
16598     printf ("test_command_lines_6 FAILED\n");
16599     failed++;
16600   }
16601   test_num++;
16602   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16603   if (test_command_lines_7 () == -1) {
16604     printf ("test_command_lines_7 FAILED\n");
16605     failed++;
16606   }
16607   test_num++;
16608   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16609   if (test_command_lines_8 () == -1) {
16610     printf ("test_command_lines_8 FAILED\n");
16611     failed++;
16612   }
16613   test_num++;
16614   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16615   if (test_command_lines_9 () == -1) {
16616     printf ("test_command_lines_9 FAILED\n");
16617     failed++;
16618   }
16619   test_num++;
16620   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16621   if (test_command_lines_10 () == -1) {
16622     printf ("test_command_lines_10 FAILED\n");
16623     failed++;
16624   }
16625   test_num++;
16626   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16627   if (test_command_0 () == -1) {
16628     printf ("test_command_0 FAILED\n");
16629     failed++;
16630   }
16631   test_num++;
16632   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16633   if (test_command_1 () == -1) {
16634     printf ("test_command_1 FAILED\n");
16635     failed++;
16636   }
16637   test_num++;
16638   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16639   if (test_command_2 () == -1) {
16640     printf ("test_command_2 FAILED\n");
16641     failed++;
16642   }
16643   test_num++;
16644   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16645   if (test_command_3 () == -1) {
16646     printf ("test_command_3 FAILED\n");
16647     failed++;
16648   }
16649   test_num++;
16650   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16651   if (test_command_4 () == -1) {
16652     printf ("test_command_4 FAILED\n");
16653     failed++;
16654   }
16655   test_num++;
16656   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16657   if (test_command_5 () == -1) {
16658     printf ("test_command_5 FAILED\n");
16659     failed++;
16660   }
16661   test_num++;
16662   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16663   if (test_command_6 () == -1) {
16664     printf ("test_command_6 FAILED\n");
16665     failed++;
16666   }
16667   test_num++;
16668   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16669   if (test_command_7 () == -1) {
16670     printf ("test_command_7 FAILED\n");
16671     failed++;
16672   }
16673   test_num++;
16674   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16675   if (test_command_8 () == -1) {
16676     printf ("test_command_8 FAILED\n");
16677     failed++;
16678   }
16679   test_num++;
16680   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16681   if (test_command_9 () == -1) {
16682     printf ("test_command_9 FAILED\n");
16683     failed++;
16684   }
16685   test_num++;
16686   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16687   if (test_command_10 () == -1) {
16688     printf ("test_command_10 FAILED\n");
16689     failed++;
16690   }
16691   test_num++;
16692   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16693   if (test_command_11 () == -1) {
16694     printf ("test_command_11 FAILED\n");
16695     failed++;
16696   }
16697   test_num++;
16698   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16699   if (test_file_0 () == -1) {
16700     printf ("test_file_0 FAILED\n");
16701     failed++;
16702   }
16703   test_num++;
16704   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16705   if (test_file_1 () == -1) {
16706     printf ("test_file_1 FAILED\n");
16707     failed++;
16708   }
16709   test_num++;
16710   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16711   if (test_file_2 () == -1) {
16712     printf ("test_file_2 FAILED\n");
16713     failed++;
16714   }
16715   test_num++;
16716   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16717   if (test_umount_all_0 () == -1) {
16718     printf ("test_umount_all_0 FAILED\n");
16719     failed++;
16720   }
16721   test_num++;
16722   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16723   if (test_umount_all_1 () == -1) {
16724     printf ("test_umount_all_1 FAILED\n");
16725     failed++;
16726   }
16727   test_num++;
16728   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16729   if (test_mounts_0 () == -1) {
16730     printf ("test_mounts_0 FAILED\n");
16731     failed++;
16732   }
16733   test_num++;
16734   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16735   if (test_umount_0 () == -1) {
16736     printf ("test_umount_0 FAILED\n");
16737     failed++;
16738   }
16739   test_num++;
16740   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16741   if (test_umount_1 () == -1) {
16742     printf ("test_umount_1 FAILED\n");
16743     failed++;
16744   }
16745   test_num++;
16746   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16747   if (test_write_file_0 () == -1) {
16748     printf ("test_write_file_0 FAILED\n");
16749     failed++;
16750   }
16751   test_num++;
16752   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16753   if (test_write_file_1 () == -1) {
16754     printf ("test_write_file_1 FAILED\n");
16755     failed++;
16756   }
16757   test_num++;
16758   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16759   if (test_write_file_2 () == -1) {
16760     printf ("test_write_file_2 FAILED\n");
16761     failed++;
16762   }
16763   test_num++;
16764   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16765   if (test_write_file_3 () == -1) {
16766     printf ("test_write_file_3 FAILED\n");
16767     failed++;
16768   }
16769   test_num++;
16770   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16771   if (test_write_file_4 () == -1) {
16772     printf ("test_write_file_4 FAILED\n");
16773     failed++;
16774   }
16775   test_num++;
16776   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16777   if (test_write_file_5 () == -1) {
16778     printf ("test_write_file_5 FAILED\n");
16779     failed++;
16780   }
16781   test_num++;
16782   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16783   if (test_mkfs_0 () == -1) {
16784     printf ("test_mkfs_0 FAILED\n");
16785     failed++;
16786   }
16787   test_num++;
16788   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16789   if (test_lvcreate_0 () == -1) {
16790     printf ("test_lvcreate_0 FAILED\n");
16791     failed++;
16792   }
16793   test_num++;
16794   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16795   if (test_vgcreate_0 () == -1) {
16796     printf ("test_vgcreate_0 FAILED\n");
16797     failed++;
16798   }
16799   test_num++;
16800   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16801   if (test_pvcreate_0 () == -1) {
16802     printf ("test_pvcreate_0 FAILED\n");
16803     failed++;
16804   }
16805   test_num++;
16806   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16807   if (test_is_dir_0 () == -1) {
16808     printf ("test_is_dir_0 FAILED\n");
16809     failed++;
16810   }
16811   test_num++;
16812   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16813   if (test_is_dir_1 () == -1) {
16814     printf ("test_is_dir_1 FAILED\n");
16815     failed++;
16816   }
16817   test_num++;
16818   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16819   if (test_is_file_0 () == -1) {
16820     printf ("test_is_file_0 FAILED\n");
16821     failed++;
16822   }
16823   test_num++;
16824   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16825   if (test_is_file_1 () == -1) {
16826     printf ("test_is_file_1 FAILED\n");
16827     failed++;
16828   }
16829   test_num++;
16830   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16831   if (test_exists_0 () == -1) {
16832     printf ("test_exists_0 FAILED\n");
16833     failed++;
16834   }
16835   test_num++;
16836   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16837   if (test_exists_1 () == -1) {
16838     printf ("test_exists_1 FAILED\n");
16839     failed++;
16840   }
16841   test_num++;
16842   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16843   if (test_mkdir_p_0 () == -1) {
16844     printf ("test_mkdir_p_0 FAILED\n");
16845     failed++;
16846   }
16847   test_num++;
16848   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16849   if (test_mkdir_p_1 () == -1) {
16850     printf ("test_mkdir_p_1 FAILED\n");
16851     failed++;
16852   }
16853   test_num++;
16854   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16855   if (test_mkdir_p_2 () == -1) {
16856     printf ("test_mkdir_p_2 FAILED\n");
16857     failed++;
16858   }
16859   test_num++;
16860   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16861   if (test_mkdir_p_3 () == -1) {
16862     printf ("test_mkdir_p_3 FAILED\n");
16863     failed++;
16864   }
16865   test_num++;
16866   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16867   if (test_mkdir_p_4 () == -1) {
16868     printf ("test_mkdir_p_4 FAILED\n");
16869     failed++;
16870   }
16871   test_num++;
16872   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16873   if (test_mkdir_0 () == -1) {
16874     printf ("test_mkdir_0 FAILED\n");
16875     failed++;
16876   }
16877   test_num++;
16878   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16879   if (test_mkdir_1 () == -1) {
16880     printf ("test_mkdir_1 FAILED\n");
16881     failed++;
16882   }
16883   test_num++;
16884   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16885   if (test_rm_rf_0 () == -1) {
16886     printf ("test_rm_rf_0 FAILED\n");
16887     failed++;
16888   }
16889   test_num++;
16890   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16891   if (test_rmdir_0 () == -1) {
16892     printf ("test_rmdir_0 FAILED\n");
16893     failed++;
16894   }
16895   test_num++;
16896   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16897   if (test_rmdir_1 () == -1) {
16898     printf ("test_rmdir_1 FAILED\n");
16899     failed++;
16900   }
16901   test_num++;
16902   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16903   if (test_rmdir_2 () == -1) {
16904     printf ("test_rmdir_2 FAILED\n");
16905     failed++;
16906   }
16907   test_num++;
16908   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16909   if (test_rm_0 () == -1) {
16910     printf ("test_rm_0 FAILED\n");
16911     failed++;
16912   }
16913   test_num++;
16914   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16915   if (test_rm_1 () == -1) {
16916     printf ("test_rm_1 FAILED\n");
16917     failed++;
16918   }
16919   test_num++;
16920   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16921   if (test_rm_2 () == -1) {
16922     printf ("test_rm_2 FAILED\n");
16923     failed++;
16924   }
16925   test_num++;
16926   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16927   if (test_read_lines_0 () == -1) {
16928     printf ("test_read_lines_0 FAILED\n");
16929     failed++;
16930   }
16931   test_num++;
16932   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16933   if (test_read_lines_1 () == -1) {
16934     printf ("test_read_lines_1 FAILED\n");
16935     failed++;
16936   }
16937   test_num++;
16938   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16939   if (test_lvs_0 () == -1) {
16940     printf ("test_lvs_0 FAILED\n");
16941     failed++;
16942   }
16943   test_num++;
16944   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16945   if (test_lvs_1 () == -1) {
16946     printf ("test_lvs_1 FAILED\n");
16947     failed++;
16948   }
16949   test_num++;
16950   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16951   if (test_vgs_0 () == -1) {
16952     printf ("test_vgs_0 FAILED\n");
16953     failed++;
16954   }
16955   test_num++;
16956   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16957   if (test_vgs_1 () == -1) {
16958     printf ("test_vgs_1 FAILED\n");
16959     failed++;
16960   }
16961   test_num++;
16962   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16963   if (test_pvs_0 () == -1) {
16964     printf ("test_pvs_0 FAILED\n");
16965     failed++;
16966   }
16967   test_num++;
16968   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16969   if (test_pvs_1 () == -1) {
16970     printf ("test_pvs_1 FAILED\n");
16971     failed++;
16972   }
16973   test_num++;
16974   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16975   if (test_list_partitions_0 () == -1) {
16976     printf ("test_list_partitions_0 FAILED\n");
16977     failed++;
16978   }
16979   test_num++;
16980   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16981   if (test_list_partitions_1 () == -1) {
16982     printf ("test_list_partitions_1 FAILED\n");
16983     failed++;
16984   }
16985   test_num++;
16986   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16987   if (test_list_devices_0 () == -1) {
16988     printf ("test_list_devices_0 FAILED\n");
16989     failed++;
16990   }
16991   test_num++;
16992   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16993   if (test_ls_0 () == -1) {
16994     printf ("test_ls_0 FAILED\n");
16995     failed++;
16996   }
16997   test_num++;
16998   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16999   if (test_cat_0 () == -1) {
17000     printf ("test_cat_0 FAILED\n");
17001     failed++;
17002   }
17003   test_num++;
17004   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17005   if (test_touch_0 () == -1) {
17006     printf ("test_touch_0 FAILED\n");
17007     failed++;
17008   }
17009   test_num++;
17010   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17011   if (test_sync_0 () == -1) {
17012     printf ("test_sync_0 FAILED\n");
17013     failed++;
17014   }
17015   test_num++;
17016   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17017   if (test_mount_0 () == -1) {
17018     printf ("test_mount_0 FAILED\n");
17019     failed++;
17020   }
17021
17022   guestfs_close (g);
17023   unlink ("test1.img");
17024   unlink ("test2.img");
17025   unlink ("test3.img");
17026
17027   if (failed > 0) {
17028     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
17029     exit (1);
17030   }
17031
17032   exit (0);
17033 }