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_launch\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 128 }
 129
 130 static int test_find_0_skip (void)
 131 {
 132   const char *str;
 133
 134   str = getenv ("SKIP_TEST_FIND_0");
 135   if (str && strcmp (str, "1") == 0) return 1;
 136   str = getenv ("SKIP_TEST_FIND");
 137   if (str && strcmp (str, "1") == 0) return 1;
 138   return 0;
 139 }
 140
 141 static int test_find_0 (void)
 142 {
 143   if (test_find_0_skip ()) {
 144     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
 145     return 0;
 146   }
 147
 148   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 149   {
 150     char device[] = "/dev/sda";
 151     device[5] = devchar;
 152     int r;
 153     suppress_error = 0;
 154     r = guestfs_blockdev_setrw (g, device);
 155     if (r == -1)
 156       return -1;
 157   }
 158   {
 159     int r;
 160     suppress_error = 0;
 161     r = guestfs_umount_all (g);
 162     if (r == -1)
 163       return -1;
 164   }
 165   {
 166     int r;
 167     suppress_error = 0;
 168     r = guestfs_lvm_remove_all (g);
 169     if (r == -1)
 170       return -1;
 171   }
 172   {
 173     char device[] = "/dev/sda";
 174     device[5] = devchar;
 175     char lines_0[] = ",";
 176     char *lines[] = {
 177       lines_0,
 178       NULL
 179     };
 180     int r;
 181     suppress_error = 0;
 182     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 183     if (r == -1)
 184       return -1;
 185   }
 186   {
 187     char fstype[] = "ext2";
 188     char device[] = "/dev/sda1";
 189     device[5] = devchar;
 190     int r;
 191     suppress_error = 0;
 192     r = guestfs_mkfs (g, fstype, device);
 193     if (r == -1)
 194       return -1;
 195   }
 196   {
 197     char device[] = "/dev/sda1";
 198     device[5] = devchar;
 199     char mountpoint[] = "/";
 200     int r;
 201     suppress_error = 0;
 202     r = guestfs_mount (g, device, mountpoint);
 203     if (r == -1)
 204       return -1;
 205   }
 206   /* TestOutputList for find (0) */
 207   {
 208     char directory[] = "/";
 209     char **r;
 210     int i;
 211     suppress_error = 0;
 212     r = guestfs_find (g, directory);
 213     if (r == NULL)
 214       return -1;
 215     if (!r[0]) {
 216       fprintf (stderr, "test_find_0: short list returned from command\n");
 217       print_strings (r);
 218       return -1;
 219     }
 220     {
 221       char expected[] = "lost+found";
 222       if (strcmp (r[0], expected) != 0) {
 223         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 224         return -1;
 225       }
 226     }
 227     if (r[1] != NULL) {
 228       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 229       print_strings (r);
 230       return -1;
 231     }
 232     for (i = 0; r[i] != NULL; ++i)
 233       free (r[i]);
 234     free (r);
 235   }
 236   return 0;
 237 }
 238
 239 static int test_find_1_skip (void)
 240 {
 241   const char *str;
 242
 243   str = getenv ("SKIP_TEST_FIND_1");
 244   if (str && strcmp (str, "1") == 0) return 1;
 245   str = getenv ("SKIP_TEST_FIND");
 246   if (str && strcmp (str, "1") == 0) return 1;
 247   return 0;
 248 }
 249
 250 static int test_find_1 (void)
 251 {
 252   if (test_find_1_skip ()) {
 253     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
 254     return 0;
 255   }
 256
 257   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
 258   {
 259     char device[] = "/dev/sda";
 260     device[5] = devchar;
 261     int r;
 262     suppress_error = 0;
 263     r = guestfs_blockdev_setrw (g, device);
 264     if (r == -1)
 265       return -1;
 266   }
 267   {
 268     int r;
 269     suppress_error = 0;
 270     r = guestfs_umount_all (g);
 271     if (r == -1)
 272       return -1;
 273   }
 274   {
 275     int r;
 276     suppress_error = 0;
 277     r = guestfs_lvm_remove_all (g);
 278     if (r == -1)
 279       return -1;
 280   }
 281   {
 282     char device[] = "/dev/sda";
 283     device[5] = devchar;
 284     char lines_0[] = ",";
 285     char *lines[] = {
 286       lines_0,
 287       NULL
 288     };
 289     int r;
 290     suppress_error = 0;
 291     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 292     if (r == -1)
 293       return -1;
 294   }
 295   {
 296     char fstype[] = "ext2";
 297     char device[] = "/dev/sda1";
 298     device[5] = devchar;
 299     int r;
 300     suppress_error = 0;
 301     r = guestfs_mkfs (g, fstype, device);
 302     if (r == -1)
 303       return -1;
 304   }
 305   {
 306     char device[] = "/dev/sda1";
 307     device[5] = devchar;
 308     char mountpoint[] = "/";
 309     int r;
 310     suppress_error = 0;
 311     r = guestfs_mount (g, device, mountpoint);
 312     if (r == -1)
 313       return -1;
 314   }
 315   /* TestOutputList for find (1) */
 316   {
 317     char path[] = "/a";
 318     int r;
 319     suppress_error = 0;
 320     r = guestfs_touch (g, path);
 321     if (r == -1)
 322       return -1;
 323   }
 324   {
 325     char path[] = "/b";
 326     int r;
 327     suppress_error = 0;
 328     r = guestfs_mkdir (g, path);
 329     if (r == -1)
 330       return -1;
 331   }
 332   {
 333     char path[] = "/b/c";
 334     int r;
 335     suppress_error = 0;
 336     r = guestfs_touch (g, path);
 337     if (r == -1)
 338       return -1;
 339   }
 340   {
 341     char directory[] = "/";
 342     char **r;
 343     int i;
 344     suppress_error = 0;
 345     r = guestfs_find (g, directory);
 346     if (r == NULL)
 347       return -1;
 348     if (!r[0]) {
 349       fprintf (stderr, "test_find_1: short list returned from command\n");
 350       print_strings (r);
 351       return -1;
 352     }
 353     {
 354       char expected[] = "a";
 355       if (strcmp (r[0], expected) != 0) {
 356         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 357         return -1;
 358       }
 359     }
 360     if (!r[1]) {
 361       fprintf (stderr, "test_find_1: short list returned from command\n");
 362       print_strings (r);
 363       return -1;
 364     }
 365     {
 366       char expected[] = "b";
 367       if (strcmp (r[1], expected) != 0) {
 368         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 369         return -1;
 370       }
 371     }
 372     if (!r[2]) {
 373       fprintf (stderr, "test_find_1: short list returned from command\n");
 374       print_strings (r);
 375       return -1;
 376     }
 377     {
 378       char expected[] = "b/c";
 379       if (strcmp (r[2], expected) != 0) {
 380         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 381         return -1;
 382       }
 383     }
 384     if (!r[3]) {
 385       fprintf (stderr, "test_find_1: short list returned from command\n");
 386       print_strings (r);
 387       return -1;
 388     }
 389     {
 390       char expected[] = "lost+found";
 391       if (strcmp (r[3], expected) != 0) {
 392         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 393         return -1;
 394       }
 395     }
 396     if (r[4] != NULL) {
 397       fprintf (stderr, "test_find_1: extra elements returned from command\n");
 398       print_strings (r);
 399       return -1;
 400     }
 401     for (i = 0; r[i] != NULL; ++i)
 402       free (r[i]);
 403     free (r);
 404   }
 405   return 0;
 406 }
 407
 408 static int test_find_2_skip (void)
 409 {
 410   const char *str;
 411
 412   str = getenv ("SKIP_TEST_FIND_2");
 413   if (str && strcmp (str, "1") == 0) return 1;
 414   str = getenv ("SKIP_TEST_FIND");
 415   if (str && strcmp (str, "1") == 0) return 1;
 416   return 0;
 417 }
 418
 419 static int test_find_2 (void)
 420 {
 421   if (test_find_2_skip ()) {
 422     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
 423     return 0;
 424   }
 425
 426   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
 427   {
 428     char device[] = "/dev/sda";
 429     device[5] = devchar;
 430     int r;
 431     suppress_error = 0;
 432     r = guestfs_blockdev_setrw (g, device);
 433     if (r == -1)
 434       return -1;
 435   }
 436   {
 437     int r;
 438     suppress_error = 0;
 439     r = guestfs_umount_all (g);
 440     if (r == -1)
 441       return -1;
 442   }
 443   {
 444     int r;
 445     suppress_error = 0;
 446     r = guestfs_lvm_remove_all (g);
 447     if (r == -1)
 448       return -1;
 449   }
 450   {
 451     char device[] = "/dev/sda";
 452     device[5] = devchar;
 453     char lines_0[] = ",";
 454     char *lines[] = {
 455       lines_0,
 456       NULL
 457     };
 458     int r;
 459     suppress_error = 0;
 460     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 461     if (r == -1)
 462       return -1;
 463   }
 464   {
 465     char fstype[] = "ext2";
 466     char device[] = "/dev/sda1";
 467     device[5] = devchar;
 468     int r;
 469     suppress_error = 0;
 470     r = guestfs_mkfs (g, fstype, device);
 471     if (r == -1)
 472       return -1;
 473   }
 474   {
 475     char device[] = "/dev/sda1";
 476     device[5] = devchar;
 477     char mountpoint[] = "/";
 478     int r;
 479     suppress_error = 0;
 480     r = guestfs_mount (g, device, mountpoint);
 481     if (r == -1)
 482       return -1;
 483   }
 484   /* TestOutputList for find (2) */
 485   {
 486     char path[] = "/a/b/c";
 487     int r;
 488     suppress_error = 0;
 489     r = guestfs_mkdir_p (g, path);
 490     if (r == -1)
 491       return -1;
 492   }
 493   {
 494     char path[] = "/a/b/c/d";
 495     int r;
 496     suppress_error = 0;
 497     r = guestfs_touch (g, path);
 498     if (r == -1)
 499       return -1;
 500   }
 501   {
 502     char directory[] = "/a/b/";
 503     char **r;
 504     int i;
 505     suppress_error = 0;
 506     r = guestfs_find (g, directory);
 507     if (r == NULL)
 508       return -1;
 509     if (!r[0]) {
 510       fprintf (stderr, "test_find_2: short list returned from command\n");
 511       print_strings (r);
 512       return -1;
 513     }
 514     {
 515       char expected[] = "c";
 516       if (strcmp (r[0], expected) != 0) {
 517         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 518         return -1;
 519       }
 520     }
 521     if (!r[1]) {
 522       fprintf (stderr, "test_find_2: short list returned from command\n");
 523       print_strings (r);
 524       return -1;
 525     }
 526     {
 527       char expected[] = "c/d";
 528       if (strcmp (r[1], expected) != 0) {
 529         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 530         return -1;
 531       }
 532     }
 533     if (r[2] != NULL) {
 534       fprintf (stderr, "test_find_2: extra elements returned from command\n");
 535       print_strings (r);
 536       return -1;
 537     }
 538     for (i = 0; r[i] != NULL; ++i)
 539       free (r[i]);
 540     free (r);
 541   }
 542   return 0;
 543 }
 544
 545 static int test_lvresize_0_skip (void)
 546 {
 547   const char *str;
 548
 549   str = getenv ("SKIP_TEST_LVRESIZE_0");
 550   if (str && strcmp (str, "1") == 0) return 1;
 551   str = getenv ("SKIP_TEST_LVRESIZE");
 552   if (str && strcmp (str, "1") == 0) return 1;
 553   return 0;
 554 }
 555
 556 static int test_lvresize_0 (void)
 557 {
 558   if (test_lvresize_0_skip ()) {
 559     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
 560     return 0;
 561   }
 562
 563   /* InitNone|InitEmpty for test_lvresize_0 */
 564   {
 565     char device[] = "/dev/sda";
 566     device[5] = devchar;
 567     int r;
 568     suppress_error = 0;
 569     r = guestfs_blockdev_setrw (g, device);
 570     if (r == -1)
 571       return -1;
 572   }
 573   {
 574     int r;
 575     suppress_error = 0;
 576     r = guestfs_umount_all (g);
 577     if (r == -1)
 578       return -1;
 579   }
 580   {
 581     int r;
 582     suppress_error = 0;
 583     r = guestfs_lvm_remove_all (g);
 584     if (r == -1)
 585       return -1;
 586   }
 587   /* TestOutput for lvresize (0) */
 588   char expected[] = "test content";
 589   {
 590     char device[] = "/dev/sda";
 591     device[5] = devchar;
 592     char lines_0[] = ",";
 593     char *lines[] = {
 594       lines_0,
 595       NULL
 596     };
 597     int r;
 598     suppress_error = 0;
 599     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 600     if (r == -1)
 601       return -1;
 602   }
 603   {
 604     char device[] = "/dev/sda1";
 605     device[5] = devchar;
 606     int r;
 607     suppress_error = 0;
 608     r = guestfs_pvcreate (g, device);
 609     if (r == -1)
 610       return -1;
 611   }
 612   {
 613     char volgroup[] = "VG";
 614     char physvols_0[] = "/dev/sda1";
 615     physvols_0[5] = devchar;
 616     char *physvols[] = {
 617       physvols_0,
 618       NULL
 619     };
 620     int r;
 621     suppress_error = 0;
 622     r = guestfs_vgcreate (g, volgroup, physvols);
 623     if (r == -1)
 624       return -1;
 625   }
 626   {
 627     char logvol[] = "LV";
 628     char volgroup[] = "VG";
 629     int r;
 630     suppress_error = 0;
 631     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 632     if (r == -1)
 633       return -1;
 634   }
 635   {
 636     char fstype[] = "ext2";
 637     char device[] = "/dev/VG/LV";
 638     int r;
 639     suppress_error = 0;
 640     r = guestfs_mkfs (g, fstype, device);
 641     if (r == -1)
 642       return -1;
 643   }
 644   {
 645     char device[] = "/dev/VG/LV";
 646     char mountpoint[] = "/";
 647     int r;
 648     suppress_error = 0;
 649     r = guestfs_mount (g, device, mountpoint);
 650     if (r == -1)
 651       return -1;
 652   }
 653   {
 654     char path[] = "/new";
 655     char content[] = "test content";
 656     int r;
 657     suppress_error = 0;
 658     r = guestfs_write_file (g, path, content, 0);
 659     if (r == -1)
 660       return -1;
 661   }
 662   {
 663     char pathordevice[] = "/";
 664     int r;
 665     suppress_error = 0;
 666     r = guestfs_umount (g, pathordevice);
 667     if (r == -1)
 668       return -1;
 669   }
 670   {
 671     char device[] = "/dev/VG/LV";
 672     int r;
 673     suppress_error = 0;
 674     r = guestfs_lvresize (g, device, 20);
 675     if (r == -1)
 676       return -1;
 677   }
 678   {
 679     char device[] = "/dev/VG/LV";
 680     int r;
 681     suppress_error = 0;
 682     r = guestfs_e2fsck_f (g, device);
 683     if (r == -1)
 684       return -1;
 685   }
 686   {
 687     char device[] = "/dev/VG/LV";
 688     int r;
 689     suppress_error = 0;
 690     r = guestfs_resize2fs (g, device);
 691     if (r == -1)
 692       return -1;
 693   }
 694   {
 695     char device[] = "/dev/VG/LV";
 696     char mountpoint[] = "/";
 697     int r;
 698     suppress_error = 0;
 699     r = guestfs_mount (g, device, mountpoint);
 700     if (r == -1)
 701       return -1;
 702   }
 703   {
 704     char path[] = "/new";
 705     char *r;
 706     suppress_error = 0;
 707     r = guestfs_cat (g, path);
 708     if (r == NULL)
 709       return -1;
 710     if (strcmp (r, expected) != 0) {
 711       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 712       return -1;
 713     }
 714     free (r);
 715   }
 716   return 0;
 717 }
 718
 719 static int test_zerofree_0_skip (void)
 720 {
 721   const char *str;
 722
 723   str = getenv ("SKIP_TEST_ZEROFREE_0");
 724   if (str && strcmp (str, "1") == 0) return 1;
 725   str = getenv ("SKIP_TEST_ZEROFREE");
 726   if (str && strcmp (str, "1") == 0) return 1;
 727   return 0;
 728 }
 729
 730 static int test_zerofree_0 (void)
 731 {
 732   if (test_zerofree_0_skip ()) {
 733     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
 734     return 0;
 735   }
 736
 737   /* InitNone|InitEmpty for test_zerofree_0 */
 738   {
 739     char device[] = "/dev/sda";
 740     device[5] = devchar;
 741     int r;
 742     suppress_error = 0;
 743     r = guestfs_blockdev_setrw (g, device);
 744     if (r == -1)
 745       return -1;
 746   }
 747   {
 748     int r;
 749     suppress_error = 0;
 750     r = guestfs_umount_all (g);
 751     if (r == -1)
 752       return -1;
 753   }
 754   {
 755     int r;
 756     suppress_error = 0;
 757     r = guestfs_lvm_remove_all (g);
 758     if (r == -1)
 759       return -1;
 760   }
 761   /* TestOutput for zerofree (0) */
 762   char expected[] = "test file";
 763   {
 764     char device[] = "/dev/sda";
 765     device[5] = devchar;
 766     char lines_0[] = ",";
 767     char *lines[] = {
 768       lines_0,
 769       NULL
 770     };
 771     int r;
 772     suppress_error = 0;
 773     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 774     if (r == -1)
 775       return -1;
 776   }
 777   {
 778     char fstype[] = "ext3";
 779     char device[] = "/dev/sda1";
 780     device[5] = devchar;
 781     int r;
 782     suppress_error = 0;
 783     r = guestfs_mkfs (g, fstype, device);
 784     if (r == -1)
 785       return -1;
 786   }
 787   {
 788     char device[] = "/dev/sda1";
 789     device[5] = devchar;
 790     char mountpoint[] = "/";
 791     int r;
 792     suppress_error = 0;
 793     r = guestfs_mount (g, device, mountpoint);
 794     if (r == -1)
 795       return -1;
 796   }
 797   {
 798     char path[] = "/new";
 799     char content[] = "test file";
 800     int r;
 801     suppress_error = 0;
 802     r = guestfs_write_file (g, path, content, 0);
 803     if (r == -1)
 804       return -1;
 805   }
 806   {
 807     char pathordevice[] = "/dev/sda1";
 808     pathordevice[5] = devchar;
 809     int r;
 810     suppress_error = 0;
 811     r = guestfs_umount (g, pathordevice);
 812     if (r == -1)
 813       return -1;
 814   }
 815   {
 816     char device[] = "/dev/sda1";
 817     device[5] = devchar;
 818     int r;
 819     suppress_error = 0;
 820     r = guestfs_zerofree (g, device);
 821     if (r == -1)
 822       return -1;
 823   }
 824   {
 825     char device[] = "/dev/sda1";
 826     device[5] = devchar;
 827     char mountpoint[] = "/";
 828     int r;
 829     suppress_error = 0;
 830     r = guestfs_mount (g, device, mountpoint);
 831     if (r == -1)
 832       return -1;
 833   }
 834   {
 835     char path[] = "/new";
 836     char *r;
 837     suppress_error = 0;
 838     r = guestfs_cat (g, path);
 839     if (r == NULL)
 840       return -1;
 841     if (strcmp (r, expected) != 0) {
 842       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
 843       return -1;
 844     }
 845     free (r);
 846   }
 847   return 0;
 848 }
 849
 850 static int test_hexdump_0_skip (void)
 851 {
 852   const char *str;
 853
 854   str = getenv ("SKIP_TEST_HEXDUMP_0");
 855   if (str && strcmp (str, "1") == 0) return 1;
 856   str = getenv ("SKIP_TEST_HEXDUMP");
 857   if (str && strcmp (str, "1") == 0) return 1;
 858   return 0;
 859 }
 860
 861 static int test_hexdump_0 (void)
 862 {
 863   if (test_hexdump_0_skip ()) {
 864     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
 865     return 0;
 866   }
 867
 868   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
 869   {
 870     char device[] = "/dev/sda";
 871     device[5] = devchar;
 872     int r;
 873     suppress_error = 0;
 874     r = guestfs_blockdev_setrw (g, device);
 875     if (r == -1)
 876       return -1;
 877   }
 878   {
 879     int r;
 880     suppress_error = 0;
 881     r = guestfs_umount_all (g);
 882     if (r == -1)
 883       return -1;
 884   }
 885   {
 886     int r;
 887     suppress_error = 0;
 888     r = guestfs_lvm_remove_all (g);
 889     if (r == -1)
 890       return -1;
 891   }
 892   {
 893     char device[] = "/dev/sda";
 894     device[5] = devchar;
 895     char lines_0[] = ",";
 896     char *lines[] = {
 897       lines_0,
 898       NULL
 899     };
 900     int r;
 901     suppress_error = 0;
 902     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 903     if (r == -1)
 904       return -1;
 905   }
 906   {
 907     char fstype[] = "ext2";
 908     char device[] = "/dev/sda1";
 909     device[5] = devchar;
 910     int r;
 911     suppress_error = 0;
 912     r = guestfs_mkfs (g, fstype, device);
 913     if (r == -1)
 914       return -1;
 915   }
 916   {
 917     char device[] = "/dev/sda1";
 918     device[5] = devchar;
 919     char mountpoint[] = "/";
 920     int r;
 921     suppress_error = 0;
 922     r = guestfs_mount (g, device, mountpoint);
 923     if (r == -1)
 924       return -1;
 925   }
 926   /* TestOutput for hexdump (0) */
 927   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
 928   {
 929     char path[] = "/new";
 930     char content[] = "hello\nworld\n";
 931     int r;
 932     suppress_error = 0;
 933     r = guestfs_write_file (g, path, content, 12);
 934     if (r == -1)
 935       return -1;
 936   }
 937   {
 938     char path[] = "/new";
 939     char *r;
 940     suppress_error = 0;
 941     r = guestfs_hexdump (g, path);
 942     if (r == NULL)
 943       return -1;
 944     if (strcmp (r, expected) != 0) {
 945       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
 946       return -1;
 947     }
 948     free (r);
 949   }
 950   return 0;
 951 }
 952
 953 static int test_strings_e_0_skip (void)
 954 {
 955   const char *str;
 956
 957   str = getenv ("SKIP_TEST_STRINGS_E_0");
 958   if (str && strcmp (str, "1") == 0) return 1;
 959   str = getenv ("SKIP_TEST_STRINGS_E");
 960   if (str && strcmp (str, "1") == 0) return 1;
 961   return 0;
 962 }
 963
 964 static int test_strings_e_0 (void)
 965 {
 966   if (test_strings_e_0_skip ()) {
 967     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
 968     return 0;
 969   }
 970
 971   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
 972   {
 973     char device[] = "/dev/sda";
 974     device[5] = devchar;
 975     int r;
 976     suppress_error = 0;
 977     r = guestfs_blockdev_setrw (g, device);
 978     if (r == -1)
 979       return -1;
 980   }
 981   {
 982     int r;
 983     suppress_error = 0;
 984     r = guestfs_umount_all (g);
 985     if (r == -1)
 986       return -1;
 987   }
 988   {
 989     int r;
 990     suppress_error = 0;
 991     r = guestfs_lvm_remove_all (g);
 992     if (r == -1)
 993       return -1;
 994   }
 995   {
 996     char device[] = "/dev/sda";
 997     device[5] = devchar;
 998     char lines_0[] = ",";
 999     char *lines[] = {
1000       lines_0,
1001       NULL
1002     };
1003     int r;
1004     suppress_error = 0;
1005     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1006     if (r == -1)
1007       return -1;
1008   }
1009   {
1010     char fstype[] = "ext2";
1011     char device[] = "/dev/sda1";
1012     device[5] = devchar;
1013     int r;
1014     suppress_error = 0;
1015     r = guestfs_mkfs (g, fstype, device);
1016     if (r == -1)
1017       return -1;
1018   }
1019   {
1020     char device[] = "/dev/sda1";
1021     device[5] = devchar;
1022     char mountpoint[] = "/";
1023     int r;
1024     suppress_error = 0;
1025     r = guestfs_mount (g, device, mountpoint);
1026     if (r == -1)
1027       return -1;
1028   }
1029   /* TestOutputList for strings_e (0) */
1030   {
1031     char path[] = "/new";
1032     char content[] = "hello\nworld\n";
1033     int r;
1034     suppress_error = 0;
1035     r = guestfs_write_file (g, path, content, 0);
1036     if (r == -1)
1037       return -1;
1038   }
1039   {
1040     char encoding[] = "b";
1041     char path[] = "/new";
1042     char **r;
1043     int i;
1044     suppress_error = 0;
1045     r = guestfs_strings_e (g, encoding, path);
1046     if (r == NULL)
1047       return -1;
1048     if (r[0] != NULL) {
1049       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1050       print_strings (r);
1051       return -1;
1052     }
1053     for (i = 0; r[i] != NULL; ++i)
1054       free (r[i]);
1055     free (r);
1056   }
1057   return 0;
1058 }
1059
1060 static int test_strings_e_1_skip (void)
1061 {
1062   const char *str;
1063
1064   str = getenv ("SKIP_TEST_STRINGS_E_1");
1065   if (str && strcmp (str, "1") == 0) return 1;
1066   str = getenv ("SKIP_TEST_STRINGS_E");
1067   if (str && strcmp (str, "1") == 0) return 1;
1068   return 0;
1069 }
1070
1071 static int test_strings_e_1 (void)
1072 {
1073   if (test_strings_e_1_skip ()) {
1074     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1075     return 0;
1076   }
1077
1078   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1079   return 0;
1080 }
1081
1082 static int test_strings_0_skip (void)
1083 {
1084   const char *str;
1085
1086   str = getenv ("SKIP_TEST_STRINGS_0");
1087   if (str && strcmp (str, "1") == 0) return 1;
1088   str = getenv ("SKIP_TEST_STRINGS");
1089   if (str && strcmp (str, "1") == 0) return 1;
1090   return 0;
1091 }
1092
1093 static int test_strings_0 (void)
1094 {
1095   if (test_strings_0_skip ()) {
1096     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1097     return 0;
1098   }
1099
1100   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1101   {
1102     char device[] = "/dev/sda";
1103     device[5] = devchar;
1104     int r;
1105     suppress_error = 0;
1106     r = guestfs_blockdev_setrw (g, device);
1107     if (r == -1)
1108       return -1;
1109   }
1110   {
1111     int r;
1112     suppress_error = 0;
1113     r = guestfs_umount_all (g);
1114     if (r == -1)
1115       return -1;
1116   }
1117   {
1118     int r;
1119     suppress_error = 0;
1120     r = guestfs_lvm_remove_all (g);
1121     if (r == -1)
1122       return -1;
1123   }
1124   {
1125     char device[] = "/dev/sda";
1126     device[5] = devchar;
1127     char lines_0[] = ",";
1128     char *lines[] = {
1129       lines_0,
1130       NULL
1131     };
1132     int r;
1133     suppress_error = 0;
1134     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1135     if (r == -1)
1136       return -1;
1137   }
1138   {
1139     char fstype[] = "ext2";
1140     char device[] = "/dev/sda1";
1141     device[5] = devchar;
1142     int r;
1143     suppress_error = 0;
1144     r = guestfs_mkfs (g, fstype, device);
1145     if (r == -1)
1146       return -1;
1147   }
1148   {
1149     char device[] = "/dev/sda1";
1150     device[5] = devchar;
1151     char mountpoint[] = "/";
1152     int r;
1153     suppress_error = 0;
1154     r = guestfs_mount (g, device, mountpoint);
1155     if (r == -1)
1156       return -1;
1157   }
1158   /* TestOutputList for strings (0) */
1159   {
1160     char path[] = "/new";
1161     char content[] = "hello\nworld\n";
1162     int r;
1163     suppress_error = 0;
1164     r = guestfs_write_file (g, path, content, 0);
1165     if (r == -1)
1166       return -1;
1167   }
1168   {
1169     char path[] = "/new";
1170     char **r;
1171     int i;
1172     suppress_error = 0;
1173     r = guestfs_strings (g, path);
1174     if (r == NULL)
1175       return -1;
1176     if (!r[0]) {
1177       fprintf (stderr, "test_strings_0: short list returned from command\n");
1178       print_strings (r);
1179       return -1;
1180     }
1181     {
1182       char expected[] = "hello";
1183       if (strcmp (r[0], expected) != 0) {
1184         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1185         return -1;
1186       }
1187     }
1188     if (!r[1]) {
1189       fprintf (stderr, "test_strings_0: short list returned from command\n");
1190       print_strings (r);
1191       return -1;
1192     }
1193     {
1194       char expected[] = "world";
1195       if (strcmp (r[1], expected) != 0) {
1196         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1197         return -1;
1198       }
1199     }
1200     if (r[2] != NULL) {
1201       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1202       print_strings (r);
1203       return -1;
1204     }
1205     for (i = 0; r[i] != NULL; ++i)
1206       free (r[i]);
1207     free (r);
1208   }
1209   return 0;
1210 }
1211
1212 static int test_strings_1_skip (void)
1213 {
1214   const char *str;
1215
1216   str = getenv ("SKIP_TEST_STRINGS_1");
1217   if (str && strcmp (str, "1") == 0) return 1;
1218   str = getenv ("SKIP_TEST_STRINGS");
1219   if (str && strcmp (str, "1") == 0) return 1;
1220   return 0;
1221 }
1222
1223 static int test_strings_1 (void)
1224 {
1225   if (test_strings_1_skip ()) {
1226     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1227     return 0;
1228   }
1229
1230   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1231   {
1232     char device[] = "/dev/sda";
1233     device[5] = devchar;
1234     int r;
1235     suppress_error = 0;
1236     r = guestfs_blockdev_setrw (g, device);
1237     if (r == -1)
1238       return -1;
1239   }
1240   {
1241     int r;
1242     suppress_error = 0;
1243     r = guestfs_umount_all (g);
1244     if (r == -1)
1245       return -1;
1246   }
1247   {
1248     int r;
1249     suppress_error = 0;
1250     r = guestfs_lvm_remove_all (g);
1251     if (r == -1)
1252       return -1;
1253   }
1254   {
1255     char device[] = "/dev/sda";
1256     device[5] = devchar;
1257     char lines_0[] = ",";
1258     char *lines[] = {
1259       lines_0,
1260       NULL
1261     };
1262     int r;
1263     suppress_error = 0;
1264     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1265     if (r == -1)
1266       return -1;
1267   }
1268   {
1269     char fstype[] = "ext2";
1270     char device[] = "/dev/sda1";
1271     device[5] = devchar;
1272     int r;
1273     suppress_error = 0;
1274     r = guestfs_mkfs (g, fstype, device);
1275     if (r == -1)
1276       return -1;
1277   }
1278   {
1279     char device[] = "/dev/sda1";
1280     device[5] = devchar;
1281     char mountpoint[] = "/";
1282     int r;
1283     suppress_error = 0;
1284     r = guestfs_mount (g, device, mountpoint);
1285     if (r == -1)
1286       return -1;
1287   }
1288   /* TestOutputList for strings (1) */
1289   {
1290     char path[] = "/new";
1291     int r;
1292     suppress_error = 0;
1293     r = guestfs_touch (g, path);
1294     if (r == -1)
1295       return -1;
1296   }
1297   {
1298     char path[] = "/new";
1299     char **r;
1300     int i;
1301     suppress_error = 0;
1302     r = guestfs_strings (g, path);
1303     if (r == NULL)
1304       return -1;
1305     if (r[0] != NULL) {
1306       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1307       print_strings (r);
1308       return -1;
1309     }
1310     for (i = 0; r[i] != NULL; ++i)
1311       free (r[i]);
1312     free (r);
1313   }
1314   return 0;
1315 }
1316
1317 static int test_equal_0_skip (void)
1318 {
1319   const char *str;
1320
1321   str = getenv ("SKIP_TEST_EQUAL_0");
1322   if (str && strcmp (str, "1") == 0) return 1;
1323   str = getenv ("SKIP_TEST_EQUAL");
1324   if (str && strcmp (str, "1") == 0) return 1;
1325   return 0;
1326 }
1327
1328 static int test_equal_0 (void)
1329 {
1330   if (test_equal_0_skip ()) {
1331     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1332     return 0;
1333   }
1334
1335   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1336   {
1337     char device[] = "/dev/sda";
1338     device[5] = devchar;
1339     int r;
1340     suppress_error = 0;
1341     r = guestfs_blockdev_setrw (g, device);
1342     if (r == -1)
1343       return -1;
1344   }
1345   {
1346     int r;
1347     suppress_error = 0;
1348     r = guestfs_umount_all (g);
1349     if (r == -1)
1350       return -1;
1351   }
1352   {
1353     int r;
1354     suppress_error = 0;
1355     r = guestfs_lvm_remove_all (g);
1356     if (r == -1)
1357       return -1;
1358   }
1359   {
1360     char device[] = "/dev/sda";
1361     device[5] = devchar;
1362     char lines_0[] = ",";
1363     char *lines[] = {
1364       lines_0,
1365       NULL
1366     };
1367     int r;
1368     suppress_error = 0;
1369     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1370     if (r == -1)
1371       return -1;
1372   }
1373   {
1374     char fstype[] = "ext2";
1375     char device[] = "/dev/sda1";
1376     device[5] = devchar;
1377     int r;
1378     suppress_error = 0;
1379     r = guestfs_mkfs (g, fstype, device);
1380     if (r == -1)
1381       return -1;
1382   }
1383   {
1384     char device[] = "/dev/sda1";
1385     device[5] = devchar;
1386     char mountpoint[] = "/";
1387     int r;
1388     suppress_error = 0;
1389     r = guestfs_mount (g, device, mountpoint);
1390     if (r == -1)
1391       return -1;
1392   }
1393   /* TestOutputTrue for equal (0) */
1394   {
1395     char path[] = "/file1";
1396     char content[] = "contents of a file";
1397     int r;
1398     suppress_error = 0;
1399     r = guestfs_write_file (g, path, content, 0);
1400     if (r == -1)
1401       return -1;
1402   }
1403   {
1404     char src[] = "/file1";
1405     char dest[] = "/file2";
1406     int r;
1407     suppress_error = 0;
1408     r = guestfs_cp (g, src, dest);
1409     if (r == -1)
1410       return -1;
1411   }
1412   {
1413     char file1[] = "/file1";
1414     char file2[] = "/file2";
1415     int r;
1416     suppress_error = 0;
1417     r = guestfs_equal (g, file1, file2);
1418     if (r == -1)
1419       return -1;
1420     if (!r) {
1421       fprintf (stderr, "test_equal_0: expected true, got false\n");
1422       return -1;
1423     }
1424   }
1425   return 0;
1426 }
1427
1428 static int test_equal_1_skip (void)
1429 {
1430   const char *str;
1431
1432   str = getenv ("SKIP_TEST_EQUAL_1");
1433   if (str && strcmp (str, "1") == 0) return 1;
1434   str = getenv ("SKIP_TEST_EQUAL");
1435   if (str && strcmp (str, "1") == 0) return 1;
1436   return 0;
1437 }
1438
1439 static int test_equal_1 (void)
1440 {
1441   if (test_equal_1_skip ()) {
1442     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1443     return 0;
1444   }
1445
1446   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1447   {
1448     char device[] = "/dev/sda";
1449     device[5] = devchar;
1450     int r;
1451     suppress_error = 0;
1452     r = guestfs_blockdev_setrw (g, device);
1453     if (r == -1)
1454       return -1;
1455   }
1456   {
1457     int r;
1458     suppress_error = 0;
1459     r = guestfs_umount_all (g);
1460     if (r == -1)
1461       return -1;
1462   }
1463   {
1464     int r;
1465     suppress_error = 0;
1466     r = guestfs_lvm_remove_all (g);
1467     if (r == -1)
1468       return -1;
1469   }
1470   {
1471     char device[] = "/dev/sda";
1472     device[5] = devchar;
1473     char lines_0[] = ",";
1474     char *lines[] = {
1475       lines_0,
1476       NULL
1477     };
1478     int r;
1479     suppress_error = 0;
1480     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1481     if (r == -1)
1482       return -1;
1483   }
1484   {
1485     char fstype[] = "ext2";
1486     char device[] = "/dev/sda1";
1487     device[5] = devchar;
1488     int r;
1489     suppress_error = 0;
1490     r = guestfs_mkfs (g, fstype, device);
1491     if (r == -1)
1492       return -1;
1493   }
1494   {
1495     char device[] = "/dev/sda1";
1496     device[5] = devchar;
1497     char mountpoint[] = "/";
1498     int r;
1499     suppress_error = 0;
1500     r = guestfs_mount (g, device, mountpoint);
1501     if (r == -1)
1502       return -1;
1503   }
1504   /* TestOutputFalse for equal (1) */
1505   {
1506     char path[] = "/file1";
1507     char content[] = "contents of a file";
1508     int r;
1509     suppress_error = 0;
1510     r = guestfs_write_file (g, path, content, 0);
1511     if (r == -1)
1512       return -1;
1513   }
1514   {
1515     char path[] = "/file2";
1516     char content[] = "contents of another file";
1517     int r;
1518     suppress_error = 0;
1519     r = guestfs_write_file (g, path, content, 0);
1520     if (r == -1)
1521       return -1;
1522   }
1523   {
1524     char file1[] = "/file1";
1525     char file2[] = "/file2";
1526     int r;
1527     suppress_error = 0;
1528     r = guestfs_equal (g, file1, file2);
1529     if (r == -1)
1530       return -1;
1531     if (r) {
1532       fprintf (stderr, "test_equal_1: expected false, got true\n");
1533       return -1;
1534     }
1535   }
1536   return 0;
1537 }
1538
1539 static int test_equal_2_skip (void)
1540 {
1541   const char *str;
1542
1543   str = getenv ("SKIP_TEST_EQUAL_2");
1544   if (str && strcmp (str, "1") == 0) return 1;
1545   str = getenv ("SKIP_TEST_EQUAL");
1546   if (str && strcmp (str, "1") == 0) return 1;
1547   return 0;
1548 }
1549
1550 static int test_equal_2 (void)
1551 {
1552   if (test_equal_2_skip ()) {
1553     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1554     return 0;
1555   }
1556
1557   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1558   {
1559     char device[] = "/dev/sda";
1560     device[5] = devchar;
1561     int r;
1562     suppress_error = 0;
1563     r = guestfs_blockdev_setrw (g, device);
1564     if (r == -1)
1565       return -1;
1566   }
1567   {
1568     int r;
1569     suppress_error = 0;
1570     r = guestfs_umount_all (g);
1571     if (r == -1)
1572       return -1;
1573   }
1574   {
1575     int r;
1576     suppress_error = 0;
1577     r = guestfs_lvm_remove_all (g);
1578     if (r == -1)
1579       return -1;
1580   }
1581   {
1582     char device[] = "/dev/sda";
1583     device[5] = devchar;
1584     char lines_0[] = ",";
1585     char *lines[] = {
1586       lines_0,
1587       NULL
1588     };
1589     int r;
1590     suppress_error = 0;
1591     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1592     if (r == -1)
1593       return -1;
1594   }
1595   {
1596     char fstype[] = "ext2";
1597     char device[] = "/dev/sda1";
1598     device[5] = devchar;
1599     int r;
1600     suppress_error = 0;
1601     r = guestfs_mkfs (g, fstype, device);
1602     if (r == -1)
1603       return -1;
1604   }
1605   {
1606     char device[] = "/dev/sda1";
1607     device[5] = devchar;
1608     char mountpoint[] = "/";
1609     int r;
1610     suppress_error = 0;
1611     r = guestfs_mount (g, device, mountpoint);
1612     if (r == -1)
1613       return -1;
1614   }
1615   /* TestLastFail for equal (2) */
1616   {
1617     char file1[] = "/file1";
1618     char file2[] = "/file2";
1619     int r;
1620     suppress_error = 1;
1621     r = guestfs_equal (g, file1, file2);
1622     if (r != -1)
1623       return -1;
1624   }
1625   return 0;
1626 }
1627
1628 static int test_ping_daemon_0_skip (void)
1629 {
1630   const char *str;
1631
1632   str = getenv ("SKIP_TEST_PING_DAEMON_0");
1633   if (str && strcmp (str, "1") == 0) return 1;
1634   str = getenv ("SKIP_TEST_PING_DAEMON");
1635   if (str && strcmp (str, "1") == 0) return 1;
1636   return 0;
1637 }
1638
1639 static int test_ping_daemon_0 (void)
1640 {
1641   if (test_ping_daemon_0_skip ()) {
1642     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1643     return 0;
1644   }
1645
1646   /* InitNone|InitEmpty for test_ping_daemon_0 */
1647   {
1648     char device[] = "/dev/sda";
1649     device[5] = devchar;
1650     int r;
1651     suppress_error = 0;
1652     r = guestfs_blockdev_setrw (g, device);
1653     if (r == -1)
1654       return -1;
1655   }
1656   {
1657     int r;
1658     suppress_error = 0;
1659     r = guestfs_umount_all (g);
1660     if (r == -1)
1661       return -1;
1662   }
1663   {
1664     int r;
1665     suppress_error = 0;
1666     r = guestfs_lvm_remove_all (g);
1667     if (r == -1)
1668       return -1;
1669   }
1670   /* TestRun for ping_daemon (0) */
1671   {
1672     int r;
1673     suppress_error = 0;
1674     r = guestfs_ping_daemon (g);
1675     if (r == -1)
1676       return -1;
1677   }
1678   return 0;
1679 }
1680
1681 static int test_dmesg_0_skip (void)
1682 {
1683   const char *str;
1684
1685   str = getenv ("SKIP_TEST_DMESG_0");
1686   if (str && strcmp (str, "1") == 0) return 1;
1687   str = getenv ("SKIP_TEST_DMESG");
1688   if (str && strcmp (str, "1") == 0) return 1;
1689   return 0;
1690 }
1691
1692 static int test_dmesg_0 (void)
1693 {
1694   if (test_dmesg_0_skip ()) {
1695     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1696     return 0;
1697   }
1698
1699   /* InitNone|InitEmpty for test_dmesg_0 */
1700   {
1701     char device[] = "/dev/sda";
1702     device[5] = devchar;
1703     int r;
1704     suppress_error = 0;
1705     r = guestfs_blockdev_setrw (g, device);
1706     if (r == -1)
1707       return -1;
1708   }
1709   {
1710     int r;
1711     suppress_error = 0;
1712     r = guestfs_umount_all (g);
1713     if (r == -1)
1714       return -1;
1715   }
1716   {
1717     int r;
1718     suppress_error = 0;
1719     r = guestfs_lvm_remove_all (g);
1720     if (r == -1)
1721       return -1;
1722   }
1723   /* TestRun for dmesg (0) */
1724   {
1725     char *r;
1726     suppress_error = 0;
1727     r = guestfs_dmesg (g);
1728     if (r == NULL)
1729       return -1;
1730     free (r);
1731   }
1732   return 0;
1733 }
1734
1735 static int test_drop_caches_0_skip (void)
1736 {
1737   const char *str;
1738
1739   str = getenv ("SKIP_TEST_DROP_CACHES_0");
1740   if (str && strcmp (str, "1") == 0) return 1;
1741   str = getenv ("SKIP_TEST_DROP_CACHES");
1742   if (str && strcmp (str, "1") == 0) return 1;
1743   return 0;
1744 }
1745
1746 static int test_drop_caches_0 (void)
1747 {
1748   if (test_drop_caches_0_skip ()) {
1749     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1750     return 0;
1751   }
1752
1753   /* InitNone|InitEmpty for test_drop_caches_0 */
1754   {
1755     char device[] = "/dev/sda";
1756     device[5] = devchar;
1757     int r;
1758     suppress_error = 0;
1759     r = guestfs_blockdev_setrw (g, device);
1760     if (r == -1)
1761       return -1;
1762   }
1763   {
1764     int r;
1765     suppress_error = 0;
1766     r = guestfs_umount_all (g);
1767     if (r == -1)
1768       return -1;
1769   }
1770   {
1771     int r;
1772     suppress_error = 0;
1773     r = guestfs_lvm_remove_all (g);
1774     if (r == -1)
1775       return -1;
1776   }
1777   /* TestRun for drop_caches (0) */
1778   {
1779     int r;
1780     suppress_error = 0;
1781     r = guestfs_drop_caches (g, 3);
1782     if (r == -1)
1783       return -1;
1784   }
1785   return 0;
1786 }
1787
1788 static int test_mv_0_skip (void)
1789 {
1790   const char *str;
1791
1792   str = getenv ("SKIP_TEST_MV_0");
1793   if (str && strcmp (str, "1") == 0) return 1;
1794   str = getenv ("SKIP_TEST_MV");
1795   if (str && strcmp (str, "1") == 0) return 1;
1796   return 0;
1797 }
1798
1799 static int test_mv_0 (void)
1800 {
1801   if (test_mv_0_skip ()) {
1802     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
1803     return 0;
1804   }
1805
1806   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1807   {
1808     char device[] = "/dev/sda";
1809     device[5] = devchar;
1810     int r;
1811     suppress_error = 0;
1812     r = guestfs_blockdev_setrw (g, device);
1813     if (r == -1)
1814       return -1;
1815   }
1816   {
1817     int r;
1818     suppress_error = 0;
1819     r = guestfs_umount_all (g);
1820     if (r == -1)
1821       return -1;
1822   }
1823   {
1824     int r;
1825     suppress_error = 0;
1826     r = guestfs_lvm_remove_all (g);
1827     if (r == -1)
1828       return -1;
1829   }
1830   {
1831     char device[] = "/dev/sda";
1832     device[5] = devchar;
1833     char lines_0[] = ",";
1834     char *lines[] = {
1835       lines_0,
1836       NULL
1837     };
1838     int r;
1839     suppress_error = 0;
1840     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1841     if (r == -1)
1842       return -1;
1843   }
1844   {
1845     char fstype[] = "ext2";
1846     char device[] = "/dev/sda1";
1847     device[5] = devchar;
1848     int r;
1849     suppress_error = 0;
1850     r = guestfs_mkfs (g, fstype, device);
1851     if (r == -1)
1852       return -1;
1853   }
1854   {
1855     char device[] = "/dev/sda1";
1856     device[5] = devchar;
1857     char mountpoint[] = "/";
1858     int r;
1859     suppress_error = 0;
1860     r = guestfs_mount (g, device, mountpoint);
1861     if (r == -1)
1862       return -1;
1863   }
1864   /* TestOutput for mv (0) */
1865   char expected[] = "file content";
1866   {
1867     char path[] = "/old";
1868     char content[] = "file content";
1869     int r;
1870     suppress_error = 0;
1871     r = guestfs_write_file (g, path, content, 0);
1872     if (r == -1)
1873       return -1;
1874   }
1875   {
1876     char src[] = "/old";
1877     char dest[] = "/new";
1878     int r;
1879     suppress_error = 0;
1880     r = guestfs_mv (g, src, dest);
1881     if (r == -1)
1882       return -1;
1883   }
1884   {
1885     char path[] = "/new";
1886     char *r;
1887     suppress_error = 0;
1888     r = guestfs_cat (g, path);
1889     if (r == NULL)
1890       return -1;
1891     if (strcmp (r, expected) != 0) {
1892       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1893       return -1;
1894     }
1895     free (r);
1896   }
1897   return 0;
1898 }
1899
1900 static int test_mv_1_skip (void)
1901 {
1902   const char *str;
1903
1904   str = getenv ("SKIP_TEST_MV_1");
1905   if (str && strcmp (str, "1") == 0) return 1;
1906   str = getenv ("SKIP_TEST_MV");
1907   if (str && strcmp (str, "1") == 0) return 1;
1908   return 0;
1909 }
1910
1911 static int test_mv_1 (void)
1912 {
1913   if (test_mv_1_skip ()) {
1914     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
1915     return 0;
1916   }
1917
1918   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1919   {
1920     char device[] = "/dev/sda";
1921     device[5] = devchar;
1922     int r;
1923     suppress_error = 0;
1924     r = guestfs_blockdev_setrw (g, device);
1925     if (r == -1)
1926       return -1;
1927   }
1928   {
1929     int r;
1930     suppress_error = 0;
1931     r = guestfs_umount_all (g);
1932     if (r == -1)
1933       return -1;
1934   }
1935   {
1936     int r;
1937     suppress_error = 0;
1938     r = guestfs_lvm_remove_all (g);
1939     if (r == -1)
1940       return -1;
1941   }
1942   {
1943     char device[] = "/dev/sda";
1944     device[5] = devchar;
1945     char lines_0[] = ",";
1946     char *lines[] = {
1947       lines_0,
1948       NULL
1949     };
1950     int r;
1951     suppress_error = 0;
1952     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1953     if (r == -1)
1954       return -1;
1955   }
1956   {
1957     char fstype[] = "ext2";
1958     char device[] = "/dev/sda1";
1959     device[5] = devchar;
1960     int r;
1961     suppress_error = 0;
1962     r = guestfs_mkfs (g, fstype, device);
1963     if (r == -1)
1964       return -1;
1965   }
1966   {
1967     char device[] = "/dev/sda1";
1968     device[5] = devchar;
1969     char mountpoint[] = "/";
1970     int r;
1971     suppress_error = 0;
1972     r = guestfs_mount (g, device, mountpoint);
1973     if (r == -1)
1974       return -1;
1975   }
1976   /* TestOutputFalse for mv (1) */
1977   {
1978     char path[] = "/old";
1979     char content[] = "file content";
1980     int r;
1981     suppress_error = 0;
1982     r = guestfs_write_file (g, path, content, 0);
1983     if (r == -1)
1984       return -1;
1985   }
1986   {
1987     char src[] = "/old";
1988     char dest[] = "/new";
1989     int r;
1990     suppress_error = 0;
1991     r = guestfs_mv (g, src, dest);
1992     if (r == -1)
1993       return -1;
1994   }
1995   {
1996     char path[] = "/old";
1997     int r;
1998     suppress_error = 0;
1999     r = guestfs_is_file (g, path);
2000     if (r == -1)
2001       return -1;
2002     if (r) {
2003       fprintf (stderr, "test_mv_1: expected false, got true\n");
2004       return -1;
2005     }
2006   }
2007   return 0;
2008 }
2009
2010 static int test_cp_a_0_skip (void)
2011 {
2012   const char *str;
2013
2014   str = getenv ("SKIP_TEST_CP_A_0");
2015   if (str && strcmp (str, "1") == 0) return 1;
2016   str = getenv ("SKIP_TEST_CP_A");
2017   if (str && strcmp (str, "1") == 0) return 1;
2018   return 0;
2019 }
2020
2021 static int test_cp_a_0 (void)
2022 {
2023   if (test_cp_a_0_skip ()) {
2024     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2025     return 0;
2026   }
2027
2028   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2029   {
2030     char device[] = "/dev/sda";
2031     device[5] = devchar;
2032     int r;
2033     suppress_error = 0;
2034     r = guestfs_blockdev_setrw (g, device);
2035     if (r == -1)
2036       return -1;
2037   }
2038   {
2039     int r;
2040     suppress_error = 0;
2041     r = guestfs_umount_all (g);
2042     if (r == -1)
2043       return -1;
2044   }
2045   {
2046     int r;
2047     suppress_error = 0;
2048     r = guestfs_lvm_remove_all (g);
2049     if (r == -1)
2050       return -1;
2051   }
2052   {
2053     char device[] = "/dev/sda";
2054     device[5] = devchar;
2055     char lines_0[] = ",";
2056     char *lines[] = {
2057       lines_0,
2058       NULL
2059     };
2060     int r;
2061     suppress_error = 0;
2062     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2063     if (r == -1)
2064       return -1;
2065   }
2066   {
2067     char fstype[] = "ext2";
2068     char device[] = "/dev/sda1";
2069     device[5] = devchar;
2070     int r;
2071     suppress_error = 0;
2072     r = guestfs_mkfs (g, fstype, device);
2073     if (r == -1)
2074       return -1;
2075   }
2076   {
2077     char device[] = "/dev/sda1";
2078     device[5] = devchar;
2079     char mountpoint[] = "/";
2080     int r;
2081     suppress_error = 0;
2082     r = guestfs_mount (g, device, mountpoint);
2083     if (r == -1)
2084       return -1;
2085   }
2086   /* TestOutput for cp_a (0) */
2087   char expected[] = "file content";
2088   {
2089     char path[] = "/olddir";
2090     int r;
2091     suppress_error = 0;
2092     r = guestfs_mkdir (g, path);
2093     if (r == -1)
2094       return -1;
2095   }
2096   {
2097     char path[] = "/newdir";
2098     int r;
2099     suppress_error = 0;
2100     r = guestfs_mkdir (g, path);
2101     if (r == -1)
2102       return -1;
2103   }
2104   {
2105     char path[] = "/olddir/file";
2106     char content[] = "file content";
2107     int r;
2108     suppress_error = 0;
2109     r = guestfs_write_file (g, path, content, 0);
2110     if (r == -1)
2111       return -1;
2112   }
2113   {
2114     char src[] = "/olddir";
2115     char dest[] = "/newdir";
2116     int r;
2117     suppress_error = 0;
2118     r = guestfs_cp_a (g, src, dest);
2119     if (r == -1)
2120       return -1;
2121   }
2122   {
2123     char path[] = "/newdir/olddir/file";
2124     char *r;
2125     suppress_error = 0;
2126     r = guestfs_cat (g, path);
2127     if (r == NULL)
2128       return -1;
2129     if (strcmp (r, expected) != 0) {
2130       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2131       return -1;
2132     }
2133     free (r);
2134   }
2135   return 0;
2136 }
2137
2138 static int test_cp_0_skip (void)
2139 {
2140   const char *str;
2141
2142   str = getenv ("SKIP_TEST_CP_0");
2143   if (str && strcmp (str, "1") == 0) return 1;
2144   str = getenv ("SKIP_TEST_CP");
2145   if (str && strcmp (str, "1") == 0) return 1;
2146   return 0;
2147 }
2148
2149 static int test_cp_0 (void)
2150 {
2151   if (test_cp_0_skip ()) {
2152     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2153     return 0;
2154   }
2155
2156   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2157   {
2158     char device[] = "/dev/sda";
2159     device[5] = devchar;
2160     int r;
2161     suppress_error = 0;
2162     r = guestfs_blockdev_setrw (g, device);
2163     if (r == -1)
2164       return -1;
2165   }
2166   {
2167     int r;
2168     suppress_error = 0;
2169     r = guestfs_umount_all (g);
2170     if (r == -1)
2171       return -1;
2172   }
2173   {
2174     int r;
2175     suppress_error = 0;
2176     r = guestfs_lvm_remove_all (g);
2177     if (r == -1)
2178       return -1;
2179   }
2180   {
2181     char device[] = "/dev/sda";
2182     device[5] = devchar;
2183     char lines_0[] = ",";
2184     char *lines[] = {
2185       lines_0,
2186       NULL
2187     };
2188     int r;
2189     suppress_error = 0;
2190     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2191     if (r == -1)
2192       return -1;
2193   }
2194   {
2195     char fstype[] = "ext2";
2196     char device[] = "/dev/sda1";
2197     device[5] = devchar;
2198     int r;
2199     suppress_error = 0;
2200     r = guestfs_mkfs (g, fstype, device);
2201     if (r == -1)
2202       return -1;
2203   }
2204   {
2205     char device[] = "/dev/sda1";
2206     device[5] = devchar;
2207     char mountpoint[] = "/";
2208     int r;
2209     suppress_error = 0;
2210     r = guestfs_mount (g, device, mountpoint);
2211     if (r == -1)
2212       return -1;
2213   }
2214   /* TestOutput for cp (0) */
2215   char expected[] = "file content";
2216   {
2217     char path[] = "/old";
2218     char content[] = "file content";
2219     int r;
2220     suppress_error = 0;
2221     r = guestfs_write_file (g, path, content, 0);
2222     if (r == -1)
2223       return -1;
2224   }
2225   {
2226     char src[] = "/old";
2227     char dest[] = "/new";
2228     int r;
2229     suppress_error = 0;
2230     r = guestfs_cp (g, src, dest);
2231     if (r == -1)
2232       return -1;
2233   }
2234   {
2235     char path[] = "/new";
2236     char *r;
2237     suppress_error = 0;
2238     r = guestfs_cat (g, path);
2239     if (r == NULL)
2240       return -1;
2241     if (strcmp (r, expected) != 0) {
2242       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2243       return -1;
2244     }
2245     free (r);
2246   }
2247   return 0;
2248 }
2249
2250 static int test_cp_1_skip (void)
2251 {
2252   const char *str;
2253
2254   str = getenv ("SKIP_TEST_CP_1");
2255   if (str && strcmp (str, "1") == 0) return 1;
2256   str = getenv ("SKIP_TEST_CP");
2257   if (str && strcmp (str, "1") == 0) return 1;
2258   return 0;
2259 }
2260
2261 static int test_cp_1 (void)
2262 {
2263   if (test_cp_1_skip ()) {
2264     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2265     return 0;
2266   }
2267
2268   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2269   {
2270     char device[] = "/dev/sda";
2271     device[5] = devchar;
2272     int r;
2273     suppress_error = 0;
2274     r = guestfs_blockdev_setrw (g, device);
2275     if (r == -1)
2276       return -1;
2277   }
2278   {
2279     int r;
2280     suppress_error = 0;
2281     r = guestfs_umount_all (g);
2282     if (r == -1)
2283       return -1;
2284   }
2285   {
2286     int r;
2287     suppress_error = 0;
2288     r = guestfs_lvm_remove_all (g);
2289     if (r == -1)
2290       return -1;
2291   }
2292   {
2293     char device[] = "/dev/sda";
2294     device[5] = devchar;
2295     char lines_0[] = ",";
2296     char *lines[] = {
2297       lines_0,
2298       NULL
2299     };
2300     int r;
2301     suppress_error = 0;
2302     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2303     if (r == -1)
2304       return -1;
2305   }
2306   {
2307     char fstype[] = "ext2";
2308     char device[] = "/dev/sda1";
2309     device[5] = devchar;
2310     int r;
2311     suppress_error = 0;
2312     r = guestfs_mkfs (g, fstype, device);
2313     if (r == -1)
2314       return -1;
2315   }
2316   {
2317     char device[] = "/dev/sda1";
2318     device[5] = devchar;
2319     char mountpoint[] = "/";
2320     int r;
2321     suppress_error = 0;
2322     r = guestfs_mount (g, device, mountpoint);
2323     if (r == -1)
2324       return -1;
2325   }
2326   /* TestOutputTrue for cp (1) */
2327   {
2328     char path[] = "/old";
2329     char content[] = "file content";
2330     int r;
2331     suppress_error = 0;
2332     r = guestfs_write_file (g, path, content, 0);
2333     if (r == -1)
2334       return -1;
2335   }
2336   {
2337     char src[] = "/old";
2338     char dest[] = "/new";
2339     int r;
2340     suppress_error = 0;
2341     r = guestfs_cp (g, src, dest);
2342     if (r == -1)
2343       return -1;
2344   }
2345   {
2346     char path[] = "/old";
2347     int r;
2348     suppress_error = 0;
2349     r = guestfs_is_file (g, path);
2350     if (r == -1)
2351       return -1;
2352     if (!r) {
2353       fprintf (stderr, "test_cp_1: expected true, got false\n");
2354       return -1;
2355     }
2356   }
2357   return 0;
2358 }
2359
2360 static int test_cp_2_skip (void)
2361 {
2362   const char *str;
2363
2364   str = getenv ("SKIP_TEST_CP_2");
2365   if (str && strcmp (str, "1") == 0) return 1;
2366   str = getenv ("SKIP_TEST_CP");
2367   if (str && strcmp (str, "1") == 0) return 1;
2368   return 0;
2369 }
2370
2371 static int test_cp_2 (void)
2372 {
2373   if (test_cp_2_skip ()) {
2374     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2375     return 0;
2376   }
2377
2378   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2379   {
2380     char device[] = "/dev/sda";
2381     device[5] = devchar;
2382     int r;
2383     suppress_error = 0;
2384     r = guestfs_blockdev_setrw (g, device);
2385     if (r == -1)
2386       return -1;
2387   }
2388   {
2389     int r;
2390     suppress_error = 0;
2391     r = guestfs_umount_all (g);
2392     if (r == -1)
2393       return -1;
2394   }
2395   {
2396     int r;
2397     suppress_error = 0;
2398     r = guestfs_lvm_remove_all (g);
2399     if (r == -1)
2400       return -1;
2401   }
2402   {
2403     char device[] = "/dev/sda";
2404     device[5] = devchar;
2405     char lines_0[] = ",";
2406     char *lines[] = {
2407       lines_0,
2408       NULL
2409     };
2410     int r;
2411     suppress_error = 0;
2412     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2413     if (r == -1)
2414       return -1;
2415   }
2416   {
2417     char fstype[] = "ext2";
2418     char device[] = "/dev/sda1";
2419     device[5] = devchar;
2420     int r;
2421     suppress_error = 0;
2422     r = guestfs_mkfs (g, fstype, device);
2423     if (r == -1)
2424       return -1;
2425   }
2426   {
2427     char device[] = "/dev/sda1";
2428     device[5] = devchar;
2429     char mountpoint[] = "/";
2430     int r;
2431     suppress_error = 0;
2432     r = guestfs_mount (g, device, mountpoint);
2433     if (r == -1)
2434       return -1;
2435   }
2436   /* TestOutput for cp (2) */
2437   char expected[] = "file content";
2438   {
2439     char path[] = "/old";
2440     char content[] = "file content";
2441     int r;
2442     suppress_error = 0;
2443     r = guestfs_write_file (g, path, content, 0);
2444     if (r == -1)
2445       return -1;
2446   }
2447   {
2448     char path[] = "/dir";
2449     int r;
2450     suppress_error = 0;
2451     r = guestfs_mkdir (g, path);
2452     if (r == -1)
2453       return -1;
2454   }
2455   {
2456     char src[] = "/old";
2457     char dest[] = "/dir/new";
2458     int r;
2459     suppress_error = 0;
2460     r = guestfs_cp (g, src, dest);
2461     if (r == -1)
2462       return -1;
2463   }
2464   {
2465     char path[] = "/dir/new";
2466     char *r;
2467     suppress_error = 0;
2468     r = guestfs_cat (g, path);
2469     if (r == NULL)
2470       return -1;
2471     if (strcmp (r, expected) != 0) {
2472       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2473       return -1;
2474     }
2475     free (r);
2476   }
2477   return 0;
2478 }
2479
2480 static int test_grub_install_0_skip (void)
2481 {
2482   const char *str;
2483
2484   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2485   if (str && strcmp (str, "1") == 0) return 1;
2486   str = getenv ("SKIP_TEST_GRUB_INSTALL");
2487   if (str && strcmp (str, "1") == 0) return 1;
2488   return 0;
2489 }
2490
2491 static int test_grub_install_0 (void)
2492 {
2493   if (test_grub_install_0_skip ()) {
2494     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2495     return 0;
2496   }
2497
2498   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2499   {
2500     char device[] = "/dev/sda";
2501     device[5] = devchar;
2502     int r;
2503     suppress_error = 0;
2504     r = guestfs_blockdev_setrw (g, device);
2505     if (r == -1)
2506       return -1;
2507   }
2508   {
2509     int r;
2510     suppress_error = 0;
2511     r = guestfs_umount_all (g);
2512     if (r == -1)
2513       return -1;
2514   }
2515   {
2516     int r;
2517     suppress_error = 0;
2518     r = guestfs_lvm_remove_all (g);
2519     if (r == -1)
2520       return -1;
2521   }
2522   {
2523     char device[] = "/dev/sda";
2524     device[5] = devchar;
2525     char lines_0[] = ",";
2526     char *lines[] = {
2527       lines_0,
2528       NULL
2529     };
2530     int r;
2531     suppress_error = 0;
2532     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2533     if (r == -1)
2534       return -1;
2535   }
2536   {
2537     char fstype[] = "ext2";
2538     char device[] = "/dev/sda1";
2539     device[5] = devchar;
2540     int r;
2541     suppress_error = 0;
2542     r = guestfs_mkfs (g, fstype, device);
2543     if (r == -1)
2544       return -1;
2545   }
2546   {
2547     char device[] = "/dev/sda1";
2548     device[5] = devchar;
2549     char mountpoint[] = "/";
2550     int r;
2551     suppress_error = 0;
2552     r = guestfs_mount (g, device, mountpoint);
2553     if (r == -1)
2554       return -1;
2555   }
2556   /* TestOutputTrue for grub_install (0) */
2557   {
2558     char root[] = "/";
2559     char device[] = "/dev/sda1";
2560     device[5] = devchar;
2561     int r;
2562     suppress_error = 0;
2563     r = guestfs_grub_install (g, root, device);
2564     if (r == -1)
2565       return -1;
2566   }
2567   {
2568     char path[] = "/boot";
2569     int r;
2570     suppress_error = 0;
2571     r = guestfs_is_dir (g, path);
2572     if (r == -1)
2573       return -1;
2574     if (!r) {
2575       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2576       return -1;
2577     }
2578   }
2579   return 0;
2580 }
2581
2582 static int test_zero_0_skip (void)
2583 {
2584   const char *str;
2585
2586   str = getenv ("SKIP_TEST_ZERO_0");
2587   if (str && strcmp (str, "1") == 0) return 1;
2588   str = getenv ("SKIP_TEST_ZERO");
2589   if (str && strcmp (str, "1") == 0) return 1;
2590   return 0;
2591 }
2592
2593 static int test_zero_0 (void)
2594 {
2595   if (test_zero_0_skip ()) {
2596     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2597     return 0;
2598   }
2599
2600   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2601   {
2602     char device[] = "/dev/sda";
2603     device[5] = devchar;
2604     int r;
2605     suppress_error = 0;
2606     r = guestfs_blockdev_setrw (g, device);
2607     if (r == -1)
2608       return -1;
2609   }
2610   {
2611     int r;
2612     suppress_error = 0;
2613     r = guestfs_umount_all (g);
2614     if (r == -1)
2615       return -1;
2616   }
2617   {
2618     int r;
2619     suppress_error = 0;
2620     r = guestfs_lvm_remove_all (g);
2621     if (r == -1)
2622       return -1;
2623   }
2624   {
2625     char device[] = "/dev/sda";
2626     device[5] = devchar;
2627     char lines_0[] = ",";
2628     char *lines[] = {
2629       lines_0,
2630       NULL
2631     };
2632     int r;
2633     suppress_error = 0;
2634     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2635     if (r == -1)
2636       return -1;
2637   }
2638   {
2639     char fstype[] = "ext2";
2640     char device[] = "/dev/sda1";
2641     device[5] = devchar;
2642     int r;
2643     suppress_error = 0;
2644     r = guestfs_mkfs (g, fstype, device);
2645     if (r == -1)
2646       return -1;
2647   }
2648   {
2649     char device[] = "/dev/sda1";
2650     device[5] = devchar;
2651     char mountpoint[] = "/";
2652     int r;
2653     suppress_error = 0;
2654     r = guestfs_mount (g, device, mountpoint);
2655     if (r == -1)
2656       return -1;
2657   }
2658   /* TestOutput for zero (0) */
2659   char expected[] = "data";
2660   {
2661     char pathordevice[] = "/dev/sda1";
2662     pathordevice[5] = devchar;
2663     int r;
2664     suppress_error = 0;
2665     r = guestfs_umount (g, pathordevice);
2666     if (r == -1)
2667       return -1;
2668   }
2669   {
2670     char device[] = "/dev/sda1";
2671     device[5] = devchar;
2672     int r;
2673     suppress_error = 0;
2674     r = guestfs_zero (g, device);
2675     if (r == -1)
2676       return -1;
2677   }
2678   {
2679     char path[] = "/dev/sda1";
2680     path[5] = devchar;
2681     char *r;
2682     suppress_error = 0;
2683     r = guestfs_file (g, path);
2684     if (r == NULL)
2685       return -1;
2686     if (strcmp (r, expected) != 0) {
2687       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2688       return -1;
2689     }
2690     free (r);
2691   }
2692   return 0;
2693 }
2694
2695 static int test_fsck_0_skip (void)
2696 {
2697   const char *str;
2698
2699   str = getenv ("SKIP_TEST_FSCK_0");
2700   if (str && strcmp (str, "1") == 0) return 1;
2701   str = getenv ("SKIP_TEST_FSCK");
2702   if (str && strcmp (str, "1") == 0) return 1;
2703   return 0;
2704 }
2705
2706 static int test_fsck_0 (void)
2707 {
2708   if (test_fsck_0_skip ()) {
2709     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2710     return 0;
2711   }
2712
2713   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2714   {
2715     char device[] = "/dev/sda";
2716     device[5] = devchar;
2717     int r;
2718     suppress_error = 0;
2719     r = guestfs_blockdev_setrw (g, device);
2720     if (r == -1)
2721       return -1;
2722   }
2723   {
2724     int r;
2725     suppress_error = 0;
2726     r = guestfs_umount_all (g);
2727     if (r == -1)
2728       return -1;
2729   }
2730   {
2731     int r;
2732     suppress_error = 0;
2733     r = guestfs_lvm_remove_all (g);
2734     if (r == -1)
2735       return -1;
2736   }
2737   {
2738     char device[] = "/dev/sda";
2739     device[5] = devchar;
2740     char lines_0[] = ",";
2741     char *lines[] = {
2742       lines_0,
2743       NULL
2744     };
2745     int r;
2746     suppress_error = 0;
2747     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2748     if (r == -1)
2749       return -1;
2750   }
2751   {
2752     char fstype[] = "ext2";
2753     char device[] = "/dev/sda1";
2754     device[5] = devchar;
2755     int r;
2756     suppress_error = 0;
2757     r = guestfs_mkfs (g, fstype, device);
2758     if (r == -1)
2759       return -1;
2760   }
2761   {
2762     char device[] = "/dev/sda1";
2763     device[5] = devchar;
2764     char mountpoint[] = "/";
2765     int r;
2766     suppress_error = 0;
2767     r = guestfs_mount (g, device, mountpoint);
2768     if (r == -1)
2769       return -1;
2770   }
2771   /* TestOutputInt for fsck (0) */
2772   {
2773     char pathordevice[] = "/dev/sda1";
2774     pathordevice[5] = devchar;
2775     int r;
2776     suppress_error = 0;
2777     r = guestfs_umount (g, pathordevice);
2778     if (r == -1)
2779       return -1;
2780   }
2781   {
2782     char fstype[] = "ext2";
2783     char device[] = "/dev/sda1";
2784     device[5] = devchar;
2785     int r;
2786     suppress_error = 0;
2787     r = guestfs_fsck (g, fstype, device);
2788     if (r == -1)
2789       return -1;
2790     if (r != 0) {
2791       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
2792       return -1;
2793     }
2794   }
2795   return 0;
2796 }
2797
2798 static int test_fsck_1_skip (void)
2799 {
2800   const char *str;
2801
2802   str = getenv ("SKIP_TEST_FSCK_1");
2803   if (str && strcmp (str, "1") == 0) return 1;
2804   str = getenv ("SKIP_TEST_FSCK");
2805   if (str && strcmp (str, "1") == 0) return 1;
2806   return 0;
2807 }
2808
2809 static int test_fsck_1 (void)
2810 {
2811   if (test_fsck_1_skip ()) {
2812     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
2813     return 0;
2814   }
2815
2816   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2817   {
2818     char device[] = "/dev/sda";
2819     device[5] = devchar;
2820     int r;
2821     suppress_error = 0;
2822     r = guestfs_blockdev_setrw (g, device);
2823     if (r == -1)
2824       return -1;
2825   }
2826   {
2827     int r;
2828     suppress_error = 0;
2829     r = guestfs_umount_all (g);
2830     if (r == -1)
2831       return -1;
2832   }
2833   {
2834     int r;
2835     suppress_error = 0;
2836     r = guestfs_lvm_remove_all (g);
2837     if (r == -1)
2838       return -1;
2839   }
2840   {
2841     char device[] = "/dev/sda";
2842     device[5] = devchar;
2843     char lines_0[] = ",";
2844     char *lines[] = {
2845       lines_0,
2846       NULL
2847     };
2848     int r;
2849     suppress_error = 0;
2850     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2851     if (r == -1)
2852       return -1;
2853   }
2854   {
2855     char fstype[] = "ext2";
2856     char device[] = "/dev/sda1";
2857     device[5] = devchar;
2858     int r;
2859     suppress_error = 0;
2860     r = guestfs_mkfs (g, fstype, device);
2861     if (r == -1)
2862       return -1;
2863   }
2864   {
2865     char device[] = "/dev/sda1";
2866     device[5] = devchar;
2867     char mountpoint[] = "/";
2868     int r;
2869     suppress_error = 0;
2870     r = guestfs_mount (g, device, mountpoint);
2871     if (r == -1)
2872       return -1;
2873   }
2874   /* TestOutputInt for fsck (1) */
2875   {
2876     char pathordevice[] = "/dev/sda1";
2877     pathordevice[5] = devchar;
2878     int r;
2879     suppress_error = 0;
2880     r = guestfs_umount (g, pathordevice);
2881     if (r == -1)
2882       return -1;
2883   }
2884   {
2885     char device[] = "/dev/sda1";
2886     device[5] = devchar;
2887     int r;
2888     suppress_error = 0;
2889     r = guestfs_zero (g, device);
2890     if (r == -1)
2891       return -1;
2892   }
2893   {
2894     char fstype[] = "ext2";
2895     char device[] = "/dev/sda1";
2896     device[5] = devchar;
2897     int r;
2898     suppress_error = 0;
2899     r = guestfs_fsck (g, fstype, device);
2900     if (r == -1)
2901       return -1;
2902     if (r != 8) {
2903       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
2904       return -1;
2905     }
2906   }
2907   return 0;
2908 }
2909
2910 static int test_set_e2uuid_0_skip (void)
2911 {
2912   const char *str;
2913
2914   str = getenv ("SKIP_TEST_SET_E2UUID_0");
2915   if (str && strcmp (str, "1") == 0) return 1;
2916   str = getenv ("SKIP_TEST_SET_E2UUID");
2917   if (str && strcmp (str, "1") == 0) return 1;
2918   return 0;
2919 }
2920
2921 static int test_set_e2uuid_0 (void)
2922 {
2923   if (test_set_e2uuid_0_skip ()) {
2924     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
2925     return 0;
2926   }
2927
2928   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2929   {
2930     char device[] = "/dev/sda";
2931     device[5] = devchar;
2932     int r;
2933     suppress_error = 0;
2934     r = guestfs_blockdev_setrw (g, device);
2935     if (r == -1)
2936       return -1;
2937   }
2938   {
2939     int r;
2940     suppress_error = 0;
2941     r = guestfs_umount_all (g);
2942     if (r == -1)
2943       return -1;
2944   }
2945   {
2946     int r;
2947     suppress_error = 0;
2948     r = guestfs_lvm_remove_all (g);
2949     if (r == -1)
2950       return -1;
2951   }
2952   {
2953     char device[] = "/dev/sda";
2954     device[5] = devchar;
2955     char lines_0[] = ",";
2956     char *lines[] = {
2957       lines_0,
2958       NULL
2959     };
2960     int r;
2961     suppress_error = 0;
2962     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2963     if (r == -1)
2964       return -1;
2965   }
2966   {
2967     char fstype[] = "ext2";
2968     char device[] = "/dev/sda1";
2969     device[5] = devchar;
2970     int r;
2971     suppress_error = 0;
2972     r = guestfs_mkfs (g, fstype, device);
2973     if (r == -1)
2974       return -1;
2975   }
2976   {
2977     char device[] = "/dev/sda1";
2978     device[5] = devchar;
2979     char mountpoint[] = "/";
2980     int r;
2981     suppress_error = 0;
2982     r = guestfs_mount (g, device, mountpoint);
2983     if (r == -1)
2984       return -1;
2985   }
2986   /* TestOutput for set_e2uuid (0) */
2987   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2988   {
2989     char device[] = "/dev/sda1";
2990     device[5] = devchar;
2991     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2992     int r;
2993     suppress_error = 0;
2994     r = guestfs_set_e2uuid (g, device, uuid);
2995     if (r == -1)
2996       return -1;
2997   }
2998   {
2999     char device[] = "/dev/sda1";
3000     device[5] = devchar;
3001     char *r;
3002     suppress_error = 0;
3003     r = guestfs_get_e2uuid (g, device);
3004     if (r == NULL)
3005       return -1;
3006     if (strcmp (r, expected) != 0) {
3007       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3008       return -1;
3009     }
3010     free (r);
3011   }
3012   return 0;
3013 }
3014
3015 static int test_set_e2uuid_1_skip (void)
3016 {
3017   const char *str;
3018
3019   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3020   if (str && strcmp (str, "1") == 0) return 1;
3021   str = getenv ("SKIP_TEST_SET_E2UUID");
3022   if (str && strcmp (str, "1") == 0) return 1;
3023   return 0;
3024 }
3025
3026 static int test_set_e2uuid_1 (void)
3027 {
3028   if (test_set_e2uuid_1_skip ()) {
3029     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3030     return 0;
3031   }
3032
3033   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3034   {
3035     char device[] = "/dev/sda";
3036     device[5] = devchar;
3037     int r;
3038     suppress_error = 0;
3039     r = guestfs_blockdev_setrw (g, device);
3040     if (r == -1)
3041       return -1;
3042   }
3043   {
3044     int r;
3045     suppress_error = 0;
3046     r = guestfs_umount_all (g);
3047     if (r == -1)
3048       return -1;
3049   }
3050   {
3051     int r;
3052     suppress_error = 0;
3053     r = guestfs_lvm_remove_all (g);
3054     if (r == -1)
3055       return -1;
3056   }
3057   {
3058     char device[] = "/dev/sda";
3059     device[5] = devchar;
3060     char lines_0[] = ",";
3061     char *lines[] = {
3062       lines_0,
3063       NULL
3064     };
3065     int r;
3066     suppress_error = 0;
3067     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3068     if (r == -1)
3069       return -1;
3070   }
3071   {
3072     char fstype[] = "ext2";
3073     char device[] = "/dev/sda1";
3074     device[5] = devchar;
3075     int r;
3076     suppress_error = 0;
3077     r = guestfs_mkfs (g, fstype, device);
3078     if (r == -1)
3079       return -1;
3080   }
3081   {
3082     char device[] = "/dev/sda1";
3083     device[5] = devchar;
3084     char mountpoint[] = "/";
3085     int r;
3086     suppress_error = 0;
3087     r = guestfs_mount (g, device, mountpoint);
3088     if (r == -1)
3089       return -1;
3090   }
3091   /* TestOutput for set_e2uuid (1) */
3092   char expected[] = "";
3093   {
3094     char device[] = "/dev/sda1";
3095     device[5] = devchar;
3096     char uuid[] = "clear";
3097     int r;
3098     suppress_error = 0;
3099     r = guestfs_set_e2uuid (g, device, uuid);
3100     if (r == -1)
3101       return -1;
3102   }
3103   {
3104     char device[] = "/dev/sda1";
3105     device[5] = devchar;
3106     char *r;
3107     suppress_error = 0;
3108     r = guestfs_get_e2uuid (g, device);
3109     if (r == NULL)
3110       return -1;
3111     if (strcmp (r, expected) != 0) {
3112       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3113       return -1;
3114     }
3115     free (r);
3116   }
3117   return 0;
3118 }
3119
3120 static int test_set_e2uuid_2_skip (void)
3121 {
3122   const char *str;
3123
3124   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3125   if (str && strcmp (str, "1") == 0) return 1;
3126   str = getenv ("SKIP_TEST_SET_E2UUID");
3127   if (str && strcmp (str, "1") == 0) return 1;
3128   return 0;
3129 }
3130
3131 static int test_set_e2uuid_2 (void)
3132 {
3133   if (test_set_e2uuid_2_skip ()) {
3134     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3135     return 0;
3136   }
3137
3138   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3139   {
3140     char device[] = "/dev/sda";
3141     device[5] = devchar;
3142     int r;
3143     suppress_error = 0;
3144     r = guestfs_blockdev_setrw (g, device);
3145     if (r == -1)
3146       return -1;
3147   }
3148   {
3149     int r;
3150     suppress_error = 0;
3151     r = guestfs_umount_all (g);
3152     if (r == -1)
3153       return -1;
3154   }
3155   {
3156     int r;
3157     suppress_error = 0;
3158     r = guestfs_lvm_remove_all (g);
3159     if (r == -1)
3160       return -1;
3161   }
3162   {
3163     char device[] = "/dev/sda";
3164     device[5] = devchar;
3165     char lines_0[] = ",";
3166     char *lines[] = {
3167       lines_0,
3168       NULL
3169     };
3170     int r;
3171     suppress_error = 0;
3172     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3173     if (r == -1)
3174       return -1;
3175   }
3176   {
3177     char fstype[] = "ext2";
3178     char device[] = "/dev/sda1";
3179     device[5] = devchar;
3180     int r;
3181     suppress_error = 0;
3182     r = guestfs_mkfs (g, fstype, device);
3183     if (r == -1)
3184       return -1;
3185   }
3186   {
3187     char device[] = "/dev/sda1";
3188     device[5] = devchar;
3189     char mountpoint[] = "/";
3190     int r;
3191     suppress_error = 0;
3192     r = guestfs_mount (g, device, mountpoint);
3193     if (r == -1)
3194       return -1;
3195   }
3196   /* TestRun for set_e2uuid (2) */
3197   {
3198     char device[] = "/dev/sda1";
3199     device[5] = devchar;
3200     char uuid[] = "random";
3201     int r;
3202     suppress_error = 0;
3203     r = guestfs_set_e2uuid (g, device, uuid);
3204     if (r == -1)
3205       return -1;
3206   }
3207   return 0;
3208 }
3209
3210 static int test_set_e2uuid_3_skip (void)
3211 {
3212   const char *str;
3213
3214   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3215   if (str && strcmp (str, "1") == 0) return 1;
3216   str = getenv ("SKIP_TEST_SET_E2UUID");
3217   if (str && strcmp (str, "1") == 0) return 1;
3218   return 0;
3219 }
3220
3221 static int test_set_e2uuid_3 (void)
3222 {
3223   if (test_set_e2uuid_3_skip ()) {
3224     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3225     return 0;
3226   }
3227
3228   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3229   {
3230     char device[] = "/dev/sda";
3231     device[5] = devchar;
3232     int r;
3233     suppress_error = 0;
3234     r = guestfs_blockdev_setrw (g, device);
3235     if (r == -1)
3236       return -1;
3237   }
3238   {
3239     int r;
3240     suppress_error = 0;
3241     r = guestfs_umount_all (g);
3242     if (r == -1)
3243       return -1;
3244   }
3245   {
3246     int r;
3247     suppress_error = 0;
3248     r = guestfs_lvm_remove_all (g);
3249     if (r == -1)
3250       return -1;
3251   }
3252   {
3253     char device[] = "/dev/sda";
3254     device[5] = devchar;
3255     char lines_0[] = ",";
3256     char *lines[] = {
3257       lines_0,
3258       NULL
3259     };
3260     int r;
3261     suppress_error = 0;
3262     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3263     if (r == -1)
3264       return -1;
3265   }
3266   {
3267     char fstype[] = "ext2";
3268     char device[] = "/dev/sda1";
3269     device[5] = devchar;
3270     int r;
3271     suppress_error = 0;
3272     r = guestfs_mkfs (g, fstype, device);
3273     if (r == -1)
3274       return -1;
3275   }
3276   {
3277     char device[] = "/dev/sda1";
3278     device[5] = devchar;
3279     char mountpoint[] = "/";
3280     int r;
3281     suppress_error = 0;
3282     r = guestfs_mount (g, device, mountpoint);
3283     if (r == -1)
3284       return -1;
3285   }
3286   /* TestRun for set_e2uuid (3) */
3287   {
3288     char device[] = "/dev/sda1";
3289     device[5] = devchar;
3290     char uuid[] = "time";
3291     int r;
3292     suppress_error = 0;
3293     r = guestfs_set_e2uuid (g, device, uuid);
3294     if (r == -1)
3295       return -1;
3296   }
3297   return 0;
3298 }
3299
3300 static int test_set_e2label_0_skip (void)
3301 {
3302   const char *str;
3303
3304   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3305   if (str && strcmp (str, "1") == 0) return 1;
3306   str = getenv ("SKIP_TEST_SET_E2LABEL");
3307   if (str && strcmp (str, "1") == 0) return 1;
3308   return 0;
3309 }
3310
3311 static int test_set_e2label_0 (void)
3312 {
3313   if (test_set_e2label_0_skip ()) {
3314     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3315     return 0;
3316   }
3317
3318   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3319   {
3320     char device[] = "/dev/sda";
3321     device[5] = devchar;
3322     int r;
3323     suppress_error = 0;
3324     r = guestfs_blockdev_setrw (g, device);
3325     if (r == -1)
3326       return -1;
3327   }
3328   {
3329     int r;
3330     suppress_error = 0;
3331     r = guestfs_umount_all (g);
3332     if (r == -1)
3333       return -1;
3334   }
3335   {
3336     int r;
3337     suppress_error = 0;
3338     r = guestfs_lvm_remove_all (g);
3339     if (r == -1)
3340       return -1;
3341   }
3342   {
3343     char device[] = "/dev/sda";
3344     device[5] = devchar;
3345     char lines_0[] = ",";
3346     char *lines[] = {
3347       lines_0,
3348       NULL
3349     };
3350     int r;
3351     suppress_error = 0;
3352     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3353     if (r == -1)
3354       return -1;
3355   }
3356   {
3357     char fstype[] = "ext2";
3358     char device[] = "/dev/sda1";
3359     device[5] = devchar;
3360     int r;
3361     suppress_error = 0;
3362     r = guestfs_mkfs (g, fstype, device);
3363     if (r == -1)
3364       return -1;
3365   }
3366   {
3367     char device[] = "/dev/sda1";
3368     device[5] = devchar;
3369     char mountpoint[] = "/";
3370     int r;
3371     suppress_error = 0;
3372     r = guestfs_mount (g, device, mountpoint);
3373     if (r == -1)
3374       return -1;
3375   }
3376   /* TestOutput for set_e2label (0) */
3377   char expected[] = "testlabel";
3378   {
3379     char device[] = "/dev/sda1";
3380     device[5] = devchar;
3381     char label[] = "testlabel";
3382     int r;
3383     suppress_error = 0;
3384     r = guestfs_set_e2label (g, device, label);
3385     if (r == -1)
3386       return -1;
3387   }
3388   {
3389     char device[] = "/dev/sda1";
3390     device[5] = devchar;
3391     char *r;
3392     suppress_error = 0;
3393     r = guestfs_get_e2label (g, device);
3394     if (r == NULL)
3395       return -1;
3396     if (strcmp (r, expected) != 0) {
3397       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3398       return -1;
3399     }
3400     free (r);
3401   }
3402   return 0;
3403 }
3404
3405 static int test_pvremove_0_skip (void)
3406 {
3407   const char *str;
3408
3409   str = getenv ("SKIP_TEST_PVREMOVE_0");
3410   if (str && strcmp (str, "1") == 0) return 1;
3411   str = getenv ("SKIP_TEST_PVREMOVE");
3412   if (str && strcmp (str, "1") == 0) return 1;
3413   return 0;
3414 }
3415
3416 static int test_pvremove_0 (void)
3417 {
3418   if (test_pvremove_0_skip ()) {
3419     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3420     return 0;
3421   }
3422
3423   /* InitNone|InitEmpty for test_pvremove_0 */
3424   {
3425     char device[] = "/dev/sda";
3426     device[5] = devchar;
3427     int r;
3428     suppress_error = 0;
3429     r = guestfs_blockdev_setrw (g, device);
3430     if (r == -1)
3431       return -1;
3432   }
3433   {
3434     int r;
3435     suppress_error = 0;
3436     r = guestfs_umount_all (g);
3437     if (r == -1)
3438       return -1;
3439   }
3440   {
3441     int r;
3442     suppress_error = 0;
3443     r = guestfs_lvm_remove_all (g);
3444     if (r == -1)
3445       return -1;
3446   }
3447   /* TestOutputList for pvremove (0) */
3448   {
3449     char device[] = "/dev/sda";
3450     device[5] = devchar;
3451     char lines_0[] = ",";
3452     char *lines[] = {
3453       lines_0,
3454       NULL
3455     };
3456     int r;
3457     suppress_error = 0;
3458     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3459     if (r == -1)
3460       return -1;
3461   }
3462   {
3463     char device[] = "/dev/sda1";
3464     device[5] = devchar;
3465     int r;
3466     suppress_error = 0;
3467     r = guestfs_pvcreate (g, device);
3468     if (r == -1)
3469       return -1;
3470   }
3471   {
3472     char volgroup[] = "VG";
3473     char physvols_0[] = "/dev/sda1";
3474     physvols_0[5] = devchar;
3475     char *physvols[] = {
3476       physvols_0,
3477       NULL
3478     };
3479     int r;
3480     suppress_error = 0;
3481     r = guestfs_vgcreate (g, volgroup, physvols);
3482     if (r == -1)
3483       return -1;
3484   }
3485   {
3486     char logvol[] = "LV1";
3487     char volgroup[] = "VG";
3488     int r;
3489     suppress_error = 0;
3490     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3491     if (r == -1)
3492       return -1;
3493   }
3494   {
3495     char logvol[] = "LV2";
3496     char volgroup[] = "VG";
3497     int r;
3498     suppress_error = 0;
3499     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3500     if (r == -1)
3501       return -1;
3502   }
3503   {
3504     char vgname[] = "VG";
3505     int r;
3506     suppress_error = 0;
3507     r = guestfs_vgremove (g, vgname);
3508     if (r == -1)
3509       return -1;
3510   }
3511   {
3512     char device[] = "/dev/sda1";
3513     device[5] = devchar;
3514     int r;
3515     suppress_error = 0;
3516     r = guestfs_pvremove (g, device);
3517     if (r == -1)
3518       return -1;
3519   }
3520   {
3521     char **r;
3522     int i;
3523     suppress_error = 0;
3524     r = guestfs_lvs (g);
3525     if (r == NULL)
3526       return -1;
3527     if (r[0] != NULL) {
3528       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3529       print_strings (r);
3530       return -1;
3531     }
3532     for (i = 0; r[i] != NULL; ++i)
3533       free (r[i]);
3534     free (r);
3535   }
3536   return 0;
3537 }
3538
3539 static int test_pvremove_1_skip (void)
3540 {
3541   const char *str;
3542
3543   str = getenv ("SKIP_TEST_PVREMOVE_1");
3544   if (str && strcmp (str, "1") == 0) return 1;
3545   str = getenv ("SKIP_TEST_PVREMOVE");
3546   if (str && strcmp (str, "1") == 0) return 1;
3547   return 0;
3548 }
3549
3550 static int test_pvremove_1 (void)
3551 {
3552   if (test_pvremove_1_skip ()) {
3553     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3554     return 0;
3555   }
3556
3557   /* InitNone|InitEmpty for test_pvremove_1 */
3558   {
3559     char device[] = "/dev/sda";
3560     device[5] = devchar;
3561     int r;
3562     suppress_error = 0;
3563     r = guestfs_blockdev_setrw (g, device);
3564     if (r == -1)
3565       return -1;
3566   }
3567   {
3568     int r;
3569     suppress_error = 0;
3570     r = guestfs_umount_all (g);
3571     if (r == -1)
3572       return -1;
3573   }
3574   {
3575     int r;
3576     suppress_error = 0;
3577     r = guestfs_lvm_remove_all (g);
3578     if (r == -1)
3579       return -1;
3580   }
3581   /* TestOutputList for pvremove (1) */
3582   {
3583     char device[] = "/dev/sda";
3584     device[5] = devchar;
3585     char lines_0[] = ",";
3586     char *lines[] = {
3587       lines_0,
3588       NULL
3589     };
3590     int r;
3591     suppress_error = 0;
3592     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3593     if (r == -1)
3594       return -1;
3595   }
3596   {
3597     char device[] = "/dev/sda1";
3598     device[5] = devchar;
3599     int r;
3600     suppress_error = 0;
3601     r = guestfs_pvcreate (g, device);
3602     if (r == -1)
3603       return -1;
3604   }
3605   {
3606     char volgroup[] = "VG";
3607     char physvols_0[] = "/dev/sda1";
3608     physvols_0[5] = devchar;
3609     char *physvols[] = {
3610       physvols_0,
3611       NULL
3612     };
3613     int r;
3614     suppress_error = 0;
3615     r = guestfs_vgcreate (g, volgroup, physvols);
3616     if (r == -1)
3617       return -1;
3618   }
3619   {
3620     char logvol[] = "LV1";
3621     char volgroup[] = "VG";
3622     int r;
3623     suppress_error = 0;
3624     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3625     if (r == -1)
3626       return -1;
3627   }
3628   {
3629     char logvol[] = "LV2";
3630     char volgroup[] = "VG";
3631     int r;
3632     suppress_error = 0;
3633     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3634     if (r == -1)
3635       return -1;
3636   }
3637   {
3638     char vgname[] = "VG";
3639     int r;
3640     suppress_error = 0;
3641     r = guestfs_vgremove (g, vgname);
3642     if (r == -1)
3643       return -1;
3644   }
3645   {
3646     char device[] = "/dev/sda1";
3647     device[5] = devchar;
3648     int r;
3649     suppress_error = 0;
3650     r = guestfs_pvremove (g, device);
3651     if (r == -1)
3652       return -1;
3653   }
3654   {
3655     char **r;
3656     int i;
3657     suppress_error = 0;
3658     r = guestfs_vgs (g);
3659     if (r == NULL)
3660       return -1;
3661     if (r[0] != NULL) {
3662       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3663       print_strings (r);
3664       return -1;
3665     }
3666     for (i = 0; r[i] != NULL; ++i)
3667       free (r[i]);
3668     free (r);
3669   }
3670   return 0;
3671 }
3672
3673 static int test_pvremove_2_skip (void)
3674 {
3675   const char *str;
3676
3677   str = getenv ("SKIP_TEST_PVREMOVE_2");
3678   if (str && strcmp (str, "1") == 0) return 1;
3679   str = getenv ("SKIP_TEST_PVREMOVE");
3680   if (str && strcmp (str, "1") == 0) return 1;
3681   return 0;
3682 }
3683
3684 static int test_pvremove_2 (void)
3685 {
3686   if (test_pvremove_2_skip ()) {
3687     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3688     return 0;
3689   }
3690
3691   /* InitNone|InitEmpty for test_pvremove_2 */
3692   {
3693     char device[] = "/dev/sda";
3694     device[5] = devchar;
3695     int r;
3696     suppress_error = 0;
3697     r = guestfs_blockdev_setrw (g, device);
3698     if (r == -1)
3699       return -1;
3700   }
3701   {
3702     int r;
3703     suppress_error = 0;
3704     r = guestfs_umount_all (g);
3705     if (r == -1)
3706       return -1;
3707   }
3708   {
3709     int r;
3710     suppress_error = 0;
3711     r = guestfs_lvm_remove_all (g);
3712     if (r == -1)
3713       return -1;
3714   }
3715   /* TestOutputList for pvremove (2) */
3716   {
3717     char device[] = "/dev/sda";
3718     device[5] = devchar;
3719     char lines_0[] = ",";
3720     char *lines[] = {
3721       lines_0,
3722       NULL
3723     };
3724     int r;
3725     suppress_error = 0;
3726     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3727     if (r == -1)
3728       return -1;
3729   }
3730   {
3731     char device[] = "/dev/sda1";
3732     device[5] = devchar;
3733     int r;
3734     suppress_error = 0;
3735     r = guestfs_pvcreate (g, device);
3736     if (r == -1)
3737       return -1;
3738   }
3739   {
3740     char volgroup[] = "VG";
3741     char physvols_0[] = "/dev/sda1";
3742     physvols_0[5] = devchar;
3743     char *physvols[] = {
3744       physvols_0,
3745       NULL
3746     };
3747     int r;
3748     suppress_error = 0;
3749     r = guestfs_vgcreate (g, volgroup, physvols);
3750     if (r == -1)
3751       return -1;
3752   }
3753   {
3754     char logvol[] = "LV1";
3755     char volgroup[] = "VG";
3756     int r;
3757     suppress_error = 0;
3758     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3759     if (r == -1)
3760       return -1;
3761   }
3762   {
3763     char logvol[] = "LV2";
3764     char volgroup[] = "VG";
3765     int r;
3766     suppress_error = 0;
3767     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3768     if (r == -1)
3769       return -1;
3770   }
3771   {
3772     char vgname[] = "VG";
3773     int r;
3774     suppress_error = 0;
3775     r = guestfs_vgremove (g, vgname);
3776     if (r == -1)
3777       return -1;
3778   }
3779   {
3780     char device[] = "/dev/sda1";
3781     device[5] = devchar;
3782     int r;
3783     suppress_error = 0;
3784     r = guestfs_pvremove (g, device);
3785     if (r == -1)
3786       return -1;
3787   }
3788   {
3789     char **r;
3790     int i;
3791     suppress_error = 0;
3792     r = guestfs_pvs (g);
3793     if (r == NULL)
3794       return -1;
3795     if (r[0] != NULL) {
3796       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3797       print_strings (r);
3798       return -1;
3799     }
3800     for (i = 0; r[i] != NULL; ++i)
3801       free (r[i]);
3802     free (r);
3803   }
3804   return 0;
3805 }
3806
3807 static int test_vgremove_0_skip (void)
3808 {
3809   const char *str;
3810
3811   str = getenv ("SKIP_TEST_VGREMOVE_0");
3812   if (str && strcmp (str, "1") == 0) return 1;
3813   str = getenv ("SKIP_TEST_VGREMOVE");
3814   if (str && strcmp (str, "1") == 0) return 1;
3815   return 0;
3816 }
3817
3818 static int test_vgremove_0 (void)
3819 {
3820   if (test_vgremove_0_skip ()) {
3821     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
3822     return 0;
3823   }
3824
3825   /* InitNone|InitEmpty for test_vgremove_0 */
3826   {
3827     char device[] = "/dev/sda";
3828     device[5] = devchar;
3829     int r;
3830     suppress_error = 0;
3831     r = guestfs_blockdev_setrw (g, device);
3832     if (r == -1)
3833       return -1;
3834   }
3835   {
3836     int r;
3837     suppress_error = 0;
3838     r = guestfs_umount_all (g);
3839     if (r == -1)
3840       return -1;
3841   }
3842   {
3843     int r;
3844     suppress_error = 0;
3845     r = guestfs_lvm_remove_all (g);
3846     if (r == -1)
3847       return -1;
3848   }
3849   /* TestOutputList for vgremove (0) */
3850   {
3851     char device[] = "/dev/sda";
3852     device[5] = devchar;
3853     char lines_0[] = ",";
3854     char *lines[] = {
3855       lines_0,
3856       NULL
3857     };
3858     int r;
3859     suppress_error = 0;
3860     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3861     if (r == -1)
3862       return -1;
3863   }
3864   {
3865     char device[] = "/dev/sda1";
3866     device[5] = devchar;
3867     int r;
3868     suppress_error = 0;
3869     r = guestfs_pvcreate (g, device);
3870     if (r == -1)
3871       return -1;
3872   }
3873   {
3874     char volgroup[] = "VG";
3875     char physvols_0[] = "/dev/sda1";
3876     physvols_0[5] = devchar;
3877     char *physvols[] = {
3878       physvols_0,
3879       NULL
3880     };
3881     int r;
3882     suppress_error = 0;
3883     r = guestfs_vgcreate (g, volgroup, physvols);
3884     if (r == -1)
3885       return -1;
3886   }
3887   {
3888     char logvol[] = "LV1";
3889     char volgroup[] = "VG";
3890     int r;
3891     suppress_error = 0;
3892     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3893     if (r == -1)
3894       return -1;
3895   }
3896   {
3897     char logvol[] = "LV2";
3898     char volgroup[] = "VG";
3899     int r;
3900     suppress_error = 0;
3901     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3902     if (r == -1)
3903       return -1;
3904   }
3905   {
3906     char vgname[] = "VG";
3907     int r;
3908     suppress_error = 0;
3909     r = guestfs_vgremove (g, vgname);
3910     if (r == -1)
3911       return -1;
3912   }
3913   {
3914     char **r;
3915     int i;
3916     suppress_error = 0;
3917     r = guestfs_lvs (g);
3918     if (r == NULL)
3919       return -1;
3920     if (r[0] != NULL) {
3921       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3922       print_strings (r);
3923       return -1;
3924     }
3925     for (i = 0; r[i] != NULL; ++i)
3926       free (r[i]);
3927     free (r);
3928   }
3929   return 0;
3930 }
3931
3932 static int test_vgremove_1_skip (void)
3933 {
3934   const char *str;
3935
3936   str = getenv ("SKIP_TEST_VGREMOVE_1");
3937   if (str && strcmp (str, "1") == 0) return 1;
3938   str = getenv ("SKIP_TEST_VGREMOVE");
3939   if (str && strcmp (str, "1") == 0) return 1;
3940   return 0;
3941 }
3942
3943 static int test_vgremove_1 (void)
3944 {
3945   if (test_vgremove_1_skip ()) {
3946     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
3947     return 0;
3948   }
3949
3950   /* InitNone|InitEmpty for test_vgremove_1 */
3951   {
3952     char device[] = "/dev/sda";
3953     device[5] = devchar;
3954     int r;
3955     suppress_error = 0;
3956     r = guestfs_blockdev_setrw (g, device);
3957     if (r == -1)
3958       return -1;
3959   }
3960   {
3961     int r;
3962     suppress_error = 0;
3963     r = guestfs_umount_all (g);
3964     if (r == -1)
3965       return -1;
3966   }
3967   {
3968     int r;
3969     suppress_error = 0;
3970     r = guestfs_lvm_remove_all (g);
3971     if (r == -1)
3972       return -1;
3973   }
3974   /* TestOutputList for vgremove (1) */
3975   {
3976     char device[] = "/dev/sda";
3977     device[5] = devchar;
3978     char lines_0[] = ",";
3979     char *lines[] = {
3980       lines_0,
3981       NULL
3982     };
3983     int r;
3984     suppress_error = 0;
3985     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3986     if (r == -1)
3987       return -1;
3988   }
3989   {
3990     char device[] = "/dev/sda1";
3991     device[5] = devchar;
3992     int r;
3993     suppress_error = 0;
3994     r = guestfs_pvcreate (g, device);
3995     if (r == -1)
3996       return -1;
3997   }
3998   {
3999     char volgroup[] = "VG";
4000     char physvols_0[] = "/dev/sda1";
4001     physvols_0[5] = devchar;
4002     char *physvols[] = {
4003       physvols_0,
4004       NULL
4005     };
4006     int r;
4007     suppress_error = 0;
4008     r = guestfs_vgcreate (g, volgroup, physvols);
4009     if (r == -1)
4010       return -1;
4011   }
4012   {
4013     char logvol[] = "LV1";
4014     char volgroup[] = "VG";
4015     int r;
4016     suppress_error = 0;
4017     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4018     if (r == -1)
4019       return -1;
4020   }
4021   {
4022     char logvol[] = "LV2";
4023     char volgroup[] = "VG";
4024     int r;
4025     suppress_error = 0;
4026     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4027     if (r == -1)
4028       return -1;
4029   }
4030   {
4031     char vgname[] = "VG";
4032     int r;
4033     suppress_error = 0;
4034     r = guestfs_vgremove (g, vgname);
4035     if (r == -1)
4036       return -1;
4037   }
4038   {
4039     char **r;
4040     int i;
4041     suppress_error = 0;
4042     r = guestfs_vgs (g);
4043     if (r == NULL)
4044       return -1;
4045     if (r[0] != NULL) {
4046       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4047       print_strings (r);
4048       return -1;
4049     }
4050     for (i = 0; r[i] != NULL; ++i)
4051       free (r[i]);
4052     free (r);
4053   }
4054   return 0;
4055 }
4056
4057 static int test_lvremove_0_skip (void)
4058 {
4059   const char *str;
4060
4061   str = getenv ("SKIP_TEST_LVREMOVE_0");
4062   if (str && strcmp (str, "1") == 0) return 1;
4063   str = getenv ("SKIP_TEST_LVREMOVE");
4064   if (str && strcmp (str, "1") == 0) return 1;
4065   return 0;
4066 }
4067
4068 static int test_lvremove_0 (void)
4069 {
4070   if (test_lvremove_0_skip ()) {
4071     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4072     return 0;
4073   }
4074
4075   /* InitNone|InitEmpty for test_lvremove_0 */
4076   {
4077     char device[] = "/dev/sda";
4078     device[5] = devchar;
4079     int r;
4080     suppress_error = 0;
4081     r = guestfs_blockdev_setrw (g, device);
4082     if (r == -1)
4083       return -1;
4084   }
4085   {
4086     int r;
4087     suppress_error = 0;
4088     r = guestfs_umount_all (g);
4089     if (r == -1)
4090       return -1;
4091   }
4092   {
4093     int r;
4094     suppress_error = 0;
4095     r = guestfs_lvm_remove_all (g);
4096     if (r == -1)
4097       return -1;
4098   }
4099   /* TestOutputList for lvremove (0) */
4100   {
4101     char device[] = "/dev/sda";
4102     device[5] = devchar;
4103     char lines_0[] = ",";
4104     char *lines[] = {
4105       lines_0,
4106       NULL
4107     };
4108     int r;
4109     suppress_error = 0;
4110     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4111     if (r == -1)
4112       return -1;
4113   }
4114   {
4115     char device[] = "/dev/sda1";
4116     device[5] = devchar;
4117     int r;
4118     suppress_error = 0;
4119     r = guestfs_pvcreate (g, device);
4120     if (r == -1)
4121       return -1;
4122   }
4123   {
4124     char volgroup[] = "VG";
4125     char physvols_0[] = "/dev/sda1";
4126     physvols_0[5] = devchar;
4127     char *physvols[] = {
4128       physvols_0,
4129       NULL
4130     };
4131     int r;
4132     suppress_error = 0;
4133     r = guestfs_vgcreate (g, volgroup, physvols);
4134     if (r == -1)
4135       return -1;
4136   }
4137   {
4138     char logvol[] = "LV1";
4139     char volgroup[] = "VG";
4140     int r;
4141     suppress_error = 0;
4142     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4143     if (r == -1)
4144       return -1;
4145   }
4146   {
4147     char logvol[] = "LV2";
4148     char volgroup[] = "VG";
4149     int r;
4150     suppress_error = 0;
4151     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4152     if (r == -1)
4153       return -1;
4154   }
4155   {
4156     char device[] = "/dev/VG/LV1";
4157     int r;
4158     suppress_error = 0;
4159     r = guestfs_lvremove (g, device);
4160     if (r == -1)
4161       return -1;
4162   }
4163   {
4164     char **r;
4165     int i;
4166     suppress_error = 0;
4167     r = guestfs_lvs (g);
4168     if (r == NULL)
4169       return -1;
4170     if (!r[0]) {
4171       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4172       print_strings (r);
4173       return -1;
4174     }
4175     {
4176       char expected[] = "/dev/VG/LV2";
4177       if (strcmp (r[0], expected) != 0) {
4178         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4179         return -1;
4180       }
4181     }
4182     if (r[1] != NULL) {
4183       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4184       print_strings (r);
4185       return -1;
4186     }
4187     for (i = 0; r[i] != NULL; ++i)
4188       free (r[i]);
4189     free (r);
4190   }
4191   return 0;
4192 }
4193
4194 static int test_lvremove_1_skip (void)
4195 {
4196   const char *str;
4197
4198   str = getenv ("SKIP_TEST_LVREMOVE_1");
4199   if (str && strcmp (str, "1") == 0) return 1;
4200   str = getenv ("SKIP_TEST_LVREMOVE");
4201   if (str && strcmp (str, "1") == 0) return 1;
4202   return 0;
4203 }
4204
4205 static int test_lvremove_1 (void)
4206 {
4207   if (test_lvremove_1_skip ()) {
4208     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4209     return 0;
4210   }
4211
4212   /* InitNone|InitEmpty for test_lvremove_1 */
4213   {
4214     char device[] = "/dev/sda";
4215     device[5] = devchar;
4216     int r;
4217     suppress_error = 0;
4218     r = guestfs_blockdev_setrw (g, device);
4219     if (r == -1)
4220       return -1;
4221   }
4222   {
4223     int r;
4224     suppress_error = 0;
4225     r = guestfs_umount_all (g);
4226     if (r == -1)
4227       return -1;
4228   }
4229   {
4230     int r;
4231     suppress_error = 0;
4232     r = guestfs_lvm_remove_all (g);
4233     if (r == -1)
4234       return -1;
4235   }
4236   /* TestOutputList for lvremove (1) */
4237   {
4238     char device[] = "/dev/sda";
4239     device[5] = devchar;
4240     char lines_0[] = ",";
4241     char *lines[] = {
4242       lines_0,
4243       NULL
4244     };
4245     int r;
4246     suppress_error = 0;
4247     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4248     if (r == -1)
4249       return -1;
4250   }
4251   {
4252     char device[] = "/dev/sda1";
4253     device[5] = devchar;
4254     int r;
4255     suppress_error = 0;
4256     r = guestfs_pvcreate (g, device);
4257     if (r == -1)
4258       return -1;
4259   }
4260   {
4261     char volgroup[] = "VG";
4262     char physvols_0[] = "/dev/sda1";
4263     physvols_0[5] = devchar;
4264     char *physvols[] = {
4265       physvols_0,
4266       NULL
4267     };
4268     int r;
4269     suppress_error = 0;
4270     r = guestfs_vgcreate (g, volgroup, physvols);
4271     if (r == -1)
4272       return -1;
4273   }
4274   {
4275     char logvol[] = "LV1";
4276     char volgroup[] = "VG";
4277     int r;
4278     suppress_error = 0;
4279     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4280     if (r == -1)
4281       return -1;
4282   }
4283   {
4284     char logvol[] = "LV2";
4285     char volgroup[] = "VG";
4286     int r;
4287     suppress_error = 0;
4288     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4289     if (r == -1)
4290       return -1;
4291   }
4292   {
4293     char device[] = "/dev/VG";
4294     int r;
4295     suppress_error = 0;
4296     r = guestfs_lvremove (g, device);
4297     if (r == -1)
4298       return -1;
4299   }
4300   {
4301     char **r;
4302     int i;
4303     suppress_error = 0;
4304     r = guestfs_lvs (g);
4305     if (r == NULL)
4306       return -1;
4307     if (r[0] != NULL) {
4308       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4309       print_strings (r);
4310       return -1;
4311     }
4312     for (i = 0; r[i] != NULL; ++i)
4313       free (r[i]);
4314     free (r);
4315   }
4316   return 0;
4317 }
4318
4319 static int test_lvremove_2_skip (void)
4320 {
4321   const char *str;
4322
4323   str = getenv ("SKIP_TEST_LVREMOVE_2");
4324   if (str && strcmp (str, "1") == 0) return 1;
4325   str = getenv ("SKIP_TEST_LVREMOVE");
4326   if (str && strcmp (str, "1") == 0) return 1;
4327   return 0;
4328 }
4329
4330 static int test_lvremove_2 (void)
4331 {
4332   if (test_lvremove_2_skip ()) {
4333     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4334     return 0;
4335   }
4336
4337   /* InitNone|InitEmpty for test_lvremove_2 */
4338   {
4339     char device[] = "/dev/sda";
4340     device[5] = devchar;
4341     int r;
4342     suppress_error = 0;
4343     r = guestfs_blockdev_setrw (g, device);
4344     if (r == -1)
4345       return -1;
4346   }
4347   {
4348     int r;
4349     suppress_error = 0;
4350     r = guestfs_umount_all (g);
4351     if (r == -1)
4352       return -1;
4353   }
4354   {
4355     int r;
4356     suppress_error = 0;
4357     r = guestfs_lvm_remove_all (g);
4358     if (r == -1)
4359       return -1;
4360   }
4361   /* TestOutputList for lvremove (2) */
4362   {
4363     char device[] = "/dev/sda";
4364     device[5] = devchar;
4365     char lines_0[] = ",";
4366     char *lines[] = {
4367       lines_0,
4368       NULL
4369     };
4370     int r;
4371     suppress_error = 0;
4372     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4373     if (r == -1)
4374       return -1;
4375   }
4376   {
4377     char device[] = "/dev/sda1";
4378     device[5] = devchar;
4379     int r;
4380     suppress_error = 0;
4381     r = guestfs_pvcreate (g, device);
4382     if (r == -1)
4383       return -1;
4384   }
4385   {
4386     char volgroup[] = "VG";
4387     char physvols_0[] = "/dev/sda1";
4388     physvols_0[5] = devchar;
4389     char *physvols[] = {
4390       physvols_0,
4391       NULL
4392     };
4393     int r;
4394     suppress_error = 0;
4395     r = guestfs_vgcreate (g, volgroup, physvols);
4396     if (r == -1)
4397       return -1;
4398   }
4399   {
4400     char logvol[] = "LV1";
4401     char volgroup[] = "VG";
4402     int r;
4403     suppress_error = 0;
4404     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4405     if (r == -1)
4406       return -1;
4407   }
4408   {
4409     char logvol[] = "LV2";
4410     char volgroup[] = "VG";
4411     int r;
4412     suppress_error = 0;
4413     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4414     if (r == -1)
4415       return -1;
4416   }
4417   {
4418     char device[] = "/dev/VG";
4419     int r;
4420     suppress_error = 0;
4421     r = guestfs_lvremove (g, device);
4422     if (r == -1)
4423       return -1;
4424   }
4425   {
4426     char **r;
4427     int i;
4428     suppress_error = 0;
4429     r = guestfs_vgs (g);
4430     if (r == NULL)
4431       return -1;
4432     if (!r[0]) {
4433       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4434       print_strings (r);
4435       return -1;
4436     }
4437     {
4438       char expected[] = "VG";
4439       if (strcmp (r[0], expected) != 0) {
4440         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4441         return -1;
4442       }
4443     }
4444     if (r[1] != NULL) {
4445       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4446       print_strings (r);
4447       return -1;
4448     }
4449     for (i = 0; r[i] != NULL; ++i)
4450       free (r[i]);
4451     free (r);
4452   }
4453   return 0;
4454 }
4455
4456 static int test_mount_ro_0_skip (void)
4457 {
4458   const char *str;
4459
4460   str = getenv ("SKIP_TEST_MOUNT_RO_0");
4461   if (str && strcmp (str, "1") == 0) return 1;
4462   str = getenv ("SKIP_TEST_MOUNT_RO");
4463   if (str && strcmp (str, "1") == 0) return 1;
4464   return 0;
4465 }
4466
4467 static int test_mount_ro_0 (void)
4468 {
4469   if (test_mount_ro_0_skip ()) {
4470     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4471     return 0;
4472   }
4473
4474   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4475   {
4476     char device[] = "/dev/sda";
4477     device[5] = devchar;
4478     int r;
4479     suppress_error = 0;
4480     r = guestfs_blockdev_setrw (g, device);
4481     if (r == -1)
4482       return -1;
4483   }
4484   {
4485     int r;
4486     suppress_error = 0;
4487     r = guestfs_umount_all (g);
4488     if (r == -1)
4489       return -1;
4490   }
4491   {
4492     int r;
4493     suppress_error = 0;
4494     r = guestfs_lvm_remove_all (g);
4495     if (r == -1)
4496       return -1;
4497   }
4498   {
4499     char device[] = "/dev/sda";
4500     device[5] = devchar;
4501     char lines_0[] = ",";
4502     char *lines[] = {
4503       lines_0,
4504       NULL
4505     };
4506     int r;
4507     suppress_error = 0;
4508     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4509     if (r == -1)
4510       return -1;
4511   }
4512   {
4513     char fstype[] = "ext2";
4514     char device[] = "/dev/sda1";
4515     device[5] = devchar;
4516     int r;
4517     suppress_error = 0;
4518     r = guestfs_mkfs (g, fstype, device);
4519     if (r == -1)
4520       return -1;
4521   }
4522   {
4523     char device[] = "/dev/sda1";
4524     device[5] = devchar;
4525     char mountpoint[] = "/";
4526     int r;
4527     suppress_error = 0;
4528     r = guestfs_mount (g, device, mountpoint);
4529     if (r == -1)
4530       return -1;
4531   }
4532   /* TestLastFail for mount_ro (0) */
4533   {
4534     char pathordevice[] = "/";
4535     int r;
4536     suppress_error = 0;
4537     r = guestfs_umount (g, pathordevice);
4538     if (r == -1)
4539       return -1;
4540   }
4541   {
4542     char device[] = "/dev/sda1";
4543     device[5] = devchar;
4544     char mountpoint[] = "/";
4545     int r;
4546     suppress_error = 0;
4547     r = guestfs_mount_ro (g, device, mountpoint);
4548     if (r == -1)
4549       return -1;
4550   }
4551   {
4552     char path[] = "/new";
4553     int r;
4554     suppress_error = 1;
4555     r = guestfs_touch (g, path);
4556     if (r != -1)
4557       return -1;
4558   }
4559   return 0;
4560 }
4561
4562 static int test_mount_ro_1_skip (void)
4563 {
4564   const char *str;
4565
4566   str = getenv ("SKIP_TEST_MOUNT_RO_1");
4567   if (str && strcmp (str, "1") == 0) return 1;
4568   str = getenv ("SKIP_TEST_MOUNT_RO");
4569   if (str && strcmp (str, "1") == 0) return 1;
4570   return 0;
4571 }
4572
4573 static int test_mount_ro_1 (void)
4574 {
4575   if (test_mount_ro_1_skip ()) {
4576     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4577     return 0;
4578   }
4579
4580   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4581   {
4582     char device[] = "/dev/sda";
4583     device[5] = devchar;
4584     int r;
4585     suppress_error = 0;
4586     r = guestfs_blockdev_setrw (g, device);
4587     if (r == -1)
4588       return -1;
4589   }
4590   {
4591     int r;
4592     suppress_error = 0;
4593     r = guestfs_umount_all (g);
4594     if (r == -1)
4595       return -1;
4596   }
4597   {
4598     int r;
4599     suppress_error = 0;
4600     r = guestfs_lvm_remove_all (g);
4601     if (r == -1)
4602       return -1;
4603   }
4604   {
4605     char device[] = "/dev/sda";
4606     device[5] = devchar;
4607     char lines_0[] = ",";
4608     char *lines[] = {
4609       lines_0,
4610       NULL
4611     };
4612     int r;
4613     suppress_error = 0;
4614     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4615     if (r == -1)
4616       return -1;
4617   }
4618   {
4619     char fstype[] = "ext2";
4620     char device[] = "/dev/sda1";
4621     device[5] = devchar;
4622     int r;
4623     suppress_error = 0;
4624     r = guestfs_mkfs (g, fstype, device);
4625     if (r == -1)
4626       return -1;
4627   }
4628   {
4629     char device[] = "/dev/sda1";
4630     device[5] = devchar;
4631     char mountpoint[] = "/";
4632     int r;
4633     suppress_error = 0;
4634     r = guestfs_mount (g, device, mountpoint);
4635     if (r == -1)
4636       return -1;
4637   }
4638   /* TestOutput for mount_ro (1) */
4639   char expected[] = "data";
4640   {
4641     char path[] = "/new";
4642     char content[] = "data";
4643     int r;
4644     suppress_error = 0;
4645     r = guestfs_write_file (g, path, content, 0);
4646     if (r == -1)
4647       return -1;
4648   }
4649   {
4650     char pathordevice[] = "/";
4651     int r;
4652     suppress_error = 0;
4653     r = guestfs_umount (g, pathordevice);
4654     if (r == -1)
4655       return -1;
4656   }
4657   {
4658     char device[] = "/dev/sda1";
4659     device[5] = devchar;
4660     char mountpoint[] = "/";
4661     int r;
4662     suppress_error = 0;
4663     r = guestfs_mount_ro (g, device, mountpoint);
4664     if (r == -1)
4665       return -1;
4666   }
4667   {
4668     char path[] = "/new";
4669     char *r;
4670     suppress_error = 0;
4671     r = guestfs_cat (g, path);
4672     if (r == NULL)
4673       return -1;
4674     if (strcmp (r, expected) != 0) {
4675       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4676       return -1;
4677     }
4678     free (r);
4679   }
4680   return 0;
4681 }
4682
4683 static int test_tgz_in_0_skip (void)
4684 {
4685   const char *str;
4686
4687   str = getenv ("SKIP_TEST_TGZ_IN_0");
4688   if (str && strcmp (str, "1") == 0) return 1;
4689   str = getenv ("SKIP_TEST_TGZ_IN");
4690   if (str && strcmp (str, "1") == 0) return 1;
4691   return 0;
4692 }
4693
4694 static int test_tgz_in_0 (void)
4695 {
4696   if (test_tgz_in_0_skip ()) {
4697     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4698     return 0;
4699   }
4700
4701   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4702   {
4703     char device[] = "/dev/sda";
4704     device[5] = devchar;
4705     int r;
4706     suppress_error = 0;
4707     r = guestfs_blockdev_setrw (g, device);
4708     if (r == -1)
4709       return -1;
4710   }
4711   {
4712     int r;
4713     suppress_error = 0;
4714     r = guestfs_umount_all (g);
4715     if (r == -1)
4716       return -1;
4717   }
4718   {
4719     int r;
4720     suppress_error = 0;
4721     r = guestfs_lvm_remove_all (g);
4722     if (r == -1)
4723       return -1;
4724   }
4725   {
4726     char device[] = "/dev/sda";
4727     device[5] = devchar;
4728     char lines_0[] = ",";
4729     char *lines[] = {
4730       lines_0,
4731       NULL
4732     };
4733     int r;
4734     suppress_error = 0;
4735     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4736     if (r == -1)
4737       return -1;
4738   }
4739   {
4740     char fstype[] = "ext2";
4741     char device[] = "/dev/sda1";
4742     device[5] = devchar;
4743     int r;
4744     suppress_error = 0;
4745     r = guestfs_mkfs (g, fstype, device);
4746     if (r == -1)
4747       return -1;
4748   }
4749   {
4750     char device[] = "/dev/sda1";
4751     device[5] = devchar;
4752     char mountpoint[] = "/";
4753     int r;
4754     suppress_error = 0;
4755     r = guestfs_mount (g, device, mountpoint);
4756     if (r == -1)
4757       return -1;
4758   }
4759   /* TestOutput for tgz_in (0) */
4760   char expected[] = "hello\n";
4761   {
4762     char directory[] = "/";
4763     int r;
4764     suppress_error = 0;
4765     r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
4766     if (r == -1)
4767       return -1;
4768   }
4769   {
4770     char path[] = "/hello";
4771     char *r;
4772     suppress_error = 0;
4773     r = guestfs_cat (g, path);
4774     if (r == NULL)
4775       return -1;
4776     if (strcmp (r, expected) != 0) {
4777       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4778       return -1;
4779     }
4780     free (r);
4781   }
4782   return 0;
4783 }
4784
4785 static int test_tar_in_0_skip (void)
4786 {
4787   const char *str;
4788
4789   str = getenv ("SKIP_TEST_TAR_IN_0");
4790   if (str && strcmp (str, "1") == 0) return 1;
4791   str = getenv ("SKIP_TEST_TAR_IN");
4792   if (str && strcmp (str, "1") == 0) return 1;
4793   return 0;
4794 }
4795
4796 static int test_tar_in_0 (void)
4797 {
4798   if (test_tar_in_0_skip ()) {
4799     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
4800     return 0;
4801   }
4802
4803   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4804   {
4805     char device[] = "/dev/sda";
4806     device[5] = devchar;
4807     int r;
4808     suppress_error = 0;
4809     r = guestfs_blockdev_setrw (g, device);
4810     if (r == -1)
4811       return -1;
4812   }
4813   {
4814     int r;
4815     suppress_error = 0;
4816     r = guestfs_umount_all (g);
4817     if (r == -1)
4818       return -1;
4819   }
4820   {
4821     int r;
4822     suppress_error = 0;
4823     r = guestfs_lvm_remove_all (g);
4824     if (r == -1)
4825       return -1;
4826   }
4827   {
4828     char device[] = "/dev/sda";
4829     device[5] = devchar;
4830     char lines_0[] = ",";
4831     char *lines[] = {
4832       lines_0,
4833       NULL
4834     };
4835     int r;
4836     suppress_error = 0;
4837     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4838     if (r == -1)
4839       return -1;
4840   }
4841   {
4842     char fstype[] = "ext2";
4843     char device[] = "/dev/sda1";
4844     device[5] = devchar;
4845     int r;
4846     suppress_error = 0;
4847     r = guestfs_mkfs (g, fstype, device);
4848     if (r == -1)
4849       return -1;
4850   }
4851   {
4852     char device[] = "/dev/sda1";
4853     device[5] = devchar;
4854     char mountpoint[] = "/";
4855     int r;
4856     suppress_error = 0;
4857     r = guestfs_mount (g, device, mountpoint);
4858     if (r == -1)
4859       return -1;
4860   }
4861   /* TestOutput for tar_in (0) */
4862   char expected[] = "hello\n";
4863   {
4864     char directory[] = "/";
4865     int r;
4866     suppress_error = 0;
4867     r = guestfs_tar_in (g, "images/helloworld.tar", directory);
4868     if (r == -1)
4869       return -1;
4870   }
4871   {
4872     char path[] = "/hello";
4873     char *r;
4874     suppress_error = 0;
4875     r = guestfs_cat (g, path);
4876     if (r == NULL)
4877       return -1;
4878     if (strcmp (r, expected) != 0) {
4879       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4880       return -1;
4881     }
4882     free (r);
4883   }
4884   return 0;
4885 }
4886
4887 static int test_checksum_0_skip (void)
4888 {
4889   const char *str;
4890
4891   str = getenv ("SKIP_TEST_CHECKSUM_0");
4892   if (str && strcmp (str, "1") == 0) return 1;
4893   str = getenv ("SKIP_TEST_CHECKSUM");
4894   if (str && strcmp (str, "1") == 0) return 1;
4895   return 0;
4896 }
4897
4898 static int test_checksum_0 (void)
4899 {
4900   if (test_checksum_0_skip ()) {
4901     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
4902     return 0;
4903   }
4904
4905   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4906   {
4907     char device[] = "/dev/sda";
4908     device[5] = devchar;
4909     int r;
4910     suppress_error = 0;
4911     r = guestfs_blockdev_setrw (g, device);
4912     if (r == -1)
4913       return -1;
4914   }
4915   {
4916     int r;
4917     suppress_error = 0;
4918     r = guestfs_umount_all (g);
4919     if (r == -1)
4920       return -1;
4921   }
4922   {
4923     int r;
4924     suppress_error = 0;
4925     r = guestfs_lvm_remove_all (g);
4926     if (r == -1)
4927       return -1;
4928   }
4929   {
4930     char device[] = "/dev/sda";
4931     device[5] = devchar;
4932     char lines_0[] = ",";
4933     char *lines[] = {
4934       lines_0,
4935       NULL
4936     };
4937     int r;
4938     suppress_error = 0;
4939     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4940     if (r == -1)
4941       return -1;
4942   }
4943   {
4944     char fstype[] = "ext2";
4945     char device[] = "/dev/sda1";
4946     device[5] = devchar;
4947     int r;
4948     suppress_error = 0;
4949     r = guestfs_mkfs (g, fstype, device);
4950     if (r == -1)
4951       return -1;
4952   }
4953   {
4954     char device[] = "/dev/sda1";
4955     device[5] = devchar;
4956     char mountpoint[] = "/";
4957     int r;
4958     suppress_error = 0;
4959     r = guestfs_mount (g, device, mountpoint);
4960     if (r == -1)
4961       return -1;
4962   }
4963   /* TestOutput for checksum (0) */
4964   char expected[] = "935282863";
4965   {
4966     char path[] = "/new";
4967     char content[] = "test\n";
4968     int r;
4969     suppress_error = 0;
4970     r = guestfs_write_file (g, path, content, 0);
4971     if (r == -1)
4972       return -1;
4973   }
4974   {
4975     char csumtype[] = "crc";
4976     char path[] = "/new";
4977     char *r;
4978     suppress_error = 0;
4979     r = guestfs_checksum (g, csumtype, path);
4980     if (r == NULL)
4981       return -1;
4982     if (strcmp (r, expected) != 0) {
4983       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
4984       return -1;
4985     }
4986     free (r);
4987   }
4988   return 0;
4989 }
4990
4991 static int test_checksum_1_skip (void)
4992 {
4993   const char *str;
4994
4995   str = getenv ("SKIP_TEST_CHECKSUM_1");
4996   if (str && strcmp (str, "1") == 0) return 1;
4997   str = getenv ("SKIP_TEST_CHECKSUM");
4998   if (str && strcmp (str, "1") == 0) return 1;
4999   return 0;
5000 }
5001
5002 static int test_checksum_1 (void)
5003 {
5004   if (test_checksum_1_skip ()) {
5005     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5006     return 0;
5007   }
5008
5009   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5010   {
5011     char device[] = "/dev/sda";
5012     device[5] = devchar;
5013     int r;
5014     suppress_error = 0;
5015     r = guestfs_blockdev_setrw (g, device);
5016     if (r == -1)
5017       return -1;
5018   }
5019   {
5020     int r;
5021     suppress_error = 0;
5022     r = guestfs_umount_all (g);
5023     if (r == -1)
5024       return -1;
5025   }
5026   {
5027     int r;
5028     suppress_error = 0;
5029     r = guestfs_lvm_remove_all (g);
5030     if (r == -1)
5031       return -1;
5032   }
5033   {
5034     char device[] = "/dev/sda";
5035     device[5] = devchar;
5036     char lines_0[] = ",";
5037     char *lines[] = {
5038       lines_0,
5039       NULL
5040     };
5041     int r;
5042     suppress_error = 0;
5043     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5044     if (r == -1)
5045       return -1;
5046   }
5047   {
5048     char fstype[] = "ext2";
5049     char device[] = "/dev/sda1";
5050     device[5] = devchar;
5051     int r;
5052     suppress_error = 0;
5053     r = guestfs_mkfs (g, fstype, device);
5054     if (r == -1)
5055       return -1;
5056   }
5057   {
5058     char device[] = "/dev/sda1";
5059     device[5] = devchar;
5060     char mountpoint[] = "/";
5061     int r;
5062     suppress_error = 0;
5063     r = guestfs_mount (g, device, mountpoint);
5064     if (r == -1)
5065       return -1;
5066   }
5067   /* TestLastFail for checksum (1) */
5068   {
5069     char csumtype[] = "crc";
5070     char path[] = "/new";
5071     char *r;
5072     suppress_error = 1;
5073     r = guestfs_checksum (g, csumtype, path);
5074     if (r != NULL)
5075       return -1;
5076     free (r);
5077   }
5078   return 0;
5079 }
5080
5081 static int test_checksum_2_skip (void)
5082 {
5083   const char *str;
5084
5085   str = getenv ("SKIP_TEST_CHECKSUM_2");
5086   if (str && strcmp (str, "1") == 0) return 1;
5087   str = getenv ("SKIP_TEST_CHECKSUM");
5088   if (str && strcmp (str, "1") == 0) return 1;
5089   return 0;
5090 }
5091
5092 static int test_checksum_2 (void)
5093 {
5094   if (test_checksum_2_skip ()) {
5095     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5096     return 0;
5097   }
5098
5099   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5100   {
5101     char device[] = "/dev/sda";
5102     device[5] = devchar;
5103     int r;
5104     suppress_error = 0;
5105     r = guestfs_blockdev_setrw (g, device);
5106     if (r == -1)
5107       return -1;
5108   }
5109   {
5110     int r;
5111     suppress_error = 0;
5112     r = guestfs_umount_all (g);
5113     if (r == -1)
5114       return -1;
5115   }
5116   {
5117     int r;
5118     suppress_error = 0;
5119     r = guestfs_lvm_remove_all (g);
5120     if (r == -1)
5121       return -1;
5122   }
5123   {
5124     char device[] = "/dev/sda";
5125     device[5] = devchar;
5126     char lines_0[] = ",";
5127     char *lines[] = {
5128       lines_0,
5129       NULL
5130     };
5131     int r;
5132     suppress_error = 0;
5133     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5134     if (r == -1)
5135       return -1;
5136   }
5137   {
5138     char fstype[] = "ext2";
5139     char device[] = "/dev/sda1";
5140     device[5] = devchar;
5141     int r;
5142     suppress_error = 0;
5143     r = guestfs_mkfs (g, fstype, device);
5144     if (r == -1)
5145       return -1;
5146   }
5147   {
5148     char device[] = "/dev/sda1";
5149     device[5] = devchar;
5150     char mountpoint[] = "/";
5151     int r;
5152     suppress_error = 0;
5153     r = guestfs_mount (g, device, mountpoint);
5154     if (r == -1)
5155       return -1;
5156   }
5157   /* TestOutput for checksum (2) */
5158   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5159   {
5160     char path[] = "/new";
5161     char content[] = "test\n";
5162     int r;
5163     suppress_error = 0;
5164     r = guestfs_write_file (g, path, content, 0);
5165     if (r == -1)
5166       return -1;
5167   }
5168   {
5169     char csumtype[] = "md5";
5170     char path[] = "/new";
5171     char *r;
5172     suppress_error = 0;
5173     r = guestfs_checksum (g, csumtype, path);
5174     if (r == NULL)
5175       return -1;
5176     if (strcmp (r, expected) != 0) {
5177       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5178       return -1;
5179     }
5180     free (r);
5181   }
5182   return 0;
5183 }
5184
5185 static int test_checksum_3_skip (void)
5186 {
5187   const char *str;
5188
5189   str = getenv ("SKIP_TEST_CHECKSUM_3");
5190   if (str && strcmp (str, "1") == 0) return 1;
5191   str = getenv ("SKIP_TEST_CHECKSUM");
5192   if (str && strcmp (str, "1") == 0) return 1;
5193   return 0;
5194 }
5195
5196 static int test_checksum_3 (void)
5197 {
5198   if (test_checksum_3_skip ()) {
5199     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5200     return 0;
5201   }
5202
5203   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5204   {
5205     char device[] = "/dev/sda";
5206     device[5] = devchar;
5207     int r;
5208     suppress_error = 0;
5209     r = guestfs_blockdev_setrw (g, device);
5210     if (r == -1)
5211       return -1;
5212   }
5213   {
5214     int r;
5215     suppress_error = 0;
5216     r = guestfs_umount_all (g);
5217     if (r == -1)
5218       return -1;
5219   }
5220   {
5221     int r;
5222     suppress_error = 0;
5223     r = guestfs_lvm_remove_all (g);
5224     if (r == -1)
5225       return -1;
5226   }
5227   {
5228     char device[] = "/dev/sda";
5229     device[5] = devchar;
5230     char lines_0[] = ",";
5231     char *lines[] = {
5232       lines_0,
5233       NULL
5234     };
5235     int r;
5236     suppress_error = 0;
5237     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5238     if (r == -1)
5239       return -1;
5240   }
5241   {
5242     char fstype[] = "ext2";
5243     char device[] = "/dev/sda1";
5244     device[5] = devchar;
5245     int r;
5246     suppress_error = 0;
5247     r = guestfs_mkfs (g, fstype, device);
5248     if (r == -1)
5249       return -1;
5250   }
5251   {
5252     char device[] = "/dev/sda1";
5253     device[5] = devchar;
5254     char mountpoint[] = "/";
5255     int r;
5256     suppress_error = 0;
5257     r = guestfs_mount (g, device, mountpoint);
5258     if (r == -1)
5259       return -1;
5260   }
5261   /* TestOutput for checksum (3) */
5262   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5263   {
5264     char path[] = "/new";
5265     char content[] = "test\n";
5266     int r;
5267     suppress_error = 0;
5268     r = guestfs_write_file (g, path, content, 0);
5269     if (r == -1)
5270       return -1;
5271   }
5272   {
5273     char csumtype[] = "sha1";
5274     char path[] = "/new";
5275     char *r;
5276     suppress_error = 0;
5277     r = guestfs_checksum (g, csumtype, path);
5278     if (r == NULL)
5279       return -1;
5280     if (strcmp (r, expected) != 0) {
5281       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5282       return -1;
5283     }
5284     free (r);
5285   }
5286   return 0;
5287 }
5288
5289 static int test_checksum_4_skip (void)
5290 {
5291   const char *str;
5292
5293   str = getenv ("SKIP_TEST_CHECKSUM_4");
5294   if (str && strcmp (str, "1") == 0) return 1;
5295   str = getenv ("SKIP_TEST_CHECKSUM");
5296   if (str && strcmp (str, "1") == 0) return 1;
5297   return 0;
5298 }
5299
5300 static int test_checksum_4 (void)
5301 {
5302   if (test_checksum_4_skip ()) {
5303     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5304     return 0;
5305   }
5306
5307   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5308   {
5309     char device[] = "/dev/sda";
5310     device[5] = devchar;
5311     int r;
5312     suppress_error = 0;
5313     r = guestfs_blockdev_setrw (g, device);
5314     if (r == -1)
5315       return -1;
5316   }
5317   {
5318     int r;
5319     suppress_error = 0;
5320     r = guestfs_umount_all (g);
5321     if (r == -1)
5322       return -1;
5323   }
5324   {
5325     int r;
5326     suppress_error = 0;
5327     r = guestfs_lvm_remove_all (g);
5328     if (r == -1)
5329       return -1;
5330   }
5331   {
5332     char device[] = "/dev/sda";
5333     device[5] = devchar;
5334     char lines_0[] = ",";
5335     char *lines[] = {
5336       lines_0,
5337       NULL
5338     };
5339     int r;
5340     suppress_error = 0;
5341     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5342     if (r == -1)
5343       return -1;
5344   }
5345   {
5346     char fstype[] = "ext2";
5347     char device[] = "/dev/sda1";
5348     device[5] = devchar;
5349     int r;
5350     suppress_error = 0;
5351     r = guestfs_mkfs (g, fstype, device);
5352     if (r == -1)
5353       return -1;
5354   }
5355   {
5356     char device[] = "/dev/sda1";
5357     device[5] = devchar;
5358     char mountpoint[] = "/";
5359     int r;
5360     suppress_error = 0;
5361     r = guestfs_mount (g, device, mountpoint);
5362     if (r == -1)
5363       return -1;
5364   }
5365   /* TestOutput for checksum (4) */
5366   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5367   {
5368     char path[] = "/new";
5369     char content[] = "test\n";
5370     int r;
5371     suppress_error = 0;
5372     r = guestfs_write_file (g, path, content, 0);
5373     if (r == -1)
5374       return -1;
5375   }
5376   {
5377     char csumtype[] = "sha224";
5378     char path[] = "/new";
5379     char *r;
5380     suppress_error = 0;
5381     r = guestfs_checksum (g, csumtype, path);
5382     if (r == NULL)
5383       return -1;
5384     if (strcmp (r, expected) != 0) {
5385       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5386       return -1;
5387     }
5388     free (r);
5389   }
5390   return 0;
5391 }
5392
5393 static int test_checksum_5_skip (void)
5394 {
5395   const char *str;
5396
5397   str = getenv ("SKIP_TEST_CHECKSUM_5");
5398   if (str && strcmp (str, "1") == 0) return 1;
5399   str = getenv ("SKIP_TEST_CHECKSUM");
5400   if (str && strcmp (str, "1") == 0) return 1;
5401   return 0;
5402 }
5403
5404 static int test_checksum_5 (void)
5405 {
5406   if (test_checksum_5_skip ()) {
5407     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5408     return 0;
5409   }
5410
5411   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5412   {
5413     char device[] = "/dev/sda";
5414     device[5] = devchar;
5415     int r;
5416     suppress_error = 0;
5417     r = guestfs_blockdev_setrw (g, device);
5418     if (r == -1)
5419       return -1;
5420   }
5421   {
5422     int r;
5423     suppress_error = 0;
5424     r = guestfs_umount_all (g);
5425     if (r == -1)
5426       return -1;
5427   }
5428   {
5429     int r;
5430     suppress_error = 0;
5431     r = guestfs_lvm_remove_all (g);
5432     if (r == -1)
5433       return -1;
5434   }
5435   {
5436     char device[] = "/dev/sda";
5437     device[5] = devchar;
5438     char lines_0[] = ",";
5439     char *lines[] = {
5440       lines_0,
5441       NULL
5442     };
5443     int r;
5444     suppress_error = 0;
5445     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5446     if (r == -1)
5447       return -1;
5448   }
5449   {
5450     char fstype[] = "ext2";
5451     char device[] = "/dev/sda1";
5452     device[5] = devchar;
5453     int r;
5454     suppress_error = 0;
5455     r = guestfs_mkfs (g, fstype, device);
5456     if (r == -1)
5457       return -1;
5458   }
5459   {
5460     char device[] = "/dev/sda1";
5461     device[5] = devchar;
5462     char mountpoint[] = "/";
5463     int r;
5464     suppress_error = 0;
5465     r = guestfs_mount (g, device, mountpoint);
5466     if (r == -1)
5467       return -1;
5468   }
5469   /* TestOutput for checksum (5) */
5470   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5471   {
5472     char path[] = "/new";
5473     char content[] = "test\n";
5474     int r;
5475     suppress_error = 0;
5476     r = guestfs_write_file (g, path, content, 0);
5477     if (r == -1)
5478       return -1;
5479   }
5480   {
5481     char csumtype[] = "sha256";
5482     char path[] = "/new";
5483     char *r;
5484     suppress_error = 0;
5485     r = guestfs_checksum (g, csumtype, path);
5486     if (r == NULL)
5487       return -1;
5488     if (strcmp (r, expected) != 0) {
5489       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5490       return -1;
5491     }
5492     free (r);
5493   }
5494   return 0;
5495 }
5496
5497 static int test_checksum_6_skip (void)
5498 {
5499   const char *str;
5500
5501   str = getenv ("SKIP_TEST_CHECKSUM_6");
5502   if (str && strcmp (str, "1") == 0) return 1;
5503   str = getenv ("SKIP_TEST_CHECKSUM");
5504   if (str && strcmp (str, "1") == 0) return 1;
5505   return 0;
5506 }
5507
5508 static int test_checksum_6 (void)
5509 {
5510   if (test_checksum_6_skip ()) {
5511     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5512     return 0;
5513   }
5514
5515   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5516   {
5517     char device[] = "/dev/sda";
5518     device[5] = devchar;
5519     int r;
5520     suppress_error = 0;
5521     r = guestfs_blockdev_setrw (g, device);
5522     if (r == -1)
5523       return -1;
5524   }
5525   {
5526     int r;
5527     suppress_error = 0;
5528     r = guestfs_umount_all (g);
5529     if (r == -1)
5530       return -1;
5531   }
5532   {
5533     int r;
5534     suppress_error = 0;
5535     r = guestfs_lvm_remove_all (g);
5536     if (r == -1)
5537       return -1;
5538   }
5539   {
5540     char device[] = "/dev/sda";
5541     device[5] = devchar;
5542     char lines_0[] = ",";
5543     char *lines[] = {
5544       lines_0,
5545       NULL
5546     };
5547     int r;
5548     suppress_error = 0;
5549     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5550     if (r == -1)
5551       return -1;
5552   }
5553   {
5554     char fstype[] = "ext2";
5555     char device[] = "/dev/sda1";
5556     device[5] = devchar;
5557     int r;
5558     suppress_error = 0;
5559     r = guestfs_mkfs (g, fstype, device);
5560     if (r == -1)
5561       return -1;
5562   }
5563   {
5564     char device[] = "/dev/sda1";
5565     device[5] = devchar;
5566     char mountpoint[] = "/";
5567     int r;
5568     suppress_error = 0;
5569     r = guestfs_mount (g, device, mountpoint);
5570     if (r == -1)
5571       return -1;
5572   }
5573   /* TestOutput for checksum (6) */
5574   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5575   {
5576     char path[] = "/new";
5577     char content[] = "test\n";
5578     int r;
5579     suppress_error = 0;
5580     r = guestfs_write_file (g, path, content, 0);
5581     if (r == -1)
5582       return -1;
5583   }
5584   {
5585     char csumtype[] = "sha384";
5586     char path[] = "/new";
5587     char *r;
5588     suppress_error = 0;
5589     r = guestfs_checksum (g, csumtype, path);
5590     if (r == NULL)
5591       return -1;
5592     if (strcmp (r, expected) != 0) {
5593       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5594       return -1;
5595     }
5596     free (r);
5597   }
5598   return 0;
5599 }
5600
5601 static int test_checksum_7_skip (void)
5602 {
5603   const char *str;
5604
5605   str = getenv ("SKIP_TEST_CHECKSUM_7");
5606   if (str && strcmp (str, "1") == 0) return 1;
5607   str = getenv ("SKIP_TEST_CHECKSUM");
5608   if (str && strcmp (str, "1") == 0) return 1;
5609   return 0;
5610 }
5611
5612 static int test_checksum_7 (void)
5613 {
5614   if (test_checksum_7_skip ()) {
5615     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5616     return 0;
5617   }
5618
5619   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5620   {
5621     char device[] = "/dev/sda";
5622     device[5] = devchar;
5623     int r;
5624     suppress_error = 0;
5625     r = guestfs_blockdev_setrw (g, device);
5626     if (r == -1)
5627       return -1;
5628   }
5629   {
5630     int r;
5631     suppress_error = 0;
5632     r = guestfs_umount_all (g);
5633     if (r == -1)
5634       return -1;
5635   }
5636   {
5637     int r;
5638     suppress_error = 0;
5639     r = guestfs_lvm_remove_all (g);
5640     if (r == -1)
5641       return -1;
5642   }
5643   {
5644     char device[] = "/dev/sda";
5645     device[5] = devchar;
5646     char lines_0[] = ",";
5647     char *lines[] = {
5648       lines_0,
5649       NULL
5650     };
5651     int r;
5652     suppress_error = 0;
5653     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5654     if (r == -1)
5655       return -1;
5656   }
5657   {
5658     char fstype[] = "ext2";
5659     char device[] = "/dev/sda1";
5660     device[5] = devchar;
5661     int r;
5662     suppress_error = 0;
5663     r = guestfs_mkfs (g, fstype, device);
5664     if (r == -1)
5665       return -1;
5666   }
5667   {
5668     char device[] = "/dev/sda1";
5669     device[5] = devchar;
5670     char mountpoint[] = "/";
5671     int r;
5672     suppress_error = 0;
5673     r = guestfs_mount (g, device, mountpoint);
5674     if (r == -1)
5675       return -1;
5676   }
5677   /* TestOutput for checksum (7) */
5678   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5679   {
5680     char path[] = "/new";
5681     char content[] = "test\n";
5682     int r;
5683     suppress_error = 0;
5684     r = guestfs_write_file (g, path, content, 0);
5685     if (r == -1)
5686       return -1;
5687   }
5688   {
5689     char csumtype[] = "sha512";
5690     char path[] = "/new";
5691     char *r;
5692     suppress_error = 0;
5693     r = guestfs_checksum (g, csumtype, path);
5694     if (r == NULL)
5695       return -1;
5696     if (strcmp (r, expected) != 0) {
5697       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5698       return -1;
5699     }
5700     free (r);
5701   }
5702   return 0;
5703 }
5704
5705 static int test_download_0_skip (void)
5706 {
5707   const char *str;
5708
5709   str = getenv ("SKIP_TEST_DOWNLOAD_0");
5710   if (str && strcmp (str, "1") == 0) return 1;
5711   str = getenv ("SKIP_TEST_DOWNLOAD");
5712   if (str && strcmp (str, "1") == 0) return 1;
5713   return 0;
5714 }
5715
5716 static int test_download_0 (void)
5717 {
5718   if (test_download_0_skip ()) {
5719     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5720     return 0;
5721   }
5722
5723   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5724   {
5725     char device[] = "/dev/sda";
5726     device[5] = devchar;
5727     int r;
5728     suppress_error = 0;
5729     r = guestfs_blockdev_setrw (g, device);
5730     if (r == -1)
5731       return -1;
5732   }
5733   {
5734     int r;
5735     suppress_error = 0;
5736     r = guestfs_umount_all (g);
5737     if (r == -1)
5738       return -1;
5739   }
5740   {
5741     int r;
5742     suppress_error = 0;
5743     r = guestfs_lvm_remove_all (g);
5744     if (r == -1)
5745       return -1;
5746   }
5747   {
5748     char device[] = "/dev/sda";
5749     device[5] = devchar;
5750     char lines_0[] = ",";
5751     char *lines[] = {
5752       lines_0,
5753       NULL
5754     };
5755     int r;
5756     suppress_error = 0;
5757     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5758     if (r == -1)
5759       return -1;
5760   }
5761   {
5762     char fstype[] = "ext2";
5763     char device[] = "/dev/sda1";
5764     device[5] = devchar;
5765     int r;
5766     suppress_error = 0;
5767     r = guestfs_mkfs (g, fstype, device);
5768     if (r == -1)
5769       return -1;
5770   }
5771   {
5772     char device[] = "/dev/sda1";
5773     device[5] = devchar;
5774     char mountpoint[] = "/";
5775     int r;
5776     suppress_error = 0;
5777     r = guestfs_mount (g, device, mountpoint);
5778     if (r == -1)
5779       return -1;
5780   }
5781   /* TestOutput for download (0) */
5782   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5783   {
5784     char remotefilename[] = "/COPYING.LIB";
5785     int r;
5786     suppress_error = 0;
5787     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
5788     if (r == -1)
5789       return -1;
5790   }
5791   {
5792     char remotefilename[] = "/COPYING.LIB";
5793     int r;
5794     suppress_error = 0;
5795     r = guestfs_download (g, remotefilename, "testdownload.tmp");
5796     if (r == -1)
5797       return -1;
5798   }
5799   {
5800     char remotefilename[] = "/upload";
5801     int r;
5802     suppress_error = 0;
5803     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5804     if (r == -1)
5805       return -1;
5806   }
5807   {
5808     char csumtype[] = "md5";
5809     char path[] = "/upload";
5810     char *r;
5811     suppress_error = 0;
5812     r = guestfs_checksum (g, csumtype, path);
5813     if (r == NULL)
5814       return -1;
5815     if (strcmp (r, expected) != 0) {
5816       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5817       return -1;
5818     }
5819     free (r);
5820   }
5821   return 0;
5822 }
5823
5824 static int test_upload_0_skip (void)
5825 {
5826   const char *str;
5827
5828   str = getenv ("SKIP_TEST_UPLOAD_0");
5829   if (str && strcmp (str, "1") == 0) return 1;
5830   str = getenv ("SKIP_TEST_UPLOAD");
5831   if (str && strcmp (str, "1") == 0) return 1;
5832   return 0;
5833 }
5834
5835 static int test_upload_0 (void)
5836 {
5837   if (test_upload_0_skip ()) {
5838     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5839     return 0;
5840   }
5841
5842   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5843   {
5844     char device[] = "/dev/sda";
5845     device[5] = devchar;
5846     int r;
5847     suppress_error = 0;
5848     r = guestfs_blockdev_setrw (g, device);
5849     if (r == -1)
5850       return -1;
5851   }
5852   {
5853     int r;
5854     suppress_error = 0;
5855     r = guestfs_umount_all (g);
5856     if (r == -1)
5857       return -1;
5858   }
5859   {
5860     int r;
5861     suppress_error = 0;
5862     r = guestfs_lvm_remove_all (g);
5863     if (r == -1)
5864       return -1;
5865   }
5866   {
5867     char device[] = "/dev/sda";
5868     device[5] = devchar;
5869     char lines_0[] = ",";
5870     char *lines[] = {
5871       lines_0,
5872       NULL
5873     };
5874     int r;
5875     suppress_error = 0;
5876     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5877     if (r == -1)
5878       return -1;
5879   }
5880   {
5881     char fstype[] = "ext2";
5882     char device[] = "/dev/sda1";
5883     device[5] = devchar;
5884     int r;
5885     suppress_error = 0;
5886     r = guestfs_mkfs (g, fstype, device);
5887     if (r == -1)
5888       return -1;
5889   }
5890   {
5891     char device[] = "/dev/sda1";
5892     device[5] = devchar;
5893     char mountpoint[] = "/";
5894     int r;
5895     suppress_error = 0;
5896     r = guestfs_mount (g, device, mountpoint);
5897     if (r == -1)
5898       return -1;
5899   }
5900   /* TestOutput for upload (0) */
5901   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5902   {
5903     char remotefilename[] = "/COPYING.LIB";
5904     int r;
5905     suppress_error = 0;
5906     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
5907     if (r == -1)
5908       return -1;
5909   }
5910   {
5911     char csumtype[] = "md5";
5912     char path[] = "/COPYING.LIB";
5913     char *r;
5914     suppress_error = 0;
5915     r = guestfs_checksum (g, csumtype, path);
5916     if (r == NULL)
5917       return -1;
5918     if (strcmp (r, expected) != 0) {
5919       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
5920       return -1;
5921     }
5922     free (r);
5923   }
5924   return 0;
5925 }
5926
5927 static int test_blockdev_rereadpt_0_skip (void)
5928 {
5929   const char *str;
5930
5931   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
5932   if (str && strcmp (str, "1") == 0) return 1;
5933   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
5934   if (str && strcmp (str, "1") == 0) return 1;
5935   return 0;
5936 }
5937
5938 static int test_blockdev_rereadpt_0 (void)
5939 {
5940   if (test_blockdev_rereadpt_0_skip ()) {
5941     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
5942     return 0;
5943   }
5944
5945   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
5946   {
5947     char device[] = "/dev/sda";
5948     device[5] = devchar;
5949     int r;
5950     suppress_error = 0;
5951     r = guestfs_blockdev_setrw (g, device);
5952     if (r == -1)
5953       return -1;
5954   }
5955   {
5956     int r;
5957     suppress_error = 0;
5958     r = guestfs_umount_all (g);
5959     if (r == -1)
5960       return -1;
5961   }
5962   {
5963     int r;
5964     suppress_error = 0;
5965     r = guestfs_lvm_remove_all (g);
5966     if (r == -1)
5967       return -1;
5968   }
5969   /* TestRun for blockdev_rereadpt (0) */
5970   {
5971     char device[] = "/dev/sda";
5972     device[5] = devchar;
5973     int r;
5974     suppress_error = 0;
5975     r = guestfs_blockdev_rereadpt (g, device);
5976     if (r == -1)
5977       return -1;
5978   }
5979   return 0;
5980 }
5981
5982 static int test_blockdev_flushbufs_0_skip (void)
5983 {
5984   const char *str;
5985
5986   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
5987   if (str && strcmp (str, "1") == 0) return 1;
5988   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
5989   if (str && strcmp (str, "1") == 0) return 1;
5990   return 0;
5991 }
5992
5993 static int test_blockdev_flushbufs_0 (void)
5994 {
5995   if (test_blockdev_flushbufs_0_skip ()) {
5996     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
5997     return 0;
5998   }
5999
6000   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6001   {
6002     char device[] = "/dev/sda";
6003     device[5] = devchar;
6004     int r;
6005     suppress_error = 0;
6006     r = guestfs_blockdev_setrw (g, device);
6007     if (r == -1)
6008       return -1;
6009   }
6010   {
6011     int r;
6012     suppress_error = 0;
6013     r = guestfs_umount_all (g);
6014     if (r == -1)
6015       return -1;
6016   }
6017   {
6018     int r;
6019     suppress_error = 0;
6020     r = guestfs_lvm_remove_all (g);
6021     if (r == -1)
6022       return -1;
6023   }
6024   /* TestRun for blockdev_flushbufs (0) */
6025   {
6026     char device[] = "/dev/sda";
6027     device[5] = devchar;
6028     int r;
6029     suppress_error = 0;
6030     r = guestfs_blockdev_flushbufs (g, device);
6031     if (r == -1)
6032       return -1;
6033   }
6034   return 0;
6035 }
6036
6037 static int test_blockdev_getsize64_0_skip (void)
6038 {
6039   const char *str;
6040
6041   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6042   if (str && strcmp (str, "1") == 0) return 1;
6043   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6044   if (str && strcmp (str, "1") == 0) return 1;
6045   return 0;
6046 }
6047
6048 static int test_blockdev_getsize64_0 (void)
6049 {
6050   if (test_blockdev_getsize64_0_skip ()) {
6051     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6052     return 0;
6053   }
6054
6055   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6056   {
6057     char device[] = "/dev/sda";
6058     device[5] = devchar;
6059     int r;
6060     suppress_error = 0;
6061     r = guestfs_blockdev_setrw (g, device);
6062     if (r == -1)
6063       return -1;
6064   }
6065   {
6066     int r;
6067     suppress_error = 0;
6068     r = guestfs_umount_all (g);
6069     if (r == -1)
6070       return -1;
6071   }
6072   {
6073     int r;
6074     suppress_error = 0;
6075     r = guestfs_lvm_remove_all (g);
6076     if (r == -1)
6077       return -1;
6078   }
6079   /* TestOutputInt for blockdev_getsize64 (0) */
6080   {
6081     char device[] = "/dev/sda";
6082     device[5] = devchar;
6083     int64_t r;
6084     suppress_error = 0;
6085     r = guestfs_blockdev_getsize64 (g, device);
6086     if (r == -1)
6087       return -1;
6088     if (r != 524288000) {
6089       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6090       return -1;
6091     }
6092   }
6093   return 0;
6094 }
6095
6096 static int test_blockdev_getsz_0_skip (void)
6097 {
6098   const char *str;
6099
6100   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6101   if (str && strcmp (str, "1") == 0) return 1;
6102   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6103   if (str && strcmp (str, "1") == 0) return 1;
6104   return 0;
6105 }
6106
6107 static int test_blockdev_getsz_0 (void)
6108 {
6109   if (test_blockdev_getsz_0_skip ()) {
6110     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6111     return 0;
6112   }
6113
6114   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6115   {
6116     char device[] = "/dev/sda";
6117     device[5] = devchar;
6118     int r;
6119     suppress_error = 0;
6120     r = guestfs_blockdev_setrw (g, device);
6121     if (r == -1)
6122       return -1;
6123   }
6124   {
6125     int r;
6126     suppress_error = 0;
6127     r = guestfs_umount_all (g);
6128     if (r == -1)
6129       return -1;
6130   }
6131   {
6132     int r;
6133     suppress_error = 0;
6134     r = guestfs_lvm_remove_all (g);
6135     if (r == -1)
6136       return -1;
6137   }
6138   /* TestOutputInt for blockdev_getsz (0) */
6139   {
6140     char device[] = "/dev/sda";
6141     device[5] = devchar;
6142     int64_t r;
6143     suppress_error = 0;
6144     r = guestfs_blockdev_getsz (g, device);
6145     if (r == -1)
6146       return -1;
6147     if (r != 1024000) {
6148       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6149       return -1;
6150     }
6151   }
6152   return 0;
6153 }
6154
6155 static int test_blockdev_getbsz_0_skip (void)
6156 {
6157   const char *str;
6158
6159   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6160   if (str && strcmp (str, "1") == 0) return 1;
6161   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6162   if (str && strcmp (str, "1") == 0) return 1;
6163   return 0;
6164 }
6165
6166 static int test_blockdev_getbsz_0 (void)
6167 {
6168   if (test_blockdev_getbsz_0_skip ()) {
6169     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6170     return 0;
6171   }
6172
6173   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6174   {
6175     char device[] = "/dev/sda";
6176     device[5] = devchar;
6177     int r;
6178     suppress_error = 0;
6179     r = guestfs_blockdev_setrw (g, device);
6180     if (r == -1)
6181       return -1;
6182   }
6183   {
6184     int r;
6185     suppress_error = 0;
6186     r = guestfs_umount_all (g);
6187     if (r == -1)
6188       return -1;
6189   }
6190   {
6191     int r;
6192     suppress_error = 0;
6193     r = guestfs_lvm_remove_all (g);
6194     if (r == -1)
6195       return -1;
6196   }
6197   /* TestOutputInt for blockdev_getbsz (0) */
6198   {
6199     char device[] = "/dev/sda";
6200     device[5] = devchar;
6201     int r;
6202     suppress_error = 0;
6203     r = guestfs_blockdev_getbsz (g, device);
6204     if (r == -1)
6205       return -1;
6206     if (r != 4096) {
6207       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6208       return -1;
6209     }
6210   }
6211   return 0;
6212 }
6213
6214 static int test_blockdev_getss_0_skip (void)
6215 {
6216   const char *str;
6217
6218   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6219   if (str && strcmp (str, "1") == 0) return 1;
6220   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6221   if (str && strcmp (str, "1") == 0) return 1;
6222   return 0;
6223 }
6224
6225 static int test_blockdev_getss_0 (void)
6226 {
6227   if (test_blockdev_getss_0_skip ()) {
6228     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6229     return 0;
6230   }
6231
6232   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6233   {
6234     char device[] = "/dev/sda";
6235     device[5] = devchar;
6236     int r;
6237     suppress_error = 0;
6238     r = guestfs_blockdev_setrw (g, device);
6239     if (r == -1)
6240       return -1;
6241   }
6242   {
6243     int r;
6244     suppress_error = 0;
6245     r = guestfs_umount_all (g);
6246     if (r == -1)
6247       return -1;
6248   }
6249   {
6250     int r;
6251     suppress_error = 0;
6252     r = guestfs_lvm_remove_all (g);
6253     if (r == -1)
6254       return -1;
6255   }
6256   /* TestOutputInt for blockdev_getss (0) */
6257   {
6258     char device[] = "/dev/sda";
6259     device[5] = devchar;
6260     int r;
6261     suppress_error = 0;
6262     r = guestfs_blockdev_getss (g, device);
6263     if (r == -1)
6264       return -1;
6265     if (r != 512) {
6266       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6267       return -1;
6268     }
6269   }
6270   return 0;
6271 }
6272
6273 static int test_blockdev_getro_0_skip (void)
6274 {
6275   const char *str;
6276
6277   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6278   if (str && strcmp (str, "1") == 0) return 1;
6279   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6280   if (str && strcmp (str, "1") == 0) return 1;
6281   return 0;
6282 }
6283
6284 static int test_blockdev_getro_0 (void)
6285 {
6286   if (test_blockdev_getro_0_skip ()) {
6287     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6288     return 0;
6289   }
6290
6291   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6292   {
6293     char device[] = "/dev/sda";
6294     device[5] = devchar;
6295     int r;
6296     suppress_error = 0;
6297     r = guestfs_blockdev_setrw (g, device);
6298     if (r == -1)
6299       return -1;
6300   }
6301   {
6302     int r;
6303     suppress_error = 0;
6304     r = guestfs_umount_all (g);
6305     if (r == -1)
6306       return -1;
6307   }
6308   {
6309     int r;
6310     suppress_error = 0;
6311     r = guestfs_lvm_remove_all (g);
6312     if (r == -1)
6313       return -1;
6314   }
6315   /* TestOutputTrue for blockdev_getro (0) */
6316   {
6317     char device[] = "/dev/sda";
6318     device[5] = devchar;
6319     int r;
6320     suppress_error = 0;
6321     r = guestfs_blockdev_setro (g, device);
6322     if (r == -1)
6323       return -1;
6324   }
6325   {
6326     char device[] = "/dev/sda";
6327     device[5] = devchar;
6328     int r;
6329     suppress_error = 0;
6330     r = guestfs_blockdev_getro (g, device);
6331     if (r == -1)
6332       return -1;
6333     if (!r) {
6334       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6335       return -1;
6336     }
6337   }
6338   return 0;
6339 }
6340
6341 static int test_blockdev_setrw_0_skip (void)
6342 {
6343   const char *str;
6344
6345   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6346   if (str && strcmp (str, "1") == 0) return 1;
6347   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6348   if (str && strcmp (str, "1") == 0) return 1;
6349   return 0;
6350 }
6351
6352 static int test_blockdev_setrw_0 (void)
6353 {
6354   if (test_blockdev_setrw_0_skip ()) {
6355     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6356     return 0;
6357   }
6358
6359   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6360   {
6361     char device[] = "/dev/sda";
6362     device[5] = devchar;
6363     int r;
6364     suppress_error = 0;
6365     r = guestfs_blockdev_setrw (g, device);
6366     if (r == -1)
6367       return -1;
6368   }
6369   {
6370     int r;
6371     suppress_error = 0;
6372     r = guestfs_umount_all (g);
6373     if (r == -1)
6374       return -1;
6375   }
6376   {
6377     int r;
6378     suppress_error = 0;
6379     r = guestfs_lvm_remove_all (g);
6380     if (r == -1)
6381       return -1;
6382   }
6383   /* TestOutputFalse for blockdev_setrw (0) */
6384   {
6385     char device[] = "/dev/sda";
6386     device[5] = devchar;
6387     int r;
6388     suppress_error = 0;
6389     r = guestfs_blockdev_setrw (g, device);
6390     if (r == -1)
6391       return -1;
6392   }
6393   {
6394     char device[] = "/dev/sda";
6395     device[5] = devchar;
6396     int r;
6397     suppress_error = 0;
6398     r = guestfs_blockdev_getro (g, device);
6399     if (r == -1)
6400       return -1;
6401     if (r) {
6402       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6403       return -1;
6404     }
6405   }
6406   return 0;
6407 }
6408
6409 static int test_blockdev_setro_0_skip (void)
6410 {
6411   const char *str;
6412
6413   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6414   if (str && strcmp (str, "1") == 0) return 1;
6415   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6416   if (str && strcmp (str, "1") == 0) return 1;
6417   return 0;
6418 }
6419
6420 static int test_blockdev_setro_0 (void)
6421 {
6422   if (test_blockdev_setro_0_skip ()) {
6423     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6424     return 0;
6425   }
6426
6427   /* InitNone|InitEmpty for test_blockdev_setro_0 */
6428   {
6429     char device[] = "/dev/sda";
6430     device[5] = devchar;
6431     int r;
6432     suppress_error = 0;
6433     r = guestfs_blockdev_setrw (g, device);
6434     if (r == -1)
6435       return -1;
6436   }
6437   {
6438     int r;
6439     suppress_error = 0;
6440     r = guestfs_umount_all (g);
6441     if (r == -1)
6442       return -1;
6443   }
6444   {
6445     int r;
6446     suppress_error = 0;
6447     r = guestfs_lvm_remove_all (g);
6448     if (r == -1)
6449       return -1;
6450   }
6451   /* TestOutputTrue for blockdev_setro (0) */
6452   {
6453     char device[] = "/dev/sda";
6454     device[5] = devchar;
6455     int r;
6456     suppress_error = 0;
6457     r = guestfs_blockdev_setro (g, device);
6458     if (r == -1)
6459       return -1;
6460   }
6461   {
6462     char device[] = "/dev/sda";
6463     device[5] = devchar;
6464     int r;
6465     suppress_error = 0;
6466     r = guestfs_blockdev_getro (g, device);
6467     if (r == -1)
6468       return -1;
6469     if (!r) {
6470       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6471       return -1;
6472     }
6473   }
6474   return 0;
6475 }
6476
6477 static int test_statvfs_0_skip (void)
6478 {
6479   const char *str;
6480
6481   str = getenv ("SKIP_TEST_STATVFS_0");
6482   if (str && strcmp (str, "1") == 0) return 1;
6483   str = getenv ("SKIP_TEST_STATVFS");
6484   if (str && strcmp (str, "1") == 0) return 1;
6485   return 0;
6486 }
6487
6488 static int test_statvfs_0 (void)
6489 {
6490   if (test_statvfs_0_skip ()) {
6491     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6492     return 0;
6493   }
6494
6495   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6496   {
6497     char device[] = "/dev/sda";
6498     device[5] = devchar;
6499     int r;
6500     suppress_error = 0;
6501     r = guestfs_blockdev_setrw (g, device);
6502     if (r == -1)
6503       return -1;
6504   }
6505   {
6506     int r;
6507     suppress_error = 0;
6508     r = guestfs_umount_all (g);
6509     if (r == -1)
6510       return -1;
6511   }
6512   {
6513     int r;
6514     suppress_error = 0;
6515     r = guestfs_lvm_remove_all (g);
6516     if (r == -1)
6517       return -1;
6518   }
6519   {
6520     char device[] = "/dev/sda";
6521     device[5] = devchar;
6522     char lines_0[] = ",";
6523     char *lines[] = {
6524       lines_0,
6525       NULL
6526     };
6527     int r;
6528     suppress_error = 0;
6529     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6530     if (r == -1)
6531       return -1;
6532   }
6533   {
6534     char fstype[] = "ext2";
6535     char device[] = "/dev/sda1";
6536     device[5] = devchar;
6537     int r;
6538     suppress_error = 0;
6539     r = guestfs_mkfs (g, fstype, device);
6540     if (r == -1)
6541       return -1;
6542   }
6543   {
6544     char device[] = "/dev/sda1";
6545     device[5] = devchar;
6546     char mountpoint[] = "/";
6547     int r;
6548     suppress_error = 0;
6549     r = guestfs_mount (g, device, mountpoint);
6550     if (r == -1)
6551       return -1;
6552   }
6553   /* TestOutputStruct for statvfs (0) */
6554   {
6555     char path[] = "/";
6556     struct guestfs_statvfs *r;
6557     suppress_error = 0;
6558     r = guestfs_statvfs (g, path);
6559     if (r == NULL)
6560       return -1;
6561     if (r->bfree != 487702) {
6562       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6563                (int) r->bfree);
6564       return -1;
6565     }
6566     if (r->blocks != 490020) {
6567       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6568                (int) r->blocks);
6569       return -1;
6570     }
6571     if (r->bsize != 1024) {
6572       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6573                (int) r->bsize);
6574       return -1;
6575     }
6576     free (r);
6577   }
6578   return 0;
6579 }
6580
6581 static int test_lstat_0_skip (void)
6582 {
6583   const char *str;
6584
6585   str = getenv ("SKIP_TEST_LSTAT_0");
6586   if (str && strcmp (str, "1") == 0) return 1;
6587   str = getenv ("SKIP_TEST_LSTAT");
6588   if (str && strcmp (str, "1") == 0) return 1;
6589   return 0;
6590 }
6591
6592 static int test_lstat_0 (void)
6593 {
6594   if (test_lstat_0_skip ()) {
6595     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6596     return 0;
6597   }
6598
6599   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6600   {
6601     char device[] = "/dev/sda";
6602     device[5] = devchar;
6603     int r;
6604     suppress_error = 0;
6605     r = guestfs_blockdev_setrw (g, device);
6606     if (r == -1)
6607       return -1;
6608   }
6609   {
6610     int r;
6611     suppress_error = 0;
6612     r = guestfs_umount_all (g);
6613     if (r == -1)
6614       return -1;
6615   }
6616   {
6617     int r;
6618     suppress_error = 0;
6619     r = guestfs_lvm_remove_all (g);
6620     if (r == -1)
6621       return -1;
6622   }
6623   {
6624     char device[] = "/dev/sda";
6625     device[5] = devchar;
6626     char lines_0[] = ",";
6627     char *lines[] = {
6628       lines_0,
6629       NULL
6630     };
6631     int r;
6632     suppress_error = 0;
6633     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6634     if (r == -1)
6635       return -1;
6636   }
6637   {
6638     char fstype[] = "ext2";
6639     char device[] = "/dev/sda1";
6640     device[5] = devchar;
6641     int r;
6642     suppress_error = 0;
6643     r = guestfs_mkfs (g, fstype, device);
6644     if (r == -1)
6645       return -1;
6646   }
6647   {
6648     char device[] = "/dev/sda1";
6649     device[5] = devchar;
6650     char mountpoint[] = "/";
6651     int r;
6652     suppress_error = 0;
6653     r = guestfs_mount (g, device, mountpoint);
6654     if (r == -1)
6655       return -1;
6656   }
6657   /* TestOutputStruct for lstat (0) */
6658   {
6659     char path[] = "/new";
6660     int r;
6661     suppress_error = 0;
6662     r = guestfs_touch (g, path);
6663     if (r == -1)
6664       return -1;
6665   }
6666   {
6667     char path[] = "/new";
6668     struct guestfs_stat *r;
6669     suppress_error = 0;
6670     r = guestfs_lstat (g, path);
6671     if (r == NULL)
6672       return -1;
6673     if (r->size != 0) {
6674       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6675                (int) r->size);
6676       return -1;
6677     }
6678     free (r);
6679   }
6680   return 0;
6681 }
6682
6683 static int test_stat_0_skip (void)
6684 {
6685   const char *str;
6686
6687   str = getenv ("SKIP_TEST_STAT_0");
6688   if (str && strcmp (str, "1") == 0) return 1;
6689   str = getenv ("SKIP_TEST_STAT");
6690   if (str && strcmp (str, "1") == 0) return 1;
6691   return 0;
6692 }
6693
6694 static int test_stat_0 (void)
6695 {
6696   if (test_stat_0_skip ()) {
6697     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6698     return 0;
6699   }
6700
6701   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6702   {
6703     char device[] = "/dev/sda";
6704     device[5] = devchar;
6705     int r;
6706     suppress_error = 0;
6707     r = guestfs_blockdev_setrw (g, device);
6708     if (r == -1)
6709       return -1;
6710   }
6711   {
6712     int r;
6713     suppress_error = 0;
6714     r = guestfs_umount_all (g);
6715     if (r == -1)
6716       return -1;
6717   }
6718   {
6719     int r;
6720     suppress_error = 0;
6721     r = guestfs_lvm_remove_all (g);
6722     if (r == -1)
6723       return -1;
6724   }
6725   {
6726     char device[] = "/dev/sda";
6727     device[5] = devchar;
6728     char lines_0[] = ",";
6729     char *lines[] = {
6730       lines_0,
6731       NULL
6732     };
6733     int r;
6734     suppress_error = 0;
6735     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6736     if (r == -1)
6737       return -1;
6738   }
6739   {
6740     char fstype[] = "ext2";
6741     char device[] = "/dev/sda1";
6742     device[5] = devchar;
6743     int r;
6744     suppress_error = 0;
6745     r = guestfs_mkfs (g, fstype, device);
6746     if (r == -1)
6747       return -1;
6748   }
6749   {
6750     char device[] = "/dev/sda1";
6751     device[5] = devchar;
6752     char mountpoint[] = "/";
6753     int r;
6754     suppress_error = 0;
6755     r = guestfs_mount (g, device, mountpoint);
6756     if (r == -1)
6757       return -1;
6758   }
6759   /* TestOutputStruct for stat (0) */
6760   {
6761     char path[] = "/new";
6762     int r;
6763     suppress_error = 0;
6764     r = guestfs_touch (g, path);
6765     if (r == -1)
6766       return -1;
6767   }
6768   {
6769     char path[] = "/new";
6770     struct guestfs_stat *r;
6771     suppress_error = 0;
6772     r = guestfs_stat (g, path);
6773     if (r == NULL)
6774       return -1;
6775     if (r->size != 0) {
6776       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6777                (int) r->size);
6778       return -1;
6779     }
6780     free (r);
6781   }
6782   return 0;
6783 }
6784
6785 static int test_command_lines_0_skip (void)
6786 {
6787   const char *str;
6788
6789   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6790   if (str && strcmp (str, "1") == 0) return 1;
6791   str = getenv ("SKIP_TEST_COMMAND_LINES");
6792   if (str && strcmp (str, "1") == 0) return 1;
6793   return 0;
6794 }
6795
6796 static int test_command_lines_0 (void)
6797 {
6798   if (test_command_lines_0_skip ()) {
6799     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6800     return 0;
6801   }
6802
6803   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6804   {
6805     char device[] = "/dev/sda";
6806     device[5] = devchar;
6807     int r;
6808     suppress_error = 0;
6809     r = guestfs_blockdev_setrw (g, device);
6810     if (r == -1)
6811       return -1;
6812   }
6813   {
6814     int r;
6815     suppress_error = 0;
6816     r = guestfs_umount_all (g);
6817     if (r == -1)
6818       return -1;
6819   }
6820   {
6821     int r;
6822     suppress_error = 0;
6823     r = guestfs_lvm_remove_all (g);
6824     if (r == -1)
6825       return -1;
6826   }
6827   {
6828     char device[] = "/dev/sda";
6829     device[5] = devchar;
6830     char lines_0[] = ",";
6831     char *lines[] = {
6832       lines_0,
6833       NULL
6834     };
6835     int r;
6836     suppress_error = 0;
6837     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6838     if (r == -1)
6839       return -1;
6840   }
6841   {
6842     char fstype[] = "ext2";
6843     char device[] = "/dev/sda1";
6844     device[5] = devchar;
6845     int r;
6846     suppress_error = 0;
6847     r = guestfs_mkfs (g, fstype, device);
6848     if (r == -1)
6849       return -1;
6850   }
6851   {
6852     char device[] = "/dev/sda1";
6853     device[5] = devchar;
6854     char mountpoint[] = "/";
6855     int r;
6856     suppress_error = 0;
6857     r = guestfs_mount (g, device, mountpoint);
6858     if (r == -1)
6859       return -1;
6860   }
6861   /* TestOutputList for command_lines (0) */
6862   {
6863     char remotefilename[] = "/test-command";
6864     int r;
6865     suppress_error = 0;
6866     r = guestfs_upload (g, "test-command", remotefilename);
6867     if (r == -1)
6868       return -1;
6869   }
6870   {
6871     char path[] = "/test-command";
6872     int r;
6873     suppress_error = 0;
6874     r = guestfs_chmod (g, 493, path);
6875     if (r == -1)
6876       return -1;
6877   }
6878   {
6879     char arguments_0[] = "/test-command";
6880     char arguments_1[] = "1";
6881     char *arguments[] = {
6882       arguments_0,
6883       arguments_1,
6884       NULL
6885     };
6886     char **r;
6887     int i;
6888     suppress_error = 0;
6889     r = guestfs_command_lines (g, arguments);
6890     if (r == NULL)
6891       return -1;
6892     if (!r[0]) {
6893       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
6894       print_strings (r);
6895       return -1;
6896     }
6897     {
6898       char expected[] = "Result1";
6899       if (strcmp (r[0], expected) != 0) {
6900         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6901         return -1;
6902       }
6903     }
6904     if (r[1] != NULL) {
6905       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
6906       print_strings (r);
6907       return -1;
6908     }
6909     for (i = 0; r[i] != NULL; ++i)
6910       free (r[i]);
6911     free (r);
6912   }
6913   return 0;
6914 }
6915
6916 static int test_command_lines_1_skip (void)
6917 {
6918   const char *str;
6919
6920   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
6921   if (str && strcmp (str, "1") == 0) return 1;
6922   str = getenv ("SKIP_TEST_COMMAND_LINES");
6923   if (str && strcmp (str, "1") == 0) return 1;
6924   return 0;
6925 }
6926
6927 static int test_command_lines_1 (void)
6928 {
6929   if (test_command_lines_1_skip ()) {
6930     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
6931     return 0;
6932   }
6933
6934   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
6935   {
6936     char device[] = "/dev/sda";
6937     device[5] = devchar;
6938     int r;
6939     suppress_error = 0;
6940     r = guestfs_blockdev_setrw (g, device);
6941     if (r == -1)
6942       return -1;
6943   }
6944   {
6945     int r;
6946     suppress_error = 0;
6947     r = guestfs_umount_all (g);
6948     if (r == -1)
6949       return -1;
6950   }
6951   {
6952     int r;
6953     suppress_error = 0;
6954     r = guestfs_lvm_remove_all (g);
6955     if (r == -1)
6956       return -1;
6957   }
6958   {
6959     char device[] = "/dev/sda";
6960     device[5] = devchar;
6961     char lines_0[] = ",";
6962     char *lines[] = {
6963       lines_0,
6964       NULL
6965     };
6966     int r;
6967     suppress_error = 0;
6968     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6969     if (r == -1)
6970       return -1;
6971   }
6972   {
6973     char fstype[] = "ext2";
6974     char device[] = "/dev/sda1";
6975     device[5] = devchar;
6976     int r;
6977     suppress_error = 0;
6978     r = guestfs_mkfs (g, fstype, device);
6979     if (r == -1)
6980       return -1;
6981   }
6982   {
6983     char device[] = "/dev/sda1";
6984     device[5] = devchar;
6985     char mountpoint[] = "/";
6986     int r;
6987     suppress_error = 0;
6988     r = guestfs_mount (g, device, mountpoint);
6989     if (r == -1)
6990       return -1;
6991   }
6992   /* TestOutputList for command_lines (1) */
6993   {
6994     char remotefilename[] = "/test-command";
6995     int r;
6996     suppress_error = 0;
6997     r = guestfs_upload (g, "test-command", remotefilename);
6998     if (r == -1)
6999       return -1;
7000   }
7001   {
7002     char path[] = "/test-command";
7003     int r;
7004     suppress_error = 0;
7005     r = guestfs_chmod (g, 493, path);
7006     if (r == -1)
7007       return -1;
7008   }
7009   {
7010     char arguments_0[] = "/test-command";
7011     char arguments_1[] = "2";
7012     char *arguments[] = {
7013       arguments_0,
7014       arguments_1,
7015       NULL
7016     };
7017     char **r;
7018     int i;
7019     suppress_error = 0;
7020     r = guestfs_command_lines (g, arguments);
7021     if (r == NULL)
7022       return -1;
7023     if (!r[0]) {
7024       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7025       print_strings (r);
7026       return -1;
7027     }
7028     {
7029       char expected[] = "Result2";
7030       if (strcmp (r[0], expected) != 0) {
7031         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7032         return -1;
7033       }
7034     }
7035     if (r[1] != NULL) {
7036       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7037       print_strings (r);
7038       return -1;
7039     }
7040     for (i = 0; r[i] != NULL; ++i)
7041       free (r[i]);
7042     free (r);
7043   }
7044   return 0;
7045 }
7046
7047 static int test_command_lines_2_skip (void)
7048 {
7049   const char *str;
7050
7051   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7052   if (str && strcmp (str, "1") == 0) return 1;
7053   str = getenv ("SKIP_TEST_COMMAND_LINES");
7054   if (str && strcmp (str, "1") == 0) return 1;
7055   return 0;
7056 }
7057
7058 static int test_command_lines_2 (void)
7059 {
7060   if (test_command_lines_2_skip ()) {
7061     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7062     return 0;
7063   }
7064
7065   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7066   {
7067     char device[] = "/dev/sda";
7068     device[5] = devchar;
7069     int r;
7070     suppress_error = 0;
7071     r = guestfs_blockdev_setrw (g, device);
7072     if (r == -1)
7073       return -1;
7074   }
7075   {
7076     int r;
7077     suppress_error = 0;
7078     r = guestfs_umount_all (g);
7079     if (r == -1)
7080       return -1;
7081   }
7082   {
7083     int r;
7084     suppress_error = 0;
7085     r = guestfs_lvm_remove_all (g);
7086     if (r == -1)
7087       return -1;
7088   }
7089   {
7090     char device[] = "/dev/sda";
7091     device[5] = devchar;
7092     char lines_0[] = ",";
7093     char *lines[] = {
7094       lines_0,
7095       NULL
7096     };
7097     int r;
7098     suppress_error = 0;
7099     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7100     if (r == -1)
7101       return -1;
7102   }
7103   {
7104     char fstype[] = "ext2";
7105     char device[] = "/dev/sda1";
7106     device[5] = devchar;
7107     int r;
7108     suppress_error = 0;
7109     r = guestfs_mkfs (g, fstype, device);
7110     if (r == -1)
7111       return -1;
7112   }
7113   {
7114     char device[] = "/dev/sda1";
7115     device[5] = devchar;
7116     char mountpoint[] = "/";
7117     int r;
7118     suppress_error = 0;
7119     r = guestfs_mount (g, device, mountpoint);
7120     if (r == -1)
7121       return -1;
7122   }
7123   /* TestOutputList for command_lines (2) */
7124   {
7125     char remotefilename[] = "/test-command";
7126     int r;
7127     suppress_error = 0;
7128     r = guestfs_upload (g, "test-command", remotefilename);
7129     if (r == -1)
7130       return -1;
7131   }
7132   {
7133     char path[] = "/test-command";
7134     int r;
7135     suppress_error = 0;
7136     r = guestfs_chmod (g, 493, path);
7137     if (r == -1)
7138       return -1;
7139   }
7140   {
7141     char arguments_0[] = "/test-command";
7142     char arguments_1[] = "3";
7143     char *arguments[] = {
7144       arguments_0,
7145       arguments_1,
7146       NULL
7147     };
7148     char **r;
7149     int i;
7150     suppress_error = 0;
7151     r = guestfs_command_lines (g, arguments);
7152     if (r == NULL)
7153       return -1;
7154     if (!r[0]) {
7155       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7156       print_strings (r);
7157       return -1;
7158     }
7159     {
7160       char expected[] = "";
7161       if (strcmp (r[0], expected) != 0) {
7162         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7163         return -1;
7164       }
7165     }
7166     if (!r[1]) {
7167       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7168       print_strings (r);
7169       return -1;
7170     }
7171     {
7172       char expected[] = "Result3";
7173       if (strcmp (r[1], expected) != 0) {
7174         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7175         return -1;
7176       }
7177     }
7178     if (r[2] != NULL) {
7179       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7180       print_strings (r);
7181       return -1;
7182     }
7183     for (i = 0; r[i] != NULL; ++i)
7184       free (r[i]);
7185     free (r);
7186   }
7187   return 0;
7188 }
7189
7190 static int test_command_lines_3_skip (void)
7191 {
7192   const char *str;
7193
7194   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7195   if (str && strcmp (str, "1") == 0) return 1;
7196   str = getenv ("SKIP_TEST_COMMAND_LINES");
7197   if (str && strcmp (str, "1") == 0) return 1;
7198   return 0;
7199 }
7200
7201 static int test_command_lines_3 (void)
7202 {
7203   if (test_command_lines_3_skip ()) {
7204     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7205     return 0;
7206   }
7207
7208   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7209   {
7210     char device[] = "/dev/sda";
7211     device[5] = devchar;
7212     int r;
7213     suppress_error = 0;
7214     r = guestfs_blockdev_setrw (g, device);
7215     if (r == -1)
7216       return -1;
7217   }
7218   {
7219     int r;
7220     suppress_error = 0;
7221     r = guestfs_umount_all (g);
7222     if (r == -1)
7223       return -1;
7224   }
7225   {
7226     int r;
7227     suppress_error = 0;
7228     r = guestfs_lvm_remove_all (g);
7229     if (r == -1)
7230       return -1;
7231   }
7232   {
7233     char device[] = "/dev/sda";
7234     device[5] = devchar;
7235     char lines_0[] = ",";
7236     char *lines[] = {
7237       lines_0,
7238       NULL
7239     };
7240     int r;
7241     suppress_error = 0;
7242     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7243     if (r == -1)
7244       return -1;
7245   }
7246   {
7247     char fstype[] = "ext2";
7248     char device[] = "/dev/sda1";
7249     device[5] = devchar;
7250     int r;
7251     suppress_error = 0;
7252     r = guestfs_mkfs (g, fstype, device);
7253     if (r == -1)
7254       return -1;
7255   }
7256   {
7257     char device[] = "/dev/sda1";
7258     device[5] = devchar;
7259     char mountpoint[] = "/";
7260     int r;
7261     suppress_error = 0;
7262     r = guestfs_mount (g, device, mountpoint);
7263     if (r == -1)
7264       return -1;
7265   }
7266   /* TestOutputList for command_lines (3) */
7267   {
7268     char remotefilename[] = "/test-command";
7269     int r;
7270     suppress_error = 0;
7271     r = guestfs_upload (g, "test-command", remotefilename);
7272     if (r == -1)
7273       return -1;
7274   }
7275   {
7276     char path[] = "/test-command";
7277     int r;
7278     suppress_error = 0;
7279     r = guestfs_chmod (g, 493, path);
7280     if (r == -1)
7281       return -1;
7282   }
7283   {
7284     char arguments_0[] = "/test-command";
7285     char arguments_1[] = "4";
7286     char *arguments[] = {
7287       arguments_0,
7288       arguments_1,
7289       NULL
7290     };
7291     char **r;
7292     int i;
7293     suppress_error = 0;
7294     r = guestfs_command_lines (g, arguments);
7295     if (r == NULL)
7296       return -1;
7297     if (!r[0]) {
7298       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7299       print_strings (r);
7300       return -1;
7301     }
7302     {
7303       char expected[] = "";
7304       if (strcmp (r[0], expected) != 0) {
7305         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7306         return -1;
7307       }
7308     }
7309     if (!r[1]) {
7310       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7311       print_strings (r);
7312       return -1;
7313     }
7314     {
7315       char expected[] = "Result4";
7316       if (strcmp (r[1], expected) != 0) {
7317         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7318         return -1;
7319       }
7320     }
7321     if (r[2] != NULL) {
7322       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7323       print_strings (r);
7324       return -1;
7325     }
7326     for (i = 0; r[i] != NULL; ++i)
7327       free (r[i]);
7328     free (r);
7329   }
7330   return 0;
7331 }
7332
7333 static int test_command_lines_4_skip (void)
7334 {
7335   const char *str;
7336
7337   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7338   if (str && strcmp (str, "1") == 0) return 1;
7339   str = getenv ("SKIP_TEST_COMMAND_LINES");
7340   if (str && strcmp (str, "1") == 0) return 1;
7341   return 0;
7342 }
7343
7344 static int test_command_lines_4 (void)
7345 {
7346   if (test_command_lines_4_skip ()) {
7347     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7348     return 0;
7349   }
7350
7351   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7352   {
7353     char device[] = "/dev/sda";
7354     device[5] = devchar;
7355     int r;
7356     suppress_error = 0;
7357     r = guestfs_blockdev_setrw (g, device);
7358     if (r == -1)
7359       return -1;
7360   }
7361   {
7362     int r;
7363     suppress_error = 0;
7364     r = guestfs_umount_all (g);
7365     if (r == -1)
7366       return -1;
7367   }
7368   {
7369     int r;
7370     suppress_error = 0;
7371     r = guestfs_lvm_remove_all (g);
7372     if (r == -1)
7373       return -1;
7374   }
7375   {
7376     char device[] = "/dev/sda";
7377     device[5] = devchar;
7378     char lines_0[] = ",";
7379     char *lines[] = {
7380       lines_0,
7381       NULL
7382     };
7383     int r;
7384     suppress_error = 0;
7385     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7386     if (r == -1)
7387       return -1;
7388   }
7389   {
7390     char fstype[] = "ext2";
7391     char device[] = "/dev/sda1";
7392     device[5] = devchar;
7393     int r;
7394     suppress_error = 0;
7395     r = guestfs_mkfs (g, fstype, device);
7396     if (r == -1)
7397       return -1;
7398   }
7399   {
7400     char device[] = "/dev/sda1";
7401     device[5] = devchar;
7402     char mountpoint[] = "/";
7403     int r;
7404     suppress_error = 0;
7405     r = guestfs_mount (g, device, mountpoint);
7406     if (r == -1)
7407       return -1;
7408   }
7409   /* TestOutputList for command_lines (4) */
7410   {
7411     char remotefilename[] = "/test-command";
7412     int r;
7413     suppress_error = 0;
7414     r = guestfs_upload (g, "test-command", remotefilename);
7415     if (r == -1)
7416       return -1;
7417   }
7418   {
7419     char path[] = "/test-command";
7420     int r;
7421     suppress_error = 0;
7422     r = guestfs_chmod (g, 493, path);
7423     if (r == -1)
7424       return -1;
7425   }
7426   {
7427     char arguments_0[] = "/test-command";
7428     char arguments_1[] = "5";
7429     char *arguments[] = {
7430       arguments_0,
7431       arguments_1,
7432       NULL
7433     };
7434     char **r;
7435     int i;
7436     suppress_error = 0;
7437     r = guestfs_command_lines (g, arguments);
7438     if (r == NULL)
7439       return -1;
7440     if (!r[0]) {
7441       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7442       print_strings (r);
7443       return -1;
7444     }
7445     {
7446       char expected[] = "";
7447       if (strcmp (r[0], expected) != 0) {
7448         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7449         return -1;
7450       }
7451     }
7452     if (!r[1]) {
7453       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7454       print_strings (r);
7455       return -1;
7456     }
7457     {
7458       char expected[] = "Result5";
7459       if (strcmp (r[1], expected) != 0) {
7460         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7461         return -1;
7462       }
7463     }
7464     if (!r[2]) {
7465       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7466       print_strings (r);
7467       return -1;
7468     }
7469     {
7470       char expected[] = "";
7471       if (strcmp (r[2], expected) != 0) {
7472         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7473         return -1;
7474       }
7475     }
7476     if (r[3] != NULL) {
7477       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7478       print_strings (r);
7479       return -1;
7480     }
7481     for (i = 0; r[i] != NULL; ++i)
7482       free (r[i]);
7483     free (r);
7484   }
7485   return 0;
7486 }
7487
7488 static int test_command_lines_5_skip (void)
7489 {
7490   const char *str;
7491
7492   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7493   if (str && strcmp (str, "1") == 0) return 1;
7494   str = getenv ("SKIP_TEST_COMMAND_LINES");
7495   if (str && strcmp (str, "1") == 0) return 1;
7496   return 0;
7497 }
7498
7499 static int test_command_lines_5 (void)
7500 {
7501   if (test_command_lines_5_skip ()) {
7502     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7503     return 0;
7504   }
7505
7506   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7507   {
7508     char device[] = "/dev/sda";
7509     device[5] = devchar;
7510     int r;
7511     suppress_error = 0;
7512     r = guestfs_blockdev_setrw (g, device);
7513     if (r == -1)
7514       return -1;
7515   }
7516   {
7517     int r;
7518     suppress_error = 0;
7519     r = guestfs_umount_all (g);
7520     if (r == -1)
7521       return -1;
7522   }
7523   {
7524     int r;
7525     suppress_error = 0;
7526     r = guestfs_lvm_remove_all (g);
7527     if (r == -1)
7528       return -1;
7529   }
7530   {
7531     char device[] = "/dev/sda";
7532     device[5] = devchar;
7533     char lines_0[] = ",";
7534     char *lines[] = {
7535       lines_0,
7536       NULL
7537     };
7538     int r;
7539     suppress_error = 0;
7540     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7541     if (r == -1)
7542       return -1;
7543   }
7544   {
7545     char fstype[] = "ext2";
7546     char device[] = "/dev/sda1";
7547     device[5] = devchar;
7548     int r;
7549     suppress_error = 0;
7550     r = guestfs_mkfs (g, fstype, device);
7551     if (r == -1)
7552       return -1;
7553   }
7554   {
7555     char device[] = "/dev/sda1";
7556     device[5] = devchar;
7557     char mountpoint[] = "/";
7558     int r;
7559     suppress_error = 0;
7560     r = guestfs_mount (g, device, mountpoint);
7561     if (r == -1)
7562       return -1;
7563   }
7564   /* TestOutputList for command_lines (5) */
7565   {
7566     char remotefilename[] = "/test-command";
7567     int r;
7568     suppress_error = 0;
7569     r = guestfs_upload (g, "test-command", remotefilename);
7570     if (r == -1)
7571       return -1;
7572   }
7573   {
7574     char path[] = "/test-command";
7575     int r;
7576     suppress_error = 0;
7577     r = guestfs_chmod (g, 493, path);
7578     if (r == -1)
7579       return -1;
7580   }
7581   {
7582     char arguments_0[] = "/test-command";
7583     char arguments_1[] = "6";
7584     char *arguments[] = {
7585       arguments_0,
7586       arguments_1,
7587       NULL
7588     };
7589     char **r;
7590     int i;
7591     suppress_error = 0;
7592     r = guestfs_command_lines (g, arguments);
7593     if (r == NULL)
7594       return -1;
7595     if (!r[0]) {
7596       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7597       print_strings (r);
7598       return -1;
7599     }
7600     {
7601       char expected[] = "";
7602       if (strcmp (r[0], expected) != 0) {
7603         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7604         return -1;
7605       }
7606     }
7607     if (!r[1]) {
7608       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7609       print_strings (r);
7610       return -1;
7611     }
7612     {
7613       char expected[] = "";
7614       if (strcmp (r[1], expected) != 0) {
7615         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7616         return -1;
7617       }
7618     }
7619     if (!r[2]) {
7620       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7621       print_strings (r);
7622       return -1;
7623     }
7624     {
7625       char expected[] = "Result6";
7626       if (strcmp (r[2], expected) != 0) {
7627         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7628         return -1;
7629       }
7630     }
7631     if (!r[3]) {
7632       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7633       print_strings (r);
7634       return -1;
7635     }
7636     {
7637       char expected[] = "";
7638       if (strcmp (r[3], expected) != 0) {
7639         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7640         return -1;
7641       }
7642     }
7643     if (r[4] != NULL) {
7644       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7645       print_strings (r);
7646       return -1;
7647     }
7648     for (i = 0; r[i] != NULL; ++i)
7649       free (r[i]);
7650     free (r);
7651   }
7652   return 0;
7653 }
7654
7655 static int test_command_lines_6_skip (void)
7656 {
7657   const char *str;
7658
7659   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7660   if (str && strcmp (str, "1") == 0) return 1;
7661   str = getenv ("SKIP_TEST_COMMAND_LINES");
7662   if (str && strcmp (str, "1") == 0) return 1;
7663   return 0;
7664 }
7665
7666 static int test_command_lines_6 (void)
7667 {
7668   if (test_command_lines_6_skip ()) {
7669     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7670     return 0;
7671   }
7672
7673   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7674   {
7675     char device[] = "/dev/sda";
7676     device[5] = devchar;
7677     int r;
7678     suppress_error = 0;
7679     r = guestfs_blockdev_setrw (g, device);
7680     if (r == -1)
7681       return -1;
7682   }
7683   {
7684     int r;
7685     suppress_error = 0;
7686     r = guestfs_umount_all (g);
7687     if (r == -1)
7688       return -1;
7689   }
7690   {
7691     int r;
7692     suppress_error = 0;
7693     r = guestfs_lvm_remove_all (g);
7694     if (r == -1)
7695       return -1;
7696   }
7697   {
7698     char device[] = "/dev/sda";
7699     device[5] = devchar;
7700     char lines_0[] = ",";
7701     char *lines[] = {
7702       lines_0,
7703       NULL
7704     };
7705     int r;
7706     suppress_error = 0;
7707     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7708     if (r == -1)
7709       return -1;
7710   }
7711   {
7712     char fstype[] = "ext2";
7713     char device[] = "/dev/sda1";
7714     device[5] = devchar;
7715     int r;
7716     suppress_error = 0;
7717     r = guestfs_mkfs (g, fstype, device);
7718     if (r == -1)
7719       return -1;
7720   }
7721   {
7722     char device[] = "/dev/sda1";
7723     device[5] = devchar;
7724     char mountpoint[] = "/";
7725     int r;
7726     suppress_error = 0;
7727     r = guestfs_mount (g, device, mountpoint);
7728     if (r == -1)
7729       return -1;
7730   }
7731   /* TestOutputList for command_lines (6) */
7732   {
7733     char remotefilename[] = "/test-command";
7734     int r;
7735     suppress_error = 0;
7736     r = guestfs_upload (g, "test-command", remotefilename);
7737     if (r == -1)
7738       return -1;
7739   }
7740   {
7741     char path[] = "/test-command";
7742     int r;
7743     suppress_error = 0;
7744     r = guestfs_chmod (g, 493, path);
7745     if (r == -1)
7746       return -1;
7747   }
7748   {
7749     char arguments_0[] = "/test-command";
7750     char arguments_1[] = "7";
7751     char *arguments[] = {
7752       arguments_0,
7753       arguments_1,
7754       NULL
7755     };
7756     char **r;
7757     int i;
7758     suppress_error = 0;
7759     r = guestfs_command_lines (g, arguments);
7760     if (r == NULL)
7761       return -1;
7762     if (r[0] != NULL) {
7763       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7764       print_strings (r);
7765       return -1;
7766     }
7767     for (i = 0; r[i] != NULL; ++i)
7768       free (r[i]);
7769     free (r);
7770   }
7771   return 0;
7772 }
7773
7774 static int test_command_lines_7_skip (void)
7775 {
7776   const char *str;
7777
7778   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7779   if (str && strcmp (str, "1") == 0) return 1;
7780   str = getenv ("SKIP_TEST_COMMAND_LINES");
7781   if (str && strcmp (str, "1") == 0) return 1;
7782   return 0;
7783 }
7784
7785 static int test_command_lines_7 (void)
7786 {
7787   if (test_command_lines_7_skip ()) {
7788     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7789     return 0;
7790   }
7791
7792   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7793   {
7794     char device[] = "/dev/sda";
7795     device[5] = devchar;
7796     int r;
7797     suppress_error = 0;
7798     r = guestfs_blockdev_setrw (g, device);
7799     if (r == -1)
7800       return -1;
7801   }
7802   {
7803     int r;
7804     suppress_error = 0;
7805     r = guestfs_umount_all (g);
7806     if (r == -1)
7807       return -1;
7808   }
7809   {
7810     int r;
7811     suppress_error = 0;
7812     r = guestfs_lvm_remove_all (g);
7813     if (r == -1)
7814       return -1;
7815   }
7816   {
7817     char device[] = "/dev/sda";
7818     device[5] = devchar;
7819     char lines_0[] = ",";
7820     char *lines[] = {
7821       lines_0,
7822       NULL
7823     };
7824     int r;
7825     suppress_error = 0;
7826     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7827     if (r == -1)
7828       return -1;
7829   }
7830   {
7831     char fstype[] = "ext2";
7832     char device[] = "/dev/sda1";
7833     device[5] = devchar;
7834     int r;
7835     suppress_error = 0;
7836     r = guestfs_mkfs (g, fstype, device);
7837     if (r == -1)
7838       return -1;
7839   }
7840   {
7841     char device[] = "/dev/sda1";
7842     device[5] = devchar;
7843     char mountpoint[] = "/";
7844     int r;
7845     suppress_error = 0;
7846     r = guestfs_mount (g, device, mountpoint);
7847     if (r == -1)
7848       return -1;
7849   }
7850   /* TestOutputList for command_lines (7) */
7851   {
7852     char remotefilename[] = "/test-command";
7853     int r;
7854     suppress_error = 0;
7855     r = guestfs_upload (g, "test-command", remotefilename);
7856     if (r == -1)
7857       return -1;
7858   }
7859   {
7860     char path[] = "/test-command";
7861     int r;
7862     suppress_error = 0;
7863     r = guestfs_chmod (g, 493, path);
7864     if (r == -1)
7865       return -1;
7866   }
7867   {
7868     char arguments_0[] = "/test-command";
7869     char arguments_1[] = "8";
7870     char *arguments[] = {
7871       arguments_0,
7872       arguments_1,
7873       NULL
7874     };
7875     char **r;
7876     int i;
7877     suppress_error = 0;
7878     r = guestfs_command_lines (g, arguments);
7879     if (r == NULL)
7880       return -1;
7881     if (!r[0]) {
7882       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
7883       print_strings (r);
7884       return -1;
7885     }
7886     {
7887       char expected[] = "";
7888       if (strcmp (r[0], expected) != 0) {
7889         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7890         return -1;
7891       }
7892     }
7893     if (r[1] != NULL) {
7894       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
7895       print_strings (r);
7896       return -1;
7897     }
7898     for (i = 0; r[i] != NULL; ++i)
7899       free (r[i]);
7900     free (r);
7901   }
7902   return 0;
7903 }
7904
7905 static int test_command_lines_8_skip (void)
7906 {
7907   const char *str;
7908
7909   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
7910   if (str && strcmp (str, "1") == 0) return 1;
7911   str = getenv ("SKIP_TEST_COMMAND_LINES");
7912   if (str && strcmp (str, "1") == 0) return 1;
7913   return 0;
7914 }
7915
7916 static int test_command_lines_8 (void)
7917 {
7918   if (test_command_lines_8_skip ()) {
7919     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
7920     return 0;
7921   }
7922
7923   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
7924   {
7925     char device[] = "/dev/sda";
7926     device[5] = devchar;
7927     int r;
7928     suppress_error = 0;
7929     r = guestfs_blockdev_setrw (g, device);
7930     if (r == -1)
7931       return -1;
7932   }
7933   {
7934     int r;
7935     suppress_error = 0;
7936     r = guestfs_umount_all (g);
7937     if (r == -1)
7938       return -1;
7939   }
7940   {
7941     int r;
7942     suppress_error = 0;
7943     r = guestfs_lvm_remove_all (g);
7944     if (r == -1)
7945       return -1;
7946   }
7947   {
7948     char device[] = "/dev/sda";
7949     device[5] = devchar;
7950     char lines_0[] = ",";
7951     char *lines[] = {
7952       lines_0,
7953       NULL
7954     };
7955     int r;
7956     suppress_error = 0;
7957     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7958     if (r == -1)
7959       return -1;
7960   }
7961   {
7962     char fstype[] = "ext2";
7963     char device[] = "/dev/sda1";
7964     device[5] = devchar;
7965     int r;
7966     suppress_error = 0;
7967     r = guestfs_mkfs (g, fstype, device);
7968     if (r == -1)
7969       return -1;
7970   }
7971   {
7972     char device[] = "/dev/sda1";
7973     device[5] = devchar;
7974     char mountpoint[] = "/";
7975     int r;
7976     suppress_error = 0;
7977     r = guestfs_mount (g, device, mountpoint);
7978     if (r == -1)
7979       return -1;
7980   }
7981   /* TestOutputList for command_lines (8) */
7982   {
7983     char remotefilename[] = "/test-command";
7984     int r;
7985     suppress_error = 0;
7986     r = guestfs_upload (g, "test-command", remotefilename);
7987     if (r == -1)
7988       return -1;
7989   }
7990   {
7991     char path[] = "/test-command";
7992     int r;
7993     suppress_error = 0;
7994     r = guestfs_chmod (g, 493, path);
7995     if (r == -1)
7996       return -1;
7997   }
7998   {
7999     char arguments_0[] = "/test-command";
8000     char arguments_1[] = "9";
8001     char *arguments[] = {
8002       arguments_0,
8003       arguments_1,
8004       NULL
8005     };
8006     char **r;
8007     int i;
8008     suppress_error = 0;
8009     r = guestfs_command_lines (g, arguments);
8010     if (r == NULL)
8011       return -1;
8012     if (!r[0]) {
8013       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8014       print_strings (r);
8015       return -1;
8016     }
8017     {
8018       char expected[] = "";
8019       if (strcmp (r[0], expected) != 0) {
8020         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8021         return -1;
8022       }
8023     }
8024     if (!r[1]) {
8025       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8026       print_strings (r);
8027       return -1;
8028     }
8029     {
8030       char expected[] = "";
8031       if (strcmp (r[1], expected) != 0) {
8032         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8033         return -1;
8034       }
8035     }
8036     if (r[2] != NULL) {
8037       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8038       print_strings (r);
8039       return -1;
8040     }
8041     for (i = 0; r[i] != NULL; ++i)
8042       free (r[i]);
8043     free (r);
8044   }
8045   return 0;
8046 }
8047
8048 static int test_command_lines_9_skip (void)
8049 {
8050   const char *str;
8051
8052   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8053   if (str && strcmp (str, "1") == 0) return 1;
8054   str = getenv ("SKIP_TEST_COMMAND_LINES");
8055   if (str && strcmp (str, "1") == 0) return 1;
8056   return 0;
8057 }
8058
8059 static int test_command_lines_9 (void)
8060 {
8061   if (test_command_lines_9_skip ()) {
8062     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8063     return 0;
8064   }
8065
8066   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8067   {
8068     char device[] = "/dev/sda";
8069     device[5] = devchar;
8070     int r;
8071     suppress_error = 0;
8072     r = guestfs_blockdev_setrw (g, device);
8073     if (r == -1)
8074       return -1;
8075   }
8076   {
8077     int r;
8078     suppress_error = 0;
8079     r = guestfs_umount_all (g);
8080     if (r == -1)
8081       return -1;
8082   }
8083   {
8084     int r;
8085     suppress_error = 0;
8086     r = guestfs_lvm_remove_all (g);
8087     if (r == -1)
8088       return -1;
8089   }
8090   {
8091     char device[] = "/dev/sda";
8092     device[5] = devchar;
8093     char lines_0[] = ",";
8094     char *lines[] = {
8095       lines_0,
8096       NULL
8097     };
8098     int r;
8099     suppress_error = 0;
8100     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8101     if (r == -1)
8102       return -1;
8103   }
8104   {
8105     char fstype[] = "ext2";
8106     char device[] = "/dev/sda1";
8107     device[5] = devchar;
8108     int r;
8109     suppress_error = 0;
8110     r = guestfs_mkfs (g, fstype, device);
8111     if (r == -1)
8112       return -1;
8113   }
8114   {
8115     char device[] = "/dev/sda1";
8116     device[5] = devchar;
8117     char mountpoint[] = "/";
8118     int r;
8119     suppress_error = 0;
8120     r = guestfs_mount (g, device, mountpoint);
8121     if (r == -1)
8122       return -1;
8123   }
8124   /* TestOutputList for command_lines (9) */
8125   {
8126     char remotefilename[] = "/test-command";
8127     int r;
8128     suppress_error = 0;
8129     r = guestfs_upload (g, "test-command", remotefilename);
8130     if (r == -1)
8131       return -1;
8132   }
8133   {
8134     char path[] = "/test-command";
8135     int r;
8136     suppress_error = 0;
8137     r = guestfs_chmod (g, 493, path);
8138     if (r == -1)
8139       return -1;
8140   }
8141   {
8142     char arguments_0[] = "/test-command";
8143     char arguments_1[] = "10";
8144     char *arguments[] = {
8145       arguments_0,
8146       arguments_1,
8147       NULL
8148     };
8149     char **r;
8150     int i;
8151     suppress_error = 0;
8152     r = guestfs_command_lines (g, arguments);
8153     if (r == NULL)
8154       return -1;
8155     if (!r[0]) {
8156       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8157       print_strings (r);
8158       return -1;
8159     }
8160     {
8161       char expected[] = "Result10-1";
8162       if (strcmp (r[0], expected) != 0) {
8163         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8164         return -1;
8165       }
8166     }
8167     if (!r[1]) {
8168       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8169       print_strings (r);
8170       return -1;
8171     }
8172     {
8173       char expected[] = "Result10-2";
8174       if (strcmp (r[1], expected) != 0) {
8175         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8176         return -1;
8177       }
8178     }
8179     if (r[2] != NULL) {
8180       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8181       print_strings (r);
8182       return -1;
8183     }
8184     for (i = 0; r[i] != NULL; ++i)
8185       free (r[i]);
8186     free (r);
8187   }
8188   return 0;
8189 }
8190
8191 static int test_command_lines_10_skip (void)
8192 {
8193   const char *str;
8194
8195   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8196   if (str && strcmp (str, "1") == 0) return 1;
8197   str = getenv ("SKIP_TEST_COMMAND_LINES");
8198   if (str && strcmp (str, "1") == 0) return 1;
8199   return 0;
8200 }
8201
8202 static int test_command_lines_10 (void)
8203 {
8204   if (test_command_lines_10_skip ()) {
8205     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8206     return 0;
8207   }
8208
8209   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8210   {
8211     char device[] = "/dev/sda";
8212     device[5] = devchar;
8213     int r;
8214     suppress_error = 0;
8215     r = guestfs_blockdev_setrw (g, device);
8216     if (r == -1)
8217       return -1;
8218   }
8219   {
8220     int r;
8221     suppress_error = 0;
8222     r = guestfs_umount_all (g);
8223     if (r == -1)
8224       return -1;
8225   }
8226   {
8227     int r;
8228     suppress_error = 0;
8229     r = guestfs_lvm_remove_all (g);
8230     if (r == -1)
8231       return -1;
8232   }
8233   {
8234     char device[] = "/dev/sda";
8235     device[5] = devchar;
8236     char lines_0[] = ",";
8237     char *lines[] = {
8238       lines_0,
8239       NULL
8240     };
8241     int r;
8242     suppress_error = 0;
8243     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8244     if (r == -1)
8245       return -1;
8246   }
8247   {
8248     char fstype[] = "ext2";
8249     char device[] = "/dev/sda1";
8250     device[5] = devchar;
8251     int r;
8252     suppress_error = 0;
8253     r = guestfs_mkfs (g, fstype, device);
8254     if (r == -1)
8255       return -1;
8256   }
8257   {
8258     char device[] = "/dev/sda1";
8259     device[5] = devchar;
8260     char mountpoint[] = "/";
8261     int r;
8262     suppress_error = 0;
8263     r = guestfs_mount (g, device, mountpoint);
8264     if (r == -1)
8265       return -1;
8266   }
8267   /* TestOutputList for command_lines (10) */
8268   {
8269     char remotefilename[] = "/test-command";
8270     int r;
8271     suppress_error = 0;
8272     r = guestfs_upload (g, "test-command", remotefilename);
8273     if (r == -1)
8274       return -1;
8275   }
8276   {
8277     char path[] = "/test-command";
8278     int r;
8279     suppress_error = 0;
8280     r = guestfs_chmod (g, 493, path);
8281     if (r == -1)
8282       return -1;
8283   }
8284   {
8285     char arguments_0[] = "/test-command";
8286     char arguments_1[] = "11";
8287     char *arguments[] = {
8288       arguments_0,
8289       arguments_1,
8290       NULL
8291     };
8292     char **r;
8293     int i;
8294     suppress_error = 0;
8295     r = guestfs_command_lines (g, arguments);
8296     if (r == NULL)
8297       return -1;
8298     if (!r[0]) {
8299       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8300       print_strings (r);
8301       return -1;
8302     }
8303     {
8304       char expected[] = "Result11-1";
8305       if (strcmp (r[0], expected) != 0) {
8306         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8307         return -1;
8308       }
8309     }
8310     if (!r[1]) {
8311       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8312       print_strings (r);
8313       return -1;
8314     }
8315     {
8316       char expected[] = "Result11-2";
8317       if (strcmp (r[1], expected) != 0) {
8318         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8319         return -1;
8320       }
8321     }
8322     if (r[2] != NULL) {
8323       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8324       print_strings (r);
8325       return -1;
8326     }
8327     for (i = 0; r[i] != NULL; ++i)
8328       free (r[i]);
8329     free (r);
8330   }
8331   return 0;
8332 }
8333
8334 static int test_command_0_skip (void)
8335 {
8336   const char *str;
8337
8338   str = getenv ("SKIP_TEST_COMMAND_0");
8339   if (str && strcmp (str, "1") == 0) return 1;
8340   str = getenv ("SKIP_TEST_COMMAND");
8341   if (str && strcmp (str, "1") == 0) return 1;
8342   return 0;
8343 }
8344
8345 static int test_command_0 (void)
8346 {
8347   if (test_command_0_skip ()) {
8348     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8349     return 0;
8350   }
8351
8352   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8353   {
8354     char device[] = "/dev/sda";
8355     device[5] = devchar;
8356     int r;
8357     suppress_error = 0;
8358     r = guestfs_blockdev_setrw (g, device);
8359     if (r == -1)
8360       return -1;
8361   }
8362   {
8363     int r;
8364     suppress_error = 0;
8365     r = guestfs_umount_all (g);
8366     if (r == -1)
8367       return -1;
8368   }
8369   {
8370     int r;
8371     suppress_error = 0;
8372     r = guestfs_lvm_remove_all (g);
8373     if (r == -1)
8374       return -1;
8375   }
8376   {
8377     char device[] = "/dev/sda";
8378     device[5] = devchar;
8379     char lines_0[] = ",";
8380     char *lines[] = {
8381       lines_0,
8382       NULL
8383     };
8384     int r;
8385     suppress_error = 0;
8386     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8387     if (r == -1)
8388       return -1;
8389   }
8390   {
8391     char fstype[] = "ext2";
8392     char device[] = "/dev/sda1";
8393     device[5] = devchar;
8394     int r;
8395     suppress_error = 0;
8396     r = guestfs_mkfs (g, fstype, device);
8397     if (r == -1)
8398       return -1;
8399   }
8400   {
8401     char device[] = "/dev/sda1";
8402     device[5] = devchar;
8403     char mountpoint[] = "/";
8404     int r;
8405     suppress_error = 0;
8406     r = guestfs_mount (g, device, mountpoint);
8407     if (r == -1)
8408       return -1;
8409   }
8410   /* TestOutput for command (0) */
8411   char expected[] = "Result1";
8412   {
8413     char remotefilename[] = "/test-command";
8414     int r;
8415     suppress_error = 0;
8416     r = guestfs_upload (g, "test-command", remotefilename);
8417     if (r == -1)
8418       return -1;
8419   }
8420   {
8421     char path[] = "/test-command";
8422     int r;
8423     suppress_error = 0;
8424     r = guestfs_chmod (g, 493, path);
8425     if (r == -1)
8426       return -1;
8427   }
8428   {
8429     char arguments_0[] = "/test-command";
8430     char arguments_1[] = "1";
8431     char *arguments[] = {
8432       arguments_0,
8433       arguments_1,
8434       NULL
8435     };
8436     char *r;
8437     suppress_error = 0;
8438     r = guestfs_command (g, arguments);
8439     if (r == NULL)
8440       return -1;
8441     if (strcmp (r, expected) != 0) {
8442       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8443       return -1;
8444     }
8445     free (r);
8446   }
8447   return 0;
8448 }
8449
8450 static int test_command_1_skip (void)
8451 {
8452   const char *str;
8453
8454   str = getenv ("SKIP_TEST_COMMAND_1");
8455   if (str && strcmp (str, "1") == 0) return 1;
8456   str = getenv ("SKIP_TEST_COMMAND");
8457   if (str && strcmp (str, "1") == 0) return 1;
8458   return 0;
8459 }
8460
8461 static int test_command_1 (void)
8462 {
8463   if (test_command_1_skip ()) {
8464     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8465     return 0;
8466   }
8467
8468   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8469   {
8470     char device[] = "/dev/sda";
8471     device[5] = devchar;
8472     int r;
8473     suppress_error = 0;
8474     r = guestfs_blockdev_setrw (g, device);
8475     if (r == -1)
8476       return -1;
8477   }
8478   {
8479     int r;
8480     suppress_error = 0;
8481     r = guestfs_umount_all (g);
8482     if (r == -1)
8483       return -1;
8484   }
8485   {
8486     int r;
8487     suppress_error = 0;
8488     r = guestfs_lvm_remove_all (g);
8489     if (r == -1)
8490       return -1;
8491   }
8492   {
8493     char device[] = "/dev/sda";
8494     device[5] = devchar;
8495     char lines_0[] = ",";
8496     char *lines[] = {
8497       lines_0,
8498       NULL
8499     };
8500     int r;
8501     suppress_error = 0;
8502     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8503     if (r == -1)
8504       return -1;
8505   }
8506   {
8507     char fstype[] = "ext2";
8508     char device[] = "/dev/sda1";
8509     device[5] = devchar;
8510     int r;
8511     suppress_error = 0;
8512     r = guestfs_mkfs (g, fstype, device);
8513     if (r == -1)
8514       return -1;
8515   }
8516   {
8517     char device[] = "/dev/sda1";
8518     device[5] = devchar;
8519     char mountpoint[] = "/";
8520     int r;
8521     suppress_error = 0;
8522     r = guestfs_mount (g, device, mountpoint);
8523     if (r == -1)
8524       return -1;
8525   }
8526   /* TestOutput for command (1) */
8527   char expected[] = "Result2\n";
8528   {
8529     char remotefilename[] = "/test-command";
8530     int r;
8531     suppress_error = 0;
8532     r = guestfs_upload (g, "test-command", remotefilename);
8533     if (r == -1)
8534       return -1;
8535   }
8536   {
8537     char path[] = "/test-command";
8538     int r;
8539     suppress_error = 0;
8540     r = guestfs_chmod (g, 493, path);
8541     if (r == -1)
8542       return -1;
8543   }
8544   {
8545     char arguments_0[] = "/test-command";
8546     char arguments_1[] = "2";
8547     char *arguments[] = {
8548       arguments_0,
8549       arguments_1,
8550       NULL
8551     };
8552     char *r;
8553     suppress_error = 0;
8554     r = guestfs_command (g, arguments);
8555     if (r == NULL)
8556       return -1;
8557     if (strcmp (r, expected) != 0) {
8558       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8559       return -1;
8560     }
8561     free (r);
8562   }
8563   return 0;
8564 }
8565
8566 static int test_command_2_skip (void)
8567 {
8568   const char *str;
8569
8570   str = getenv ("SKIP_TEST_COMMAND_2");
8571   if (str && strcmp (str, "1") == 0) return 1;
8572   str = getenv ("SKIP_TEST_COMMAND");
8573   if (str && strcmp (str, "1") == 0) return 1;
8574   return 0;
8575 }
8576
8577 static int test_command_2 (void)
8578 {
8579   if (test_command_2_skip ()) {
8580     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8581     return 0;
8582   }
8583
8584   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8585   {
8586     char device[] = "/dev/sda";
8587     device[5] = devchar;
8588     int r;
8589     suppress_error = 0;
8590     r = guestfs_blockdev_setrw (g, device);
8591     if (r == -1)
8592       return -1;
8593   }
8594   {
8595     int r;
8596     suppress_error = 0;
8597     r = guestfs_umount_all (g);
8598     if (r == -1)
8599       return -1;
8600   }
8601   {
8602     int r;
8603     suppress_error = 0;
8604     r = guestfs_lvm_remove_all (g);
8605     if (r == -1)
8606       return -1;
8607   }
8608   {
8609     char device[] = "/dev/sda";
8610     device[5] = devchar;
8611     char lines_0[] = ",";
8612     char *lines[] = {
8613       lines_0,
8614       NULL
8615     };
8616     int r;
8617     suppress_error = 0;
8618     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8619     if (r == -1)
8620       return -1;
8621   }
8622   {
8623     char fstype[] = "ext2";
8624     char device[] = "/dev/sda1";
8625     device[5] = devchar;
8626     int r;
8627     suppress_error = 0;
8628     r = guestfs_mkfs (g, fstype, device);
8629     if (r == -1)
8630       return -1;
8631   }
8632   {
8633     char device[] = "/dev/sda1";
8634     device[5] = devchar;
8635     char mountpoint[] = "/";
8636     int r;
8637     suppress_error = 0;
8638     r = guestfs_mount (g, device, mountpoint);
8639     if (r == -1)
8640       return -1;
8641   }
8642   /* TestOutput for command (2) */
8643   char expected[] = "\nResult3";
8644   {
8645     char remotefilename[] = "/test-command";
8646     int r;
8647     suppress_error = 0;
8648     r = guestfs_upload (g, "test-command", remotefilename);
8649     if (r == -1)
8650       return -1;
8651   }
8652   {
8653     char path[] = "/test-command";
8654     int r;
8655     suppress_error = 0;
8656     r = guestfs_chmod (g, 493, path);
8657     if (r == -1)
8658       return -1;
8659   }
8660   {
8661     char arguments_0[] = "/test-command";
8662     char arguments_1[] = "3";
8663     char *arguments[] = {
8664       arguments_0,
8665       arguments_1,
8666       NULL
8667     };
8668     char *r;
8669     suppress_error = 0;
8670     r = guestfs_command (g, arguments);
8671     if (r == NULL)
8672       return -1;
8673     if (strcmp (r, expected) != 0) {
8674       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8675       return -1;
8676     }
8677     free (r);
8678   }
8679   return 0;
8680 }
8681
8682 static int test_command_3_skip (void)
8683 {
8684   const char *str;
8685
8686   str = getenv ("SKIP_TEST_COMMAND_3");
8687   if (str && strcmp (str, "1") == 0) return 1;
8688   str = getenv ("SKIP_TEST_COMMAND");
8689   if (str && strcmp (str, "1") == 0) return 1;
8690   return 0;
8691 }
8692
8693 static int test_command_3 (void)
8694 {
8695   if (test_command_3_skip ()) {
8696     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8697     return 0;
8698   }
8699
8700   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8701   {
8702     char device[] = "/dev/sda";
8703     device[5] = devchar;
8704     int r;
8705     suppress_error = 0;
8706     r = guestfs_blockdev_setrw (g, device);
8707     if (r == -1)
8708       return -1;
8709   }
8710   {
8711     int r;
8712     suppress_error = 0;
8713     r = guestfs_umount_all (g);
8714     if (r == -1)
8715       return -1;
8716   }
8717   {
8718     int r;
8719     suppress_error = 0;
8720     r = guestfs_lvm_remove_all (g);
8721     if (r == -1)
8722       return -1;
8723   }
8724   {
8725     char device[] = "/dev/sda";
8726     device[5] = devchar;
8727     char lines_0[] = ",";
8728     char *lines[] = {
8729       lines_0,
8730       NULL
8731     };
8732     int r;
8733     suppress_error = 0;
8734     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8735     if (r == -1)
8736       return -1;
8737   }
8738   {
8739     char fstype[] = "ext2";
8740     char device[] = "/dev/sda1";
8741     device[5] = devchar;
8742     int r;
8743     suppress_error = 0;
8744     r = guestfs_mkfs (g, fstype, device);
8745     if (r == -1)
8746       return -1;
8747   }
8748   {
8749     char device[] = "/dev/sda1";
8750     device[5] = devchar;
8751     char mountpoint[] = "/";
8752     int r;
8753     suppress_error = 0;
8754     r = guestfs_mount (g, device, mountpoint);
8755     if (r == -1)
8756       return -1;
8757   }
8758   /* TestOutput for command (3) */
8759   char expected[] = "\nResult4\n";
8760   {
8761     char remotefilename[] = "/test-command";
8762     int r;
8763     suppress_error = 0;
8764     r = guestfs_upload (g, "test-command", remotefilename);
8765     if (r == -1)
8766       return -1;
8767   }
8768   {
8769     char path[] = "/test-command";
8770     int r;
8771     suppress_error = 0;
8772     r = guestfs_chmod (g, 493, path);
8773     if (r == -1)
8774       return -1;
8775   }
8776   {
8777     char arguments_0[] = "/test-command";
8778     char arguments_1[] = "4";
8779     char *arguments[] = {
8780       arguments_0,
8781       arguments_1,
8782       NULL
8783     };
8784     char *r;
8785     suppress_error = 0;
8786     r = guestfs_command (g, arguments);
8787     if (r == NULL)
8788       return -1;
8789     if (strcmp (r, expected) != 0) {
8790       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8791       return -1;
8792     }
8793     free (r);
8794   }
8795   return 0;
8796 }
8797
8798 static int test_command_4_skip (void)
8799 {
8800   const char *str;
8801
8802   str = getenv ("SKIP_TEST_COMMAND_4");
8803   if (str && strcmp (str, "1") == 0) return 1;
8804   str = getenv ("SKIP_TEST_COMMAND");
8805   if (str && strcmp (str, "1") == 0) return 1;
8806   return 0;
8807 }
8808
8809 static int test_command_4 (void)
8810 {
8811   if (test_command_4_skip ()) {
8812     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8813     return 0;
8814   }
8815
8816   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8817   {
8818     char device[] = "/dev/sda";
8819     device[5] = devchar;
8820     int r;
8821     suppress_error = 0;
8822     r = guestfs_blockdev_setrw (g, device);
8823     if (r == -1)
8824       return -1;
8825   }
8826   {
8827     int r;
8828     suppress_error = 0;
8829     r = guestfs_umount_all (g);
8830     if (r == -1)
8831       return -1;
8832   }
8833   {
8834     int r;
8835     suppress_error = 0;
8836     r = guestfs_lvm_remove_all (g);
8837     if (r == -1)
8838       return -1;
8839   }
8840   {
8841     char device[] = "/dev/sda";
8842     device[5] = devchar;
8843     char lines_0[] = ",";
8844     char *lines[] = {
8845       lines_0,
8846       NULL
8847     };
8848     int r;
8849     suppress_error = 0;
8850     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8851     if (r == -1)
8852       return -1;
8853   }
8854   {
8855     char fstype[] = "ext2";
8856     char device[] = "/dev/sda1";
8857     device[5] = devchar;
8858     int r;
8859     suppress_error = 0;
8860     r = guestfs_mkfs (g, fstype, device);
8861     if (r == -1)
8862       return -1;
8863   }
8864   {
8865     char device[] = "/dev/sda1";
8866     device[5] = devchar;
8867     char mountpoint[] = "/";
8868     int r;
8869     suppress_error = 0;
8870     r = guestfs_mount (g, device, mountpoint);
8871     if (r == -1)
8872       return -1;
8873   }
8874   /* TestOutput for command (4) */
8875   char expected[] = "\nResult5\n\n";
8876   {
8877     char remotefilename[] = "/test-command";
8878     int r;
8879     suppress_error = 0;
8880     r = guestfs_upload (g, "test-command", remotefilename);
8881     if (r == -1)
8882       return -1;
8883   }
8884   {
8885     char path[] = "/test-command";
8886     int r;
8887     suppress_error = 0;
8888     r = guestfs_chmod (g, 493, path);
8889     if (r == -1)
8890       return -1;
8891   }
8892   {
8893     char arguments_0[] = "/test-command";
8894     char arguments_1[] = "5";
8895     char *arguments[] = {
8896       arguments_0,
8897       arguments_1,
8898       NULL
8899     };
8900     char *r;
8901     suppress_error = 0;
8902     r = guestfs_command (g, arguments);
8903     if (r == NULL)
8904       return -1;
8905     if (strcmp (r, expected) != 0) {
8906       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
8907       return -1;
8908     }
8909     free (r);
8910   }
8911   return 0;
8912 }
8913
8914 static int test_command_5_skip (void)
8915 {
8916   const char *str;
8917
8918   str = getenv ("SKIP_TEST_COMMAND_5");
8919   if (str && strcmp (str, "1") == 0) return 1;
8920   str = getenv ("SKIP_TEST_COMMAND");
8921   if (str && strcmp (str, "1") == 0) return 1;
8922   return 0;
8923 }
8924
8925 static int test_command_5 (void)
8926 {
8927   if (test_command_5_skip ()) {
8928     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
8929     return 0;
8930   }
8931
8932   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
8933   {
8934     char device[] = "/dev/sda";
8935     device[5] = devchar;
8936     int r;
8937     suppress_error = 0;
8938     r = guestfs_blockdev_setrw (g, device);
8939     if (r == -1)
8940       return -1;
8941   }
8942   {
8943     int r;
8944     suppress_error = 0;
8945     r = guestfs_umount_all (g);
8946     if (r == -1)
8947       return -1;
8948   }
8949   {
8950     int r;
8951     suppress_error = 0;
8952     r = guestfs_lvm_remove_all (g);
8953     if (r == -1)
8954       return -1;
8955   }
8956   {
8957     char device[] = "/dev/sda";
8958     device[5] = devchar;
8959     char lines_0[] = ",";
8960     char *lines[] = {
8961       lines_0,
8962       NULL
8963     };
8964     int r;
8965     suppress_error = 0;
8966     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8967     if (r == -1)
8968       return -1;
8969   }
8970   {
8971     char fstype[] = "ext2";
8972     char device[] = "/dev/sda1";
8973     device[5] = devchar;
8974     int r;
8975     suppress_error = 0;
8976     r = guestfs_mkfs (g, fstype, device);
8977     if (r == -1)
8978       return -1;
8979   }
8980   {
8981     char device[] = "/dev/sda1";
8982     device[5] = devchar;
8983     char mountpoint[] = "/";
8984     int r;
8985     suppress_error = 0;
8986     r = guestfs_mount (g, device, mountpoint);
8987     if (r == -1)
8988       return -1;
8989   }
8990   /* TestOutput for command (5) */
8991   char expected[] = "\n\nResult6\n\n";
8992   {
8993     char remotefilename[] = "/test-command";
8994     int r;
8995     suppress_error = 0;
8996     r = guestfs_upload (g, "test-command", remotefilename);
8997     if (r == -1)
8998       return -1;
8999   }
9000   {
9001     char path[] = "/test-command";
9002     int r;
9003     suppress_error = 0;
9004     r = guestfs_chmod (g, 493, path);
9005     if (r == -1)
9006       return -1;
9007   }
9008   {
9009     char arguments_0[] = "/test-command";
9010     char arguments_1[] = "6";
9011     char *arguments[] = {
9012       arguments_0,
9013       arguments_1,
9014       NULL
9015     };
9016     char *r;
9017     suppress_error = 0;
9018     r = guestfs_command (g, arguments);
9019     if (r == NULL)
9020       return -1;
9021     if (strcmp (r, expected) != 0) {
9022       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9023       return -1;
9024     }
9025     free (r);
9026   }
9027   return 0;
9028 }
9029
9030 static int test_command_6_skip (void)
9031 {
9032   const char *str;
9033
9034   str = getenv ("SKIP_TEST_COMMAND_6");
9035   if (str && strcmp (str, "1") == 0) return 1;
9036   str = getenv ("SKIP_TEST_COMMAND");
9037   if (str && strcmp (str, "1") == 0) return 1;
9038   return 0;
9039 }
9040
9041 static int test_command_6 (void)
9042 {
9043   if (test_command_6_skip ()) {
9044     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9045     return 0;
9046   }
9047
9048   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9049   {
9050     char device[] = "/dev/sda";
9051     device[5] = devchar;
9052     int r;
9053     suppress_error = 0;
9054     r = guestfs_blockdev_setrw (g, device);
9055     if (r == -1)
9056       return -1;
9057   }
9058   {
9059     int r;
9060     suppress_error = 0;
9061     r = guestfs_umount_all (g);
9062     if (r == -1)
9063       return -1;
9064   }
9065   {
9066     int r;
9067     suppress_error = 0;
9068     r = guestfs_lvm_remove_all (g);
9069     if (r == -1)
9070       return -1;
9071   }
9072   {
9073     char device[] = "/dev/sda";
9074     device[5] = devchar;
9075     char lines_0[] = ",";
9076     char *lines[] = {
9077       lines_0,
9078       NULL
9079     };
9080     int r;
9081     suppress_error = 0;
9082     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9083     if (r == -1)
9084       return -1;
9085   }
9086   {
9087     char fstype[] = "ext2";
9088     char device[] = "/dev/sda1";
9089     device[5] = devchar;
9090     int r;
9091     suppress_error = 0;
9092     r = guestfs_mkfs (g, fstype, device);
9093     if (r == -1)
9094       return -1;
9095   }
9096   {
9097     char device[] = "/dev/sda1";
9098     device[5] = devchar;
9099     char mountpoint[] = "/";
9100     int r;
9101     suppress_error = 0;
9102     r = guestfs_mount (g, device, mountpoint);
9103     if (r == -1)
9104       return -1;
9105   }
9106   /* TestOutput for command (6) */
9107   char expected[] = "";
9108   {
9109     char remotefilename[] = "/test-command";
9110     int r;
9111     suppress_error = 0;
9112     r = guestfs_upload (g, "test-command", remotefilename);
9113     if (r == -1)
9114       return -1;
9115   }
9116   {
9117     char path[] = "/test-command";
9118     int r;
9119     suppress_error = 0;
9120     r = guestfs_chmod (g, 493, path);
9121     if (r == -1)
9122       return -1;
9123   }
9124   {
9125     char arguments_0[] = "/test-command";
9126     char arguments_1[] = "7";
9127     char *arguments[] = {
9128       arguments_0,
9129       arguments_1,
9130       NULL
9131     };
9132     char *r;
9133     suppress_error = 0;
9134     r = guestfs_command (g, arguments);
9135     if (r == NULL)
9136       return -1;
9137     if (strcmp (r, expected) != 0) {
9138       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9139       return -1;
9140     }
9141     free (r);
9142   }
9143   return 0;
9144 }
9145
9146 static int test_command_7_skip (void)
9147 {
9148   const char *str;
9149
9150   str = getenv ("SKIP_TEST_COMMAND_7");
9151   if (str && strcmp (str, "1") == 0) return 1;
9152   str = getenv ("SKIP_TEST_COMMAND");
9153   if (str && strcmp (str, "1") == 0) return 1;
9154   return 0;
9155 }
9156
9157 static int test_command_7 (void)
9158 {
9159   if (test_command_7_skip ()) {
9160     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9161     return 0;
9162   }
9163
9164   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9165   {
9166     char device[] = "/dev/sda";
9167     device[5] = devchar;
9168     int r;
9169     suppress_error = 0;
9170     r = guestfs_blockdev_setrw (g, device);
9171     if (r == -1)
9172       return -1;
9173   }
9174   {
9175     int r;
9176     suppress_error = 0;
9177     r = guestfs_umount_all (g);
9178     if (r == -1)
9179       return -1;
9180   }
9181   {
9182     int r;
9183     suppress_error = 0;
9184     r = guestfs_lvm_remove_all (g);
9185     if (r == -1)
9186       return -1;
9187   }
9188   {
9189     char device[] = "/dev/sda";
9190     device[5] = devchar;
9191     char lines_0[] = ",";
9192     char *lines[] = {
9193       lines_0,
9194       NULL
9195     };
9196     int r;
9197     suppress_error = 0;
9198     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9199     if (r == -1)
9200       return -1;
9201   }
9202   {
9203     char fstype[] = "ext2";
9204     char device[] = "/dev/sda1";
9205     device[5] = devchar;
9206     int r;
9207     suppress_error = 0;
9208     r = guestfs_mkfs (g, fstype, device);
9209     if (r == -1)
9210       return -1;
9211   }
9212   {
9213     char device[] = "/dev/sda1";
9214     device[5] = devchar;
9215     char mountpoint[] = "/";
9216     int r;
9217     suppress_error = 0;
9218     r = guestfs_mount (g, device, mountpoint);
9219     if (r == -1)
9220       return -1;
9221   }
9222   /* TestOutput for command (7) */
9223   char expected[] = "\n";
9224   {
9225     char remotefilename[] = "/test-command";
9226     int r;
9227     suppress_error = 0;
9228     r = guestfs_upload (g, "test-command", remotefilename);
9229     if (r == -1)
9230       return -1;
9231   }
9232   {
9233     char path[] = "/test-command";
9234     int r;
9235     suppress_error = 0;
9236     r = guestfs_chmod (g, 493, path);
9237     if (r == -1)
9238       return -1;
9239   }
9240   {
9241     char arguments_0[] = "/test-command";
9242     char arguments_1[] = "8";
9243     char *arguments[] = {
9244       arguments_0,
9245       arguments_1,
9246       NULL
9247     };
9248     char *r;
9249     suppress_error = 0;
9250     r = guestfs_command (g, arguments);
9251     if (r == NULL)
9252       return -1;
9253     if (strcmp (r, expected) != 0) {
9254       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9255       return -1;
9256     }
9257     free (r);
9258   }
9259   return 0;
9260 }
9261
9262 static int test_command_8_skip (void)
9263 {
9264   const char *str;
9265
9266   str = getenv ("SKIP_TEST_COMMAND_8");
9267   if (str && strcmp (str, "1") == 0) return 1;
9268   str = getenv ("SKIP_TEST_COMMAND");
9269   if (str && strcmp (str, "1") == 0) return 1;
9270   return 0;
9271 }
9272
9273 static int test_command_8 (void)
9274 {
9275   if (test_command_8_skip ()) {
9276     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9277     return 0;
9278   }
9279
9280   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9281   {
9282     char device[] = "/dev/sda";
9283     device[5] = devchar;
9284     int r;
9285     suppress_error = 0;
9286     r = guestfs_blockdev_setrw (g, device);
9287     if (r == -1)
9288       return -1;
9289   }
9290   {
9291     int r;
9292     suppress_error = 0;
9293     r = guestfs_umount_all (g);
9294     if (r == -1)
9295       return -1;
9296   }
9297   {
9298     int r;
9299     suppress_error = 0;
9300     r = guestfs_lvm_remove_all (g);
9301     if (r == -1)
9302       return -1;
9303   }
9304   {
9305     char device[] = "/dev/sda";
9306     device[5] = devchar;
9307     char lines_0[] = ",";
9308     char *lines[] = {
9309       lines_0,
9310       NULL
9311     };
9312     int r;
9313     suppress_error = 0;
9314     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9315     if (r == -1)
9316       return -1;
9317   }
9318   {
9319     char fstype[] = "ext2";
9320     char device[] = "/dev/sda1";
9321     device[5] = devchar;
9322     int r;
9323     suppress_error = 0;
9324     r = guestfs_mkfs (g, fstype, device);
9325     if (r == -1)
9326       return -1;
9327   }
9328   {
9329     char device[] = "/dev/sda1";
9330     device[5] = devchar;
9331     char mountpoint[] = "/";
9332     int r;
9333     suppress_error = 0;
9334     r = guestfs_mount (g, device, mountpoint);
9335     if (r == -1)
9336       return -1;
9337   }
9338   /* TestOutput for command (8) */
9339   char expected[] = "\n\n";
9340   {
9341     char remotefilename[] = "/test-command";
9342     int r;
9343     suppress_error = 0;
9344     r = guestfs_upload (g, "test-command", remotefilename);
9345     if (r == -1)
9346       return -1;
9347   }
9348   {
9349     char path[] = "/test-command";
9350     int r;
9351     suppress_error = 0;
9352     r = guestfs_chmod (g, 493, path);
9353     if (r == -1)
9354       return -1;
9355   }
9356   {
9357     char arguments_0[] = "/test-command";
9358     char arguments_1[] = "9";
9359     char *arguments[] = {
9360       arguments_0,
9361       arguments_1,
9362       NULL
9363     };
9364     char *r;
9365     suppress_error = 0;
9366     r = guestfs_command (g, arguments);
9367     if (r == NULL)
9368       return -1;
9369     if (strcmp (r, expected) != 0) {
9370       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9371       return -1;
9372     }
9373     free (r);
9374   }
9375   return 0;
9376 }
9377
9378 static int test_command_9_skip (void)
9379 {
9380   const char *str;
9381
9382   str = getenv ("SKIP_TEST_COMMAND_9");
9383   if (str && strcmp (str, "1") == 0) return 1;
9384   str = getenv ("SKIP_TEST_COMMAND");
9385   if (str && strcmp (str, "1") == 0) return 1;
9386   return 0;
9387 }
9388
9389 static int test_command_9 (void)
9390 {
9391   if (test_command_9_skip ()) {
9392     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9393     return 0;
9394   }
9395
9396   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9397   {
9398     char device[] = "/dev/sda";
9399     device[5] = devchar;
9400     int r;
9401     suppress_error = 0;
9402     r = guestfs_blockdev_setrw (g, device);
9403     if (r == -1)
9404       return -1;
9405   }
9406   {
9407     int r;
9408     suppress_error = 0;
9409     r = guestfs_umount_all (g);
9410     if (r == -1)
9411       return -1;
9412   }
9413   {
9414     int r;
9415     suppress_error = 0;
9416     r = guestfs_lvm_remove_all (g);
9417     if (r == -1)
9418       return -1;
9419   }
9420   {
9421     char device[] = "/dev/sda";
9422     device[5] = devchar;
9423     char lines_0[] = ",";
9424     char *lines[] = {
9425       lines_0,
9426       NULL
9427     };
9428     int r;
9429     suppress_error = 0;
9430     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9431     if (r == -1)
9432       return -1;
9433   }
9434   {
9435     char fstype[] = "ext2";
9436     char device[] = "/dev/sda1";
9437     device[5] = devchar;
9438     int r;
9439     suppress_error = 0;
9440     r = guestfs_mkfs (g, fstype, device);
9441     if (r == -1)
9442       return -1;
9443   }
9444   {
9445     char device[] = "/dev/sda1";
9446     device[5] = devchar;
9447     char mountpoint[] = "/";
9448     int r;
9449     suppress_error = 0;
9450     r = guestfs_mount (g, device, mountpoint);
9451     if (r == -1)
9452       return -1;
9453   }
9454   /* TestOutput for command (9) */
9455   char expected[] = "Result10-1\nResult10-2\n";
9456   {
9457     char remotefilename[] = "/test-command";
9458     int r;
9459     suppress_error = 0;
9460     r = guestfs_upload (g, "test-command", remotefilename);
9461     if (r == -1)
9462       return -1;
9463   }
9464   {
9465     char path[] = "/test-command";
9466     int r;
9467     suppress_error = 0;
9468     r = guestfs_chmod (g, 493, path);
9469     if (r == -1)
9470       return -1;
9471   }
9472   {
9473     char arguments_0[] = "/test-command";
9474     char arguments_1[] = "10";
9475     char *arguments[] = {
9476       arguments_0,
9477       arguments_1,
9478       NULL
9479     };
9480     char *r;
9481     suppress_error = 0;
9482     r = guestfs_command (g, arguments);
9483     if (r == NULL)
9484       return -1;
9485     if (strcmp (r, expected) != 0) {
9486       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9487       return -1;
9488     }
9489     free (r);
9490   }
9491   return 0;
9492 }
9493
9494 static int test_command_10_skip (void)
9495 {
9496   const char *str;
9497
9498   str = getenv ("SKIP_TEST_COMMAND_10");
9499   if (str && strcmp (str, "1") == 0) return 1;
9500   str = getenv ("SKIP_TEST_COMMAND");
9501   if (str && strcmp (str, "1") == 0) return 1;
9502   return 0;
9503 }
9504
9505 static int test_command_10 (void)
9506 {
9507   if (test_command_10_skip ()) {
9508     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9509     return 0;
9510   }
9511
9512   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9513   {
9514     char device[] = "/dev/sda";
9515     device[5] = devchar;
9516     int r;
9517     suppress_error = 0;
9518     r = guestfs_blockdev_setrw (g, device);
9519     if (r == -1)
9520       return -1;
9521   }
9522   {
9523     int r;
9524     suppress_error = 0;
9525     r = guestfs_umount_all (g);
9526     if (r == -1)
9527       return -1;
9528   }
9529   {
9530     int r;
9531     suppress_error = 0;
9532     r = guestfs_lvm_remove_all (g);
9533     if (r == -1)
9534       return -1;
9535   }
9536   {
9537     char device[] = "/dev/sda";
9538     device[5] = devchar;
9539     char lines_0[] = ",";
9540     char *lines[] = {
9541       lines_0,
9542       NULL
9543     };
9544     int r;
9545     suppress_error = 0;
9546     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9547     if (r == -1)
9548       return -1;
9549   }
9550   {
9551     char fstype[] = "ext2";
9552     char device[] = "/dev/sda1";
9553     device[5] = devchar;
9554     int r;
9555     suppress_error = 0;
9556     r = guestfs_mkfs (g, fstype, device);
9557     if (r == -1)
9558       return -1;
9559   }
9560   {
9561     char device[] = "/dev/sda1";
9562     device[5] = devchar;
9563     char mountpoint[] = "/";
9564     int r;
9565     suppress_error = 0;
9566     r = guestfs_mount (g, device, mountpoint);
9567     if (r == -1)
9568       return -1;
9569   }
9570   /* TestOutput for command (10) */
9571   char expected[] = "Result11-1\nResult11-2";
9572   {
9573     char remotefilename[] = "/test-command";
9574     int r;
9575     suppress_error = 0;
9576     r = guestfs_upload (g, "test-command", remotefilename);
9577     if (r == -1)
9578       return -1;
9579   }
9580   {
9581     char path[] = "/test-command";
9582     int r;
9583     suppress_error = 0;
9584     r = guestfs_chmod (g, 493, path);
9585     if (r == -1)
9586       return -1;
9587   }
9588   {
9589     char arguments_0[] = "/test-command";
9590     char arguments_1[] = "11";
9591     char *arguments[] = {
9592       arguments_0,
9593       arguments_1,
9594       NULL
9595     };
9596     char *r;
9597     suppress_error = 0;
9598     r = guestfs_command (g, arguments);
9599     if (r == NULL)
9600       return -1;
9601     if (strcmp (r, expected) != 0) {
9602       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9603       return -1;
9604     }
9605     free (r);
9606   }
9607   return 0;
9608 }
9609
9610 static int test_command_11_skip (void)
9611 {
9612   const char *str;
9613
9614   str = getenv ("SKIP_TEST_COMMAND_11");
9615   if (str && strcmp (str, "1") == 0) return 1;
9616   str = getenv ("SKIP_TEST_COMMAND");
9617   if (str && strcmp (str, "1") == 0) return 1;
9618   return 0;
9619 }
9620
9621 static int test_command_11 (void)
9622 {
9623   if (test_command_11_skip ()) {
9624     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9625     return 0;
9626   }
9627
9628   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9629   {
9630     char device[] = "/dev/sda";
9631     device[5] = devchar;
9632     int r;
9633     suppress_error = 0;
9634     r = guestfs_blockdev_setrw (g, device);
9635     if (r == -1)
9636       return -1;
9637   }
9638   {
9639     int r;
9640     suppress_error = 0;
9641     r = guestfs_umount_all (g);
9642     if (r == -1)
9643       return -1;
9644   }
9645   {
9646     int r;
9647     suppress_error = 0;
9648     r = guestfs_lvm_remove_all (g);
9649     if (r == -1)
9650       return -1;
9651   }
9652   {
9653     char device[] = "/dev/sda";
9654     device[5] = devchar;
9655     char lines_0[] = ",";
9656     char *lines[] = {
9657       lines_0,
9658       NULL
9659     };
9660     int r;
9661     suppress_error = 0;
9662     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9663     if (r == -1)
9664       return -1;
9665   }
9666   {
9667     char fstype[] = "ext2";
9668     char device[] = "/dev/sda1";
9669     device[5] = devchar;
9670     int r;
9671     suppress_error = 0;
9672     r = guestfs_mkfs (g, fstype, device);
9673     if (r == -1)
9674       return -1;
9675   }
9676   {
9677     char device[] = "/dev/sda1";
9678     device[5] = devchar;
9679     char mountpoint[] = "/";
9680     int r;
9681     suppress_error = 0;
9682     r = guestfs_mount (g, device, mountpoint);
9683     if (r == -1)
9684       return -1;
9685   }
9686   /* TestLastFail for command (11) */
9687   {
9688     char remotefilename[] = "/test-command";
9689     int r;
9690     suppress_error = 0;
9691     r = guestfs_upload (g, "test-command", remotefilename);
9692     if (r == -1)
9693       return -1;
9694   }
9695   {
9696     char path[] = "/test-command";
9697     int r;
9698     suppress_error = 0;
9699     r = guestfs_chmod (g, 493, path);
9700     if (r == -1)
9701       return -1;
9702   }
9703   {
9704     char arguments_0[] = "/test-command";
9705     char *arguments[] = {
9706       arguments_0,
9707       NULL
9708     };
9709     char *r;
9710     suppress_error = 1;
9711     r = guestfs_command (g, arguments);
9712     if (r != NULL)
9713       return -1;
9714     free (r);
9715   }
9716   return 0;
9717 }
9718
9719 static int test_file_0_skip (void)
9720 {
9721   const char *str;
9722
9723   str = getenv ("SKIP_TEST_FILE_0");
9724   if (str && strcmp (str, "1") == 0) return 1;
9725   str = getenv ("SKIP_TEST_FILE");
9726   if (str && strcmp (str, "1") == 0) return 1;
9727   return 0;
9728 }
9729
9730 static int test_file_0 (void)
9731 {
9732   if (test_file_0_skip ()) {
9733     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9734     return 0;
9735   }
9736
9737   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9738   {
9739     char device[] = "/dev/sda";
9740     device[5] = devchar;
9741     int r;
9742     suppress_error = 0;
9743     r = guestfs_blockdev_setrw (g, device);
9744     if (r == -1)
9745       return -1;
9746   }
9747   {
9748     int r;
9749     suppress_error = 0;
9750     r = guestfs_umount_all (g);
9751     if (r == -1)
9752       return -1;
9753   }
9754   {
9755     int r;
9756     suppress_error = 0;
9757     r = guestfs_lvm_remove_all (g);
9758     if (r == -1)
9759       return -1;
9760   }
9761   {
9762     char device[] = "/dev/sda";
9763     device[5] = devchar;
9764     char lines_0[] = ",";
9765     char *lines[] = {
9766       lines_0,
9767       NULL
9768     };
9769     int r;
9770     suppress_error = 0;
9771     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9772     if (r == -1)
9773       return -1;
9774   }
9775   {
9776     char fstype[] = "ext2";
9777     char device[] = "/dev/sda1";
9778     device[5] = devchar;
9779     int r;
9780     suppress_error = 0;
9781     r = guestfs_mkfs (g, fstype, device);
9782     if (r == -1)
9783       return -1;
9784   }
9785   {
9786     char device[] = "/dev/sda1";
9787     device[5] = devchar;
9788     char mountpoint[] = "/";
9789     int r;
9790     suppress_error = 0;
9791     r = guestfs_mount (g, device, mountpoint);
9792     if (r == -1)
9793       return -1;
9794   }
9795   /* TestOutput for file (0) */
9796   char expected[] = "empty";
9797   {
9798     char path[] = "/new";
9799     int r;
9800     suppress_error = 0;
9801     r = guestfs_touch (g, path);
9802     if (r == -1)
9803       return -1;
9804   }
9805   {
9806     char path[] = "/new";
9807     char *r;
9808     suppress_error = 0;
9809     r = guestfs_file (g, path);
9810     if (r == NULL)
9811       return -1;
9812     if (strcmp (r, expected) != 0) {
9813       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9814       return -1;
9815     }
9816     free (r);
9817   }
9818   return 0;
9819 }
9820
9821 static int test_file_1_skip (void)
9822 {
9823   const char *str;
9824
9825   str = getenv ("SKIP_TEST_FILE_1");
9826   if (str && strcmp (str, "1") == 0) return 1;
9827   str = getenv ("SKIP_TEST_FILE");
9828   if (str && strcmp (str, "1") == 0) return 1;
9829   return 0;
9830 }
9831
9832 static int test_file_1 (void)
9833 {
9834   if (test_file_1_skip ()) {
9835     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9836     return 0;
9837   }
9838
9839   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9840   {
9841     char device[] = "/dev/sda";
9842     device[5] = devchar;
9843     int r;
9844     suppress_error = 0;
9845     r = guestfs_blockdev_setrw (g, device);
9846     if (r == -1)
9847       return -1;
9848   }
9849   {
9850     int r;
9851     suppress_error = 0;
9852     r = guestfs_umount_all (g);
9853     if (r == -1)
9854       return -1;
9855   }
9856   {
9857     int r;
9858     suppress_error = 0;
9859     r = guestfs_lvm_remove_all (g);
9860     if (r == -1)
9861       return -1;
9862   }
9863   {
9864     char device[] = "/dev/sda";
9865     device[5] = devchar;
9866     char lines_0[] = ",";
9867     char *lines[] = {
9868       lines_0,
9869       NULL
9870     };
9871     int r;
9872     suppress_error = 0;
9873     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9874     if (r == -1)
9875       return -1;
9876   }
9877   {
9878     char fstype[] = "ext2";
9879     char device[] = "/dev/sda1";
9880     device[5] = devchar;
9881     int r;
9882     suppress_error = 0;
9883     r = guestfs_mkfs (g, fstype, device);
9884     if (r == -1)
9885       return -1;
9886   }
9887   {
9888     char device[] = "/dev/sda1";
9889     device[5] = devchar;
9890     char mountpoint[] = "/";
9891     int r;
9892     suppress_error = 0;
9893     r = guestfs_mount (g, device, mountpoint);
9894     if (r == -1)
9895       return -1;
9896   }
9897   /* TestOutput for file (1) */
9898   char expected[] = "ASCII text";
9899   {
9900     char path[] = "/new";
9901     char content[] = "some content\n";
9902     int r;
9903     suppress_error = 0;
9904     r = guestfs_write_file (g, path, content, 0);
9905     if (r == -1)
9906       return -1;
9907   }
9908   {
9909     char path[] = "/new";
9910     char *r;
9911     suppress_error = 0;
9912     r = guestfs_file (g, path);
9913     if (r == NULL)
9914       return -1;
9915     if (strcmp (r, expected) != 0) {
9916       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9917       return -1;
9918     }
9919     free (r);
9920   }
9921   return 0;
9922 }
9923
9924 static int test_file_2_skip (void)
9925 {
9926   const char *str;
9927
9928   str = getenv ("SKIP_TEST_FILE_2");
9929   if (str && strcmp (str, "1") == 0) return 1;
9930   str = getenv ("SKIP_TEST_FILE");
9931   if (str && strcmp (str, "1") == 0) return 1;
9932   return 0;
9933 }
9934
9935 static int test_file_2 (void)
9936 {
9937   if (test_file_2_skip ()) {
9938     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
9939     return 0;
9940   }
9941
9942   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
9943   {
9944     char device[] = "/dev/sda";
9945     device[5] = devchar;
9946     int r;
9947     suppress_error = 0;
9948     r = guestfs_blockdev_setrw (g, device);
9949     if (r == -1)
9950       return -1;
9951   }
9952   {
9953     int r;
9954     suppress_error = 0;
9955     r = guestfs_umount_all (g);
9956     if (r == -1)
9957       return -1;
9958   }
9959   {
9960     int r;
9961     suppress_error = 0;
9962     r = guestfs_lvm_remove_all (g);
9963     if (r == -1)
9964       return -1;
9965   }
9966   {
9967     char device[] = "/dev/sda";
9968     device[5] = devchar;
9969     char lines_0[] = ",";
9970     char *lines[] = {
9971       lines_0,
9972       NULL
9973     };
9974     int r;
9975     suppress_error = 0;
9976     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9977     if (r == -1)
9978       return -1;
9979   }
9980   {
9981     char fstype[] = "ext2";
9982     char device[] = "/dev/sda1";
9983     device[5] = devchar;
9984     int r;
9985     suppress_error = 0;
9986     r = guestfs_mkfs (g, fstype, device);
9987     if (r == -1)
9988       return -1;
9989   }
9990   {
9991     char device[] = "/dev/sda1";
9992     device[5] = devchar;
9993     char mountpoint[] = "/";
9994     int r;
9995     suppress_error = 0;
9996     r = guestfs_mount (g, device, mountpoint);
9997     if (r == -1)
9998       return -1;
9999   }
10000   /* TestLastFail for file (2) */
10001   {
10002     char path[] = "/nofile";
10003     char *r;
10004     suppress_error = 1;
10005     r = guestfs_file (g, path);
10006     if (r != NULL)
10007       return -1;
10008     free (r);
10009   }
10010   return 0;
10011 }
10012
10013 static int test_umount_all_0_skip (void)
10014 {
10015   const char *str;
10016
10017   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10018   if (str && strcmp (str, "1") == 0) return 1;
10019   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10020   if (str && strcmp (str, "1") == 0) return 1;
10021   return 0;
10022 }
10023
10024 static int test_umount_all_0 (void)
10025 {
10026   if (test_umount_all_0_skip ()) {
10027     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10028     return 0;
10029   }
10030
10031   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10032   {
10033     char device[] = "/dev/sda";
10034     device[5] = devchar;
10035     int r;
10036     suppress_error = 0;
10037     r = guestfs_blockdev_setrw (g, device);
10038     if (r == -1)
10039       return -1;
10040   }
10041   {
10042     int r;
10043     suppress_error = 0;
10044     r = guestfs_umount_all (g);
10045     if (r == -1)
10046       return -1;
10047   }
10048   {
10049     int r;
10050     suppress_error = 0;
10051     r = guestfs_lvm_remove_all (g);
10052     if (r == -1)
10053       return -1;
10054   }
10055   {
10056     char device[] = "/dev/sda";
10057     device[5] = devchar;
10058     char lines_0[] = ",";
10059     char *lines[] = {
10060       lines_0,
10061       NULL
10062     };
10063     int r;
10064     suppress_error = 0;
10065     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10066     if (r == -1)
10067       return -1;
10068   }
10069   {
10070     char fstype[] = "ext2";
10071     char device[] = "/dev/sda1";
10072     device[5] = devchar;
10073     int r;
10074     suppress_error = 0;
10075     r = guestfs_mkfs (g, fstype, device);
10076     if (r == -1)
10077       return -1;
10078   }
10079   {
10080     char device[] = "/dev/sda1";
10081     device[5] = devchar;
10082     char mountpoint[] = "/";
10083     int r;
10084     suppress_error = 0;
10085     r = guestfs_mount (g, device, mountpoint);
10086     if (r == -1)
10087       return -1;
10088   }
10089   /* TestOutputList for umount_all (0) */
10090   {
10091     int r;
10092     suppress_error = 0;
10093     r = guestfs_umount_all (g);
10094     if (r == -1)
10095       return -1;
10096   }
10097   {
10098     char **r;
10099     int i;
10100     suppress_error = 0;
10101     r = guestfs_mounts (g);
10102     if (r == NULL)
10103       return -1;
10104     if (r[0] != NULL) {
10105       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10106       print_strings (r);
10107       return -1;
10108     }
10109     for (i = 0; r[i] != NULL; ++i)
10110       free (r[i]);
10111     free (r);
10112   }
10113   return 0;
10114 }
10115
10116 static int test_umount_all_1_skip (void)
10117 {
10118   const char *str;
10119
10120   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10121   if (str && strcmp (str, "1") == 0) return 1;
10122   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10123   if (str && strcmp (str, "1") == 0) return 1;
10124   return 0;
10125 }
10126
10127 static int test_umount_all_1 (void)
10128 {
10129   if (test_umount_all_1_skip ()) {
10130     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10131     return 0;
10132   }
10133
10134   /* InitNone|InitEmpty for test_umount_all_1 */
10135   {
10136     char device[] = "/dev/sda";
10137     device[5] = devchar;
10138     int r;
10139     suppress_error = 0;
10140     r = guestfs_blockdev_setrw (g, device);
10141     if (r == -1)
10142       return -1;
10143   }
10144   {
10145     int r;
10146     suppress_error = 0;
10147     r = guestfs_umount_all (g);
10148     if (r == -1)
10149       return -1;
10150   }
10151   {
10152     int r;
10153     suppress_error = 0;
10154     r = guestfs_lvm_remove_all (g);
10155     if (r == -1)
10156       return -1;
10157   }
10158   /* TestOutputList for umount_all (1) */
10159   {
10160     char device[] = "/dev/sda";
10161     device[5] = devchar;
10162     char lines_0[] = ",10";
10163     char lines_1[] = ",20";
10164     char lines_2[] = ",";
10165     char *lines[] = {
10166       lines_0,
10167       lines_1,
10168       lines_2,
10169       NULL
10170     };
10171     int r;
10172     suppress_error = 0;
10173     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10174     if (r == -1)
10175       return -1;
10176   }
10177   {
10178     char fstype[] = "ext2";
10179     char device[] = "/dev/sda1";
10180     device[5] = devchar;
10181     int r;
10182     suppress_error = 0;
10183     r = guestfs_mkfs (g, fstype, device);
10184     if (r == -1)
10185       return -1;
10186   }
10187   {
10188     char fstype[] = "ext2";
10189     char device[] = "/dev/sda2";
10190     device[5] = devchar;
10191     int r;
10192     suppress_error = 0;
10193     r = guestfs_mkfs (g, fstype, device);
10194     if (r == -1)
10195       return -1;
10196   }
10197   {
10198     char fstype[] = "ext2";
10199     char device[] = "/dev/sda3";
10200     device[5] = devchar;
10201     int r;
10202     suppress_error = 0;
10203     r = guestfs_mkfs (g, fstype, device);
10204     if (r == -1)
10205       return -1;
10206   }
10207   {
10208     char device[] = "/dev/sda1";
10209     device[5] = devchar;
10210     char mountpoint[] = "/";
10211     int r;
10212     suppress_error = 0;
10213     r = guestfs_mount (g, device, mountpoint);
10214     if (r == -1)
10215       return -1;
10216   }
10217   {
10218     char path[] = "/mp1";
10219     int r;
10220     suppress_error = 0;
10221     r = guestfs_mkdir (g, path);
10222     if (r == -1)
10223       return -1;
10224   }
10225   {
10226     char device[] = "/dev/sda2";
10227     device[5] = devchar;
10228     char mountpoint[] = "/mp1";
10229     int r;
10230     suppress_error = 0;
10231     r = guestfs_mount (g, device, mountpoint);
10232     if (r == -1)
10233       return -1;
10234   }
10235   {
10236     char path[] = "/mp1/mp2";
10237     int r;
10238     suppress_error = 0;
10239     r = guestfs_mkdir (g, path);
10240     if (r == -1)
10241       return -1;
10242   }
10243   {
10244     char device[] = "/dev/sda3";
10245     device[5] = devchar;
10246     char mountpoint[] = "/mp1/mp2";
10247     int r;
10248     suppress_error = 0;
10249     r = guestfs_mount (g, device, mountpoint);
10250     if (r == -1)
10251       return -1;
10252   }
10253   {
10254     char path[] = "/mp1/mp2/mp3";
10255     int r;
10256     suppress_error = 0;
10257     r = guestfs_mkdir (g, path);
10258     if (r == -1)
10259       return -1;
10260   }
10261   {
10262     int r;
10263     suppress_error = 0;
10264     r = guestfs_umount_all (g);
10265     if (r == -1)
10266       return -1;
10267   }
10268   {
10269     char **r;
10270     int i;
10271     suppress_error = 0;
10272     r = guestfs_mounts (g);
10273     if (r == NULL)
10274       return -1;
10275     if (r[0] != NULL) {
10276       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10277       print_strings (r);
10278       return -1;
10279     }
10280     for (i = 0; r[i] != NULL; ++i)
10281       free (r[i]);
10282     free (r);
10283   }
10284   return 0;
10285 }
10286
10287 static int test_mounts_0_skip (void)
10288 {
10289   const char *str;
10290
10291   str = getenv ("SKIP_TEST_MOUNTS_0");
10292   if (str && strcmp (str, "1") == 0) return 1;
10293   str = getenv ("SKIP_TEST_MOUNTS");
10294   if (str && strcmp (str, "1") == 0) return 1;
10295   return 0;
10296 }
10297
10298 static int test_mounts_0 (void)
10299 {
10300   if (test_mounts_0_skip ()) {
10301     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10302     return 0;
10303   }
10304
10305   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10306   {
10307     char device[] = "/dev/sda";
10308     device[5] = devchar;
10309     int r;
10310     suppress_error = 0;
10311     r = guestfs_blockdev_setrw (g, device);
10312     if (r == -1)
10313       return -1;
10314   }
10315   {
10316     int r;
10317     suppress_error = 0;
10318     r = guestfs_umount_all (g);
10319     if (r == -1)
10320       return -1;
10321   }
10322   {
10323     int r;
10324     suppress_error = 0;
10325     r = guestfs_lvm_remove_all (g);
10326     if (r == -1)
10327       return -1;
10328   }
10329   {
10330     char device[] = "/dev/sda";
10331     device[5] = devchar;
10332     char lines_0[] = ",";
10333     char *lines[] = {
10334       lines_0,
10335       NULL
10336     };
10337     int r;
10338     suppress_error = 0;
10339     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10340     if (r == -1)
10341       return -1;
10342   }
10343   {
10344     char fstype[] = "ext2";
10345     char device[] = "/dev/sda1";
10346     device[5] = devchar;
10347     int r;
10348     suppress_error = 0;
10349     r = guestfs_mkfs (g, fstype, device);
10350     if (r == -1)
10351       return -1;
10352   }
10353   {
10354     char device[] = "/dev/sda1";
10355     device[5] = devchar;
10356     char mountpoint[] = "/";
10357     int r;
10358     suppress_error = 0;
10359     r = guestfs_mount (g, device, mountpoint);
10360     if (r == -1)
10361       return -1;
10362   }
10363   /* TestOutputList for mounts (0) */
10364   {
10365     char **r;
10366     int i;
10367     suppress_error = 0;
10368     r = guestfs_mounts (g);
10369     if (r == NULL)
10370       return -1;
10371     if (!r[0]) {
10372       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10373       print_strings (r);
10374       return -1;
10375     }
10376     {
10377       char expected[] = "/dev/sda1";
10378       expected[5] = devchar;
10379       if (strcmp (r[0], expected) != 0) {
10380         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10381         return -1;
10382       }
10383     }
10384     if (r[1] != NULL) {
10385       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10386       print_strings (r);
10387       return -1;
10388     }
10389     for (i = 0; r[i] != NULL; ++i)
10390       free (r[i]);
10391     free (r);
10392   }
10393   return 0;
10394 }
10395
10396 static int test_umount_0_skip (void)
10397 {
10398   const char *str;
10399
10400   str = getenv ("SKIP_TEST_UMOUNT_0");
10401   if (str && strcmp (str, "1") == 0) return 1;
10402   str = getenv ("SKIP_TEST_UMOUNT");
10403   if (str && strcmp (str, "1") == 0) return 1;
10404   return 0;
10405 }
10406
10407 static int test_umount_0 (void)
10408 {
10409   if (test_umount_0_skip ()) {
10410     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10411     return 0;
10412   }
10413
10414   /* InitNone|InitEmpty for test_umount_0 */
10415   {
10416     char device[] = "/dev/sda";
10417     device[5] = devchar;
10418     int r;
10419     suppress_error = 0;
10420     r = guestfs_blockdev_setrw (g, device);
10421     if (r == -1)
10422       return -1;
10423   }
10424   {
10425     int r;
10426     suppress_error = 0;
10427     r = guestfs_umount_all (g);
10428     if (r == -1)
10429       return -1;
10430   }
10431   {
10432     int r;
10433     suppress_error = 0;
10434     r = guestfs_lvm_remove_all (g);
10435     if (r == -1)
10436       return -1;
10437   }
10438   /* TestOutputList for umount (0) */
10439   {
10440     char device[] = "/dev/sda";
10441     device[5] = devchar;
10442     char lines_0[] = ",";
10443     char *lines[] = {
10444       lines_0,
10445       NULL
10446     };
10447     int r;
10448     suppress_error = 0;
10449     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10450     if (r == -1)
10451       return -1;
10452   }
10453   {
10454     char fstype[] = "ext2";
10455     char device[] = "/dev/sda1";
10456     device[5] = devchar;
10457     int r;
10458     suppress_error = 0;
10459     r = guestfs_mkfs (g, fstype, device);
10460     if (r == -1)
10461       return -1;
10462   }
10463   {
10464     char device[] = "/dev/sda1";
10465     device[5] = devchar;
10466     char mountpoint[] = "/";
10467     int r;
10468     suppress_error = 0;
10469     r = guestfs_mount (g, device, mountpoint);
10470     if (r == -1)
10471       return -1;
10472   }
10473   {
10474     char **r;
10475     int i;
10476     suppress_error = 0;
10477     r = guestfs_mounts (g);
10478     if (r == NULL)
10479       return -1;
10480     if (!r[0]) {
10481       fprintf (stderr, "test_umount_0: short list returned from command\n");
10482       print_strings (r);
10483       return -1;
10484     }
10485     {
10486       char expected[] = "/dev/sda1";
10487       expected[5] = devchar;
10488       if (strcmp (r[0], expected) != 0) {
10489         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10490         return -1;
10491       }
10492     }
10493     if (r[1] != NULL) {
10494       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10495       print_strings (r);
10496       return -1;
10497     }
10498     for (i = 0; r[i] != NULL; ++i)
10499       free (r[i]);
10500     free (r);
10501   }
10502   return 0;
10503 }
10504
10505 static int test_umount_1_skip (void)
10506 {
10507   const char *str;
10508
10509   str = getenv ("SKIP_TEST_UMOUNT_1");
10510   if (str && strcmp (str, "1") == 0) return 1;
10511   str = getenv ("SKIP_TEST_UMOUNT");
10512   if (str && strcmp (str, "1") == 0) return 1;
10513   return 0;
10514 }
10515
10516 static int test_umount_1 (void)
10517 {
10518   if (test_umount_1_skip ()) {
10519     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10520     return 0;
10521   }
10522
10523   /* InitNone|InitEmpty for test_umount_1 */
10524   {
10525     char device[] = "/dev/sda";
10526     device[5] = devchar;
10527     int r;
10528     suppress_error = 0;
10529     r = guestfs_blockdev_setrw (g, device);
10530     if (r == -1)
10531       return -1;
10532   }
10533   {
10534     int r;
10535     suppress_error = 0;
10536     r = guestfs_umount_all (g);
10537     if (r == -1)
10538       return -1;
10539   }
10540   {
10541     int r;
10542     suppress_error = 0;
10543     r = guestfs_lvm_remove_all (g);
10544     if (r == -1)
10545       return -1;
10546   }
10547   /* TestOutputList for umount (1) */
10548   {
10549     char device[] = "/dev/sda";
10550     device[5] = devchar;
10551     char lines_0[] = ",";
10552     char *lines[] = {
10553       lines_0,
10554       NULL
10555     };
10556     int r;
10557     suppress_error = 0;
10558     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10559     if (r == -1)
10560       return -1;
10561   }
10562   {
10563     char fstype[] = "ext2";
10564     char device[] = "/dev/sda1";
10565     device[5] = devchar;
10566     int r;
10567     suppress_error = 0;
10568     r = guestfs_mkfs (g, fstype, device);
10569     if (r == -1)
10570       return -1;
10571   }
10572   {
10573     char device[] = "/dev/sda1";
10574     device[5] = devchar;
10575     char mountpoint[] = "/";
10576     int r;
10577     suppress_error = 0;
10578     r = guestfs_mount (g, device, mountpoint);
10579     if (r == -1)
10580       return -1;
10581   }
10582   {
10583     char pathordevice[] = "/";
10584     int r;
10585     suppress_error = 0;
10586     r = guestfs_umount (g, pathordevice);
10587     if (r == -1)
10588       return -1;
10589   }
10590   {
10591     char **r;
10592     int i;
10593     suppress_error = 0;
10594     r = guestfs_mounts (g);
10595     if (r == NULL)
10596       return -1;
10597     if (r[0] != NULL) {
10598       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10599       print_strings (r);
10600       return -1;
10601     }
10602     for (i = 0; r[i] != NULL; ++i)
10603       free (r[i]);
10604     free (r);
10605   }
10606   return 0;
10607 }
10608
10609 static int test_write_file_0_skip (void)
10610 {
10611   const char *str;
10612
10613   str = getenv ("SKIP_TEST_WRITE_FILE_0");
10614   if (str && strcmp (str, "1") == 0) return 1;
10615   str = getenv ("SKIP_TEST_WRITE_FILE");
10616   if (str && strcmp (str, "1") == 0) return 1;
10617   return 0;
10618 }
10619
10620 static int test_write_file_0 (void)
10621 {
10622   if (test_write_file_0_skip ()) {
10623     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10624     return 0;
10625   }
10626
10627   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10628   {
10629     char device[] = "/dev/sda";
10630     device[5] = devchar;
10631     int r;
10632     suppress_error = 0;
10633     r = guestfs_blockdev_setrw (g, device);
10634     if (r == -1)
10635       return -1;
10636   }
10637   {
10638     int r;
10639     suppress_error = 0;
10640     r = guestfs_umount_all (g);
10641     if (r == -1)
10642       return -1;
10643   }
10644   {
10645     int r;
10646     suppress_error = 0;
10647     r = guestfs_lvm_remove_all (g);
10648     if (r == -1)
10649       return -1;
10650   }
10651   {
10652     char device[] = "/dev/sda";
10653     device[5] = devchar;
10654     char lines_0[] = ",";
10655     char *lines[] = {
10656       lines_0,
10657       NULL
10658     };
10659     int r;
10660     suppress_error = 0;
10661     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10662     if (r == -1)
10663       return -1;
10664   }
10665   {
10666     char fstype[] = "ext2";
10667     char device[] = "/dev/sda1";
10668     device[5] = devchar;
10669     int r;
10670     suppress_error = 0;
10671     r = guestfs_mkfs (g, fstype, device);
10672     if (r == -1)
10673       return -1;
10674   }
10675   {
10676     char device[] = "/dev/sda1";
10677     device[5] = devchar;
10678     char mountpoint[] = "/";
10679     int r;
10680     suppress_error = 0;
10681     r = guestfs_mount (g, device, mountpoint);
10682     if (r == -1)
10683       return -1;
10684   }
10685   /* TestOutput for write_file (0) */
10686   char expected[] = "new file contents";
10687   {
10688     char path[] = "/new";
10689     char content[] = "new file contents";
10690     int r;
10691     suppress_error = 0;
10692     r = guestfs_write_file (g, path, content, 0);
10693     if (r == -1)
10694       return -1;
10695   }
10696   {
10697     char path[] = "/new";
10698     char *r;
10699     suppress_error = 0;
10700     r = guestfs_cat (g, path);
10701     if (r == NULL)
10702       return -1;
10703     if (strcmp (r, expected) != 0) {
10704       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10705       return -1;
10706     }
10707     free (r);
10708   }
10709   return 0;
10710 }
10711
10712 static int test_write_file_1_skip (void)
10713 {
10714   const char *str;
10715
10716   str = getenv ("SKIP_TEST_WRITE_FILE_1");
10717   if (str && strcmp (str, "1") == 0) return 1;
10718   str = getenv ("SKIP_TEST_WRITE_FILE");
10719   if (str && strcmp (str, "1") == 0) return 1;
10720   return 0;
10721 }
10722
10723 static int test_write_file_1 (void)
10724 {
10725   if (test_write_file_1_skip ()) {
10726     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10727     return 0;
10728   }
10729
10730   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10731   {
10732     char device[] = "/dev/sda";
10733     device[5] = devchar;
10734     int r;
10735     suppress_error = 0;
10736     r = guestfs_blockdev_setrw (g, device);
10737     if (r == -1)
10738       return -1;
10739   }
10740   {
10741     int r;
10742     suppress_error = 0;
10743     r = guestfs_umount_all (g);
10744     if (r == -1)
10745       return -1;
10746   }
10747   {
10748     int r;
10749     suppress_error = 0;
10750     r = guestfs_lvm_remove_all (g);
10751     if (r == -1)
10752       return -1;
10753   }
10754   {
10755     char device[] = "/dev/sda";
10756     device[5] = devchar;
10757     char lines_0[] = ",";
10758     char *lines[] = {
10759       lines_0,
10760       NULL
10761     };
10762     int r;
10763     suppress_error = 0;
10764     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10765     if (r == -1)
10766       return -1;
10767   }
10768   {
10769     char fstype[] = "ext2";
10770     char device[] = "/dev/sda1";
10771     device[5] = devchar;
10772     int r;
10773     suppress_error = 0;
10774     r = guestfs_mkfs (g, fstype, device);
10775     if (r == -1)
10776       return -1;
10777   }
10778   {
10779     char device[] = "/dev/sda1";
10780     device[5] = devchar;
10781     char mountpoint[] = "/";
10782     int r;
10783     suppress_error = 0;
10784     r = guestfs_mount (g, device, mountpoint);
10785     if (r == -1)
10786       return -1;
10787   }
10788   /* TestOutput for write_file (1) */
10789   char expected[] = "\nnew file contents\n";
10790   {
10791     char path[] = "/new";
10792     char content[] = "\nnew file contents\n";
10793     int r;
10794     suppress_error = 0;
10795     r = guestfs_write_file (g, path, content, 0);
10796     if (r == -1)
10797       return -1;
10798   }
10799   {
10800     char path[] = "/new";
10801     char *r;
10802     suppress_error = 0;
10803     r = guestfs_cat (g, path);
10804     if (r == NULL)
10805       return -1;
10806     if (strcmp (r, expected) != 0) {
10807       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10808       return -1;
10809     }
10810     free (r);
10811   }
10812   return 0;
10813 }
10814
10815 static int test_write_file_2_skip (void)
10816 {
10817   const char *str;
10818
10819   str = getenv ("SKIP_TEST_WRITE_FILE_2");
10820   if (str && strcmp (str, "1") == 0) return 1;
10821   str = getenv ("SKIP_TEST_WRITE_FILE");
10822   if (str && strcmp (str, "1") == 0) return 1;
10823   return 0;
10824 }
10825
10826 static int test_write_file_2 (void)
10827 {
10828   if (test_write_file_2_skip ()) {
10829     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10830     return 0;
10831   }
10832
10833   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10834   {
10835     char device[] = "/dev/sda";
10836     device[5] = devchar;
10837     int r;
10838     suppress_error = 0;
10839     r = guestfs_blockdev_setrw (g, device);
10840     if (r == -1)
10841       return -1;
10842   }
10843   {
10844     int r;
10845     suppress_error = 0;
10846     r = guestfs_umount_all (g);
10847     if (r == -1)
10848       return -1;
10849   }
10850   {
10851     int r;
10852     suppress_error = 0;
10853     r = guestfs_lvm_remove_all (g);
10854     if (r == -1)
10855       return -1;
10856   }
10857   {
10858     char device[] = "/dev/sda";
10859     device[5] = devchar;
10860     char lines_0[] = ",";
10861     char *lines[] = {
10862       lines_0,
10863       NULL
10864     };
10865     int r;
10866     suppress_error = 0;
10867     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10868     if (r == -1)
10869       return -1;
10870   }
10871   {
10872     char fstype[] = "ext2";
10873     char device[] = "/dev/sda1";
10874     device[5] = devchar;
10875     int r;
10876     suppress_error = 0;
10877     r = guestfs_mkfs (g, fstype, device);
10878     if (r == -1)
10879       return -1;
10880   }
10881   {
10882     char device[] = "/dev/sda1";
10883     device[5] = devchar;
10884     char mountpoint[] = "/";
10885     int r;
10886     suppress_error = 0;
10887     r = guestfs_mount (g, device, mountpoint);
10888     if (r == -1)
10889       return -1;
10890   }
10891   /* TestOutput for write_file (2) */
10892   char expected[] = "\n\n";
10893   {
10894     char path[] = "/new";
10895     char content[] = "\n\n";
10896     int r;
10897     suppress_error = 0;
10898     r = guestfs_write_file (g, path, content, 0);
10899     if (r == -1)
10900       return -1;
10901   }
10902   {
10903     char path[] = "/new";
10904     char *r;
10905     suppress_error = 0;
10906     r = guestfs_cat (g, path);
10907     if (r == NULL)
10908       return -1;
10909     if (strcmp (r, expected) != 0) {
10910       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
10911       return -1;
10912     }
10913     free (r);
10914   }
10915   return 0;
10916 }
10917
10918 static int test_write_file_3_skip (void)
10919 {
10920   const char *str;
10921
10922   str = getenv ("SKIP_TEST_WRITE_FILE_3");
10923   if (str && strcmp (str, "1") == 0) return 1;
10924   str = getenv ("SKIP_TEST_WRITE_FILE");
10925   if (str && strcmp (str, "1") == 0) return 1;
10926   return 0;
10927 }
10928
10929 static int test_write_file_3 (void)
10930 {
10931   if (test_write_file_3_skip ()) {
10932     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
10933     return 0;
10934   }
10935
10936   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
10937   {
10938     char device[] = "/dev/sda";
10939     device[5] = devchar;
10940     int r;
10941     suppress_error = 0;
10942     r = guestfs_blockdev_setrw (g, device);
10943     if (r == -1)
10944       return -1;
10945   }
10946   {
10947     int r;
10948     suppress_error = 0;
10949     r = guestfs_umount_all (g);
10950     if (r == -1)
10951       return -1;
10952   }
10953   {
10954     int r;
10955     suppress_error = 0;
10956     r = guestfs_lvm_remove_all (g);
10957     if (r == -1)
10958       return -1;
10959   }
10960   {
10961     char device[] = "/dev/sda";
10962     device[5] = devchar;
10963     char lines_0[] = ",";
10964     char *lines[] = {
10965       lines_0,
10966       NULL
10967     };
10968     int r;
10969     suppress_error = 0;
10970     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10971     if (r == -1)
10972       return -1;
10973   }
10974   {
10975     char fstype[] = "ext2";
10976     char device[] = "/dev/sda1";
10977     device[5] = devchar;
10978     int r;
10979     suppress_error = 0;
10980     r = guestfs_mkfs (g, fstype, device);
10981     if (r == -1)
10982       return -1;
10983   }
10984   {
10985     char device[] = "/dev/sda1";
10986     device[5] = devchar;
10987     char mountpoint[] = "/";
10988     int r;
10989     suppress_error = 0;
10990     r = guestfs_mount (g, device, mountpoint);
10991     if (r == -1)
10992       return -1;
10993   }
10994   /* TestOutput for write_file (3) */
10995   char expected[] = "";
10996   {
10997     char path[] = "/new";
10998     char content[] = "";
10999     int r;
11000     suppress_error = 0;
11001     r = guestfs_write_file (g, path, content, 0);
11002     if (r == -1)
11003       return -1;
11004   }
11005   {
11006     char path[] = "/new";
11007     char *r;
11008     suppress_error = 0;
11009     r = guestfs_cat (g, path);
11010     if (r == NULL)
11011       return -1;
11012     if (strcmp (r, expected) != 0) {
11013       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11014       return -1;
11015     }
11016     free (r);
11017   }
11018   return 0;
11019 }
11020
11021 static int test_write_file_4_skip (void)
11022 {
11023   const char *str;
11024
11025   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11026   if (str && strcmp (str, "1") == 0) return 1;
11027   str = getenv ("SKIP_TEST_WRITE_FILE");
11028   if (str && strcmp (str, "1") == 0) return 1;
11029   return 0;
11030 }
11031
11032 static int test_write_file_4 (void)
11033 {
11034   if (test_write_file_4_skip ()) {
11035     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11036     return 0;
11037   }
11038
11039   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11040   {
11041     char device[] = "/dev/sda";
11042     device[5] = devchar;
11043     int r;
11044     suppress_error = 0;
11045     r = guestfs_blockdev_setrw (g, device);
11046     if (r == -1)
11047       return -1;
11048   }
11049   {
11050     int r;
11051     suppress_error = 0;
11052     r = guestfs_umount_all (g);
11053     if (r == -1)
11054       return -1;
11055   }
11056   {
11057     int r;
11058     suppress_error = 0;
11059     r = guestfs_lvm_remove_all (g);
11060     if (r == -1)
11061       return -1;
11062   }
11063   {
11064     char device[] = "/dev/sda";
11065     device[5] = devchar;
11066     char lines_0[] = ",";
11067     char *lines[] = {
11068       lines_0,
11069       NULL
11070     };
11071     int r;
11072     suppress_error = 0;
11073     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11074     if (r == -1)
11075       return -1;
11076   }
11077   {
11078     char fstype[] = "ext2";
11079     char device[] = "/dev/sda1";
11080     device[5] = devchar;
11081     int r;
11082     suppress_error = 0;
11083     r = guestfs_mkfs (g, fstype, device);
11084     if (r == -1)
11085       return -1;
11086   }
11087   {
11088     char device[] = "/dev/sda1";
11089     device[5] = devchar;
11090     char mountpoint[] = "/";
11091     int r;
11092     suppress_error = 0;
11093     r = guestfs_mount (g, device, mountpoint);
11094     if (r == -1)
11095       return -1;
11096   }
11097   /* TestOutput for write_file (4) */
11098   char expected[] = "\n\n\n";
11099   {
11100     char path[] = "/new";
11101     char content[] = "\n\n\n";
11102     int r;
11103     suppress_error = 0;
11104     r = guestfs_write_file (g, path, content, 0);
11105     if (r == -1)
11106       return -1;
11107   }
11108   {
11109     char path[] = "/new";
11110     char *r;
11111     suppress_error = 0;
11112     r = guestfs_cat (g, path);
11113     if (r == NULL)
11114       return -1;
11115     if (strcmp (r, expected) != 0) {
11116       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11117       return -1;
11118     }
11119     free (r);
11120   }
11121   return 0;
11122 }
11123
11124 static int test_write_file_5_skip (void)
11125 {
11126   const char *str;
11127
11128   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11129   if (str && strcmp (str, "1") == 0) return 1;
11130   str = getenv ("SKIP_TEST_WRITE_FILE");
11131   if (str && strcmp (str, "1") == 0) return 1;
11132   return 0;
11133 }
11134
11135 static int test_write_file_5 (void)
11136 {
11137   if (test_write_file_5_skip ()) {
11138     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11139     return 0;
11140   }
11141
11142   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11143   {
11144     char device[] = "/dev/sda";
11145     device[5] = devchar;
11146     int r;
11147     suppress_error = 0;
11148     r = guestfs_blockdev_setrw (g, device);
11149     if (r == -1)
11150       return -1;
11151   }
11152   {
11153     int r;
11154     suppress_error = 0;
11155     r = guestfs_umount_all (g);
11156     if (r == -1)
11157       return -1;
11158   }
11159   {
11160     int r;
11161     suppress_error = 0;
11162     r = guestfs_lvm_remove_all (g);
11163     if (r == -1)
11164       return -1;
11165   }
11166   {
11167     char device[] = "/dev/sda";
11168     device[5] = devchar;
11169     char lines_0[] = ",";
11170     char *lines[] = {
11171       lines_0,
11172       NULL
11173     };
11174     int r;
11175     suppress_error = 0;
11176     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11177     if (r == -1)
11178       return -1;
11179   }
11180   {
11181     char fstype[] = "ext2";
11182     char device[] = "/dev/sda1";
11183     device[5] = devchar;
11184     int r;
11185     suppress_error = 0;
11186     r = guestfs_mkfs (g, fstype, device);
11187     if (r == -1)
11188       return -1;
11189   }
11190   {
11191     char device[] = "/dev/sda1";
11192     device[5] = devchar;
11193     char mountpoint[] = "/";
11194     int r;
11195     suppress_error = 0;
11196     r = guestfs_mount (g, device, mountpoint);
11197     if (r == -1)
11198       return -1;
11199   }
11200   /* TestOutput for write_file (5) */
11201   char expected[] = "\n";
11202   {
11203     char path[] = "/new";
11204     char content[] = "\n";
11205     int r;
11206     suppress_error = 0;
11207     r = guestfs_write_file (g, path, content, 0);
11208     if (r == -1)
11209       return -1;
11210   }
11211   {
11212     char path[] = "/new";
11213     char *r;
11214     suppress_error = 0;
11215     r = guestfs_cat (g, path);
11216     if (r == NULL)
11217       return -1;
11218     if (strcmp (r, expected) != 0) {
11219       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11220       return -1;
11221     }
11222     free (r);
11223   }
11224   return 0;
11225 }
11226
11227 static int test_mkfs_0_skip (void)
11228 {
11229   const char *str;
11230
11231   str = getenv ("SKIP_TEST_MKFS_0");
11232   if (str && strcmp (str, "1") == 0) return 1;
11233   str = getenv ("SKIP_TEST_MKFS");
11234   if (str && strcmp (str, "1") == 0) return 1;
11235   return 0;
11236 }
11237
11238 static int test_mkfs_0 (void)
11239 {
11240   if (test_mkfs_0_skip ()) {
11241     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11242     return 0;
11243   }
11244
11245   /* InitNone|InitEmpty for test_mkfs_0 */
11246   {
11247     char device[] = "/dev/sda";
11248     device[5] = devchar;
11249     int r;
11250     suppress_error = 0;
11251     r = guestfs_blockdev_setrw (g, device);
11252     if (r == -1)
11253       return -1;
11254   }
11255   {
11256     int r;
11257     suppress_error = 0;
11258     r = guestfs_umount_all (g);
11259     if (r == -1)
11260       return -1;
11261   }
11262   {
11263     int r;
11264     suppress_error = 0;
11265     r = guestfs_lvm_remove_all (g);
11266     if (r == -1)
11267       return -1;
11268   }
11269   /* TestOutput for mkfs (0) */
11270   char expected[] = "new file contents";
11271   {
11272     char device[] = "/dev/sda";
11273     device[5] = devchar;
11274     char lines_0[] = ",";
11275     char *lines[] = {
11276       lines_0,
11277       NULL
11278     };
11279     int r;
11280     suppress_error = 0;
11281     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11282     if (r == -1)
11283       return -1;
11284   }
11285   {
11286     char fstype[] = "ext2";
11287     char device[] = "/dev/sda1";
11288     device[5] = devchar;
11289     int r;
11290     suppress_error = 0;
11291     r = guestfs_mkfs (g, fstype, device);
11292     if (r == -1)
11293       return -1;
11294   }
11295   {
11296     char device[] = "/dev/sda1";
11297     device[5] = devchar;
11298     char mountpoint[] = "/";
11299     int r;
11300     suppress_error = 0;
11301     r = guestfs_mount (g, device, mountpoint);
11302     if (r == -1)
11303       return -1;
11304   }
11305   {
11306     char path[] = "/new";
11307     char content[] = "new file contents";
11308     int r;
11309     suppress_error = 0;
11310     r = guestfs_write_file (g, path, content, 0);
11311     if (r == -1)
11312       return -1;
11313   }
11314   {
11315     char path[] = "/new";
11316     char *r;
11317     suppress_error = 0;
11318     r = guestfs_cat (g, path);
11319     if (r == NULL)
11320       return -1;
11321     if (strcmp (r, expected) != 0) {
11322       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11323       return -1;
11324     }
11325     free (r);
11326   }
11327   return 0;
11328 }
11329
11330 static int test_lvcreate_0_skip (void)
11331 {
11332   const char *str;
11333
11334   str = getenv ("SKIP_TEST_LVCREATE_0");
11335   if (str && strcmp (str, "1") == 0) return 1;
11336   str = getenv ("SKIP_TEST_LVCREATE");
11337   if (str && strcmp (str, "1") == 0) return 1;
11338   return 0;
11339 }
11340
11341 static int test_lvcreate_0 (void)
11342 {
11343   if (test_lvcreate_0_skip ()) {
11344     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11345     return 0;
11346   }
11347
11348   /* InitNone|InitEmpty for test_lvcreate_0 */
11349   {
11350     char device[] = "/dev/sda";
11351     device[5] = devchar;
11352     int r;
11353     suppress_error = 0;
11354     r = guestfs_blockdev_setrw (g, device);
11355     if (r == -1)
11356       return -1;
11357   }
11358   {
11359     int r;
11360     suppress_error = 0;
11361     r = guestfs_umount_all (g);
11362     if (r == -1)
11363       return -1;
11364   }
11365   {
11366     int r;
11367     suppress_error = 0;
11368     r = guestfs_lvm_remove_all (g);
11369     if (r == -1)
11370       return -1;
11371   }
11372   /* TestOutputList for lvcreate (0) */
11373   {
11374     char device[] = "/dev/sda";
11375     device[5] = devchar;
11376     char lines_0[] = ",10";
11377     char lines_1[] = ",20";
11378     char lines_2[] = ",";
11379     char *lines[] = {
11380       lines_0,
11381       lines_1,
11382       lines_2,
11383       NULL
11384     };
11385     int r;
11386     suppress_error = 0;
11387     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11388     if (r == -1)
11389       return -1;
11390   }
11391   {
11392     char device[] = "/dev/sda1";
11393     device[5] = devchar;
11394     int r;
11395     suppress_error = 0;
11396     r = guestfs_pvcreate (g, device);
11397     if (r == -1)
11398       return -1;
11399   }
11400   {
11401     char device[] = "/dev/sda2";
11402     device[5] = devchar;
11403     int r;
11404     suppress_error = 0;
11405     r = guestfs_pvcreate (g, device);
11406     if (r == -1)
11407       return -1;
11408   }
11409   {
11410     char device[] = "/dev/sda3";
11411     device[5] = devchar;
11412     int r;
11413     suppress_error = 0;
11414     r = guestfs_pvcreate (g, device);
11415     if (r == -1)
11416       return -1;
11417   }
11418   {
11419     char volgroup[] = "VG1";
11420     char physvols_0[] = "/dev/sda1";
11421     physvols_0[5] = devchar;
11422     char physvols_1[] = "/dev/sda2";
11423     physvols_1[5] = devchar;
11424     char *physvols[] = {
11425       physvols_0,
11426       physvols_1,
11427       NULL
11428     };
11429     int r;
11430     suppress_error = 0;
11431     r = guestfs_vgcreate (g, volgroup, physvols);
11432     if (r == -1)
11433       return -1;
11434   }
11435   {
11436     char volgroup[] = "VG2";
11437     char physvols_0[] = "/dev/sda3";
11438     physvols_0[5] = devchar;
11439     char *physvols[] = {
11440       physvols_0,
11441       NULL
11442     };
11443     int r;
11444     suppress_error = 0;
11445     r = guestfs_vgcreate (g, volgroup, physvols);
11446     if (r == -1)
11447       return -1;
11448   }
11449   {
11450     char logvol[] = "LV1";
11451     char volgroup[] = "VG1";
11452     int r;
11453     suppress_error = 0;
11454     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11455     if (r == -1)
11456       return -1;
11457   }
11458   {
11459     char logvol[] = "LV2";
11460     char volgroup[] = "VG1";
11461     int r;
11462     suppress_error = 0;
11463     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11464     if (r == -1)
11465       return -1;
11466   }
11467   {
11468     char logvol[] = "LV3";
11469     char volgroup[] = "VG2";
11470     int r;
11471     suppress_error = 0;
11472     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11473     if (r == -1)
11474       return -1;
11475   }
11476   {
11477     char logvol[] = "LV4";
11478     char volgroup[] = "VG2";
11479     int r;
11480     suppress_error = 0;
11481     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11482     if (r == -1)
11483       return -1;
11484   }
11485   {
11486     char logvol[] = "LV5";
11487     char volgroup[] = "VG2";
11488     int r;
11489     suppress_error = 0;
11490     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11491     if (r == -1)
11492       return -1;
11493   }
11494   {
11495     char **r;
11496     int i;
11497     suppress_error = 0;
11498     r = guestfs_lvs (g);
11499     if (r == NULL)
11500       return -1;
11501     if (!r[0]) {
11502       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11503       print_strings (r);
11504       return -1;
11505     }
11506     {
11507       char expected[] = "/dev/VG1/LV1";
11508       if (strcmp (r[0], expected) != 0) {
11509         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11510         return -1;
11511       }
11512     }
11513     if (!r[1]) {
11514       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11515       print_strings (r);
11516       return -1;
11517     }
11518     {
11519       char expected[] = "/dev/VG1/LV2";
11520       if (strcmp (r[1], expected) != 0) {
11521         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11522         return -1;
11523       }
11524     }
11525     if (!r[2]) {
11526       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11527       print_strings (r);
11528       return -1;
11529     }
11530     {
11531       char expected[] = "/dev/VG2/LV3";
11532       if (strcmp (r[2], expected) != 0) {
11533         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11534         return -1;
11535       }
11536     }
11537     if (!r[3]) {
11538       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11539       print_strings (r);
11540       return -1;
11541     }
11542     {
11543       char expected[] = "/dev/VG2/LV4";
11544       if (strcmp (r[3], expected) != 0) {
11545         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11546         return -1;
11547       }
11548     }
11549     if (!r[4]) {
11550       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11551       print_strings (r);
11552       return -1;
11553     }
11554     {
11555       char expected[] = "/dev/VG2/LV5";
11556       if (strcmp (r[4], expected) != 0) {
11557         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11558         return -1;
11559       }
11560     }
11561     if (r[5] != NULL) {
11562       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11563       print_strings (r);
11564       return -1;
11565     }
11566     for (i = 0; r[i] != NULL; ++i)
11567       free (r[i]);
11568     free (r);
11569   }
11570   return 0;
11571 }
11572
11573 static int test_vgcreate_0_skip (void)
11574 {
11575   const char *str;
11576
11577   str = getenv ("SKIP_TEST_VGCREATE_0");
11578   if (str && strcmp (str, "1") == 0) return 1;
11579   str = getenv ("SKIP_TEST_VGCREATE");
11580   if (str && strcmp (str, "1") == 0) return 1;
11581   return 0;
11582 }
11583
11584 static int test_vgcreate_0 (void)
11585 {
11586   if (test_vgcreate_0_skip ()) {
11587     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11588     return 0;
11589   }
11590
11591   /* InitNone|InitEmpty for test_vgcreate_0 */
11592   {
11593     char device[] = "/dev/sda";
11594     device[5] = devchar;
11595     int r;
11596     suppress_error = 0;
11597     r = guestfs_blockdev_setrw (g, device);
11598     if (r == -1)
11599       return -1;
11600   }
11601   {
11602     int r;
11603     suppress_error = 0;
11604     r = guestfs_umount_all (g);
11605     if (r == -1)
11606       return -1;
11607   }
11608   {
11609     int r;
11610     suppress_error = 0;
11611     r = guestfs_lvm_remove_all (g);
11612     if (r == -1)
11613       return -1;
11614   }
11615   /* TestOutputList for vgcreate (0) */
11616   {
11617     char device[] = "/dev/sda";
11618     device[5] = devchar;
11619     char lines_0[] = ",10";
11620     char lines_1[] = ",20";
11621     char lines_2[] = ",";
11622     char *lines[] = {
11623       lines_0,
11624       lines_1,
11625       lines_2,
11626       NULL
11627     };
11628     int r;
11629     suppress_error = 0;
11630     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11631     if (r == -1)
11632       return -1;
11633   }
11634   {
11635     char device[] = "/dev/sda1";
11636     device[5] = devchar;
11637     int r;
11638     suppress_error = 0;
11639     r = guestfs_pvcreate (g, device);
11640     if (r == -1)
11641       return -1;
11642   }
11643   {
11644     char device[] = "/dev/sda2";
11645     device[5] = devchar;
11646     int r;
11647     suppress_error = 0;
11648     r = guestfs_pvcreate (g, device);
11649     if (r == -1)
11650       return -1;
11651   }
11652   {
11653     char device[] = "/dev/sda3";
11654     device[5] = devchar;
11655     int r;
11656     suppress_error = 0;
11657     r = guestfs_pvcreate (g, device);
11658     if (r == -1)
11659       return -1;
11660   }
11661   {
11662     char volgroup[] = "VG1";
11663     char physvols_0[] = "/dev/sda1";
11664     physvols_0[5] = devchar;
11665     char physvols_1[] = "/dev/sda2";
11666     physvols_1[5] = devchar;
11667     char *physvols[] = {
11668       physvols_0,
11669       physvols_1,
11670       NULL
11671     };
11672     int r;
11673     suppress_error = 0;
11674     r = guestfs_vgcreate (g, volgroup, physvols);
11675     if (r == -1)
11676       return -1;
11677   }
11678   {
11679     char volgroup[] = "VG2";
11680     char physvols_0[] = "/dev/sda3";
11681     physvols_0[5] = devchar;
11682     char *physvols[] = {
11683       physvols_0,
11684       NULL
11685     };
11686     int r;
11687     suppress_error = 0;
11688     r = guestfs_vgcreate (g, volgroup, physvols);
11689     if (r == -1)
11690       return -1;
11691   }
11692   {
11693     char **r;
11694     int i;
11695     suppress_error = 0;
11696     r = guestfs_vgs (g);
11697     if (r == NULL)
11698       return -1;
11699     if (!r[0]) {
11700       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11701       print_strings (r);
11702       return -1;
11703     }
11704     {
11705       char expected[] = "VG1";
11706       if (strcmp (r[0], expected) != 0) {
11707         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11708         return -1;
11709       }
11710     }
11711     if (!r[1]) {
11712       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11713       print_strings (r);
11714       return -1;
11715     }
11716     {
11717       char expected[] = "VG2";
11718       if (strcmp (r[1], expected) != 0) {
11719         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11720         return -1;
11721       }
11722     }
11723     if (r[2] != NULL) {
11724       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11725       print_strings (r);
11726       return -1;
11727     }
11728     for (i = 0; r[i] != NULL; ++i)
11729       free (r[i]);
11730     free (r);
11731   }
11732   return 0;
11733 }
11734
11735 static int test_pvcreate_0_skip (void)
11736 {
11737   const char *str;
11738
11739   str = getenv ("SKIP_TEST_PVCREATE_0");
11740   if (str && strcmp (str, "1") == 0) return 1;
11741   str = getenv ("SKIP_TEST_PVCREATE");
11742   if (str && strcmp (str, "1") == 0) return 1;
11743   return 0;
11744 }
11745
11746 static int test_pvcreate_0 (void)
11747 {
11748   if (test_pvcreate_0_skip ()) {
11749     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11750     return 0;
11751   }
11752
11753   /* InitNone|InitEmpty for test_pvcreate_0 */
11754   {
11755     char device[] = "/dev/sda";
11756     device[5] = devchar;
11757     int r;
11758     suppress_error = 0;
11759     r = guestfs_blockdev_setrw (g, device);
11760     if (r == -1)
11761       return -1;
11762   }
11763   {
11764     int r;
11765     suppress_error = 0;
11766     r = guestfs_umount_all (g);
11767     if (r == -1)
11768       return -1;
11769   }
11770   {
11771     int r;
11772     suppress_error = 0;
11773     r = guestfs_lvm_remove_all (g);
11774     if (r == -1)
11775       return -1;
11776   }
11777   /* TestOutputList for pvcreate (0) */
11778   {
11779     char device[] = "/dev/sda";
11780     device[5] = devchar;
11781     char lines_0[] = ",10";
11782     char lines_1[] = ",20";
11783     char lines_2[] = ",";
11784     char *lines[] = {
11785       lines_0,
11786       lines_1,
11787       lines_2,
11788       NULL
11789     };
11790     int r;
11791     suppress_error = 0;
11792     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11793     if (r == -1)
11794       return -1;
11795   }
11796   {
11797     char device[] = "/dev/sda1";
11798     device[5] = devchar;
11799     int r;
11800     suppress_error = 0;
11801     r = guestfs_pvcreate (g, device);
11802     if (r == -1)
11803       return -1;
11804   }
11805   {
11806     char device[] = "/dev/sda2";
11807     device[5] = devchar;
11808     int r;
11809     suppress_error = 0;
11810     r = guestfs_pvcreate (g, device);
11811     if (r == -1)
11812       return -1;
11813   }
11814   {
11815     char device[] = "/dev/sda3";
11816     device[5] = devchar;
11817     int r;
11818     suppress_error = 0;
11819     r = guestfs_pvcreate (g, device);
11820     if (r == -1)
11821       return -1;
11822   }
11823   {
11824     char **r;
11825     int i;
11826     suppress_error = 0;
11827     r = guestfs_pvs (g);
11828     if (r == NULL)
11829       return -1;
11830     if (!r[0]) {
11831       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11832       print_strings (r);
11833       return -1;
11834     }
11835     {
11836       char expected[] = "/dev/sda1";
11837       expected[5] = devchar;
11838       if (strcmp (r[0], expected) != 0) {
11839         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11840         return -1;
11841       }
11842     }
11843     if (!r[1]) {
11844       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11845       print_strings (r);
11846       return -1;
11847     }
11848     {
11849       char expected[] = "/dev/sda2";
11850       expected[5] = devchar;
11851       if (strcmp (r[1], expected) != 0) {
11852         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11853         return -1;
11854       }
11855     }
11856     if (!r[2]) {
11857       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11858       print_strings (r);
11859       return -1;
11860     }
11861     {
11862       char expected[] = "/dev/sda3";
11863       expected[5] = devchar;
11864       if (strcmp (r[2], expected) != 0) {
11865         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11866         return -1;
11867       }
11868     }
11869     if (r[3] != NULL) {
11870       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
11871       print_strings (r);
11872       return -1;
11873     }
11874     for (i = 0; r[i] != NULL; ++i)
11875       free (r[i]);
11876     free (r);
11877   }
11878   return 0;
11879 }
11880
11881 static int test_is_dir_0_skip (void)
11882 {
11883   const char *str;
11884
11885   str = getenv ("SKIP_TEST_IS_DIR_0");
11886   if (str && strcmp (str, "1") == 0) return 1;
11887   str = getenv ("SKIP_TEST_IS_DIR");
11888   if (str && strcmp (str, "1") == 0) return 1;
11889   return 0;
11890 }
11891
11892 static int test_is_dir_0 (void)
11893 {
11894   if (test_is_dir_0_skip ()) {
11895     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
11896     return 0;
11897   }
11898
11899   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
11900   {
11901     char device[] = "/dev/sda";
11902     device[5] = devchar;
11903     int r;
11904     suppress_error = 0;
11905     r = guestfs_blockdev_setrw (g, device);
11906     if (r == -1)
11907       return -1;
11908   }
11909   {
11910     int r;
11911     suppress_error = 0;
11912     r = guestfs_umount_all (g);
11913     if (r == -1)
11914       return -1;
11915   }
11916   {
11917     int r;
11918     suppress_error = 0;
11919     r = guestfs_lvm_remove_all (g);
11920     if (r == -1)
11921       return -1;
11922   }
11923   {
11924     char device[] = "/dev/sda";
11925     device[5] = devchar;
11926     char lines_0[] = ",";
11927     char *lines[] = {
11928       lines_0,
11929       NULL
11930     };
11931     int r;
11932     suppress_error = 0;
11933     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11934     if (r == -1)
11935       return -1;
11936   }
11937   {
11938     char fstype[] = "ext2";
11939     char device[] = "/dev/sda1";
11940     device[5] = devchar;
11941     int r;
11942     suppress_error = 0;
11943     r = guestfs_mkfs (g, fstype, device);
11944     if (r == -1)
11945       return -1;
11946   }
11947   {
11948     char device[] = "/dev/sda1";
11949     device[5] = devchar;
11950     char mountpoint[] = "/";
11951     int r;
11952     suppress_error = 0;
11953     r = guestfs_mount (g, device, mountpoint);
11954     if (r == -1)
11955       return -1;
11956   }
11957   /* TestOutputFalse for is_dir (0) */
11958   {
11959     char path[] = "/new";
11960     int r;
11961     suppress_error = 0;
11962     r = guestfs_touch (g, path);
11963     if (r == -1)
11964       return -1;
11965   }
11966   {
11967     char path[] = "/new";
11968     int r;
11969     suppress_error = 0;
11970     r = guestfs_is_dir (g, path);
11971     if (r == -1)
11972       return -1;
11973     if (r) {
11974       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
11975       return -1;
11976     }
11977   }
11978   return 0;
11979 }
11980
11981 static int test_is_dir_1_skip (void)
11982 {
11983   const char *str;
11984
11985   str = getenv ("SKIP_TEST_IS_DIR_1");
11986   if (str && strcmp (str, "1") == 0) return 1;
11987   str = getenv ("SKIP_TEST_IS_DIR");
11988   if (str && strcmp (str, "1") == 0) return 1;
11989   return 0;
11990 }
11991
11992 static int test_is_dir_1 (void)
11993 {
11994   if (test_is_dir_1_skip ()) {
11995     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
11996     return 0;
11997   }
11998
11999   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12000   {
12001     char device[] = "/dev/sda";
12002     device[5] = devchar;
12003     int r;
12004     suppress_error = 0;
12005     r = guestfs_blockdev_setrw (g, device);
12006     if (r == -1)
12007       return -1;
12008   }
12009   {
12010     int r;
12011     suppress_error = 0;
12012     r = guestfs_umount_all (g);
12013     if (r == -1)
12014       return -1;
12015   }
12016   {
12017     int r;
12018     suppress_error = 0;
12019     r = guestfs_lvm_remove_all (g);
12020     if (r == -1)
12021       return -1;
12022   }
12023   {
12024     char device[] = "/dev/sda";
12025     device[5] = devchar;
12026     char lines_0[] = ",";
12027     char *lines[] = {
12028       lines_0,
12029       NULL
12030     };
12031     int r;
12032     suppress_error = 0;
12033     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12034     if (r == -1)
12035       return -1;
12036   }
12037   {
12038     char fstype[] = "ext2";
12039     char device[] = "/dev/sda1";
12040     device[5] = devchar;
12041     int r;
12042     suppress_error = 0;
12043     r = guestfs_mkfs (g, fstype, device);
12044     if (r == -1)
12045       return -1;
12046   }
12047   {
12048     char device[] = "/dev/sda1";
12049     device[5] = devchar;
12050     char mountpoint[] = "/";
12051     int r;
12052     suppress_error = 0;
12053     r = guestfs_mount (g, device, mountpoint);
12054     if (r == -1)
12055       return -1;
12056   }
12057   /* TestOutputTrue for is_dir (1) */
12058   {
12059     char path[] = "/new";
12060     int r;
12061     suppress_error = 0;
12062     r = guestfs_mkdir (g, path);
12063     if (r == -1)
12064       return -1;
12065   }
12066   {
12067     char path[] = "/new";
12068     int r;
12069     suppress_error = 0;
12070     r = guestfs_is_dir (g, path);
12071     if (r == -1)
12072       return -1;
12073     if (!r) {
12074       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12075       return -1;
12076     }
12077   }
12078   return 0;
12079 }
12080
12081 static int test_is_file_0_skip (void)
12082 {
12083   const char *str;
12084
12085   str = getenv ("SKIP_TEST_IS_FILE_0");
12086   if (str && strcmp (str, "1") == 0) return 1;
12087   str = getenv ("SKIP_TEST_IS_FILE");
12088   if (str && strcmp (str, "1") == 0) return 1;
12089   return 0;
12090 }
12091
12092 static int test_is_file_0 (void)
12093 {
12094   if (test_is_file_0_skip ()) {
12095     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12096     return 0;
12097   }
12098
12099   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12100   {
12101     char device[] = "/dev/sda";
12102     device[5] = devchar;
12103     int r;
12104     suppress_error = 0;
12105     r = guestfs_blockdev_setrw (g, device);
12106     if (r == -1)
12107       return -1;
12108   }
12109   {
12110     int r;
12111     suppress_error = 0;
12112     r = guestfs_umount_all (g);
12113     if (r == -1)
12114       return -1;
12115   }
12116   {
12117     int r;
12118     suppress_error = 0;
12119     r = guestfs_lvm_remove_all (g);
12120     if (r == -1)
12121       return -1;
12122   }
12123   {
12124     char device[] = "/dev/sda";
12125     device[5] = devchar;
12126     char lines_0[] = ",";
12127     char *lines[] = {
12128       lines_0,
12129       NULL
12130     };
12131     int r;
12132     suppress_error = 0;
12133     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12134     if (r == -1)
12135       return -1;
12136   }
12137   {
12138     char fstype[] = "ext2";
12139     char device[] = "/dev/sda1";
12140     device[5] = devchar;
12141     int r;
12142     suppress_error = 0;
12143     r = guestfs_mkfs (g, fstype, device);
12144     if (r == -1)
12145       return -1;
12146   }
12147   {
12148     char device[] = "/dev/sda1";
12149     device[5] = devchar;
12150     char mountpoint[] = "/";
12151     int r;
12152     suppress_error = 0;
12153     r = guestfs_mount (g, device, mountpoint);
12154     if (r == -1)
12155       return -1;
12156   }
12157   /* TestOutputTrue for is_file (0) */
12158   {
12159     char path[] = "/new";
12160     int r;
12161     suppress_error = 0;
12162     r = guestfs_touch (g, path);
12163     if (r == -1)
12164       return -1;
12165   }
12166   {
12167     char path[] = "/new";
12168     int r;
12169     suppress_error = 0;
12170     r = guestfs_is_file (g, path);
12171     if (r == -1)
12172       return -1;
12173     if (!r) {
12174       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12175       return -1;
12176     }
12177   }
12178   return 0;
12179 }
12180
12181 static int test_is_file_1_skip (void)
12182 {
12183   const char *str;
12184
12185   str = getenv ("SKIP_TEST_IS_FILE_1");
12186   if (str && strcmp (str, "1") == 0) return 1;
12187   str = getenv ("SKIP_TEST_IS_FILE");
12188   if (str && strcmp (str, "1") == 0) return 1;
12189   return 0;
12190 }
12191
12192 static int test_is_file_1 (void)
12193 {
12194   if (test_is_file_1_skip ()) {
12195     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12196     return 0;
12197   }
12198
12199   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12200   {
12201     char device[] = "/dev/sda";
12202     device[5] = devchar;
12203     int r;
12204     suppress_error = 0;
12205     r = guestfs_blockdev_setrw (g, device);
12206     if (r == -1)
12207       return -1;
12208   }
12209   {
12210     int r;
12211     suppress_error = 0;
12212     r = guestfs_umount_all (g);
12213     if (r == -1)
12214       return -1;
12215   }
12216   {
12217     int r;
12218     suppress_error = 0;
12219     r = guestfs_lvm_remove_all (g);
12220     if (r == -1)
12221       return -1;
12222   }
12223   {
12224     char device[] = "/dev/sda";
12225     device[5] = devchar;
12226     char lines_0[] = ",";
12227     char *lines[] = {
12228       lines_0,
12229       NULL
12230     };
12231     int r;
12232     suppress_error = 0;
12233     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12234     if (r == -1)
12235       return -1;
12236   }
12237   {
12238     char fstype[] = "ext2";
12239     char device[] = "/dev/sda1";
12240     device[5] = devchar;
12241     int r;
12242     suppress_error = 0;
12243     r = guestfs_mkfs (g, fstype, device);
12244     if (r == -1)
12245       return -1;
12246   }
12247   {
12248     char device[] = "/dev/sda1";
12249     device[5] = devchar;
12250     char mountpoint[] = "/";
12251     int r;
12252     suppress_error = 0;
12253     r = guestfs_mount (g, device, mountpoint);
12254     if (r == -1)
12255       return -1;
12256   }
12257   /* TestOutputFalse for is_file (1) */
12258   {
12259     char path[] = "/new";
12260     int r;
12261     suppress_error = 0;
12262     r = guestfs_mkdir (g, path);
12263     if (r == -1)
12264       return -1;
12265   }
12266   {
12267     char path[] = "/new";
12268     int r;
12269     suppress_error = 0;
12270     r = guestfs_is_file (g, path);
12271     if (r == -1)
12272       return -1;
12273     if (r) {
12274       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12275       return -1;
12276     }
12277   }
12278   return 0;
12279 }
12280
12281 static int test_exists_0_skip (void)
12282 {
12283   const char *str;
12284
12285   str = getenv ("SKIP_TEST_EXISTS_0");
12286   if (str && strcmp (str, "1") == 0) return 1;
12287   str = getenv ("SKIP_TEST_EXISTS");
12288   if (str && strcmp (str, "1") == 0) return 1;
12289   return 0;
12290 }
12291
12292 static int test_exists_0 (void)
12293 {
12294   if (test_exists_0_skip ()) {
12295     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12296     return 0;
12297   }
12298
12299   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12300   {
12301     char device[] = "/dev/sda";
12302     device[5] = devchar;
12303     int r;
12304     suppress_error = 0;
12305     r = guestfs_blockdev_setrw (g, device);
12306     if (r == -1)
12307       return -1;
12308   }
12309   {
12310     int r;
12311     suppress_error = 0;
12312     r = guestfs_umount_all (g);
12313     if (r == -1)
12314       return -1;
12315   }
12316   {
12317     int r;
12318     suppress_error = 0;
12319     r = guestfs_lvm_remove_all (g);
12320     if (r == -1)
12321       return -1;
12322   }
12323   {
12324     char device[] = "/dev/sda";
12325     device[5] = devchar;
12326     char lines_0[] = ",";
12327     char *lines[] = {
12328       lines_0,
12329       NULL
12330     };
12331     int r;
12332     suppress_error = 0;
12333     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12334     if (r == -1)
12335       return -1;
12336   }
12337   {
12338     char fstype[] = "ext2";
12339     char device[] = "/dev/sda1";
12340     device[5] = devchar;
12341     int r;
12342     suppress_error = 0;
12343     r = guestfs_mkfs (g, fstype, device);
12344     if (r == -1)
12345       return -1;
12346   }
12347   {
12348     char device[] = "/dev/sda1";
12349     device[5] = devchar;
12350     char mountpoint[] = "/";
12351     int r;
12352     suppress_error = 0;
12353     r = guestfs_mount (g, device, mountpoint);
12354     if (r == -1)
12355       return -1;
12356   }
12357   /* TestOutputTrue for exists (0) */
12358   {
12359     char path[] = "/new";
12360     int r;
12361     suppress_error = 0;
12362     r = guestfs_touch (g, path);
12363     if (r == -1)
12364       return -1;
12365   }
12366   {
12367     char path[] = "/new";
12368     int r;
12369     suppress_error = 0;
12370     r = guestfs_exists (g, path);
12371     if (r == -1)
12372       return -1;
12373     if (!r) {
12374       fprintf (stderr, "test_exists_0: expected true, got false\n");
12375       return -1;
12376     }
12377   }
12378   return 0;
12379 }
12380
12381 static int test_exists_1_skip (void)
12382 {
12383   const char *str;
12384
12385   str = getenv ("SKIP_TEST_EXISTS_1");
12386   if (str && strcmp (str, "1") == 0) return 1;
12387   str = getenv ("SKIP_TEST_EXISTS");
12388   if (str && strcmp (str, "1") == 0) return 1;
12389   return 0;
12390 }
12391
12392 static int test_exists_1 (void)
12393 {
12394   if (test_exists_1_skip ()) {
12395     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12396     return 0;
12397   }
12398
12399   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12400   {
12401     char device[] = "/dev/sda";
12402     device[5] = devchar;
12403     int r;
12404     suppress_error = 0;
12405     r = guestfs_blockdev_setrw (g, device);
12406     if (r == -1)
12407       return -1;
12408   }
12409   {
12410     int r;
12411     suppress_error = 0;
12412     r = guestfs_umount_all (g);
12413     if (r == -1)
12414       return -1;
12415   }
12416   {
12417     int r;
12418     suppress_error = 0;
12419     r = guestfs_lvm_remove_all (g);
12420     if (r == -1)
12421       return -1;
12422   }
12423   {
12424     char device[] = "/dev/sda";
12425     device[5] = devchar;
12426     char lines_0[] = ",";
12427     char *lines[] = {
12428       lines_0,
12429       NULL
12430     };
12431     int r;
12432     suppress_error = 0;
12433     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12434     if (r == -1)
12435       return -1;
12436   }
12437   {
12438     char fstype[] = "ext2";
12439     char device[] = "/dev/sda1";
12440     device[5] = devchar;
12441     int r;
12442     suppress_error = 0;
12443     r = guestfs_mkfs (g, fstype, device);
12444     if (r == -1)
12445       return -1;
12446   }
12447   {
12448     char device[] = "/dev/sda1";
12449     device[5] = devchar;
12450     char mountpoint[] = "/";
12451     int r;
12452     suppress_error = 0;
12453     r = guestfs_mount (g, device, mountpoint);
12454     if (r == -1)
12455       return -1;
12456   }
12457   /* TestOutputTrue for exists (1) */
12458   {
12459     char path[] = "/new";
12460     int r;
12461     suppress_error = 0;
12462     r = guestfs_mkdir (g, path);
12463     if (r == -1)
12464       return -1;
12465   }
12466   {
12467     char path[] = "/new";
12468     int r;
12469     suppress_error = 0;
12470     r = guestfs_exists (g, path);
12471     if (r == -1)
12472       return -1;
12473     if (!r) {
12474       fprintf (stderr, "test_exists_1: expected true, got false\n");
12475       return -1;
12476     }
12477   }
12478   return 0;
12479 }
12480
12481 static int test_mkdir_p_0_skip (void)
12482 {
12483   const char *str;
12484
12485   str = getenv ("SKIP_TEST_MKDIR_P_0");
12486   if (str && strcmp (str, "1") == 0) return 1;
12487   str = getenv ("SKIP_TEST_MKDIR_P");
12488   if (str && strcmp (str, "1") == 0) return 1;
12489   return 0;
12490 }
12491
12492 static int test_mkdir_p_0 (void)
12493 {
12494   if (test_mkdir_p_0_skip ()) {
12495     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12496     return 0;
12497   }
12498
12499   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12500   {
12501     char device[] = "/dev/sda";
12502     device[5] = devchar;
12503     int r;
12504     suppress_error = 0;
12505     r = guestfs_blockdev_setrw (g, device);
12506     if (r == -1)
12507       return -1;
12508   }
12509   {
12510     int r;
12511     suppress_error = 0;
12512     r = guestfs_umount_all (g);
12513     if (r == -1)
12514       return -1;
12515   }
12516   {
12517     int r;
12518     suppress_error = 0;
12519     r = guestfs_lvm_remove_all (g);
12520     if (r == -1)
12521       return -1;
12522   }
12523   {
12524     char device[] = "/dev/sda";
12525     device[5] = devchar;
12526     char lines_0[] = ",";
12527     char *lines[] = {
12528       lines_0,
12529       NULL
12530     };
12531     int r;
12532     suppress_error = 0;
12533     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12534     if (r == -1)
12535       return -1;
12536   }
12537   {
12538     char fstype[] = "ext2";
12539     char device[] = "/dev/sda1";
12540     device[5] = devchar;
12541     int r;
12542     suppress_error = 0;
12543     r = guestfs_mkfs (g, fstype, device);
12544     if (r == -1)
12545       return -1;
12546   }
12547   {
12548     char device[] = "/dev/sda1";
12549     device[5] = devchar;
12550     char mountpoint[] = "/";
12551     int r;
12552     suppress_error = 0;
12553     r = guestfs_mount (g, device, mountpoint);
12554     if (r == -1)
12555       return -1;
12556   }
12557   /* TestOutputTrue for mkdir_p (0) */
12558   {
12559     char path[] = "/new/foo/bar";
12560     int r;
12561     suppress_error = 0;
12562     r = guestfs_mkdir_p (g, path);
12563     if (r == -1)
12564       return -1;
12565   }
12566   {
12567     char path[] = "/new/foo/bar";
12568     int r;
12569     suppress_error = 0;
12570     r = guestfs_is_dir (g, path);
12571     if (r == -1)
12572       return -1;
12573     if (!r) {
12574       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12575       return -1;
12576     }
12577   }
12578   return 0;
12579 }
12580
12581 static int test_mkdir_p_1_skip (void)
12582 {
12583   const char *str;
12584
12585   str = getenv ("SKIP_TEST_MKDIR_P_1");
12586   if (str && strcmp (str, "1") == 0) return 1;
12587   str = getenv ("SKIP_TEST_MKDIR_P");
12588   if (str && strcmp (str, "1") == 0) return 1;
12589   return 0;
12590 }
12591
12592 static int test_mkdir_p_1 (void)
12593 {
12594   if (test_mkdir_p_1_skip ()) {
12595     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12596     return 0;
12597   }
12598
12599   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12600   {
12601     char device[] = "/dev/sda";
12602     device[5] = devchar;
12603     int r;
12604     suppress_error = 0;
12605     r = guestfs_blockdev_setrw (g, device);
12606     if (r == -1)
12607       return -1;
12608   }
12609   {
12610     int r;
12611     suppress_error = 0;
12612     r = guestfs_umount_all (g);
12613     if (r == -1)
12614       return -1;
12615   }
12616   {
12617     int r;
12618     suppress_error = 0;
12619     r = guestfs_lvm_remove_all (g);
12620     if (r == -1)
12621       return -1;
12622   }
12623   {
12624     char device[] = "/dev/sda";
12625     device[5] = devchar;
12626     char lines_0[] = ",";
12627     char *lines[] = {
12628       lines_0,
12629       NULL
12630     };
12631     int r;
12632     suppress_error = 0;
12633     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12634     if (r == -1)
12635       return -1;
12636   }
12637   {
12638     char fstype[] = "ext2";
12639     char device[] = "/dev/sda1";
12640     device[5] = devchar;
12641     int r;
12642     suppress_error = 0;
12643     r = guestfs_mkfs (g, fstype, device);
12644     if (r == -1)
12645       return -1;
12646   }
12647   {
12648     char device[] = "/dev/sda1";
12649     device[5] = devchar;
12650     char mountpoint[] = "/";
12651     int r;
12652     suppress_error = 0;
12653     r = guestfs_mount (g, device, mountpoint);
12654     if (r == -1)
12655       return -1;
12656   }
12657   /* TestOutputTrue for mkdir_p (1) */
12658   {
12659     char path[] = "/new/foo/bar";
12660     int r;
12661     suppress_error = 0;
12662     r = guestfs_mkdir_p (g, path);
12663     if (r == -1)
12664       return -1;
12665   }
12666   {
12667     char path[] = "/new/foo";
12668     int r;
12669     suppress_error = 0;
12670     r = guestfs_is_dir (g, path);
12671     if (r == -1)
12672       return -1;
12673     if (!r) {
12674       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12675       return -1;
12676     }
12677   }
12678   return 0;
12679 }
12680
12681 static int test_mkdir_p_2_skip (void)
12682 {
12683   const char *str;
12684
12685   str = getenv ("SKIP_TEST_MKDIR_P_2");
12686   if (str && strcmp (str, "1") == 0) return 1;
12687   str = getenv ("SKIP_TEST_MKDIR_P");
12688   if (str && strcmp (str, "1") == 0) return 1;
12689   return 0;
12690 }
12691
12692 static int test_mkdir_p_2 (void)
12693 {
12694   if (test_mkdir_p_2_skip ()) {
12695     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12696     return 0;
12697   }
12698
12699   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12700   {
12701     char device[] = "/dev/sda";
12702     device[5] = devchar;
12703     int r;
12704     suppress_error = 0;
12705     r = guestfs_blockdev_setrw (g, device);
12706     if (r == -1)
12707       return -1;
12708   }
12709   {
12710     int r;
12711     suppress_error = 0;
12712     r = guestfs_umount_all (g);
12713     if (r == -1)
12714       return -1;
12715   }
12716   {
12717     int r;
12718     suppress_error = 0;
12719     r = guestfs_lvm_remove_all (g);
12720     if (r == -1)
12721       return -1;
12722   }
12723   {
12724     char device[] = "/dev/sda";
12725     device[5] = devchar;
12726     char lines_0[] = ",";
12727     char *lines[] = {
12728       lines_0,
12729       NULL
12730     };
12731     int r;
12732     suppress_error = 0;
12733     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12734     if (r == -1)
12735       return -1;
12736   }
12737   {
12738     char fstype[] = "ext2";
12739     char device[] = "/dev/sda1";
12740     device[5] = devchar;
12741     int r;
12742     suppress_error = 0;
12743     r = guestfs_mkfs (g, fstype, device);
12744     if (r == -1)
12745       return -1;
12746   }
12747   {
12748     char device[] = "/dev/sda1";
12749     device[5] = devchar;
12750     char mountpoint[] = "/";
12751     int r;
12752     suppress_error = 0;
12753     r = guestfs_mount (g, device, mountpoint);
12754     if (r == -1)
12755       return -1;
12756   }
12757   /* TestOutputTrue for mkdir_p (2) */
12758   {
12759     char path[] = "/new/foo/bar";
12760     int r;
12761     suppress_error = 0;
12762     r = guestfs_mkdir_p (g, path);
12763     if (r == -1)
12764       return -1;
12765   }
12766   {
12767     char path[] = "/new";
12768     int r;
12769     suppress_error = 0;
12770     r = guestfs_is_dir (g, path);
12771     if (r == -1)
12772       return -1;
12773     if (!r) {
12774       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12775       return -1;
12776     }
12777   }
12778   return 0;
12779 }
12780
12781 static int test_mkdir_0_skip (void)
12782 {
12783   const char *str;
12784
12785   str = getenv ("SKIP_TEST_MKDIR_0");
12786   if (str && strcmp (str, "1") == 0) return 1;
12787   str = getenv ("SKIP_TEST_MKDIR");
12788   if (str && strcmp (str, "1") == 0) return 1;
12789   return 0;
12790 }
12791
12792 static int test_mkdir_0 (void)
12793 {
12794   if (test_mkdir_0_skip ()) {
12795     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
12796     return 0;
12797   }
12798
12799   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
12800   {
12801     char device[] = "/dev/sda";
12802     device[5] = devchar;
12803     int r;
12804     suppress_error = 0;
12805     r = guestfs_blockdev_setrw (g, device);
12806     if (r == -1)
12807       return -1;
12808   }
12809   {
12810     int r;
12811     suppress_error = 0;
12812     r = guestfs_umount_all (g);
12813     if (r == -1)
12814       return -1;
12815   }
12816   {
12817     int r;
12818     suppress_error = 0;
12819     r = guestfs_lvm_remove_all (g);
12820     if (r == -1)
12821       return -1;
12822   }
12823   {
12824     char device[] = "/dev/sda";
12825     device[5] = devchar;
12826     char lines_0[] = ",";
12827     char *lines[] = {
12828       lines_0,
12829       NULL
12830     };
12831     int r;
12832     suppress_error = 0;
12833     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12834     if (r == -1)
12835       return -1;
12836   }
12837   {
12838     char fstype[] = "ext2";
12839     char device[] = "/dev/sda1";
12840     device[5] = devchar;
12841     int r;
12842     suppress_error = 0;
12843     r = guestfs_mkfs (g, fstype, device);
12844     if (r == -1)
12845       return -1;
12846   }
12847   {
12848     char device[] = "/dev/sda1";
12849     device[5] = devchar;
12850     char mountpoint[] = "/";
12851     int r;
12852     suppress_error = 0;
12853     r = guestfs_mount (g, device, mountpoint);
12854     if (r == -1)
12855       return -1;
12856   }
12857   /* TestOutputTrue for mkdir (0) */
12858   {
12859     char path[] = "/new";
12860     int r;
12861     suppress_error = 0;
12862     r = guestfs_mkdir (g, path);
12863     if (r == -1)
12864       return -1;
12865   }
12866   {
12867     char path[] = "/new";
12868     int r;
12869     suppress_error = 0;
12870     r = guestfs_is_dir (g, path);
12871     if (r == -1)
12872       return -1;
12873     if (!r) {
12874       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
12875       return -1;
12876     }
12877   }
12878   return 0;
12879 }
12880
12881 static int test_mkdir_1_skip (void)
12882 {
12883   const char *str;
12884
12885   str = getenv ("SKIP_TEST_MKDIR_1");
12886   if (str && strcmp (str, "1") == 0) return 1;
12887   str = getenv ("SKIP_TEST_MKDIR");
12888   if (str && strcmp (str, "1") == 0) return 1;
12889   return 0;
12890 }
12891
12892 static int test_mkdir_1 (void)
12893 {
12894   if (test_mkdir_1_skip ()) {
12895     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
12896     return 0;
12897   }
12898
12899   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
12900   {
12901     char device[] = "/dev/sda";
12902     device[5] = devchar;
12903     int r;
12904     suppress_error = 0;
12905     r = guestfs_blockdev_setrw (g, device);
12906     if (r == -1)
12907       return -1;
12908   }
12909   {
12910     int r;
12911     suppress_error = 0;
12912     r = guestfs_umount_all (g);
12913     if (r == -1)
12914       return -1;
12915   }
12916   {
12917     int r;
12918     suppress_error = 0;
12919     r = guestfs_lvm_remove_all (g);
12920     if (r == -1)
12921       return -1;
12922   }
12923   {
12924     char device[] = "/dev/sda";
12925     device[5] = devchar;
12926     char lines_0[] = ",";
12927     char *lines[] = {
12928       lines_0,
12929       NULL
12930     };
12931     int r;
12932     suppress_error = 0;
12933     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12934     if (r == -1)
12935       return -1;
12936   }
12937   {
12938     char fstype[] = "ext2";
12939     char device[] = "/dev/sda1";
12940     device[5] = devchar;
12941     int r;
12942     suppress_error = 0;
12943     r = guestfs_mkfs (g, fstype, device);
12944     if (r == -1)
12945       return -1;
12946   }
12947   {
12948     char device[] = "/dev/sda1";
12949     device[5] = devchar;
12950     char mountpoint[] = "/";
12951     int r;
12952     suppress_error = 0;
12953     r = guestfs_mount (g, device, mountpoint);
12954     if (r == -1)
12955       return -1;
12956   }
12957   /* TestLastFail for mkdir (1) */
12958   {
12959     char path[] = "/new/foo/bar";
12960     int r;
12961     suppress_error = 1;
12962     r = guestfs_mkdir (g, path);
12963     if (r != -1)
12964       return -1;
12965   }
12966   return 0;
12967 }
12968
12969 static int test_rm_rf_0_skip (void)
12970 {
12971   const char *str;
12972
12973   str = getenv ("SKIP_TEST_RM_RF_0");
12974   if (str && strcmp (str, "1") == 0) return 1;
12975   str = getenv ("SKIP_TEST_RM_RF");
12976   if (str && strcmp (str, "1") == 0) return 1;
12977   return 0;
12978 }
12979
12980 static int test_rm_rf_0 (void)
12981 {
12982   if (test_rm_rf_0_skip ()) {
12983     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
12984     return 0;
12985   }
12986
12987   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
12988   {
12989     char device[] = "/dev/sda";
12990     device[5] = devchar;
12991     int r;
12992     suppress_error = 0;
12993     r = guestfs_blockdev_setrw (g, device);
12994     if (r == -1)
12995       return -1;
12996   }
12997   {
12998     int r;
12999     suppress_error = 0;
13000     r = guestfs_umount_all (g);
13001     if (r == -1)
13002       return -1;
13003   }
13004   {
13005     int r;
13006     suppress_error = 0;
13007     r = guestfs_lvm_remove_all (g);
13008     if (r == -1)
13009       return -1;
13010   }
13011   {
13012     char device[] = "/dev/sda";
13013     device[5] = devchar;
13014     char lines_0[] = ",";
13015     char *lines[] = {
13016       lines_0,
13017       NULL
13018     };
13019     int r;
13020     suppress_error = 0;
13021     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13022     if (r == -1)
13023       return -1;
13024   }
13025   {
13026     char fstype[] = "ext2";
13027     char device[] = "/dev/sda1";
13028     device[5] = devchar;
13029     int r;
13030     suppress_error = 0;
13031     r = guestfs_mkfs (g, fstype, device);
13032     if (r == -1)
13033       return -1;
13034   }
13035   {
13036     char device[] = "/dev/sda1";
13037     device[5] = devchar;
13038     char mountpoint[] = "/";
13039     int r;
13040     suppress_error = 0;
13041     r = guestfs_mount (g, device, mountpoint);
13042     if (r == -1)
13043       return -1;
13044   }
13045   /* TestOutputFalse for rm_rf (0) */
13046   {
13047     char path[] = "/new";
13048     int r;
13049     suppress_error = 0;
13050     r = guestfs_mkdir (g, path);
13051     if (r == -1)
13052       return -1;
13053   }
13054   {
13055     char path[] = "/new/foo";
13056     int r;
13057     suppress_error = 0;
13058     r = guestfs_mkdir (g, path);
13059     if (r == -1)
13060       return -1;
13061   }
13062   {
13063     char path[] = "/new/foo/bar";
13064     int r;
13065     suppress_error = 0;
13066     r = guestfs_touch (g, path);
13067     if (r == -1)
13068       return -1;
13069   }
13070   {
13071     char path[] = "/new";
13072     int r;
13073     suppress_error = 0;
13074     r = guestfs_rm_rf (g, path);
13075     if (r == -1)
13076       return -1;
13077   }
13078   {
13079     char path[] = "/new";
13080     int r;
13081     suppress_error = 0;
13082     r = guestfs_exists (g, path);
13083     if (r == -1)
13084       return -1;
13085     if (r) {
13086       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13087       return -1;
13088     }
13089   }
13090   return 0;
13091 }
13092
13093 static int test_rmdir_0_skip (void)
13094 {
13095   const char *str;
13096
13097   str = getenv ("SKIP_TEST_RMDIR_0");
13098   if (str && strcmp (str, "1") == 0) return 1;
13099   str = getenv ("SKIP_TEST_RMDIR");
13100   if (str && strcmp (str, "1") == 0) return 1;
13101   return 0;
13102 }
13103
13104 static int test_rmdir_0 (void)
13105 {
13106   if (test_rmdir_0_skip ()) {
13107     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13108     return 0;
13109   }
13110
13111   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13112   {
13113     char device[] = "/dev/sda";
13114     device[5] = devchar;
13115     int r;
13116     suppress_error = 0;
13117     r = guestfs_blockdev_setrw (g, device);
13118     if (r == -1)
13119       return -1;
13120   }
13121   {
13122     int r;
13123     suppress_error = 0;
13124     r = guestfs_umount_all (g);
13125     if (r == -1)
13126       return -1;
13127   }
13128   {
13129     int r;
13130     suppress_error = 0;
13131     r = guestfs_lvm_remove_all (g);
13132     if (r == -1)
13133       return -1;
13134   }
13135   {
13136     char device[] = "/dev/sda";
13137     device[5] = devchar;
13138     char lines_0[] = ",";
13139     char *lines[] = {
13140       lines_0,
13141       NULL
13142     };
13143     int r;
13144     suppress_error = 0;
13145     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13146     if (r == -1)
13147       return -1;
13148   }
13149   {
13150     char fstype[] = "ext2";
13151     char device[] = "/dev/sda1";
13152     device[5] = devchar;
13153     int r;
13154     suppress_error = 0;
13155     r = guestfs_mkfs (g, fstype, device);
13156     if (r == -1)
13157       return -1;
13158   }
13159   {
13160     char device[] = "/dev/sda1";
13161     device[5] = devchar;
13162     char mountpoint[] = "/";
13163     int r;
13164     suppress_error = 0;
13165     r = guestfs_mount (g, device, mountpoint);
13166     if (r == -1)
13167       return -1;
13168   }
13169   /* TestRun for rmdir (0) */
13170   {
13171     char path[] = "/new";
13172     int r;
13173     suppress_error = 0;
13174     r = guestfs_mkdir (g, path);
13175     if (r == -1)
13176       return -1;
13177   }
13178   {
13179     char path[] = "/new";
13180     int r;
13181     suppress_error = 0;
13182     r = guestfs_rmdir (g, path);
13183     if (r == -1)
13184       return -1;
13185   }
13186   return 0;
13187 }
13188
13189 static int test_rmdir_1_skip (void)
13190 {
13191   const char *str;
13192
13193   str = getenv ("SKIP_TEST_RMDIR_1");
13194   if (str && strcmp (str, "1") == 0) return 1;
13195   str = getenv ("SKIP_TEST_RMDIR");
13196   if (str && strcmp (str, "1") == 0) return 1;
13197   return 0;
13198 }
13199
13200 static int test_rmdir_1 (void)
13201 {
13202   if (test_rmdir_1_skip ()) {
13203     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13204     return 0;
13205   }
13206
13207   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13208   {
13209     char device[] = "/dev/sda";
13210     device[5] = devchar;
13211     int r;
13212     suppress_error = 0;
13213     r = guestfs_blockdev_setrw (g, device);
13214     if (r == -1)
13215       return -1;
13216   }
13217   {
13218     int r;
13219     suppress_error = 0;
13220     r = guestfs_umount_all (g);
13221     if (r == -1)
13222       return -1;
13223   }
13224   {
13225     int r;
13226     suppress_error = 0;
13227     r = guestfs_lvm_remove_all (g);
13228     if (r == -1)
13229       return -1;
13230   }
13231   {
13232     char device[] = "/dev/sda";
13233     device[5] = devchar;
13234     char lines_0[] = ",";
13235     char *lines[] = {
13236       lines_0,
13237       NULL
13238     };
13239     int r;
13240     suppress_error = 0;
13241     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13242     if (r == -1)
13243       return -1;
13244   }
13245   {
13246     char fstype[] = "ext2";
13247     char device[] = "/dev/sda1";
13248     device[5] = devchar;
13249     int r;
13250     suppress_error = 0;
13251     r = guestfs_mkfs (g, fstype, device);
13252     if (r == -1)
13253       return -1;
13254   }
13255   {
13256     char device[] = "/dev/sda1";
13257     device[5] = devchar;
13258     char mountpoint[] = "/";
13259     int r;
13260     suppress_error = 0;
13261     r = guestfs_mount (g, device, mountpoint);
13262     if (r == -1)
13263       return -1;
13264   }
13265   /* TestLastFail for rmdir (1) */
13266   {
13267     char path[] = "/new";
13268     int r;
13269     suppress_error = 1;
13270     r = guestfs_rmdir (g, path);
13271     if (r != -1)
13272       return -1;
13273   }
13274   return 0;
13275 }
13276
13277 static int test_rmdir_2_skip (void)
13278 {
13279   const char *str;
13280
13281   str = getenv ("SKIP_TEST_RMDIR_2");
13282   if (str && strcmp (str, "1") == 0) return 1;
13283   str = getenv ("SKIP_TEST_RMDIR");
13284   if (str && strcmp (str, "1") == 0) return 1;
13285   return 0;
13286 }
13287
13288 static int test_rmdir_2 (void)
13289 {
13290   if (test_rmdir_2_skip ()) {
13291     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13292     return 0;
13293   }
13294
13295   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13296   {
13297     char device[] = "/dev/sda";
13298     device[5] = devchar;
13299     int r;
13300     suppress_error = 0;
13301     r = guestfs_blockdev_setrw (g, device);
13302     if (r == -1)
13303       return -1;
13304   }
13305   {
13306     int r;
13307     suppress_error = 0;
13308     r = guestfs_umount_all (g);
13309     if (r == -1)
13310       return -1;
13311   }
13312   {
13313     int r;
13314     suppress_error = 0;
13315     r = guestfs_lvm_remove_all (g);
13316     if (r == -1)
13317       return -1;
13318   }
13319   {
13320     char device[] = "/dev/sda";
13321     device[5] = devchar;
13322     char lines_0[] = ",";
13323     char *lines[] = {
13324       lines_0,
13325       NULL
13326     };
13327     int r;
13328     suppress_error = 0;
13329     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13330     if (r == -1)
13331       return -1;
13332   }
13333   {
13334     char fstype[] = "ext2";
13335     char device[] = "/dev/sda1";
13336     device[5] = devchar;
13337     int r;
13338     suppress_error = 0;
13339     r = guestfs_mkfs (g, fstype, device);
13340     if (r == -1)
13341       return -1;
13342   }
13343   {
13344     char device[] = "/dev/sda1";
13345     device[5] = devchar;
13346     char mountpoint[] = "/";
13347     int r;
13348     suppress_error = 0;
13349     r = guestfs_mount (g, device, mountpoint);
13350     if (r == -1)
13351       return -1;
13352   }
13353   /* TestLastFail for rmdir (2) */
13354   {
13355     char path[] = "/new";
13356     int r;
13357     suppress_error = 0;
13358     r = guestfs_touch (g, path);
13359     if (r == -1)
13360       return -1;
13361   }
13362   {
13363     char path[] = "/new";
13364     int r;
13365     suppress_error = 1;
13366     r = guestfs_rmdir (g, path);
13367     if (r != -1)
13368       return -1;
13369   }
13370   return 0;
13371 }
13372
13373 static int test_rm_0_skip (void)
13374 {
13375   const char *str;
13376
13377   str = getenv ("SKIP_TEST_RM_0");
13378   if (str && strcmp (str, "1") == 0) return 1;
13379   str = getenv ("SKIP_TEST_RM");
13380   if (str && strcmp (str, "1") == 0) return 1;
13381   return 0;
13382 }
13383
13384 static int test_rm_0 (void)
13385 {
13386   if (test_rm_0_skip ()) {
13387     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13388     return 0;
13389   }
13390
13391   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13392   {
13393     char device[] = "/dev/sda";
13394     device[5] = devchar;
13395     int r;
13396     suppress_error = 0;
13397     r = guestfs_blockdev_setrw (g, device);
13398     if (r == -1)
13399       return -1;
13400   }
13401   {
13402     int r;
13403     suppress_error = 0;
13404     r = guestfs_umount_all (g);
13405     if (r == -1)
13406       return -1;
13407   }
13408   {
13409     int r;
13410     suppress_error = 0;
13411     r = guestfs_lvm_remove_all (g);
13412     if (r == -1)
13413       return -1;
13414   }
13415   {
13416     char device[] = "/dev/sda";
13417     device[5] = devchar;
13418     char lines_0[] = ",";
13419     char *lines[] = {
13420       lines_0,
13421       NULL
13422     };
13423     int r;
13424     suppress_error = 0;
13425     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13426     if (r == -1)
13427       return -1;
13428   }
13429   {
13430     char fstype[] = "ext2";
13431     char device[] = "/dev/sda1";
13432     device[5] = devchar;
13433     int r;
13434     suppress_error = 0;
13435     r = guestfs_mkfs (g, fstype, device);
13436     if (r == -1)
13437       return -1;
13438   }
13439   {
13440     char device[] = "/dev/sda1";
13441     device[5] = devchar;
13442     char mountpoint[] = "/";
13443     int r;
13444     suppress_error = 0;
13445     r = guestfs_mount (g, device, mountpoint);
13446     if (r == -1)
13447       return -1;
13448   }
13449   /* TestRun for rm (0) */
13450   {
13451     char path[] = "/new";
13452     int r;
13453     suppress_error = 0;
13454     r = guestfs_touch (g, path);
13455     if (r == -1)
13456       return -1;
13457   }
13458   {
13459     char path[] = "/new";
13460     int r;
13461     suppress_error = 0;
13462     r = guestfs_rm (g, path);
13463     if (r == -1)
13464       return -1;
13465   }
13466   return 0;
13467 }
13468
13469 static int test_rm_1_skip (void)
13470 {
13471   const char *str;
13472
13473   str = getenv ("SKIP_TEST_RM_1");
13474   if (str && strcmp (str, "1") == 0) return 1;
13475   str = getenv ("SKIP_TEST_RM");
13476   if (str && strcmp (str, "1") == 0) return 1;
13477   return 0;
13478 }
13479
13480 static int test_rm_1 (void)
13481 {
13482   if (test_rm_1_skip ()) {
13483     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13484     return 0;
13485   }
13486
13487   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13488   {
13489     char device[] = "/dev/sda";
13490     device[5] = devchar;
13491     int r;
13492     suppress_error = 0;
13493     r = guestfs_blockdev_setrw (g, device);
13494     if (r == -1)
13495       return -1;
13496   }
13497   {
13498     int r;
13499     suppress_error = 0;
13500     r = guestfs_umount_all (g);
13501     if (r == -1)
13502       return -1;
13503   }
13504   {
13505     int r;
13506     suppress_error = 0;
13507     r = guestfs_lvm_remove_all (g);
13508     if (r == -1)
13509       return -1;
13510   }
13511   {
13512     char device[] = "/dev/sda";
13513     device[5] = devchar;
13514     char lines_0[] = ",";
13515     char *lines[] = {
13516       lines_0,
13517       NULL
13518     };
13519     int r;
13520     suppress_error = 0;
13521     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13522     if (r == -1)
13523       return -1;
13524   }
13525   {
13526     char fstype[] = "ext2";
13527     char device[] = "/dev/sda1";
13528     device[5] = devchar;
13529     int r;
13530     suppress_error = 0;
13531     r = guestfs_mkfs (g, fstype, device);
13532     if (r == -1)
13533       return -1;
13534   }
13535   {
13536     char device[] = "/dev/sda1";
13537     device[5] = devchar;
13538     char mountpoint[] = "/";
13539     int r;
13540     suppress_error = 0;
13541     r = guestfs_mount (g, device, mountpoint);
13542     if (r == -1)
13543       return -1;
13544   }
13545   /* TestLastFail for rm (1) */
13546   {
13547     char path[] = "/new";
13548     int r;
13549     suppress_error = 1;
13550     r = guestfs_rm (g, path);
13551     if (r != -1)
13552       return -1;
13553   }
13554   return 0;
13555 }
13556
13557 static int test_rm_2_skip (void)
13558 {
13559   const char *str;
13560
13561   str = getenv ("SKIP_TEST_RM_2");
13562   if (str && strcmp (str, "1") == 0) return 1;
13563   str = getenv ("SKIP_TEST_RM");
13564   if (str && strcmp (str, "1") == 0) return 1;
13565   return 0;
13566 }
13567
13568 static int test_rm_2 (void)
13569 {
13570   if (test_rm_2_skip ()) {
13571     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13572     return 0;
13573   }
13574
13575   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13576   {
13577     char device[] = "/dev/sda";
13578     device[5] = devchar;
13579     int r;
13580     suppress_error = 0;
13581     r = guestfs_blockdev_setrw (g, device);
13582     if (r == -1)
13583       return -1;
13584   }
13585   {
13586     int r;
13587     suppress_error = 0;
13588     r = guestfs_umount_all (g);
13589     if (r == -1)
13590       return -1;
13591   }
13592   {
13593     int r;
13594     suppress_error = 0;
13595     r = guestfs_lvm_remove_all (g);
13596     if (r == -1)
13597       return -1;
13598   }
13599   {
13600     char device[] = "/dev/sda";
13601     device[5] = devchar;
13602     char lines_0[] = ",";
13603     char *lines[] = {
13604       lines_0,
13605       NULL
13606     };
13607     int r;
13608     suppress_error = 0;
13609     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13610     if (r == -1)
13611       return -1;
13612   }
13613   {
13614     char fstype[] = "ext2";
13615     char device[] = "/dev/sda1";
13616     device[5] = devchar;
13617     int r;
13618     suppress_error = 0;
13619     r = guestfs_mkfs (g, fstype, device);
13620     if (r == -1)
13621       return -1;
13622   }
13623   {
13624     char device[] = "/dev/sda1";
13625     device[5] = devchar;
13626     char mountpoint[] = "/";
13627     int r;
13628     suppress_error = 0;
13629     r = guestfs_mount (g, device, mountpoint);
13630     if (r == -1)
13631       return -1;
13632   }
13633   /* TestLastFail for rm (2) */
13634   {
13635     char path[] = "/new";
13636     int r;
13637     suppress_error = 0;
13638     r = guestfs_mkdir (g, path);
13639     if (r == -1)
13640       return -1;
13641   }
13642   {
13643     char path[] = "/new";
13644     int r;
13645     suppress_error = 1;
13646     r = guestfs_rm (g, path);
13647     if (r != -1)
13648       return -1;
13649   }
13650   return 0;
13651 }
13652
13653 static int test_read_lines_0_skip (void)
13654 {
13655   const char *str;
13656
13657   str = getenv ("SKIP_TEST_READ_LINES_0");
13658   if (str && strcmp (str, "1") == 0) return 1;
13659   str = getenv ("SKIP_TEST_READ_LINES");
13660   if (str && strcmp (str, "1") == 0) return 1;
13661   return 0;
13662 }
13663
13664 static int test_read_lines_0 (void)
13665 {
13666   if (test_read_lines_0_skip ()) {
13667     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13668     return 0;
13669   }
13670
13671   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13672   {
13673     char device[] = "/dev/sda";
13674     device[5] = devchar;
13675     int r;
13676     suppress_error = 0;
13677     r = guestfs_blockdev_setrw (g, device);
13678     if (r == -1)
13679       return -1;
13680   }
13681   {
13682     int r;
13683     suppress_error = 0;
13684     r = guestfs_umount_all (g);
13685     if (r == -1)
13686       return -1;
13687   }
13688   {
13689     int r;
13690     suppress_error = 0;
13691     r = guestfs_lvm_remove_all (g);
13692     if (r == -1)
13693       return -1;
13694   }
13695   {
13696     char device[] = "/dev/sda";
13697     device[5] = devchar;
13698     char lines_0[] = ",";
13699     char *lines[] = {
13700       lines_0,
13701       NULL
13702     };
13703     int r;
13704     suppress_error = 0;
13705     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13706     if (r == -1)
13707       return -1;
13708   }
13709   {
13710     char fstype[] = "ext2";
13711     char device[] = "/dev/sda1";
13712     device[5] = devchar;
13713     int r;
13714     suppress_error = 0;
13715     r = guestfs_mkfs (g, fstype, device);
13716     if (r == -1)
13717       return -1;
13718   }
13719   {
13720     char device[] = "/dev/sda1";
13721     device[5] = devchar;
13722     char mountpoint[] = "/";
13723     int r;
13724     suppress_error = 0;
13725     r = guestfs_mount (g, device, mountpoint);
13726     if (r == -1)
13727       return -1;
13728   }
13729   /* TestOutputList for read_lines (0) */
13730   {
13731     char path[] = "/new";
13732     char content[] = "line1\r\nline2\nline3";
13733     int r;
13734     suppress_error = 0;
13735     r = guestfs_write_file (g, path, content, 0);
13736     if (r == -1)
13737       return -1;
13738   }
13739   {
13740     char path[] = "/new";
13741     char **r;
13742     int i;
13743     suppress_error = 0;
13744     r = guestfs_read_lines (g, path);
13745     if (r == NULL)
13746       return -1;
13747     if (!r[0]) {
13748       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13749       print_strings (r);
13750       return -1;
13751     }
13752     {
13753       char expected[] = "line1";
13754       if (strcmp (r[0], expected) != 0) {
13755         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13756         return -1;
13757       }
13758     }
13759     if (!r[1]) {
13760       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13761       print_strings (r);
13762       return -1;
13763     }
13764     {
13765       char expected[] = "line2";
13766       if (strcmp (r[1], expected) != 0) {
13767         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13768         return -1;
13769       }
13770     }
13771     if (!r[2]) {
13772       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13773       print_strings (r);
13774       return -1;
13775     }
13776     {
13777       char expected[] = "line3";
13778       if (strcmp (r[2], expected) != 0) {
13779         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13780         return -1;
13781       }
13782     }
13783     if (r[3] != NULL) {
13784       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
13785       print_strings (r);
13786       return -1;
13787     }
13788     for (i = 0; r[i] != NULL; ++i)
13789       free (r[i]);
13790     free (r);
13791   }
13792   return 0;
13793 }
13794
13795 static int test_read_lines_1_skip (void)
13796 {
13797   const char *str;
13798
13799   str = getenv ("SKIP_TEST_READ_LINES_1");
13800   if (str && strcmp (str, "1") == 0) return 1;
13801   str = getenv ("SKIP_TEST_READ_LINES");
13802   if (str && strcmp (str, "1") == 0) return 1;
13803   return 0;
13804 }
13805
13806 static int test_read_lines_1 (void)
13807 {
13808   if (test_read_lines_1_skip ()) {
13809     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
13810     return 0;
13811   }
13812
13813   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
13814   {
13815     char device[] = "/dev/sda";
13816     device[5] = devchar;
13817     int r;
13818     suppress_error = 0;
13819     r = guestfs_blockdev_setrw (g, device);
13820     if (r == -1)
13821       return -1;
13822   }
13823   {
13824     int r;
13825     suppress_error = 0;
13826     r = guestfs_umount_all (g);
13827     if (r == -1)
13828       return -1;
13829   }
13830   {
13831     int r;
13832     suppress_error = 0;
13833     r = guestfs_lvm_remove_all (g);
13834     if (r == -1)
13835       return -1;
13836   }
13837   {
13838     char device[] = "/dev/sda";
13839     device[5] = devchar;
13840     char lines_0[] = ",";
13841     char *lines[] = {
13842       lines_0,
13843       NULL
13844     };
13845     int r;
13846     suppress_error = 0;
13847     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13848     if (r == -1)
13849       return -1;
13850   }
13851   {
13852     char fstype[] = "ext2";
13853     char device[] = "/dev/sda1";
13854     device[5] = devchar;
13855     int r;
13856     suppress_error = 0;
13857     r = guestfs_mkfs (g, fstype, device);
13858     if (r == -1)
13859       return -1;
13860   }
13861   {
13862     char device[] = "/dev/sda1";
13863     device[5] = devchar;
13864     char mountpoint[] = "/";
13865     int r;
13866     suppress_error = 0;
13867     r = guestfs_mount (g, device, mountpoint);
13868     if (r == -1)
13869       return -1;
13870   }
13871   /* TestOutputList for read_lines (1) */
13872   {
13873     char path[] = "/new";
13874     char content[] = "";
13875     int r;
13876     suppress_error = 0;
13877     r = guestfs_write_file (g, path, content, 0);
13878     if (r == -1)
13879       return -1;
13880   }
13881   {
13882     char path[] = "/new";
13883     char **r;
13884     int i;
13885     suppress_error = 0;
13886     r = guestfs_read_lines (g, path);
13887     if (r == NULL)
13888       return -1;
13889     if (r[0] != NULL) {
13890       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
13891       print_strings (r);
13892       return -1;
13893     }
13894     for (i = 0; r[i] != NULL; ++i)
13895       free (r[i]);
13896     free (r);
13897   }
13898   return 0;
13899 }
13900
13901 static int test_lvs_0_skip (void)
13902 {
13903   const char *str;
13904
13905   str = getenv ("SKIP_TEST_LVS_0");
13906   if (str && strcmp (str, "1") == 0) return 1;
13907   str = getenv ("SKIP_TEST_LVS");
13908   if (str && strcmp (str, "1") == 0) return 1;
13909   return 0;
13910 }
13911
13912 static int test_lvs_0 (void)
13913 {
13914   if (test_lvs_0_skip ()) {
13915     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
13916     return 0;
13917   }
13918
13919   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
13920   {
13921     char device[] = "/dev/sda";
13922     device[5] = devchar;
13923     int r;
13924     suppress_error = 0;
13925     r = guestfs_blockdev_setrw (g, device);
13926     if (r == -1)
13927       return -1;
13928   }
13929   {
13930     int r;
13931     suppress_error = 0;
13932     r = guestfs_umount_all (g);
13933     if (r == -1)
13934       return -1;
13935   }
13936   {
13937     int r;
13938     suppress_error = 0;
13939     r = guestfs_lvm_remove_all (g);
13940     if (r == -1)
13941       return -1;
13942   }
13943   {
13944     char device[] = "/dev/sda";
13945     device[5] = devchar;
13946     char lines_0[] = ",";
13947     char *lines[] = {
13948       lines_0,
13949       NULL
13950     };
13951     int r;
13952     suppress_error = 0;
13953     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13954     if (r == -1)
13955       return -1;
13956   }
13957   {
13958     char device[] = "/dev/sda1";
13959     device[5] = devchar;
13960     int r;
13961     suppress_error = 0;
13962     r = guestfs_pvcreate (g, device);
13963     if (r == -1)
13964       return -1;
13965   }
13966   {
13967     char volgroup[] = "VG";
13968     char physvols_0[] = "/dev/sda1";
13969     physvols_0[5] = devchar;
13970     char *physvols[] = {
13971       physvols_0,
13972       NULL
13973     };
13974     int r;
13975     suppress_error = 0;
13976     r = guestfs_vgcreate (g, volgroup, physvols);
13977     if (r == -1)
13978       return -1;
13979   }
13980   {
13981     char logvol[] = "LV";
13982     char volgroup[] = "VG";
13983     int r;
13984     suppress_error = 0;
13985     r = guestfs_lvcreate (g, logvol, volgroup, 8);
13986     if (r == -1)
13987       return -1;
13988   }
13989   {
13990     char fstype[] = "ext2";
13991     char device[] = "/dev/VG/LV";
13992     int r;
13993     suppress_error = 0;
13994     r = guestfs_mkfs (g, fstype, device);
13995     if (r == -1)
13996       return -1;
13997   }
13998   {
13999     char device[] = "/dev/VG/LV";
14000     char mountpoint[] = "/";
14001     int r;
14002     suppress_error = 0;
14003     r = guestfs_mount (g, device, mountpoint);
14004     if (r == -1)
14005       return -1;
14006   }
14007   /* TestOutputList for lvs (0) */
14008   {
14009     char **r;
14010     int i;
14011     suppress_error = 0;
14012     r = guestfs_lvs (g);
14013     if (r == NULL)
14014       return -1;
14015     if (!r[0]) {
14016       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14017       print_strings (r);
14018       return -1;
14019     }
14020     {
14021       char expected[] = "/dev/VG/LV";
14022       if (strcmp (r[0], expected) != 0) {
14023         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14024         return -1;
14025       }
14026     }
14027     if (r[1] != NULL) {
14028       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14029       print_strings (r);
14030       return -1;
14031     }
14032     for (i = 0; r[i] != NULL; ++i)
14033       free (r[i]);
14034     free (r);
14035   }
14036   return 0;
14037 }
14038
14039 static int test_lvs_1_skip (void)
14040 {
14041   const char *str;
14042
14043   str = getenv ("SKIP_TEST_LVS_1");
14044   if (str && strcmp (str, "1") == 0) return 1;
14045   str = getenv ("SKIP_TEST_LVS");
14046   if (str && strcmp (str, "1") == 0) return 1;
14047   return 0;
14048 }
14049
14050 static int test_lvs_1 (void)
14051 {
14052   if (test_lvs_1_skip ()) {
14053     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14054     return 0;
14055   }
14056
14057   /* InitNone|InitEmpty for test_lvs_1 */
14058   {
14059     char device[] = "/dev/sda";
14060     device[5] = devchar;
14061     int r;
14062     suppress_error = 0;
14063     r = guestfs_blockdev_setrw (g, device);
14064     if (r == -1)
14065       return -1;
14066   }
14067   {
14068     int r;
14069     suppress_error = 0;
14070     r = guestfs_umount_all (g);
14071     if (r == -1)
14072       return -1;
14073   }
14074   {
14075     int r;
14076     suppress_error = 0;
14077     r = guestfs_lvm_remove_all (g);
14078     if (r == -1)
14079       return -1;
14080   }
14081   /* TestOutputList for lvs (1) */
14082   {
14083     char device[] = "/dev/sda";
14084     device[5] = devchar;
14085     char lines_0[] = ",10";
14086     char lines_1[] = ",20";
14087     char lines_2[] = ",";
14088     char *lines[] = {
14089       lines_0,
14090       lines_1,
14091       lines_2,
14092       NULL
14093     };
14094     int r;
14095     suppress_error = 0;
14096     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14097     if (r == -1)
14098       return -1;
14099   }
14100   {
14101     char device[] = "/dev/sda1";
14102     device[5] = devchar;
14103     int r;
14104     suppress_error = 0;
14105     r = guestfs_pvcreate (g, device);
14106     if (r == -1)
14107       return -1;
14108   }
14109   {
14110     char device[] = "/dev/sda2";
14111     device[5] = devchar;
14112     int r;
14113     suppress_error = 0;
14114     r = guestfs_pvcreate (g, device);
14115     if (r == -1)
14116       return -1;
14117   }
14118   {
14119     char device[] = "/dev/sda3";
14120     device[5] = devchar;
14121     int r;
14122     suppress_error = 0;
14123     r = guestfs_pvcreate (g, device);
14124     if (r == -1)
14125       return -1;
14126   }
14127   {
14128     char volgroup[] = "VG1";
14129     char physvols_0[] = "/dev/sda1";
14130     physvols_0[5] = devchar;
14131     char physvols_1[] = "/dev/sda2";
14132     physvols_1[5] = devchar;
14133     char *physvols[] = {
14134       physvols_0,
14135       physvols_1,
14136       NULL
14137     };
14138     int r;
14139     suppress_error = 0;
14140     r = guestfs_vgcreate (g, volgroup, physvols);
14141     if (r == -1)
14142       return -1;
14143   }
14144   {
14145     char volgroup[] = "VG2";
14146     char physvols_0[] = "/dev/sda3";
14147     physvols_0[5] = devchar;
14148     char *physvols[] = {
14149       physvols_0,
14150       NULL
14151     };
14152     int r;
14153     suppress_error = 0;
14154     r = guestfs_vgcreate (g, volgroup, physvols);
14155     if (r == -1)
14156       return -1;
14157   }
14158   {
14159     char logvol[] = "LV1";
14160     char volgroup[] = "VG1";
14161     int r;
14162     suppress_error = 0;
14163     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14164     if (r == -1)
14165       return -1;
14166   }
14167   {
14168     char logvol[] = "LV2";
14169     char volgroup[] = "VG1";
14170     int r;
14171     suppress_error = 0;
14172     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14173     if (r == -1)
14174       return -1;
14175   }
14176   {
14177     char logvol[] = "LV3";
14178     char volgroup[] = "VG2";
14179     int r;
14180     suppress_error = 0;
14181     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14182     if (r == -1)
14183       return -1;
14184   }
14185   {
14186     char **r;
14187     int i;
14188     suppress_error = 0;
14189     r = guestfs_lvs (g);
14190     if (r == NULL)
14191       return -1;
14192     if (!r[0]) {
14193       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14194       print_strings (r);
14195       return -1;
14196     }
14197     {
14198       char expected[] = "/dev/VG1/LV1";
14199       if (strcmp (r[0], expected) != 0) {
14200         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14201         return -1;
14202       }
14203     }
14204     if (!r[1]) {
14205       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14206       print_strings (r);
14207       return -1;
14208     }
14209     {
14210       char expected[] = "/dev/VG1/LV2";
14211       if (strcmp (r[1], expected) != 0) {
14212         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14213         return -1;
14214       }
14215     }
14216     if (!r[2]) {
14217       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14218       print_strings (r);
14219       return -1;
14220     }
14221     {
14222       char expected[] = "/dev/VG2/LV3";
14223       if (strcmp (r[2], expected) != 0) {
14224         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14225         return -1;
14226       }
14227     }
14228     if (r[3] != NULL) {
14229       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14230       print_strings (r);
14231       return -1;
14232     }
14233     for (i = 0; r[i] != NULL; ++i)
14234       free (r[i]);
14235     free (r);
14236   }
14237   return 0;
14238 }
14239
14240 static int test_vgs_0_skip (void)
14241 {
14242   const char *str;
14243
14244   str = getenv ("SKIP_TEST_VGS_0");
14245   if (str && strcmp (str, "1") == 0) return 1;
14246   str = getenv ("SKIP_TEST_VGS");
14247   if (str && strcmp (str, "1") == 0) return 1;
14248   return 0;
14249 }
14250
14251 static int test_vgs_0 (void)
14252 {
14253   if (test_vgs_0_skip ()) {
14254     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14255     return 0;
14256   }
14257
14258   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14259   {
14260     char device[] = "/dev/sda";
14261     device[5] = devchar;
14262     int r;
14263     suppress_error = 0;
14264     r = guestfs_blockdev_setrw (g, device);
14265     if (r == -1)
14266       return -1;
14267   }
14268   {
14269     int r;
14270     suppress_error = 0;
14271     r = guestfs_umount_all (g);
14272     if (r == -1)
14273       return -1;
14274   }
14275   {
14276     int r;
14277     suppress_error = 0;
14278     r = guestfs_lvm_remove_all (g);
14279     if (r == -1)
14280       return -1;
14281   }
14282   {
14283     char device[] = "/dev/sda";
14284     device[5] = devchar;
14285     char lines_0[] = ",";
14286     char *lines[] = {
14287       lines_0,
14288       NULL
14289     };
14290     int r;
14291     suppress_error = 0;
14292     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14293     if (r == -1)
14294       return -1;
14295   }
14296   {
14297     char device[] = "/dev/sda1";
14298     device[5] = devchar;
14299     int r;
14300     suppress_error = 0;
14301     r = guestfs_pvcreate (g, device);
14302     if (r == -1)
14303       return -1;
14304   }
14305   {
14306     char volgroup[] = "VG";
14307     char physvols_0[] = "/dev/sda1";
14308     physvols_0[5] = devchar;
14309     char *physvols[] = {
14310       physvols_0,
14311       NULL
14312     };
14313     int r;
14314     suppress_error = 0;
14315     r = guestfs_vgcreate (g, volgroup, physvols);
14316     if (r == -1)
14317       return -1;
14318   }
14319   {
14320     char logvol[] = "LV";
14321     char volgroup[] = "VG";
14322     int r;
14323     suppress_error = 0;
14324     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14325     if (r == -1)
14326       return -1;
14327   }
14328   {
14329     char fstype[] = "ext2";
14330     char device[] = "/dev/VG/LV";
14331     int r;
14332     suppress_error = 0;
14333     r = guestfs_mkfs (g, fstype, device);
14334     if (r == -1)
14335       return -1;
14336   }
14337   {
14338     char device[] = "/dev/VG/LV";
14339     char mountpoint[] = "/";
14340     int r;
14341     suppress_error = 0;
14342     r = guestfs_mount (g, device, mountpoint);
14343     if (r == -1)
14344       return -1;
14345   }
14346   /* TestOutputList for vgs (0) */
14347   {
14348     char **r;
14349     int i;
14350     suppress_error = 0;
14351     r = guestfs_vgs (g);
14352     if (r == NULL)
14353       return -1;
14354     if (!r[0]) {
14355       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14356       print_strings (r);
14357       return -1;
14358     }
14359     {
14360       char expected[] = "VG";
14361       if (strcmp (r[0], expected) != 0) {
14362         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14363         return -1;
14364       }
14365     }
14366     if (r[1] != NULL) {
14367       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14368       print_strings (r);
14369       return -1;
14370     }
14371     for (i = 0; r[i] != NULL; ++i)
14372       free (r[i]);
14373     free (r);
14374   }
14375   return 0;
14376 }
14377
14378 static int test_vgs_1_skip (void)
14379 {
14380   const char *str;
14381
14382   str = getenv ("SKIP_TEST_VGS_1");
14383   if (str && strcmp (str, "1") == 0) return 1;
14384   str = getenv ("SKIP_TEST_VGS");
14385   if (str && strcmp (str, "1") == 0) return 1;
14386   return 0;
14387 }
14388
14389 static int test_vgs_1 (void)
14390 {
14391   if (test_vgs_1_skip ()) {
14392     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14393     return 0;
14394   }
14395
14396   /* InitNone|InitEmpty for test_vgs_1 */
14397   {
14398     char device[] = "/dev/sda";
14399     device[5] = devchar;
14400     int r;
14401     suppress_error = 0;
14402     r = guestfs_blockdev_setrw (g, device);
14403     if (r == -1)
14404       return -1;
14405   }
14406   {
14407     int r;
14408     suppress_error = 0;
14409     r = guestfs_umount_all (g);
14410     if (r == -1)
14411       return -1;
14412   }
14413   {
14414     int r;
14415     suppress_error = 0;
14416     r = guestfs_lvm_remove_all (g);
14417     if (r == -1)
14418       return -1;
14419   }
14420   /* TestOutputList for vgs (1) */
14421   {
14422     char device[] = "/dev/sda";
14423     device[5] = devchar;
14424     char lines_0[] = ",10";
14425     char lines_1[] = ",20";
14426     char lines_2[] = ",";
14427     char *lines[] = {
14428       lines_0,
14429       lines_1,
14430       lines_2,
14431       NULL
14432     };
14433     int r;
14434     suppress_error = 0;
14435     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14436     if (r == -1)
14437       return -1;
14438   }
14439   {
14440     char device[] = "/dev/sda1";
14441     device[5] = devchar;
14442     int r;
14443     suppress_error = 0;
14444     r = guestfs_pvcreate (g, device);
14445     if (r == -1)
14446       return -1;
14447   }
14448   {
14449     char device[] = "/dev/sda2";
14450     device[5] = devchar;
14451     int r;
14452     suppress_error = 0;
14453     r = guestfs_pvcreate (g, device);
14454     if (r == -1)
14455       return -1;
14456   }
14457   {
14458     char device[] = "/dev/sda3";
14459     device[5] = devchar;
14460     int r;
14461     suppress_error = 0;
14462     r = guestfs_pvcreate (g, device);
14463     if (r == -1)
14464       return -1;
14465   }
14466   {
14467     char volgroup[] = "VG1";
14468     char physvols_0[] = "/dev/sda1";
14469     physvols_0[5] = devchar;
14470     char physvols_1[] = "/dev/sda2";
14471     physvols_1[5] = devchar;
14472     char *physvols[] = {
14473       physvols_0,
14474       physvols_1,
14475       NULL
14476     };
14477     int r;
14478     suppress_error = 0;
14479     r = guestfs_vgcreate (g, volgroup, physvols);
14480     if (r == -1)
14481       return -1;
14482   }
14483   {
14484     char volgroup[] = "VG2";
14485     char physvols_0[] = "/dev/sda3";
14486     physvols_0[5] = devchar;
14487     char *physvols[] = {
14488       physvols_0,
14489       NULL
14490     };
14491     int r;
14492     suppress_error = 0;
14493     r = guestfs_vgcreate (g, volgroup, physvols);
14494     if (r == -1)
14495       return -1;
14496   }
14497   {
14498     char **r;
14499     int i;
14500     suppress_error = 0;
14501     r = guestfs_vgs (g);
14502     if (r == NULL)
14503       return -1;
14504     if (!r[0]) {
14505       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14506       print_strings (r);
14507       return -1;
14508     }
14509     {
14510       char expected[] = "VG1";
14511       if (strcmp (r[0], expected) != 0) {
14512         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14513         return -1;
14514       }
14515     }
14516     if (!r[1]) {
14517       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14518       print_strings (r);
14519       return -1;
14520     }
14521     {
14522       char expected[] = "VG2";
14523       if (strcmp (r[1], expected) != 0) {
14524         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14525         return -1;
14526       }
14527     }
14528     if (r[2] != NULL) {
14529       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14530       print_strings (r);
14531       return -1;
14532     }
14533     for (i = 0; r[i] != NULL; ++i)
14534       free (r[i]);
14535     free (r);
14536   }
14537   return 0;
14538 }
14539
14540 static int test_pvs_0_skip (void)
14541 {
14542   const char *str;
14543
14544   str = getenv ("SKIP_TEST_PVS_0");
14545   if (str && strcmp (str, "1") == 0) return 1;
14546   str = getenv ("SKIP_TEST_PVS");
14547   if (str && strcmp (str, "1") == 0) return 1;
14548   return 0;
14549 }
14550
14551 static int test_pvs_0 (void)
14552 {
14553   if (test_pvs_0_skip ()) {
14554     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14555     return 0;
14556   }
14557
14558   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14559   {
14560     char device[] = "/dev/sda";
14561     device[5] = devchar;
14562     int r;
14563     suppress_error = 0;
14564     r = guestfs_blockdev_setrw (g, device);
14565     if (r == -1)
14566       return -1;
14567   }
14568   {
14569     int r;
14570     suppress_error = 0;
14571     r = guestfs_umount_all (g);
14572     if (r == -1)
14573       return -1;
14574   }
14575   {
14576     int r;
14577     suppress_error = 0;
14578     r = guestfs_lvm_remove_all (g);
14579     if (r == -1)
14580       return -1;
14581   }
14582   {
14583     char device[] = "/dev/sda";
14584     device[5] = devchar;
14585     char lines_0[] = ",";
14586     char *lines[] = {
14587       lines_0,
14588       NULL
14589     };
14590     int r;
14591     suppress_error = 0;
14592     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14593     if (r == -1)
14594       return -1;
14595   }
14596   {
14597     char device[] = "/dev/sda1";
14598     device[5] = devchar;
14599     int r;
14600     suppress_error = 0;
14601     r = guestfs_pvcreate (g, device);
14602     if (r == -1)
14603       return -1;
14604   }
14605   {
14606     char volgroup[] = "VG";
14607     char physvols_0[] = "/dev/sda1";
14608     physvols_0[5] = devchar;
14609     char *physvols[] = {
14610       physvols_0,
14611       NULL
14612     };
14613     int r;
14614     suppress_error = 0;
14615     r = guestfs_vgcreate (g, volgroup, physvols);
14616     if (r == -1)
14617       return -1;
14618   }
14619   {
14620     char logvol[] = "LV";
14621     char volgroup[] = "VG";
14622     int r;
14623     suppress_error = 0;
14624     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14625     if (r == -1)
14626       return -1;
14627   }
14628   {
14629     char fstype[] = "ext2";
14630     char device[] = "/dev/VG/LV";
14631     int r;
14632     suppress_error = 0;
14633     r = guestfs_mkfs (g, fstype, device);
14634     if (r == -1)
14635       return -1;
14636   }
14637   {
14638     char device[] = "/dev/VG/LV";
14639     char mountpoint[] = "/";
14640     int r;
14641     suppress_error = 0;
14642     r = guestfs_mount (g, device, mountpoint);
14643     if (r == -1)
14644       return -1;
14645   }
14646   /* TestOutputList for pvs (0) */
14647   {
14648     char **r;
14649     int i;
14650     suppress_error = 0;
14651     r = guestfs_pvs (g);
14652     if (r == NULL)
14653       return -1;
14654     if (!r[0]) {
14655       fprintf (stderr, "test_pvs_0: short list returned from command\n");
14656       print_strings (r);
14657       return -1;
14658     }
14659     {
14660       char expected[] = "/dev/sda1";
14661       expected[5] = devchar;
14662       if (strcmp (r[0], expected) != 0) {
14663         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14664         return -1;
14665       }
14666     }
14667     if (r[1] != NULL) {
14668       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14669       print_strings (r);
14670       return -1;
14671     }
14672     for (i = 0; r[i] != NULL; ++i)
14673       free (r[i]);
14674     free (r);
14675   }
14676   return 0;
14677 }
14678
14679 static int test_pvs_1_skip (void)
14680 {
14681   const char *str;
14682
14683   str = getenv ("SKIP_TEST_PVS_1");
14684   if (str && strcmp (str, "1") == 0) return 1;
14685   str = getenv ("SKIP_TEST_PVS");
14686   if (str && strcmp (str, "1") == 0) return 1;
14687   return 0;
14688 }
14689
14690 static int test_pvs_1 (void)
14691 {
14692   if (test_pvs_1_skip ()) {
14693     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
14694     return 0;
14695   }
14696
14697   /* InitNone|InitEmpty for test_pvs_1 */
14698   {
14699     char device[] = "/dev/sda";
14700     device[5] = devchar;
14701     int r;
14702     suppress_error = 0;
14703     r = guestfs_blockdev_setrw (g, device);
14704     if (r == -1)
14705       return -1;
14706   }
14707   {
14708     int r;
14709     suppress_error = 0;
14710     r = guestfs_umount_all (g);
14711     if (r == -1)
14712       return -1;
14713   }
14714   {
14715     int r;
14716     suppress_error = 0;
14717     r = guestfs_lvm_remove_all (g);
14718     if (r == -1)
14719       return -1;
14720   }
14721   /* TestOutputList for pvs (1) */
14722   {
14723     char device[] = "/dev/sda";
14724     device[5] = devchar;
14725     char lines_0[] = ",10";
14726     char lines_1[] = ",20";
14727     char lines_2[] = ",";
14728     char *lines[] = {
14729       lines_0,
14730       lines_1,
14731       lines_2,
14732       NULL
14733     };
14734     int r;
14735     suppress_error = 0;
14736     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14737     if (r == -1)
14738       return -1;
14739   }
14740   {
14741     char device[] = "/dev/sda1";
14742     device[5] = devchar;
14743     int r;
14744     suppress_error = 0;
14745     r = guestfs_pvcreate (g, device);
14746     if (r == -1)
14747       return -1;
14748   }
14749   {
14750     char device[] = "/dev/sda2";
14751     device[5] = devchar;
14752     int r;
14753     suppress_error = 0;
14754     r = guestfs_pvcreate (g, device);
14755     if (r == -1)
14756       return -1;
14757   }
14758   {
14759     char device[] = "/dev/sda3";
14760     device[5] = devchar;
14761     int r;
14762     suppress_error = 0;
14763     r = guestfs_pvcreate (g, device);
14764     if (r == -1)
14765       return -1;
14766   }
14767   {
14768     char **r;
14769     int i;
14770     suppress_error = 0;
14771     r = guestfs_pvs (g);
14772     if (r == NULL)
14773       return -1;
14774     if (!r[0]) {
14775       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14776       print_strings (r);
14777       return -1;
14778     }
14779     {
14780       char expected[] = "/dev/sda1";
14781       expected[5] = devchar;
14782       if (strcmp (r[0], expected) != 0) {
14783         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14784         return -1;
14785       }
14786     }
14787     if (!r[1]) {
14788       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14789       print_strings (r);
14790       return -1;
14791     }
14792     {
14793       char expected[] = "/dev/sda2";
14794       expected[5] = devchar;
14795       if (strcmp (r[1], expected) != 0) {
14796         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14797         return -1;
14798       }
14799     }
14800     if (!r[2]) {
14801       fprintf (stderr, "test_pvs_1: short list returned from command\n");
14802       print_strings (r);
14803       return -1;
14804     }
14805     {
14806       char expected[] = "/dev/sda3";
14807       expected[5] = devchar;
14808       if (strcmp (r[2], expected) != 0) {
14809         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14810         return -1;
14811       }
14812     }
14813     if (r[3] != NULL) {
14814       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
14815       print_strings (r);
14816       return -1;
14817     }
14818     for (i = 0; r[i] != NULL; ++i)
14819       free (r[i]);
14820     free (r);
14821   }
14822   return 0;
14823 }
14824
14825 static int test_list_partitions_0_skip (void)
14826 {
14827   const char *str;
14828
14829   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
14830   if (str && strcmp (str, "1") == 0) return 1;
14831   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14832   if (str && strcmp (str, "1") == 0) return 1;
14833   return 0;
14834 }
14835
14836 static int test_list_partitions_0 (void)
14837 {
14838   if (test_list_partitions_0_skip ()) {
14839     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
14840     return 0;
14841   }
14842
14843   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
14844   {
14845     char device[] = "/dev/sda";
14846     device[5] = devchar;
14847     int r;
14848     suppress_error = 0;
14849     r = guestfs_blockdev_setrw (g, device);
14850     if (r == -1)
14851       return -1;
14852   }
14853   {
14854     int r;
14855     suppress_error = 0;
14856     r = guestfs_umount_all (g);
14857     if (r == -1)
14858       return -1;
14859   }
14860   {
14861     int r;
14862     suppress_error = 0;
14863     r = guestfs_lvm_remove_all (g);
14864     if (r == -1)
14865       return -1;
14866   }
14867   {
14868     char device[] = "/dev/sda";
14869     device[5] = devchar;
14870     char lines_0[] = ",";
14871     char *lines[] = {
14872       lines_0,
14873       NULL
14874     };
14875     int r;
14876     suppress_error = 0;
14877     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14878     if (r == -1)
14879       return -1;
14880   }
14881   {
14882     char fstype[] = "ext2";
14883     char device[] = "/dev/sda1";
14884     device[5] = devchar;
14885     int r;
14886     suppress_error = 0;
14887     r = guestfs_mkfs (g, fstype, device);
14888     if (r == -1)
14889       return -1;
14890   }
14891   {
14892     char device[] = "/dev/sda1";
14893     device[5] = devchar;
14894     char mountpoint[] = "/";
14895     int r;
14896     suppress_error = 0;
14897     r = guestfs_mount (g, device, mountpoint);
14898     if (r == -1)
14899       return -1;
14900   }
14901   /* TestOutputList for list_partitions (0) */
14902   {
14903     char **r;
14904     int i;
14905     suppress_error = 0;
14906     r = guestfs_list_partitions (g);
14907     if (r == NULL)
14908       return -1;
14909     if (!r[0]) {
14910       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
14911       print_strings (r);
14912       return -1;
14913     }
14914     {
14915       char expected[] = "/dev/sda1";
14916       expected[5] = devchar;
14917       if (strcmp (r[0], expected) != 0) {
14918         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14919         return -1;
14920       }
14921     }
14922     if (r[1] != NULL) {
14923       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
14924       print_strings (r);
14925       return -1;
14926     }
14927     for (i = 0; r[i] != NULL; ++i)
14928       free (r[i]);
14929     free (r);
14930   }
14931   return 0;
14932 }
14933
14934 static int test_list_partitions_1_skip (void)
14935 {
14936   const char *str;
14937
14938   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
14939   if (str && strcmp (str, "1") == 0) return 1;
14940   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14941   if (str && strcmp (str, "1") == 0) return 1;
14942   return 0;
14943 }
14944
14945 static int test_list_partitions_1 (void)
14946 {
14947   if (test_list_partitions_1_skip ()) {
14948     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
14949     return 0;
14950   }
14951
14952   /* InitNone|InitEmpty for test_list_partitions_1 */
14953   {
14954     char device[] = "/dev/sda";
14955     device[5] = devchar;
14956     int r;
14957     suppress_error = 0;
14958     r = guestfs_blockdev_setrw (g, device);
14959     if (r == -1)
14960       return -1;
14961   }
14962   {
14963     int r;
14964     suppress_error = 0;
14965     r = guestfs_umount_all (g);
14966     if (r == -1)
14967       return -1;
14968   }
14969   {
14970     int r;
14971     suppress_error = 0;
14972     r = guestfs_lvm_remove_all (g);
14973     if (r == -1)
14974       return -1;
14975   }
14976   /* TestOutputList for list_partitions (1) */
14977   {
14978     char device[] = "/dev/sda";
14979     device[5] = devchar;
14980     char lines_0[] = ",10";
14981     char lines_1[] = ",20";
14982     char lines_2[] = ",";
14983     char *lines[] = {
14984       lines_0,
14985       lines_1,
14986       lines_2,
14987       NULL
14988     };
14989     int r;
14990     suppress_error = 0;
14991     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14992     if (r == -1)
14993       return -1;
14994   }
14995   {
14996     char **r;
14997     int i;
14998     suppress_error = 0;
14999     r = guestfs_list_partitions (g);
15000     if (r == NULL)
15001       return -1;
15002     if (!r[0]) {
15003       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15004       print_strings (r);
15005       return -1;
15006     }
15007     {
15008       char expected[] = "/dev/sda1";
15009       expected[5] = devchar;
15010       if (strcmp (r[0], expected) != 0) {
15011         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15012         return -1;
15013       }
15014     }
15015     if (!r[1]) {
15016       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15017       print_strings (r);
15018       return -1;
15019     }
15020     {
15021       char expected[] = "/dev/sda2";
15022       expected[5] = devchar;
15023       if (strcmp (r[1], expected) != 0) {
15024         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15025         return -1;
15026       }
15027     }
15028     if (!r[2]) {
15029       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15030       print_strings (r);
15031       return -1;
15032     }
15033     {
15034       char expected[] = "/dev/sda3";
15035       expected[5] = devchar;
15036       if (strcmp (r[2], expected) != 0) {
15037         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15038         return -1;
15039       }
15040     }
15041     if (r[3] != NULL) {
15042       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15043       print_strings (r);
15044       return -1;
15045     }
15046     for (i = 0; r[i] != NULL; ++i)
15047       free (r[i]);
15048     free (r);
15049   }
15050   return 0;
15051 }
15052
15053 static int test_list_devices_0_skip (void)
15054 {
15055   const char *str;
15056
15057   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15058   if (str && strcmp (str, "1") == 0) return 1;
15059   str = getenv ("SKIP_TEST_LIST_DEVICES");
15060   if (str && strcmp (str, "1") == 0) return 1;
15061   return 0;
15062 }
15063
15064 static int test_list_devices_0 (void)
15065 {
15066   if (test_list_devices_0_skip ()) {
15067     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15068     return 0;
15069   }
15070
15071   /* InitNone|InitEmpty for test_list_devices_0 */
15072   {
15073     char device[] = "/dev/sda";
15074     device[5] = devchar;
15075     int r;
15076     suppress_error = 0;
15077     r = guestfs_blockdev_setrw (g, device);
15078     if (r == -1)
15079       return -1;
15080   }
15081   {
15082     int r;
15083     suppress_error = 0;
15084     r = guestfs_umount_all (g);
15085     if (r == -1)
15086       return -1;
15087   }
15088   {
15089     int r;
15090     suppress_error = 0;
15091     r = guestfs_lvm_remove_all (g);
15092     if (r == -1)
15093       return -1;
15094   }
15095   /* TestOutputList for list_devices (0) */
15096   {
15097     char **r;
15098     int i;
15099     suppress_error = 0;
15100     r = guestfs_list_devices (g);
15101     if (r == NULL)
15102       return -1;
15103     if (!r[0]) {
15104       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15105       print_strings (r);
15106       return -1;
15107     }
15108     {
15109       char expected[] = "/dev/sda";
15110       expected[5] = devchar;
15111       if (strcmp (r[0], expected) != 0) {
15112         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15113         return -1;
15114       }
15115     }
15116     if (!r[1]) {
15117       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15118       print_strings (r);
15119       return -1;
15120     }
15121     {
15122       char expected[] = "/dev/sdb";
15123       expected[5] = devchar;
15124       if (strcmp (r[1], expected) != 0) {
15125         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15126         return -1;
15127       }
15128     }
15129     if (!r[2]) {
15130       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15131       print_strings (r);
15132       return -1;
15133     }
15134     {
15135       char expected[] = "/dev/sdc";
15136       expected[5] = devchar;
15137       if (strcmp (r[2], expected) != 0) {
15138         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15139         return -1;
15140       }
15141     }
15142     if (r[3] != NULL) {
15143       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15144       print_strings (r);
15145       return -1;
15146     }
15147     for (i = 0; r[i] != NULL; ++i)
15148       free (r[i]);
15149     free (r);
15150   }
15151   return 0;
15152 }
15153
15154 static int test_ls_0_skip (void)
15155 {
15156   const char *str;
15157
15158   str = getenv ("SKIP_TEST_LS_0");
15159   if (str && strcmp (str, "1") == 0) return 1;
15160   str = getenv ("SKIP_TEST_LS");
15161   if (str && strcmp (str, "1") == 0) return 1;
15162   return 0;
15163 }
15164
15165 static int test_ls_0 (void)
15166 {
15167   if (test_ls_0_skip ()) {
15168     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15169     return 0;
15170   }
15171
15172   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15173   {
15174     char device[] = "/dev/sda";
15175     device[5] = devchar;
15176     int r;
15177     suppress_error = 0;
15178     r = guestfs_blockdev_setrw (g, device);
15179     if (r == -1)
15180       return -1;
15181   }
15182   {
15183     int r;
15184     suppress_error = 0;
15185     r = guestfs_umount_all (g);
15186     if (r == -1)
15187       return -1;
15188   }
15189   {
15190     int r;
15191     suppress_error = 0;
15192     r = guestfs_lvm_remove_all (g);
15193     if (r == -1)
15194       return -1;
15195   }
15196   {
15197     char device[] = "/dev/sda";
15198     device[5] = devchar;
15199     char lines_0[] = ",";
15200     char *lines[] = {
15201       lines_0,
15202       NULL
15203     };
15204     int r;
15205     suppress_error = 0;
15206     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15207     if (r == -1)
15208       return -1;
15209   }
15210   {
15211     char fstype[] = "ext2";
15212     char device[] = "/dev/sda1";
15213     device[5] = devchar;
15214     int r;
15215     suppress_error = 0;
15216     r = guestfs_mkfs (g, fstype, device);
15217     if (r == -1)
15218       return -1;
15219   }
15220   {
15221     char device[] = "/dev/sda1";
15222     device[5] = devchar;
15223     char mountpoint[] = "/";
15224     int r;
15225     suppress_error = 0;
15226     r = guestfs_mount (g, device, mountpoint);
15227     if (r == -1)
15228       return -1;
15229   }
15230   /* TestOutputList for ls (0) */
15231   {
15232     char path[] = "/new";
15233     int r;
15234     suppress_error = 0;
15235     r = guestfs_touch (g, path);
15236     if (r == -1)
15237       return -1;
15238   }
15239   {
15240     char path[] = "/newer";
15241     int r;
15242     suppress_error = 0;
15243     r = guestfs_touch (g, path);
15244     if (r == -1)
15245       return -1;
15246   }
15247   {
15248     char path[] = "/newest";
15249     int r;
15250     suppress_error = 0;
15251     r = guestfs_touch (g, path);
15252     if (r == -1)
15253       return -1;
15254   }
15255   {
15256     char directory[] = "/";
15257     char **r;
15258     int i;
15259     suppress_error = 0;
15260     r = guestfs_ls (g, directory);
15261     if (r == NULL)
15262       return -1;
15263     if (!r[0]) {
15264       fprintf (stderr, "test_ls_0: short list returned from command\n");
15265       print_strings (r);
15266       return -1;
15267     }
15268     {
15269       char expected[] = "lost+found";
15270       if (strcmp (r[0], expected) != 0) {
15271         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15272         return -1;
15273       }
15274     }
15275     if (!r[1]) {
15276       fprintf (stderr, "test_ls_0: short list returned from command\n");
15277       print_strings (r);
15278       return -1;
15279     }
15280     {
15281       char expected[] = "new";
15282       if (strcmp (r[1], expected) != 0) {
15283         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15284         return -1;
15285       }
15286     }
15287     if (!r[2]) {
15288       fprintf (stderr, "test_ls_0: short list returned from command\n");
15289       print_strings (r);
15290       return -1;
15291     }
15292     {
15293       char expected[] = "newer";
15294       if (strcmp (r[2], expected) != 0) {
15295         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15296         return -1;
15297       }
15298     }
15299     if (!r[3]) {
15300       fprintf (stderr, "test_ls_0: short list returned from command\n");
15301       print_strings (r);
15302       return -1;
15303     }
15304     {
15305       char expected[] = "newest";
15306       if (strcmp (r[3], expected) != 0) {
15307         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15308         return -1;
15309       }
15310     }
15311     if (r[4] != NULL) {
15312       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15313       print_strings (r);
15314       return -1;
15315     }
15316     for (i = 0; r[i] != NULL; ++i)
15317       free (r[i]);
15318     free (r);
15319   }
15320   return 0;
15321 }
15322
15323 static int test_cat_0_skip (void)
15324 {
15325   const char *str;
15326
15327   str = getenv ("SKIP_TEST_CAT_0");
15328   if (str && strcmp (str, "1") == 0) return 1;
15329   str = getenv ("SKIP_TEST_CAT");
15330   if (str && strcmp (str, "1") == 0) return 1;
15331   return 0;
15332 }
15333
15334 static int test_cat_0 (void)
15335 {
15336   if (test_cat_0_skip ()) {
15337     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15338     return 0;
15339   }
15340
15341   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15342   {
15343     char device[] = "/dev/sda";
15344     device[5] = devchar;
15345     int r;
15346     suppress_error = 0;
15347     r = guestfs_blockdev_setrw (g, device);
15348     if (r == -1)
15349       return -1;
15350   }
15351   {
15352     int r;
15353     suppress_error = 0;
15354     r = guestfs_umount_all (g);
15355     if (r == -1)
15356       return -1;
15357   }
15358   {
15359     int r;
15360     suppress_error = 0;
15361     r = guestfs_lvm_remove_all (g);
15362     if (r == -1)
15363       return -1;
15364   }
15365   {
15366     char device[] = "/dev/sda";
15367     device[5] = devchar;
15368     char lines_0[] = ",";
15369     char *lines[] = {
15370       lines_0,
15371       NULL
15372     };
15373     int r;
15374     suppress_error = 0;
15375     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15376     if (r == -1)
15377       return -1;
15378   }
15379   {
15380     char fstype[] = "ext2";
15381     char device[] = "/dev/sda1";
15382     device[5] = devchar;
15383     int r;
15384     suppress_error = 0;
15385     r = guestfs_mkfs (g, fstype, device);
15386     if (r == -1)
15387       return -1;
15388   }
15389   {
15390     char device[] = "/dev/sda1";
15391     device[5] = devchar;
15392     char mountpoint[] = "/";
15393     int r;
15394     suppress_error = 0;
15395     r = guestfs_mount (g, device, mountpoint);
15396     if (r == -1)
15397       return -1;
15398   }
15399   /* TestOutput for cat (0) */
15400   char expected[] = "new file contents";
15401   {
15402     char path[] = "/new";
15403     char content[] = "new file contents";
15404     int r;
15405     suppress_error = 0;
15406     r = guestfs_write_file (g, path, content, 0);
15407     if (r == -1)
15408       return -1;
15409   }
15410   {
15411     char path[] = "/new";
15412     char *r;
15413     suppress_error = 0;
15414     r = guestfs_cat (g, path);
15415     if (r == NULL)
15416       return -1;
15417     if (strcmp (r, expected) != 0) {
15418       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15419       return -1;
15420     }
15421     free (r);
15422   }
15423   return 0;
15424 }
15425
15426 static int test_touch_0_skip (void)
15427 {
15428   const char *str;
15429
15430   str = getenv ("SKIP_TEST_TOUCH_0");
15431   if (str && strcmp (str, "1") == 0) return 1;
15432   str = getenv ("SKIP_TEST_TOUCH");
15433   if (str && strcmp (str, "1") == 0) return 1;
15434   return 0;
15435 }
15436
15437 static int test_touch_0 (void)
15438 {
15439   if (test_touch_0_skip ()) {
15440     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15441     return 0;
15442   }
15443
15444   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15445   {
15446     char device[] = "/dev/sda";
15447     device[5] = devchar;
15448     int r;
15449     suppress_error = 0;
15450     r = guestfs_blockdev_setrw (g, device);
15451     if (r == -1)
15452       return -1;
15453   }
15454   {
15455     int r;
15456     suppress_error = 0;
15457     r = guestfs_umount_all (g);
15458     if (r == -1)
15459       return -1;
15460   }
15461   {
15462     int r;
15463     suppress_error = 0;
15464     r = guestfs_lvm_remove_all (g);
15465     if (r == -1)
15466       return -1;
15467   }
15468   {
15469     char device[] = "/dev/sda";
15470     device[5] = devchar;
15471     char lines_0[] = ",";
15472     char *lines[] = {
15473       lines_0,
15474       NULL
15475     };
15476     int r;
15477     suppress_error = 0;
15478     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15479     if (r == -1)
15480       return -1;
15481   }
15482   {
15483     char fstype[] = "ext2";
15484     char device[] = "/dev/sda1";
15485     device[5] = devchar;
15486     int r;
15487     suppress_error = 0;
15488     r = guestfs_mkfs (g, fstype, device);
15489     if (r == -1)
15490       return -1;
15491   }
15492   {
15493     char device[] = "/dev/sda1";
15494     device[5] = devchar;
15495     char mountpoint[] = "/";
15496     int r;
15497     suppress_error = 0;
15498     r = guestfs_mount (g, device, mountpoint);
15499     if (r == -1)
15500       return -1;
15501   }
15502   /* TestOutputTrue for touch (0) */
15503   {
15504     char path[] = "/new";
15505     int r;
15506     suppress_error = 0;
15507     r = guestfs_touch (g, path);
15508     if (r == -1)
15509       return -1;
15510   }
15511   {
15512     char path[] = "/new";
15513     int r;
15514     suppress_error = 0;
15515     r = guestfs_exists (g, path);
15516     if (r == -1)
15517       return -1;
15518     if (!r) {
15519       fprintf (stderr, "test_touch_0: expected true, got false\n");
15520       return -1;
15521     }
15522   }
15523   return 0;
15524 }
15525
15526 static int test_sync_0_skip (void)
15527 {
15528   const char *str;
15529
15530   str = getenv ("SKIP_TEST_SYNC_0");
15531   if (str && strcmp (str, "1") == 0) return 1;
15532   str = getenv ("SKIP_TEST_SYNC");
15533   if (str && strcmp (str, "1") == 0) return 1;
15534   return 0;
15535 }
15536
15537 static int test_sync_0 (void)
15538 {
15539   if (test_sync_0_skip ()) {
15540     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15541     return 0;
15542   }
15543
15544   /* InitNone|InitEmpty for test_sync_0 */
15545   {
15546     char device[] = "/dev/sda";
15547     device[5] = devchar;
15548     int r;
15549     suppress_error = 0;
15550     r = guestfs_blockdev_setrw (g, device);
15551     if (r == -1)
15552       return -1;
15553   }
15554   {
15555     int r;
15556     suppress_error = 0;
15557     r = guestfs_umount_all (g);
15558     if (r == -1)
15559       return -1;
15560   }
15561   {
15562     int r;
15563     suppress_error = 0;
15564     r = guestfs_lvm_remove_all (g);
15565     if (r == -1)
15566       return -1;
15567   }
15568   /* TestRun for sync (0) */
15569   {
15570     int r;
15571     suppress_error = 0;
15572     r = guestfs_sync (g);
15573     if (r == -1)
15574       return -1;
15575   }
15576   return 0;
15577 }
15578
15579 static int test_mount_0_skip (void)
15580 {
15581   const char *str;
15582
15583   str = getenv ("SKIP_TEST_MOUNT_0");
15584   if (str && strcmp (str, "1") == 0) return 1;
15585   str = getenv ("SKIP_TEST_MOUNT");
15586   if (str && strcmp (str, "1") == 0) return 1;
15587   return 0;
15588 }
15589
15590 static int test_mount_0 (void)
15591 {
15592   if (test_mount_0_skip ()) {
15593     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15594     return 0;
15595   }
15596
15597   /* InitNone|InitEmpty for test_mount_0 */
15598   {
15599     char device[] = "/dev/sda";
15600     device[5] = devchar;
15601     int r;
15602     suppress_error = 0;
15603     r = guestfs_blockdev_setrw (g, device);
15604     if (r == -1)
15605       return -1;
15606   }
15607   {
15608     int r;
15609     suppress_error = 0;
15610     r = guestfs_umount_all (g);
15611     if (r == -1)
15612       return -1;
15613   }
15614   {
15615     int r;
15616     suppress_error = 0;
15617     r = guestfs_lvm_remove_all (g);
15618     if (r == -1)
15619       return -1;
15620   }
15621   /* TestOutput for mount (0) */
15622   char expected[] = "new file contents";
15623   {
15624     char device[] = "/dev/sda";
15625     device[5] = devchar;
15626     char lines_0[] = ",";
15627     char *lines[] = {
15628       lines_0,
15629       NULL
15630     };
15631     int r;
15632     suppress_error = 0;
15633     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15634     if (r == -1)
15635       return -1;
15636   }
15637   {
15638     char fstype[] = "ext2";
15639     char device[] = "/dev/sda1";
15640     device[5] = devchar;
15641     int r;
15642     suppress_error = 0;
15643     r = guestfs_mkfs (g, fstype, device);
15644     if (r == -1)
15645       return -1;
15646   }
15647   {
15648     char device[] = "/dev/sda1";
15649     device[5] = devchar;
15650     char mountpoint[] = "/";
15651     int r;
15652     suppress_error = 0;
15653     r = guestfs_mount (g, device, mountpoint);
15654     if (r == -1)
15655       return -1;
15656   }
15657   {
15658     char path[] = "/new";
15659     char content[] = "new file contents";
15660     int r;
15661     suppress_error = 0;
15662     r = guestfs_write_file (g, path, content, 0);
15663     if (r == -1)
15664       return -1;
15665   }
15666   {
15667     char path[] = "/new";
15668     char *r;
15669     suppress_error = 0;
15670     r = guestfs_cat (g, path);
15671     if (r == NULL)
15672       return -1;
15673     if (strcmp (r, expected) != 0) {
15674       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
15675       return -1;
15676     }
15677     free (r);
15678   }
15679   return 0;
15680 }
15681
15682 int main (int argc, char *argv[])
15683 {
15684   char c = 0;
15685   int failed = 0;
15686   const char *srcdir;
15687   const char *filename;
15688   int fd, i;
15689   int nr_tests, test_num = 0;
15690   char **devs;
15691
15692   no_test_warnings ();
15693
15694   g = guestfs_create ();
15695   if (g == NULL) {
15696     printf ("guestfs_create FAILED\n");
15697     exit (1);
15698   }
15699
15700   guestfs_set_error_handler (g, print_error, NULL);
15701
15702   srcdir = getenv ("srcdir");
15703   if (!srcdir) srcdir = ".";
15704   chdir (srcdir);
15705   guestfs_set_path (g, ".");
15706
15707   filename = "test1.img";
15708   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15709   if (fd == -1) {
15710     perror (filename);
15711     exit (1);
15712   }
15713   if (lseek (fd, 524288000, SEEK_SET) == -1) {
15714     perror ("lseek");
15715     close (fd);
15716     unlink (filename);
15717     exit (1);
15718   }
15719   if (write (fd, &c, 1) == -1) {
15720     perror ("write");
15721     close (fd);
15722     unlink (filename);
15723     exit (1);
15724   }
15725   if (close (fd) == -1) {
15726     perror (filename);
15727     unlink (filename);
15728     exit (1);
15729   }
15730   if (guestfs_add_drive (g, filename) == -1) {
15731     printf ("guestfs_add_drive %s FAILED\n", filename);
15732     exit (1);
15733   }
15734
15735   filename = "test2.img";
15736   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15737   if (fd == -1) {
15738     perror (filename);
15739     exit (1);
15740   }
15741   if (lseek (fd, 52428800, SEEK_SET) == -1) {
15742     perror ("lseek");
15743     close (fd);
15744     unlink (filename);
15745     exit (1);
15746   }
15747   if (write (fd, &c, 1) == -1) {
15748     perror ("write");
15749     close (fd);
15750     unlink (filename);
15751     exit (1);
15752   }
15753   if (close (fd) == -1) {
15754     perror (filename);
15755     unlink (filename);
15756     exit (1);
15757   }
15758   if (guestfs_add_drive (g, filename) == -1) {
15759     printf ("guestfs_add_drive %s FAILED\n", filename);
15760     exit (1);
15761   }
15762
15763   filename = "test3.img";
15764   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15765   if (fd == -1) {
15766     perror (filename);
15767     exit (1);
15768   }
15769   if (lseek (fd, 10485760, SEEK_SET) == -1) {
15770     perror ("lseek");
15771     close (fd);
15772     unlink (filename);
15773     exit (1);
15774   }
15775   if (write (fd, &c, 1) == -1) {
15776     perror ("write");
15777     close (fd);
15778     unlink (filename);
15779     exit (1);
15780   }
15781   if (close (fd) == -1) {
15782     perror (filename);
15783     unlink (filename);
15784     exit (1);
15785   }
15786   if (guestfs_add_drive (g, filename) == -1) {
15787     printf ("guestfs_add_drive %s FAILED\n", filename);
15788     exit (1);
15789   }
15790
15791   if (guestfs_launch (g) == -1) {
15792     printf ("guestfs_launch FAILED\n");
15793     exit (1);
15794   }
15795   if (guestfs_wait_ready (g) == -1) {
15796     printf ("guestfs_wait_ready FAILED\n");
15797     exit (1);
15798   }
15799
15800   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
15801    * names.  This changed between RHEL 5 and RHEL 6 so we have to
15802    * support both.
15803    */
15804   devs = guestfs_list_devices (g);
15805   if (devs == NULL || devs[0] == NULL) {
15806     printf ("guestfs_list_devices FAILED\n");
15807     exit (1);
15808   }
15809   if (strncmp (devs[0], "/dev/sd", 7) == 0)
15810     devchar = 's';
15811   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
15812     devchar = 'h';
15813   else {
15814     printf ("guestfs_list_devices returned unexpected string '%s'\n",
15815             devs[0]);
15816     exit (1);
15817   }
15818   for (i = 0; devs[i] != NULL; ++i)
15819     free (devs[i]);
15820   free (devs);
15821
15822   nr_tests = 140;
15823
15824   test_num++;
15825   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
15826   if (test_find_0 () == -1) {
15827     printf ("test_find_0 FAILED\n");
15828     failed++;
15829   }
15830   test_num++;
15831   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
15832   if (test_find_1 () == -1) {
15833     printf ("test_find_1 FAILED\n");
15834     failed++;
15835   }
15836   test_num++;
15837   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
15838   if (test_find_2 () == -1) {
15839     printf ("test_find_2 FAILED\n");
15840     failed++;
15841   }
15842   test_num++;
15843   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
15844   if (test_lvresize_0 () == -1) {
15845     printf ("test_lvresize_0 FAILED\n");
15846     failed++;
15847   }
15848   test_num++;
15849   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
15850   if (test_zerofree_0 () == -1) {
15851     printf ("test_zerofree_0 FAILED\n");
15852     failed++;
15853   }
15854   test_num++;
15855   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
15856   if (test_hexdump_0 () == -1) {
15857     printf ("test_hexdump_0 FAILED\n");
15858     failed++;
15859   }
15860   test_num++;
15861   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
15862   if (test_strings_e_0 () == -1) {
15863     printf ("test_strings_e_0 FAILED\n");
15864     failed++;
15865   }
15866   test_num++;
15867   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
15868   if (test_strings_e_1 () == -1) {
15869     printf ("test_strings_e_1 FAILED\n");
15870     failed++;
15871   }
15872   test_num++;
15873   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
15874   if (test_strings_0 () == -1) {
15875     printf ("test_strings_0 FAILED\n");
15876     failed++;
15877   }
15878   test_num++;
15879   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
15880   if (test_strings_1 () == -1) {
15881     printf ("test_strings_1 FAILED\n");
15882     failed++;
15883   }
15884   test_num++;
15885   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
15886   if (test_equal_0 () == -1) {
15887     printf ("test_equal_0 FAILED\n");
15888     failed++;
15889   }
15890   test_num++;
15891   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
15892   if (test_equal_1 () == -1) {
15893     printf ("test_equal_1 FAILED\n");
15894     failed++;
15895   }
15896   test_num++;
15897   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
15898   if (test_equal_2 () == -1) {
15899     printf ("test_equal_2 FAILED\n");
15900     failed++;
15901   }
15902   test_num++;
15903   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
15904   if (test_ping_daemon_0 () == -1) {
15905     printf ("test_ping_daemon_0 FAILED\n");
15906     failed++;
15907   }
15908   test_num++;
15909   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
15910   if (test_dmesg_0 () == -1) {
15911     printf ("test_dmesg_0 FAILED\n");
15912     failed++;
15913   }
15914   test_num++;
15915   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
15916   if (test_drop_caches_0 () == -1) {
15917     printf ("test_drop_caches_0 FAILED\n");
15918     failed++;
15919   }
15920   test_num++;
15921   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
15922   if (test_mv_0 () == -1) {
15923     printf ("test_mv_0 FAILED\n");
15924     failed++;
15925   }
15926   test_num++;
15927   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
15928   if (test_mv_1 () == -1) {
15929     printf ("test_mv_1 FAILED\n");
15930     failed++;
15931   }
15932   test_num++;
15933   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
15934   if (test_cp_a_0 () == -1) {
15935     printf ("test_cp_a_0 FAILED\n");
15936     failed++;
15937   }
15938   test_num++;
15939   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
15940   if (test_cp_0 () == -1) {
15941     printf ("test_cp_0 FAILED\n");
15942     failed++;
15943   }
15944   test_num++;
15945   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
15946   if (test_cp_1 () == -1) {
15947     printf ("test_cp_1 FAILED\n");
15948     failed++;
15949   }
15950   test_num++;
15951   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
15952   if (test_cp_2 () == -1) {
15953     printf ("test_cp_2 FAILED\n");
15954     failed++;
15955   }
15956   test_num++;
15957   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
15958   if (test_grub_install_0 () == -1) {
15959     printf ("test_grub_install_0 FAILED\n");
15960     failed++;
15961   }
15962   test_num++;
15963   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
15964   if (test_zero_0 () == -1) {
15965     printf ("test_zero_0 FAILED\n");
15966     failed++;
15967   }
15968   test_num++;
15969   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
15970   if (test_fsck_0 () == -1) {
15971     printf ("test_fsck_0 FAILED\n");
15972     failed++;
15973   }
15974   test_num++;
15975   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
15976   if (test_fsck_1 () == -1) {
15977     printf ("test_fsck_1 FAILED\n");
15978     failed++;
15979   }
15980   test_num++;
15981   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
15982   if (test_set_e2uuid_0 () == -1) {
15983     printf ("test_set_e2uuid_0 FAILED\n");
15984     failed++;
15985   }
15986   test_num++;
15987   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
15988   if (test_set_e2uuid_1 () == -1) {
15989     printf ("test_set_e2uuid_1 FAILED\n");
15990     failed++;
15991   }
15992   test_num++;
15993   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
15994   if (test_set_e2uuid_2 () == -1) {
15995     printf ("test_set_e2uuid_2 FAILED\n");
15996     failed++;
15997   }
15998   test_num++;
15999   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16000   if (test_set_e2uuid_3 () == -1) {
16001     printf ("test_set_e2uuid_3 FAILED\n");
16002     failed++;
16003   }
16004   test_num++;
16005   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16006   if (test_set_e2label_0 () == -1) {
16007     printf ("test_set_e2label_0 FAILED\n");
16008     failed++;
16009   }
16010   test_num++;
16011   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16012   if (test_pvremove_0 () == -1) {
16013     printf ("test_pvremove_0 FAILED\n");
16014     failed++;
16015   }
16016   test_num++;
16017   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16018   if (test_pvremove_1 () == -1) {
16019     printf ("test_pvremove_1 FAILED\n");
16020     failed++;
16021   }
16022   test_num++;
16023   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16024   if (test_pvremove_2 () == -1) {
16025     printf ("test_pvremove_2 FAILED\n");
16026     failed++;
16027   }
16028   test_num++;
16029   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16030   if (test_vgremove_0 () == -1) {
16031     printf ("test_vgremove_0 FAILED\n");
16032     failed++;
16033   }
16034   test_num++;
16035   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16036   if (test_vgremove_1 () == -1) {
16037     printf ("test_vgremove_1 FAILED\n");
16038     failed++;
16039   }
16040   test_num++;
16041   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16042   if (test_lvremove_0 () == -1) {
16043     printf ("test_lvremove_0 FAILED\n");
16044     failed++;
16045   }
16046   test_num++;
16047   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16048   if (test_lvremove_1 () == -1) {
16049     printf ("test_lvremove_1 FAILED\n");
16050     failed++;
16051   }
16052   test_num++;
16053   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16054   if (test_lvremove_2 () == -1) {
16055     printf ("test_lvremove_2 FAILED\n");
16056     failed++;
16057   }
16058   test_num++;
16059   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16060   if (test_mount_ro_0 () == -1) {
16061     printf ("test_mount_ro_0 FAILED\n");
16062     failed++;
16063   }
16064   test_num++;
16065   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16066   if (test_mount_ro_1 () == -1) {
16067     printf ("test_mount_ro_1 FAILED\n");
16068     failed++;
16069   }
16070   test_num++;
16071   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16072   if (test_tgz_in_0 () == -1) {
16073     printf ("test_tgz_in_0 FAILED\n");
16074     failed++;
16075   }
16076   test_num++;
16077   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16078   if (test_tar_in_0 () == -1) {
16079     printf ("test_tar_in_0 FAILED\n");
16080     failed++;
16081   }
16082   test_num++;
16083   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16084   if (test_checksum_0 () == -1) {
16085     printf ("test_checksum_0 FAILED\n");
16086     failed++;
16087   }
16088   test_num++;
16089   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16090   if (test_checksum_1 () == -1) {
16091     printf ("test_checksum_1 FAILED\n");
16092     failed++;
16093   }
16094   test_num++;
16095   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16096   if (test_checksum_2 () == -1) {
16097     printf ("test_checksum_2 FAILED\n");
16098     failed++;
16099   }
16100   test_num++;
16101   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16102   if (test_checksum_3 () == -1) {
16103     printf ("test_checksum_3 FAILED\n");
16104     failed++;
16105   }
16106   test_num++;
16107   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16108   if (test_checksum_4 () == -1) {
16109     printf ("test_checksum_4 FAILED\n");
16110     failed++;
16111   }
16112   test_num++;
16113   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16114   if (test_checksum_5 () == -1) {
16115     printf ("test_checksum_5 FAILED\n");
16116     failed++;
16117   }
16118   test_num++;
16119   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16120   if (test_checksum_6 () == -1) {
16121     printf ("test_checksum_6 FAILED\n");
16122     failed++;
16123   }
16124   test_num++;
16125   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16126   if (test_checksum_7 () == -1) {
16127     printf ("test_checksum_7 FAILED\n");
16128     failed++;
16129   }
16130   test_num++;
16131   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16132   if (test_download_0 () == -1) {
16133     printf ("test_download_0 FAILED\n");
16134     failed++;
16135   }
16136   test_num++;
16137   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16138   if (test_upload_0 () == -1) {
16139     printf ("test_upload_0 FAILED\n");
16140     failed++;
16141   }
16142   test_num++;
16143   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16144   if (test_blockdev_rereadpt_0 () == -1) {
16145     printf ("test_blockdev_rereadpt_0 FAILED\n");
16146     failed++;
16147   }
16148   test_num++;
16149   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16150   if (test_blockdev_flushbufs_0 () == -1) {
16151     printf ("test_blockdev_flushbufs_0 FAILED\n");
16152     failed++;
16153   }
16154   test_num++;
16155   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16156   if (test_blockdev_getsize64_0 () == -1) {
16157     printf ("test_blockdev_getsize64_0 FAILED\n");
16158     failed++;
16159   }
16160   test_num++;
16161   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16162   if (test_blockdev_getsz_0 () == -1) {
16163     printf ("test_blockdev_getsz_0 FAILED\n");
16164     failed++;
16165   }
16166   test_num++;
16167   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16168   if (test_blockdev_getbsz_0 () == -1) {
16169     printf ("test_blockdev_getbsz_0 FAILED\n");
16170     failed++;
16171   }
16172   test_num++;
16173   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16174   if (test_blockdev_getss_0 () == -1) {
16175     printf ("test_blockdev_getss_0 FAILED\n");
16176     failed++;
16177   }
16178   test_num++;
16179   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16180   if (test_blockdev_getro_0 () == -1) {
16181     printf ("test_blockdev_getro_0 FAILED\n");
16182     failed++;
16183   }
16184   test_num++;
16185   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16186   if (test_blockdev_setrw_0 () == -1) {
16187     printf ("test_blockdev_setrw_0 FAILED\n");
16188     failed++;
16189   }
16190   test_num++;
16191   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16192   if (test_blockdev_setro_0 () == -1) {
16193     printf ("test_blockdev_setro_0 FAILED\n");
16194     failed++;
16195   }
16196   test_num++;
16197   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16198   if (test_statvfs_0 () == -1) {
16199     printf ("test_statvfs_0 FAILED\n");
16200     failed++;
16201   }
16202   test_num++;
16203   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16204   if (test_lstat_0 () == -1) {
16205     printf ("test_lstat_0 FAILED\n");
16206     failed++;
16207   }
16208   test_num++;
16209   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16210   if (test_stat_0 () == -1) {
16211     printf ("test_stat_0 FAILED\n");
16212     failed++;
16213   }
16214   test_num++;
16215   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16216   if (test_command_lines_0 () == -1) {
16217     printf ("test_command_lines_0 FAILED\n");
16218     failed++;
16219   }
16220   test_num++;
16221   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16222   if (test_command_lines_1 () == -1) {
16223     printf ("test_command_lines_1 FAILED\n");
16224     failed++;
16225   }
16226   test_num++;
16227   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16228   if (test_command_lines_2 () == -1) {
16229     printf ("test_command_lines_2 FAILED\n");
16230     failed++;
16231   }
16232   test_num++;
16233   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16234   if (test_command_lines_3 () == -1) {
16235     printf ("test_command_lines_3 FAILED\n");
16236     failed++;
16237   }
16238   test_num++;
16239   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16240   if (test_command_lines_4 () == -1) {
16241     printf ("test_command_lines_4 FAILED\n");
16242     failed++;
16243   }
16244   test_num++;
16245   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16246   if (test_command_lines_5 () == -1) {
16247     printf ("test_command_lines_5 FAILED\n");
16248     failed++;
16249   }
16250   test_num++;
16251   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16252   if (test_command_lines_6 () == -1) {
16253     printf ("test_command_lines_6 FAILED\n");
16254     failed++;
16255   }
16256   test_num++;
16257   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16258   if (test_command_lines_7 () == -1) {
16259     printf ("test_command_lines_7 FAILED\n");
16260     failed++;
16261   }
16262   test_num++;
16263   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16264   if (test_command_lines_8 () == -1) {
16265     printf ("test_command_lines_8 FAILED\n");
16266     failed++;
16267   }
16268   test_num++;
16269   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16270   if (test_command_lines_9 () == -1) {
16271     printf ("test_command_lines_9 FAILED\n");
16272     failed++;
16273   }
16274   test_num++;
16275   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16276   if (test_command_lines_10 () == -1) {
16277     printf ("test_command_lines_10 FAILED\n");
16278     failed++;
16279   }
16280   test_num++;
16281   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16282   if (test_command_0 () == -1) {
16283     printf ("test_command_0 FAILED\n");
16284     failed++;
16285   }
16286   test_num++;
16287   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16288   if (test_command_1 () == -1) {
16289     printf ("test_command_1 FAILED\n");
16290     failed++;
16291   }
16292   test_num++;
16293   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16294   if (test_command_2 () == -1) {
16295     printf ("test_command_2 FAILED\n");
16296     failed++;
16297   }
16298   test_num++;
16299   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16300   if (test_command_3 () == -1) {
16301     printf ("test_command_3 FAILED\n");
16302     failed++;
16303   }
16304   test_num++;
16305   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16306   if (test_command_4 () == -1) {
16307     printf ("test_command_4 FAILED\n");
16308     failed++;
16309   }
16310   test_num++;
16311   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16312   if (test_command_5 () == -1) {
16313     printf ("test_command_5 FAILED\n");
16314     failed++;
16315   }
16316   test_num++;
16317   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16318   if (test_command_6 () == -1) {
16319     printf ("test_command_6 FAILED\n");
16320     failed++;
16321   }
16322   test_num++;
16323   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16324   if (test_command_7 () == -1) {
16325     printf ("test_command_7 FAILED\n");
16326     failed++;
16327   }
16328   test_num++;
16329   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16330   if (test_command_8 () == -1) {
16331     printf ("test_command_8 FAILED\n");
16332     failed++;
16333   }
16334   test_num++;
16335   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16336   if (test_command_9 () == -1) {
16337     printf ("test_command_9 FAILED\n");
16338     failed++;
16339   }
16340   test_num++;
16341   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16342   if (test_command_10 () == -1) {
16343     printf ("test_command_10 FAILED\n");
16344     failed++;
16345   }
16346   test_num++;
16347   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16348   if (test_command_11 () == -1) {
16349     printf ("test_command_11 FAILED\n");
16350     failed++;
16351   }
16352   test_num++;
16353   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16354   if (test_file_0 () == -1) {
16355     printf ("test_file_0 FAILED\n");
16356     failed++;
16357   }
16358   test_num++;
16359   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16360   if (test_file_1 () == -1) {
16361     printf ("test_file_1 FAILED\n");
16362     failed++;
16363   }
16364   test_num++;
16365   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16366   if (test_file_2 () == -1) {
16367     printf ("test_file_2 FAILED\n");
16368     failed++;
16369   }
16370   test_num++;
16371   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16372   if (test_umount_all_0 () == -1) {
16373     printf ("test_umount_all_0 FAILED\n");
16374     failed++;
16375   }
16376   test_num++;
16377   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16378   if (test_umount_all_1 () == -1) {
16379     printf ("test_umount_all_1 FAILED\n");
16380     failed++;
16381   }
16382   test_num++;
16383   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16384   if (test_mounts_0 () == -1) {
16385     printf ("test_mounts_0 FAILED\n");
16386     failed++;
16387   }
16388   test_num++;
16389   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16390   if (test_umount_0 () == -1) {
16391     printf ("test_umount_0 FAILED\n");
16392     failed++;
16393   }
16394   test_num++;
16395   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16396   if (test_umount_1 () == -1) {
16397     printf ("test_umount_1 FAILED\n");
16398     failed++;
16399   }
16400   test_num++;
16401   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16402   if (test_write_file_0 () == -1) {
16403     printf ("test_write_file_0 FAILED\n");
16404     failed++;
16405   }
16406   test_num++;
16407   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16408   if (test_write_file_1 () == -1) {
16409     printf ("test_write_file_1 FAILED\n");
16410     failed++;
16411   }
16412   test_num++;
16413   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16414   if (test_write_file_2 () == -1) {
16415     printf ("test_write_file_2 FAILED\n");
16416     failed++;
16417   }
16418   test_num++;
16419   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16420   if (test_write_file_3 () == -1) {
16421     printf ("test_write_file_3 FAILED\n");
16422     failed++;
16423   }
16424   test_num++;
16425   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16426   if (test_write_file_4 () == -1) {
16427     printf ("test_write_file_4 FAILED\n");
16428     failed++;
16429   }
16430   test_num++;
16431   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16432   if (test_write_file_5 () == -1) {
16433     printf ("test_write_file_5 FAILED\n");
16434     failed++;
16435   }
16436   test_num++;
16437   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16438   if (test_mkfs_0 () == -1) {
16439     printf ("test_mkfs_0 FAILED\n");
16440     failed++;
16441   }
16442   test_num++;
16443   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16444   if (test_lvcreate_0 () == -1) {
16445     printf ("test_lvcreate_0 FAILED\n");
16446     failed++;
16447   }
16448   test_num++;
16449   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16450   if (test_vgcreate_0 () == -1) {
16451     printf ("test_vgcreate_0 FAILED\n");
16452     failed++;
16453   }
16454   test_num++;
16455   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16456   if (test_pvcreate_0 () == -1) {
16457     printf ("test_pvcreate_0 FAILED\n");
16458     failed++;
16459   }
16460   test_num++;
16461   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16462   if (test_is_dir_0 () == -1) {
16463     printf ("test_is_dir_0 FAILED\n");
16464     failed++;
16465   }
16466   test_num++;
16467   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16468   if (test_is_dir_1 () == -1) {
16469     printf ("test_is_dir_1 FAILED\n");
16470     failed++;
16471   }
16472   test_num++;
16473   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16474   if (test_is_file_0 () == -1) {
16475     printf ("test_is_file_0 FAILED\n");
16476     failed++;
16477   }
16478   test_num++;
16479   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16480   if (test_is_file_1 () == -1) {
16481     printf ("test_is_file_1 FAILED\n");
16482     failed++;
16483   }
16484   test_num++;
16485   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16486   if (test_exists_0 () == -1) {
16487     printf ("test_exists_0 FAILED\n");
16488     failed++;
16489   }
16490   test_num++;
16491   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16492   if (test_exists_1 () == -1) {
16493     printf ("test_exists_1 FAILED\n");
16494     failed++;
16495   }
16496   test_num++;
16497   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16498   if (test_mkdir_p_0 () == -1) {
16499     printf ("test_mkdir_p_0 FAILED\n");
16500     failed++;
16501   }
16502   test_num++;
16503   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16504   if (test_mkdir_p_1 () == -1) {
16505     printf ("test_mkdir_p_1 FAILED\n");
16506     failed++;
16507   }
16508   test_num++;
16509   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16510   if (test_mkdir_p_2 () == -1) {
16511     printf ("test_mkdir_p_2 FAILED\n");
16512     failed++;
16513   }
16514   test_num++;
16515   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16516   if (test_mkdir_0 () == -1) {
16517     printf ("test_mkdir_0 FAILED\n");
16518     failed++;
16519   }
16520   test_num++;
16521   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16522   if (test_mkdir_1 () == -1) {
16523     printf ("test_mkdir_1 FAILED\n");
16524     failed++;
16525   }
16526   test_num++;
16527   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16528   if (test_rm_rf_0 () == -1) {
16529     printf ("test_rm_rf_0 FAILED\n");
16530     failed++;
16531   }
16532   test_num++;
16533   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16534   if (test_rmdir_0 () == -1) {
16535     printf ("test_rmdir_0 FAILED\n");
16536     failed++;
16537   }
16538   test_num++;
16539   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16540   if (test_rmdir_1 () == -1) {
16541     printf ("test_rmdir_1 FAILED\n");
16542     failed++;
16543   }
16544   test_num++;
16545   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16546   if (test_rmdir_2 () == -1) {
16547     printf ("test_rmdir_2 FAILED\n");
16548     failed++;
16549   }
16550   test_num++;
16551   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16552   if (test_rm_0 () == -1) {
16553     printf ("test_rm_0 FAILED\n");
16554     failed++;
16555   }
16556   test_num++;
16557   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16558   if (test_rm_1 () == -1) {
16559     printf ("test_rm_1 FAILED\n");
16560     failed++;
16561   }
16562   test_num++;
16563   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16564   if (test_rm_2 () == -1) {
16565     printf ("test_rm_2 FAILED\n");
16566     failed++;
16567   }
16568   test_num++;
16569   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16570   if (test_read_lines_0 () == -1) {
16571     printf ("test_read_lines_0 FAILED\n");
16572     failed++;
16573   }
16574   test_num++;
16575   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16576   if (test_read_lines_1 () == -1) {
16577     printf ("test_read_lines_1 FAILED\n");
16578     failed++;
16579   }
16580   test_num++;
16581   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16582   if (test_lvs_0 () == -1) {
16583     printf ("test_lvs_0 FAILED\n");
16584     failed++;
16585   }
16586   test_num++;
16587   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16588   if (test_lvs_1 () == -1) {
16589     printf ("test_lvs_1 FAILED\n");
16590     failed++;
16591   }
16592   test_num++;
16593   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16594   if (test_vgs_0 () == -1) {
16595     printf ("test_vgs_0 FAILED\n");
16596     failed++;
16597   }
16598   test_num++;
16599   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16600   if (test_vgs_1 () == -1) {
16601     printf ("test_vgs_1 FAILED\n");
16602     failed++;
16603   }
16604   test_num++;
16605   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16606   if (test_pvs_0 () == -1) {
16607     printf ("test_pvs_0 FAILED\n");
16608     failed++;
16609   }
16610   test_num++;
16611   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16612   if (test_pvs_1 () == -1) {
16613     printf ("test_pvs_1 FAILED\n");
16614     failed++;
16615   }
16616   test_num++;
16617   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16618   if (test_list_partitions_0 () == -1) {
16619     printf ("test_list_partitions_0 FAILED\n");
16620     failed++;
16621   }
16622   test_num++;
16623   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16624   if (test_list_partitions_1 () == -1) {
16625     printf ("test_list_partitions_1 FAILED\n");
16626     failed++;
16627   }
16628   test_num++;
16629   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16630   if (test_list_devices_0 () == -1) {
16631     printf ("test_list_devices_0 FAILED\n");
16632     failed++;
16633   }
16634   test_num++;
16635   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16636   if (test_ls_0 () == -1) {
16637     printf ("test_ls_0 FAILED\n");
16638     failed++;
16639   }
16640   test_num++;
16641   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16642   if (test_cat_0 () == -1) {
16643     printf ("test_cat_0 FAILED\n");
16644     failed++;
16645   }
16646   test_num++;
16647   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
16648   if (test_touch_0 () == -1) {
16649     printf ("test_touch_0 FAILED\n");
16650     failed++;
16651   }
16652   test_num++;
16653   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
16654   if (test_sync_0 () == -1) {
16655     printf ("test_sync_0 FAILED\n");
16656     failed++;
16657   }
16658   test_num++;
16659   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
16660   if (test_mount_0 () == -1) {
16661     printf ("test_mount_0 FAILED\n");
16662     failed++;
16663   }
16664
16665   guestfs_close (g);
16666   unlink ("test1.img");
16667   unlink ("test2.img");
16668   unlink ("test3.img");
16669
16670   if (failed > 0) {
16671     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
16672     exit (1);
16673   }
16674
16675   exit (0);
16676 }