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 }
 128
 129 static int test_find_0 (void)
 130 {
 131   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 132   {
 133     char device[] = "/dev/sda";
 134     device[5] = devchar;
 135     int r;
 136     suppress_error = 0;
 137     r = guestfs_blockdev_setrw (g, device);
 138     if (r == -1)
 139       return -1;
 140   }
 141   {
 142     int r;
 143     suppress_error = 0;
 144     r = guestfs_umount_all (g);
 145     if (r == -1)
 146       return -1;
 147   }
 148   {
 149     int r;
 150     suppress_error = 0;
 151     r = guestfs_lvm_remove_all (g);
 152     if (r == -1)
 153       return -1;
 154   }
 155   {
 156     char device[] = "/dev/sda";
 157     device[5] = devchar;
 158     char lines_0[] = ",";
 159     char *lines[] = {
 160       lines_0,
 161       NULL
 162     };
 163     int r;
 164     suppress_error = 0;
 165     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 166     if (r == -1)
 167       return -1;
 168   }
 169   {
 170     char fstype[] = "ext2";
 171     char device[] = "/dev/sda1";
 172     device[5] = devchar;
 173     int r;
 174     suppress_error = 0;
 175     r = guestfs_mkfs (g, fstype, device);
 176     if (r == -1)
 177       return -1;
 178   }
 179   {
 180     char device[] = "/dev/sda1";
 181     device[5] = devchar;
 182     char mountpoint[] = "/";
 183     int r;
 184     suppress_error = 0;
 185     r = guestfs_mount (g, device, mountpoint);
 186     if (r == -1)
 187       return -1;
 188   }
 189   /* TestOutputList for find (0) */
 190   {
 191     char directory[] = "/";
 192     char **r;
 193     int i;
 194     suppress_error = 0;
 195     r = guestfs_find (g, directory);
 196     if (r == NULL)
 197       return -1;
 198     if (!r[0]) {
 199       fprintf (stderr, "test_find_0: short list returned from command\n");
 200       print_strings (r);
 201       return -1;
 202     }
 203     {
 204       char expected[] = "lost+found";
 205       if (strcmp (r[0], expected) != 0) {
 206         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 207         return -1;
 208       }
 209     }
 210     if (r[1] != NULL) {
 211       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 212       print_strings (r);
 213       return -1;
 214     }
 215     for (i = 0; r[i] != NULL; ++i)
 216       free (r[i]);
 217     free (r);
 218   }
 219   return 0;
 220 }
 221
 222 static int test_find_1 (void)
 223 {
 224   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
 225   {
 226     char device[] = "/dev/sda";
 227     device[5] = devchar;
 228     int r;
 229     suppress_error = 0;
 230     r = guestfs_blockdev_setrw (g, device);
 231     if (r == -1)
 232       return -1;
 233   }
 234   {
 235     int r;
 236     suppress_error = 0;
 237     r = guestfs_umount_all (g);
 238     if (r == -1)
 239       return -1;
 240   }
 241   {
 242     int r;
 243     suppress_error = 0;
 244     r = guestfs_lvm_remove_all (g);
 245     if (r == -1)
 246       return -1;
 247   }
 248   {
 249     char device[] = "/dev/sda";
 250     device[5] = devchar;
 251     char lines_0[] = ",";
 252     char *lines[] = {
 253       lines_0,
 254       NULL
 255     };
 256     int r;
 257     suppress_error = 0;
 258     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 259     if (r == -1)
 260       return -1;
 261   }
 262   {
 263     char fstype[] = "ext2";
 264     char device[] = "/dev/sda1";
 265     device[5] = devchar;
 266     int r;
 267     suppress_error = 0;
 268     r = guestfs_mkfs (g, fstype, device);
 269     if (r == -1)
 270       return -1;
 271   }
 272   {
 273     char device[] = "/dev/sda1";
 274     device[5] = devchar;
 275     char mountpoint[] = "/";
 276     int r;
 277     suppress_error = 0;
 278     r = guestfs_mount (g, device, mountpoint);
 279     if (r == -1)
 280       return -1;
 281   }
 282   /* TestOutputList for find (1) */
 283   {
 284     char path[] = "/a";
 285     int r;
 286     suppress_error = 0;
 287     r = guestfs_touch (g, path);
 288     if (r == -1)
 289       return -1;
 290   }
 291   {
 292     char path[] = "/b";
 293     int r;
 294     suppress_error = 0;
 295     r = guestfs_mkdir (g, path);
 296     if (r == -1)
 297       return -1;
 298   }
 299   {
 300     char path[] = "/b/c";
 301     int r;
 302     suppress_error = 0;
 303     r = guestfs_touch (g, path);
 304     if (r == -1)
 305       return -1;
 306   }
 307   {
 308     char directory[] = "/";
 309     char **r;
 310     int i;
 311     suppress_error = 0;
 312     r = guestfs_find (g, directory);
 313     if (r == NULL)
 314       return -1;
 315     if (!r[0]) {
 316       fprintf (stderr, "test_find_1: short list returned from command\n");
 317       print_strings (r);
 318       return -1;
 319     }
 320     {
 321       char expected[] = "a";
 322       if (strcmp (r[0], expected) != 0) {
 323         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 324         return -1;
 325       }
 326     }
 327     if (!r[1]) {
 328       fprintf (stderr, "test_find_1: short list returned from command\n");
 329       print_strings (r);
 330       return -1;
 331     }
 332     {
 333       char expected[] = "b";
 334       if (strcmp (r[1], expected) != 0) {
 335         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 336         return -1;
 337       }
 338     }
 339     if (!r[2]) {
 340       fprintf (stderr, "test_find_1: short list returned from command\n");
 341       print_strings (r);
 342       return -1;
 343     }
 344     {
 345       char expected[] = "b/c";
 346       if (strcmp (r[2], expected) != 0) {
 347         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 348         return -1;
 349       }
 350     }
 351     if (!r[3]) {
 352       fprintf (stderr, "test_find_1: short list returned from command\n");
 353       print_strings (r);
 354       return -1;
 355     }
 356     {
 357       char expected[] = "lost+found";
 358       if (strcmp (r[3], expected) != 0) {
 359         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 360         return -1;
 361       }
 362     }
 363     if (r[4] != NULL) {
 364       fprintf (stderr, "test_find_1: extra elements returned from command\n");
 365       print_strings (r);
 366       return -1;
 367     }
 368     for (i = 0; r[i] != NULL; ++i)
 369       free (r[i]);
 370     free (r);
 371   }
 372   return 0;
 373 }
 374
 375 static int test_find_2 (void)
 376 {
 377   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
 378   {
 379     char device[] = "/dev/sda";
 380     device[5] = devchar;
 381     int r;
 382     suppress_error = 0;
 383     r = guestfs_blockdev_setrw (g, device);
 384     if (r == -1)
 385       return -1;
 386   }
 387   {
 388     int r;
 389     suppress_error = 0;
 390     r = guestfs_umount_all (g);
 391     if (r == -1)
 392       return -1;
 393   }
 394   {
 395     int r;
 396     suppress_error = 0;
 397     r = guestfs_lvm_remove_all (g);
 398     if (r == -1)
 399       return -1;
 400   }
 401   {
 402     char device[] = "/dev/sda";
 403     device[5] = devchar;
 404     char lines_0[] = ",";
 405     char *lines[] = {
 406       lines_0,
 407       NULL
 408     };
 409     int r;
 410     suppress_error = 0;
 411     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 412     if (r == -1)
 413       return -1;
 414   }
 415   {
 416     char fstype[] = "ext2";
 417     char device[] = "/dev/sda1";
 418     device[5] = devchar;
 419     int r;
 420     suppress_error = 0;
 421     r = guestfs_mkfs (g, fstype, device);
 422     if (r == -1)
 423       return -1;
 424   }
 425   {
 426     char device[] = "/dev/sda1";
 427     device[5] = devchar;
 428     char mountpoint[] = "/";
 429     int r;
 430     suppress_error = 0;
 431     r = guestfs_mount (g, device, mountpoint);
 432     if (r == -1)
 433       return -1;
 434   }
 435   /* TestOutputList for find (2) */
 436   {
 437     char path[] = "/a/b/c";
 438     int r;
 439     suppress_error = 0;
 440     r = guestfs_mkdir_p (g, path);
 441     if (r == -1)
 442       return -1;
 443   }
 444   {
 445     char path[] = "/a/b/c/d";
 446     int r;
 447     suppress_error = 0;
 448     r = guestfs_touch (g, path);
 449     if (r == -1)
 450       return -1;
 451   }
 452   {
 453     char directory[] = "/a/b/";
 454     char **r;
 455     int i;
 456     suppress_error = 0;
 457     r = guestfs_find (g, directory);
 458     if (r == NULL)
 459       return -1;
 460     if (!r[0]) {
 461       fprintf (stderr, "test_find_2: short list returned from command\n");
 462       print_strings (r);
 463       return -1;
 464     }
 465     {
 466       char expected[] = "c";
 467       if (strcmp (r[0], expected) != 0) {
 468         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 469         return -1;
 470       }
 471     }
 472     if (!r[1]) {
 473       fprintf (stderr, "test_find_2: short list returned from command\n");
 474       print_strings (r);
 475       return -1;
 476     }
 477     {
 478       char expected[] = "c/d";
 479       if (strcmp (r[1], expected) != 0) {
 480         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 481         return -1;
 482       }
 483     }
 484     if (r[2] != NULL) {
 485       fprintf (stderr, "test_find_2: extra elements returned from command\n");
 486       print_strings (r);
 487       return -1;
 488     }
 489     for (i = 0; r[i] != NULL; ++i)
 490       free (r[i]);
 491     free (r);
 492   }
 493   return 0;
 494 }
 495
 496 static int test_lvresize_0 (void)
 497 {
 498   /* InitNone|InitEmpty for test_lvresize_0 */
 499   {
 500     char device[] = "/dev/sda";
 501     device[5] = devchar;
 502     int r;
 503     suppress_error = 0;
 504     r = guestfs_blockdev_setrw (g, device);
 505     if (r == -1)
 506       return -1;
 507   }
 508   {
 509     int r;
 510     suppress_error = 0;
 511     r = guestfs_umount_all (g);
 512     if (r == -1)
 513       return -1;
 514   }
 515   {
 516     int r;
 517     suppress_error = 0;
 518     r = guestfs_lvm_remove_all (g);
 519     if (r == -1)
 520       return -1;
 521   }
 522   /* TestOutput for lvresize (0) */
 523   char expected[] = "test content";
 524   {
 525     char device[] = "/dev/sda";
 526     device[5] = devchar;
 527     char lines_0[] = ",";
 528     char *lines[] = {
 529       lines_0,
 530       NULL
 531     };
 532     int r;
 533     suppress_error = 0;
 534     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 535     if (r == -1)
 536       return -1;
 537   }
 538   {
 539     char device[] = "/dev/sda1";
 540     device[5] = devchar;
 541     int r;
 542     suppress_error = 0;
 543     r = guestfs_pvcreate (g, device);
 544     if (r == -1)
 545       return -1;
 546   }
 547   {
 548     char volgroup[] = "VG";
 549     char physvols_0[] = "/dev/sda1";
 550     physvols_0[5] = devchar;
 551     char *physvols[] = {
 552       physvols_0,
 553       NULL
 554     };
 555     int r;
 556     suppress_error = 0;
 557     r = guestfs_vgcreate (g, volgroup, physvols);
 558     if (r == -1)
 559       return -1;
 560   }
 561   {
 562     char logvol[] = "LV";
 563     char volgroup[] = "VG";
 564     int r;
 565     suppress_error = 0;
 566     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 567     if (r == -1)
 568       return -1;
 569   }
 570   {
 571     char fstype[] = "ext2";
 572     char device[] = "/dev/VG/LV";
 573     int r;
 574     suppress_error = 0;
 575     r = guestfs_mkfs (g, fstype, device);
 576     if (r == -1)
 577       return -1;
 578   }
 579   {
 580     char device[] = "/dev/VG/LV";
 581     char mountpoint[] = "/";
 582     int r;
 583     suppress_error = 0;
 584     r = guestfs_mount (g, device, mountpoint);
 585     if (r == -1)
 586       return -1;
 587   }
 588   {
 589     char path[] = "/new";
 590     char content[] = "test content";
 591     int r;
 592     suppress_error = 0;
 593     r = guestfs_write_file (g, path, content, 0);
 594     if (r == -1)
 595       return -1;
 596   }
 597   {
 598     char pathordevice[] = "/";
 599     int r;
 600     suppress_error = 0;
 601     r = guestfs_umount (g, pathordevice);
 602     if (r == -1)
 603       return -1;
 604   }
 605   {
 606     char device[] = "/dev/VG/LV";
 607     int r;
 608     suppress_error = 0;
 609     r = guestfs_lvresize (g, device, 20);
 610     if (r == -1)
 611       return -1;
 612   }
 613   {
 614     char device[] = "/dev/VG/LV";
 615     int r;
 616     suppress_error = 0;
 617     r = guestfs_resize2fs (g, device);
 618     if (r == -1)
 619       return -1;
 620   }
 621   {
 622     char device[] = "/dev/VG/LV";
 623     char mountpoint[] = "/";
 624     int r;
 625     suppress_error = 0;
 626     r = guestfs_mount (g, device, mountpoint);
 627     if (r == -1)
 628       return -1;
 629   }
 630   {
 631     char path[] = "/new";
 632     char *r;
 633     suppress_error = 0;
 634     r = guestfs_cat (g, path);
 635     if (r == NULL)
 636       return -1;
 637     if (strcmp (r, expected) != 0) {
 638       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 639       return -1;
 640     }
 641     free (r);
 642   }
 643   return 0;
 644 }
 645
 646 static int test_zerofree_0_prereq (void)
 647 {
 648   const char *str = getenv ("SKIP_ZEROFREE");
 649   return str && strcmp (str, "1") == 0;
 650 }
 651
 652 static int test_zerofree_0 (void)
 653 {
 654   if (! test_zerofree_0_prereq ()) {
 655   /* InitNone|InitEmpty for test_zerofree_0 */
 656   {
 657     char device[] = "/dev/sda";
 658     device[5] = devchar;
 659     int r;
 660     suppress_error = 0;
 661     r = guestfs_blockdev_setrw (g, device);
 662     if (r == -1)
 663       return -1;
 664   }
 665   {
 666     int r;
 667     suppress_error = 0;
 668     r = guestfs_umount_all (g);
 669     if (r == -1)
 670       return -1;
 671   }
 672   {
 673     int r;
 674     suppress_error = 0;
 675     r = guestfs_lvm_remove_all (g);
 676     if (r == -1)
 677       return -1;
 678   }
 679   /* TestOutput for zerofree (0) */
 680   char expected[] = "test file";
 681   {
 682     char device[] = "/dev/sda";
 683     device[5] = devchar;
 684     char lines_0[] = ",";
 685     char *lines[] = {
 686       lines_0,
 687       NULL
 688     };
 689     int r;
 690     suppress_error = 0;
 691     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 692     if (r == -1)
 693       return -1;
 694   }
 695   {
 696     char fstype[] = "ext3";
 697     char device[] = "/dev/sda1";
 698     device[5] = devchar;
 699     int r;
 700     suppress_error = 0;
 701     r = guestfs_mkfs (g, fstype, device);
 702     if (r == -1)
 703       return -1;
 704   }
 705   {
 706     char device[] = "/dev/sda1";
 707     device[5] = devchar;
 708     char mountpoint[] = "/";
 709     int r;
 710     suppress_error = 0;
 711     r = guestfs_mount (g, device, mountpoint);
 712     if (r == -1)
 713       return -1;
 714   }
 715   {
 716     char path[] = "/new";
 717     char content[] = "test file";
 718     int r;
 719     suppress_error = 0;
 720     r = guestfs_write_file (g, path, content, 0);
 721     if (r == -1)
 722       return -1;
 723   }
 724   {
 725     char pathordevice[] = "/dev/sda1";
 726     pathordevice[5] = devchar;
 727     int r;
 728     suppress_error = 0;
 729     r = guestfs_umount (g, pathordevice);
 730     if (r == -1)
 731       return -1;
 732   }
 733   {
 734     char device[] = "/dev/sda1";
 735     device[5] = devchar;
 736     int r;
 737     suppress_error = 0;
 738     r = guestfs_zerofree (g, device);
 739     if (r == -1)
 740       return -1;
 741   }
 742   {
 743     char device[] = "/dev/sda1";
 744     device[5] = devchar;
 745     char mountpoint[] = "/";
 746     int r;
 747     suppress_error = 0;
 748     r = guestfs_mount (g, device, mountpoint);
 749     if (r == -1)
 750       return -1;
 751   }
 752   {
 753     char path[] = "/new";
 754     char *r;
 755     suppress_error = 0;
 756     r = guestfs_cat (g, path);
 757     if (r == NULL)
 758       return -1;
 759     if (strcmp (r, expected) != 0) {
 760       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
 761       return -1;
 762     }
 763     free (r);
 764   }
 765   } else
 766     printf ("%s skipped (reason: test prerequisite)\n", "test_zerofree_0");
 767   return 0;
 768 }
 769
 770 static int test_hexdump_0 (void)
 771 {
 772   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
 773   {
 774     char device[] = "/dev/sda";
 775     device[5] = devchar;
 776     int r;
 777     suppress_error = 0;
 778     r = guestfs_blockdev_setrw (g, device);
 779     if (r == -1)
 780       return -1;
 781   }
 782   {
 783     int r;
 784     suppress_error = 0;
 785     r = guestfs_umount_all (g);
 786     if (r == -1)
 787       return -1;
 788   }
 789   {
 790     int r;
 791     suppress_error = 0;
 792     r = guestfs_lvm_remove_all (g);
 793     if (r == -1)
 794       return -1;
 795   }
 796   {
 797     char device[] = "/dev/sda";
 798     device[5] = devchar;
 799     char lines_0[] = ",";
 800     char *lines[] = {
 801       lines_0,
 802       NULL
 803     };
 804     int r;
 805     suppress_error = 0;
 806     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 807     if (r == -1)
 808       return -1;
 809   }
 810   {
 811     char fstype[] = "ext2";
 812     char device[] = "/dev/sda1";
 813     device[5] = devchar;
 814     int r;
 815     suppress_error = 0;
 816     r = guestfs_mkfs (g, fstype, device);
 817     if (r == -1)
 818       return -1;
 819   }
 820   {
 821     char device[] = "/dev/sda1";
 822     device[5] = devchar;
 823     char mountpoint[] = "/";
 824     int r;
 825     suppress_error = 0;
 826     r = guestfs_mount (g, device, mountpoint);
 827     if (r == -1)
 828       return -1;
 829   }
 830   /* TestOutput for hexdump (0) */
 831   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
 832   {
 833     char path[] = "/new";
 834     char content[] = "hello\nworld\n";
 835     int r;
 836     suppress_error = 0;
 837     r = guestfs_write_file (g, path, content, 12);
 838     if (r == -1)
 839       return -1;
 840   }
 841   {
 842     char path[] = "/new";
 843     char *r;
 844     suppress_error = 0;
 845     r = guestfs_hexdump (g, path);
 846     if (r == NULL)
 847       return -1;
 848     if (strcmp (r, expected) != 0) {
 849       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
 850       return -1;
 851     }
 852     free (r);
 853   }
 854   return 0;
 855 }
 856
 857 static int test_strings_e_0 (void)
 858 {
 859   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
 860   {
 861     char device[] = "/dev/sda";
 862     device[5] = devchar;
 863     int r;
 864     suppress_error = 0;
 865     r = guestfs_blockdev_setrw (g, device);
 866     if (r == -1)
 867       return -1;
 868   }
 869   {
 870     int r;
 871     suppress_error = 0;
 872     r = guestfs_umount_all (g);
 873     if (r == -1)
 874       return -1;
 875   }
 876   {
 877     int r;
 878     suppress_error = 0;
 879     r = guestfs_lvm_remove_all (g);
 880     if (r == -1)
 881       return -1;
 882   }
 883   {
 884     char device[] = "/dev/sda";
 885     device[5] = devchar;
 886     char lines_0[] = ",";
 887     char *lines[] = {
 888       lines_0,
 889       NULL
 890     };
 891     int r;
 892     suppress_error = 0;
 893     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 894     if (r == -1)
 895       return -1;
 896   }
 897   {
 898     char fstype[] = "ext2";
 899     char device[] = "/dev/sda1";
 900     device[5] = devchar;
 901     int r;
 902     suppress_error = 0;
 903     r = guestfs_mkfs (g, fstype, device);
 904     if (r == -1)
 905       return -1;
 906   }
 907   {
 908     char device[] = "/dev/sda1";
 909     device[5] = devchar;
 910     char mountpoint[] = "/";
 911     int r;
 912     suppress_error = 0;
 913     r = guestfs_mount (g, device, mountpoint);
 914     if (r == -1)
 915       return -1;
 916   }
 917   /* TestOutputList for strings_e (0) */
 918   {
 919     char path[] = "/new";
 920     char content[] = "hello\nworld\n";
 921     int r;
 922     suppress_error = 0;
 923     r = guestfs_write_file (g, path, content, 0);
 924     if (r == -1)
 925       return -1;
 926   }
 927   {
 928     char encoding[] = "b";
 929     char path[] = "/new";
 930     char **r;
 931     int i;
 932     suppress_error = 0;
 933     r = guestfs_strings_e (g, encoding, path);
 934     if (r == NULL)
 935       return -1;
 936     if (r[0] != NULL) {
 937       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
 938       print_strings (r);
 939       return -1;
 940     }
 941     for (i = 0; r[i] != NULL; ++i)
 942       free (r[i]);
 943     free (r);
 944   }
 945   return 0;
 946 }
 947
 948 static int test_strings_e_1 (void)
 949 {
 950   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
 951   return 0;
 952 }
 953
 954 static int test_strings_0 (void)
 955 {
 956   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
 957   {
 958     char device[] = "/dev/sda";
 959     device[5] = devchar;
 960     int r;
 961     suppress_error = 0;
 962     r = guestfs_blockdev_setrw (g, device);
 963     if (r == -1)
 964       return -1;
 965   }
 966   {
 967     int r;
 968     suppress_error = 0;
 969     r = guestfs_umount_all (g);
 970     if (r == -1)
 971       return -1;
 972   }
 973   {
 974     int r;
 975     suppress_error = 0;
 976     r = guestfs_lvm_remove_all (g);
 977     if (r == -1)
 978       return -1;
 979   }
 980   {
 981     char device[] = "/dev/sda";
 982     device[5] = devchar;
 983     char lines_0[] = ",";
 984     char *lines[] = {
 985       lines_0,
 986       NULL
 987     };
 988     int r;
 989     suppress_error = 0;
 990     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 991     if (r == -1)
 992       return -1;
 993   }
 994   {
 995     char fstype[] = "ext2";
 996     char device[] = "/dev/sda1";
 997     device[5] = devchar;
 998     int r;
 999     suppress_error = 0;
1000     r = guestfs_mkfs (g, fstype, device);
1001     if (r == -1)
1002       return -1;
1003   }
1004   {
1005     char device[] = "/dev/sda1";
1006     device[5] = devchar;
1007     char mountpoint[] = "/";
1008     int r;
1009     suppress_error = 0;
1010     r = guestfs_mount (g, device, mountpoint);
1011     if (r == -1)
1012       return -1;
1013   }
1014   /* TestOutputList for strings (0) */
1015   {
1016     char path[] = "/new";
1017     char content[] = "hello\nworld\n";
1018     int r;
1019     suppress_error = 0;
1020     r = guestfs_write_file (g, path, content, 0);
1021     if (r == -1)
1022       return -1;
1023   }
1024   {
1025     char path[] = "/new";
1026     char **r;
1027     int i;
1028     suppress_error = 0;
1029     r = guestfs_strings (g, path);
1030     if (r == NULL)
1031       return -1;
1032     if (!r[0]) {
1033       fprintf (stderr, "test_strings_0: short list returned from command\n");
1034       print_strings (r);
1035       return -1;
1036     }
1037     {
1038       char expected[] = "hello";
1039       if (strcmp (r[0], expected) != 0) {
1040         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1041         return -1;
1042       }
1043     }
1044     if (!r[1]) {
1045       fprintf (stderr, "test_strings_0: short list returned from command\n");
1046       print_strings (r);
1047       return -1;
1048     }
1049     {
1050       char expected[] = "world";
1051       if (strcmp (r[1], expected) != 0) {
1052         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1053         return -1;
1054       }
1055     }
1056     if (r[2] != NULL) {
1057       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1058       print_strings (r);
1059       return -1;
1060     }
1061     for (i = 0; r[i] != NULL; ++i)
1062       free (r[i]);
1063     free (r);
1064   }
1065   return 0;
1066 }
1067
1068 static int test_strings_1 (void)
1069 {
1070   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1071   {
1072     char device[] = "/dev/sda";
1073     device[5] = devchar;
1074     int r;
1075     suppress_error = 0;
1076     r = guestfs_blockdev_setrw (g, device);
1077     if (r == -1)
1078       return -1;
1079   }
1080   {
1081     int r;
1082     suppress_error = 0;
1083     r = guestfs_umount_all (g);
1084     if (r == -1)
1085       return -1;
1086   }
1087   {
1088     int r;
1089     suppress_error = 0;
1090     r = guestfs_lvm_remove_all (g);
1091     if (r == -1)
1092       return -1;
1093   }
1094   {
1095     char device[] = "/dev/sda";
1096     device[5] = devchar;
1097     char lines_0[] = ",";
1098     char *lines[] = {
1099       lines_0,
1100       NULL
1101     };
1102     int r;
1103     suppress_error = 0;
1104     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1105     if (r == -1)
1106       return -1;
1107   }
1108   {
1109     char fstype[] = "ext2";
1110     char device[] = "/dev/sda1";
1111     device[5] = devchar;
1112     int r;
1113     suppress_error = 0;
1114     r = guestfs_mkfs (g, fstype, device);
1115     if (r == -1)
1116       return -1;
1117   }
1118   {
1119     char device[] = "/dev/sda1";
1120     device[5] = devchar;
1121     char mountpoint[] = "/";
1122     int r;
1123     suppress_error = 0;
1124     r = guestfs_mount (g, device, mountpoint);
1125     if (r == -1)
1126       return -1;
1127   }
1128   /* TestOutputList for strings (1) */
1129   {
1130     char path[] = "/new";
1131     int r;
1132     suppress_error = 0;
1133     r = guestfs_touch (g, path);
1134     if (r == -1)
1135       return -1;
1136   }
1137   {
1138     char path[] = "/new";
1139     char **r;
1140     int i;
1141     suppress_error = 0;
1142     r = guestfs_strings (g, path);
1143     if (r == NULL)
1144       return -1;
1145     if (r[0] != NULL) {
1146       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1147       print_strings (r);
1148       return -1;
1149     }
1150     for (i = 0; r[i] != NULL; ++i)
1151       free (r[i]);
1152     free (r);
1153   }
1154   return 0;
1155 }
1156
1157 static int test_equal_0 (void)
1158 {
1159   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1160   {
1161     char device[] = "/dev/sda";
1162     device[5] = devchar;
1163     int r;
1164     suppress_error = 0;
1165     r = guestfs_blockdev_setrw (g, device);
1166     if (r == -1)
1167       return -1;
1168   }
1169   {
1170     int r;
1171     suppress_error = 0;
1172     r = guestfs_umount_all (g);
1173     if (r == -1)
1174       return -1;
1175   }
1176   {
1177     int r;
1178     suppress_error = 0;
1179     r = guestfs_lvm_remove_all (g);
1180     if (r == -1)
1181       return -1;
1182   }
1183   {
1184     char device[] = "/dev/sda";
1185     device[5] = devchar;
1186     char lines_0[] = ",";
1187     char *lines[] = {
1188       lines_0,
1189       NULL
1190     };
1191     int r;
1192     suppress_error = 0;
1193     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1194     if (r == -1)
1195       return -1;
1196   }
1197   {
1198     char fstype[] = "ext2";
1199     char device[] = "/dev/sda1";
1200     device[5] = devchar;
1201     int r;
1202     suppress_error = 0;
1203     r = guestfs_mkfs (g, fstype, device);
1204     if (r == -1)
1205       return -1;
1206   }
1207   {
1208     char device[] = "/dev/sda1";
1209     device[5] = devchar;
1210     char mountpoint[] = "/";
1211     int r;
1212     suppress_error = 0;
1213     r = guestfs_mount (g, device, mountpoint);
1214     if (r == -1)
1215       return -1;
1216   }
1217   /* TestOutputTrue for equal (0) */
1218   {
1219     char path[] = "/file1";
1220     char content[] = "contents of a file";
1221     int r;
1222     suppress_error = 0;
1223     r = guestfs_write_file (g, path, content, 0);
1224     if (r == -1)
1225       return -1;
1226   }
1227   {
1228     char src[] = "/file1";
1229     char dest[] = "/file2";
1230     int r;
1231     suppress_error = 0;
1232     r = guestfs_cp (g, src, dest);
1233     if (r == -1)
1234       return -1;
1235   }
1236   {
1237     char file1[] = "/file1";
1238     char file2[] = "/file2";
1239     int r;
1240     suppress_error = 0;
1241     r = guestfs_equal (g, file1, file2);
1242     if (r == -1)
1243       return -1;
1244     if (!r) {
1245       fprintf (stderr, "test_equal_0: expected true, got false\n");
1246       return -1;
1247     }
1248   }
1249   return 0;
1250 }
1251
1252 static int test_equal_1 (void)
1253 {
1254   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1255   {
1256     char device[] = "/dev/sda";
1257     device[5] = devchar;
1258     int r;
1259     suppress_error = 0;
1260     r = guestfs_blockdev_setrw (g, device);
1261     if (r == -1)
1262       return -1;
1263   }
1264   {
1265     int r;
1266     suppress_error = 0;
1267     r = guestfs_umount_all (g);
1268     if (r == -1)
1269       return -1;
1270   }
1271   {
1272     int r;
1273     suppress_error = 0;
1274     r = guestfs_lvm_remove_all (g);
1275     if (r == -1)
1276       return -1;
1277   }
1278   {
1279     char device[] = "/dev/sda";
1280     device[5] = devchar;
1281     char lines_0[] = ",";
1282     char *lines[] = {
1283       lines_0,
1284       NULL
1285     };
1286     int r;
1287     suppress_error = 0;
1288     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1289     if (r == -1)
1290       return -1;
1291   }
1292   {
1293     char fstype[] = "ext2";
1294     char device[] = "/dev/sda1";
1295     device[5] = devchar;
1296     int r;
1297     suppress_error = 0;
1298     r = guestfs_mkfs (g, fstype, device);
1299     if (r == -1)
1300       return -1;
1301   }
1302   {
1303     char device[] = "/dev/sda1";
1304     device[5] = devchar;
1305     char mountpoint[] = "/";
1306     int r;
1307     suppress_error = 0;
1308     r = guestfs_mount (g, device, mountpoint);
1309     if (r == -1)
1310       return -1;
1311   }
1312   /* TestOutputFalse for equal (1) */
1313   {
1314     char path[] = "/file1";
1315     char content[] = "contents of a file";
1316     int r;
1317     suppress_error = 0;
1318     r = guestfs_write_file (g, path, content, 0);
1319     if (r == -1)
1320       return -1;
1321   }
1322   {
1323     char path[] = "/file2";
1324     char content[] = "contents of another file";
1325     int r;
1326     suppress_error = 0;
1327     r = guestfs_write_file (g, path, content, 0);
1328     if (r == -1)
1329       return -1;
1330   }
1331   {
1332     char file1[] = "/file1";
1333     char file2[] = "/file2";
1334     int r;
1335     suppress_error = 0;
1336     r = guestfs_equal (g, file1, file2);
1337     if (r == -1)
1338       return -1;
1339     if (r) {
1340       fprintf (stderr, "test_equal_1: expected false, got true\n");
1341       return -1;
1342     }
1343   }
1344   return 0;
1345 }
1346
1347 static int test_equal_2 (void)
1348 {
1349   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1350   {
1351     char device[] = "/dev/sda";
1352     device[5] = devchar;
1353     int r;
1354     suppress_error = 0;
1355     r = guestfs_blockdev_setrw (g, device);
1356     if (r == -1)
1357       return -1;
1358   }
1359   {
1360     int r;
1361     suppress_error = 0;
1362     r = guestfs_umount_all (g);
1363     if (r == -1)
1364       return -1;
1365   }
1366   {
1367     int r;
1368     suppress_error = 0;
1369     r = guestfs_lvm_remove_all (g);
1370     if (r == -1)
1371       return -1;
1372   }
1373   {
1374     char device[] = "/dev/sda";
1375     device[5] = devchar;
1376     char lines_0[] = ",";
1377     char *lines[] = {
1378       lines_0,
1379       NULL
1380     };
1381     int r;
1382     suppress_error = 0;
1383     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1384     if (r == -1)
1385       return -1;
1386   }
1387   {
1388     char fstype[] = "ext2";
1389     char device[] = "/dev/sda1";
1390     device[5] = devchar;
1391     int r;
1392     suppress_error = 0;
1393     r = guestfs_mkfs (g, fstype, device);
1394     if (r == -1)
1395       return -1;
1396   }
1397   {
1398     char device[] = "/dev/sda1";
1399     device[5] = devchar;
1400     char mountpoint[] = "/";
1401     int r;
1402     suppress_error = 0;
1403     r = guestfs_mount (g, device, mountpoint);
1404     if (r == -1)
1405       return -1;
1406   }
1407   /* TestLastFail for equal (2) */
1408   {
1409     char file1[] = "/file1";
1410     char file2[] = "/file2";
1411     int r;
1412     suppress_error = 1;
1413     r = guestfs_equal (g, file1, file2);
1414     if (r != -1)
1415       return -1;
1416   }
1417   return 0;
1418 }
1419
1420 static int test_ping_daemon_0 (void)
1421 {
1422   /* InitNone|InitEmpty for test_ping_daemon_0 */
1423   {
1424     char device[] = "/dev/sda";
1425     device[5] = devchar;
1426     int r;
1427     suppress_error = 0;
1428     r = guestfs_blockdev_setrw (g, device);
1429     if (r == -1)
1430       return -1;
1431   }
1432   {
1433     int r;
1434     suppress_error = 0;
1435     r = guestfs_umount_all (g);
1436     if (r == -1)
1437       return -1;
1438   }
1439   {
1440     int r;
1441     suppress_error = 0;
1442     r = guestfs_lvm_remove_all (g);
1443     if (r == -1)
1444       return -1;
1445   }
1446   /* TestRun for ping_daemon (0) */
1447   {
1448     int r;
1449     suppress_error = 0;
1450     r = guestfs_ping_daemon (g);
1451     if (r == -1)
1452       return -1;
1453   }
1454   return 0;
1455 }
1456
1457 static int test_dmesg_0 (void)
1458 {
1459   /* InitNone|InitEmpty for test_dmesg_0 */
1460   {
1461     char device[] = "/dev/sda";
1462     device[5] = devchar;
1463     int r;
1464     suppress_error = 0;
1465     r = guestfs_blockdev_setrw (g, device);
1466     if (r == -1)
1467       return -1;
1468   }
1469   {
1470     int r;
1471     suppress_error = 0;
1472     r = guestfs_umount_all (g);
1473     if (r == -1)
1474       return -1;
1475   }
1476   {
1477     int r;
1478     suppress_error = 0;
1479     r = guestfs_lvm_remove_all (g);
1480     if (r == -1)
1481       return -1;
1482   }
1483   /* TestRun for dmesg (0) */
1484   {
1485     char *r;
1486     suppress_error = 0;
1487     r = guestfs_dmesg (g);
1488     if (r == NULL)
1489       return -1;
1490     free (r);
1491   }
1492   return 0;
1493 }
1494
1495 static int test_drop_caches_0 (void)
1496 {
1497   /* InitNone|InitEmpty for test_drop_caches_0 */
1498   {
1499     char device[] = "/dev/sda";
1500     device[5] = devchar;
1501     int r;
1502     suppress_error = 0;
1503     r = guestfs_blockdev_setrw (g, device);
1504     if (r == -1)
1505       return -1;
1506   }
1507   {
1508     int r;
1509     suppress_error = 0;
1510     r = guestfs_umount_all (g);
1511     if (r == -1)
1512       return -1;
1513   }
1514   {
1515     int r;
1516     suppress_error = 0;
1517     r = guestfs_lvm_remove_all (g);
1518     if (r == -1)
1519       return -1;
1520   }
1521   /* TestRun for drop_caches (0) */
1522   {
1523     int r;
1524     suppress_error = 0;
1525     r = guestfs_drop_caches (g, 3);
1526     if (r == -1)
1527       return -1;
1528   }
1529   return 0;
1530 }
1531
1532 static int test_mv_0 (void)
1533 {
1534   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1535   {
1536     char device[] = "/dev/sda";
1537     device[5] = devchar;
1538     int r;
1539     suppress_error = 0;
1540     r = guestfs_blockdev_setrw (g, device);
1541     if (r == -1)
1542       return -1;
1543   }
1544   {
1545     int r;
1546     suppress_error = 0;
1547     r = guestfs_umount_all (g);
1548     if (r == -1)
1549       return -1;
1550   }
1551   {
1552     int r;
1553     suppress_error = 0;
1554     r = guestfs_lvm_remove_all (g);
1555     if (r == -1)
1556       return -1;
1557   }
1558   {
1559     char device[] = "/dev/sda";
1560     device[5] = devchar;
1561     char lines_0[] = ",";
1562     char *lines[] = {
1563       lines_0,
1564       NULL
1565     };
1566     int r;
1567     suppress_error = 0;
1568     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1569     if (r == -1)
1570       return -1;
1571   }
1572   {
1573     char fstype[] = "ext2";
1574     char device[] = "/dev/sda1";
1575     device[5] = devchar;
1576     int r;
1577     suppress_error = 0;
1578     r = guestfs_mkfs (g, fstype, device);
1579     if (r == -1)
1580       return -1;
1581   }
1582   {
1583     char device[] = "/dev/sda1";
1584     device[5] = devchar;
1585     char mountpoint[] = "/";
1586     int r;
1587     suppress_error = 0;
1588     r = guestfs_mount (g, device, mountpoint);
1589     if (r == -1)
1590       return -1;
1591   }
1592   /* TestOutput for mv (0) */
1593   char expected[] = "file content";
1594   {
1595     char path[] = "/old";
1596     char content[] = "file content";
1597     int r;
1598     suppress_error = 0;
1599     r = guestfs_write_file (g, path, content, 0);
1600     if (r == -1)
1601       return -1;
1602   }
1603   {
1604     char src[] = "/old";
1605     char dest[] = "/new";
1606     int r;
1607     suppress_error = 0;
1608     r = guestfs_mv (g, src, dest);
1609     if (r == -1)
1610       return -1;
1611   }
1612   {
1613     char path[] = "/new";
1614     char *r;
1615     suppress_error = 0;
1616     r = guestfs_cat (g, path);
1617     if (r == NULL)
1618       return -1;
1619     if (strcmp (r, expected) != 0) {
1620       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1621       return -1;
1622     }
1623     free (r);
1624   }
1625   return 0;
1626 }
1627
1628 static int test_mv_1 (void)
1629 {
1630   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1631   {
1632     char device[] = "/dev/sda";
1633     device[5] = devchar;
1634     int r;
1635     suppress_error = 0;
1636     r = guestfs_blockdev_setrw (g, device);
1637     if (r == -1)
1638       return -1;
1639   }
1640   {
1641     int r;
1642     suppress_error = 0;
1643     r = guestfs_umount_all (g);
1644     if (r == -1)
1645       return -1;
1646   }
1647   {
1648     int r;
1649     suppress_error = 0;
1650     r = guestfs_lvm_remove_all (g);
1651     if (r == -1)
1652       return -1;
1653   }
1654   {
1655     char device[] = "/dev/sda";
1656     device[5] = devchar;
1657     char lines_0[] = ",";
1658     char *lines[] = {
1659       lines_0,
1660       NULL
1661     };
1662     int r;
1663     suppress_error = 0;
1664     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1665     if (r == -1)
1666       return -1;
1667   }
1668   {
1669     char fstype[] = "ext2";
1670     char device[] = "/dev/sda1";
1671     device[5] = devchar;
1672     int r;
1673     suppress_error = 0;
1674     r = guestfs_mkfs (g, fstype, device);
1675     if (r == -1)
1676       return -1;
1677   }
1678   {
1679     char device[] = "/dev/sda1";
1680     device[5] = devchar;
1681     char mountpoint[] = "/";
1682     int r;
1683     suppress_error = 0;
1684     r = guestfs_mount (g, device, mountpoint);
1685     if (r == -1)
1686       return -1;
1687   }
1688   /* TestOutputFalse for mv (1) */
1689   {
1690     char path[] = "/old";
1691     char content[] = "file content";
1692     int r;
1693     suppress_error = 0;
1694     r = guestfs_write_file (g, path, content, 0);
1695     if (r == -1)
1696       return -1;
1697   }
1698   {
1699     char src[] = "/old";
1700     char dest[] = "/new";
1701     int r;
1702     suppress_error = 0;
1703     r = guestfs_mv (g, src, dest);
1704     if (r == -1)
1705       return -1;
1706   }
1707   {
1708     char path[] = "/old";
1709     int r;
1710     suppress_error = 0;
1711     r = guestfs_is_file (g, path);
1712     if (r == -1)
1713       return -1;
1714     if (r) {
1715       fprintf (stderr, "test_mv_1: expected false, got true\n");
1716       return -1;
1717     }
1718   }
1719   return 0;
1720 }
1721
1722 static int test_cp_a_0 (void)
1723 {
1724   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
1725   {
1726     char device[] = "/dev/sda";
1727     device[5] = devchar;
1728     int r;
1729     suppress_error = 0;
1730     r = guestfs_blockdev_setrw (g, device);
1731     if (r == -1)
1732       return -1;
1733   }
1734   {
1735     int r;
1736     suppress_error = 0;
1737     r = guestfs_umount_all (g);
1738     if (r == -1)
1739       return -1;
1740   }
1741   {
1742     int r;
1743     suppress_error = 0;
1744     r = guestfs_lvm_remove_all (g);
1745     if (r == -1)
1746       return -1;
1747   }
1748   {
1749     char device[] = "/dev/sda";
1750     device[5] = devchar;
1751     char lines_0[] = ",";
1752     char *lines[] = {
1753       lines_0,
1754       NULL
1755     };
1756     int r;
1757     suppress_error = 0;
1758     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1759     if (r == -1)
1760       return -1;
1761   }
1762   {
1763     char fstype[] = "ext2";
1764     char device[] = "/dev/sda1";
1765     device[5] = devchar;
1766     int r;
1767     suppress_error = 0;
1768     r = guestfs_mkfs (g, fstype, device);
1769     if (r == -1)
1770       return -1;
1771   }
1772   {
1773     char device[] = "/dev/sda1";
1774     device[5] = devchar;
1775     char mountpoint[] = "/";
1776     int r;
1777     suppress_error = 0;
1778     r = guestfs_mount (g, device, mountpoint);
1779     if (r == -1)
1780       return -1;
1781   }
1782   /* TestOutput for cp_a (0) */
1783   char expected[] = "file content";
1784   {
1785     char path[] = "/olddir";
1786     int r;
1787     suppress_error = 0;
1788     r = guestfs_mkdir (g, path);
1789     if (r == -1)
1790       return -1;
1791   }
1792   {
1793     char path[] = "/newdir";
1794     int r;
1795     suppress_error = 0;
1796     r = guestfs_mkdir (g, path);
1797     if (r == -1)
1798       return -1;
1799   }
1800   {
1801     char path[] = "/olddir/file";
1802     char content[] = "file content";
1803     int r;
1804     suppress_error = 0;
1805     r = guestfs_write_file (g, path, content, 0);
1806     if (r == -1)
1807       return -1;
1808   }
1809   {
1810     char src[] = "/olddir";
1811     char dest[] = "/newdir";
1812     int r;
1813     suppress_error = 0;
1814     r = guestfs_cp_a (g, src, dest);
1815     if (r == -1)
1816       return -1;
1817   }
1818   {
1819     char path[] = "/newdir/olddir/file";
1820     char *r;
1821     suppress_error = 0;
1822     r = guestfs_cat (g, path);
1823     if (r == NULL)
1824       return -1;
1825     if (strcmp (r, expected) != 0) {
1826       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1827       return -1;
1828     }
1829     free (r);
1830   }
1831   return 0;
1832 }
1833
1834 static int test_cp_0 (void)
1835 {
1836   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
1837   {
1838     char device[] = "/dev/sda";
1839     device[5] = devchar;
1840     int r;
1841     suppress_error = 0;
1842     r = guestfs_blockdev_setrw (g, device);
1843     if (r == -1)
1844       return -1;
1845   }
1846   {
1847     int r;
1848     suppress_error = 0;
1849     r = guestfs_umount_all (g);
1850     if (r == -1)
1851       return -1;
1852   }
1853   {
1854     int r;
1855     suppress_error = 0;
1856     r = guestfs_lvm_remove_all (g);
1857     if (r == -1)
1858       return -1;
1859   }
1860   {
1861     char device[] = "/dev/sda";
1862     device[5] = devchar;
1863     char lines_0[] = ",";
1864     char *lines[] = {
1865       lines_0,
1866       NULL
1867     };
1868     int r;
1869     suppress_error = 0;
1870     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1871     if (r == -1)
1872       return -1;
1873   }
1874   {
1875     char fstype[] = "ext2";
1876     char device[] = "/dev/sda1";
1877     device[5] = devchar;
1878     int r;
1879     suppress_error = 0;
1880     r = guestfs_mkfs (g, fstype, device);
1881     if (r == -1)
1882       return -1;
1883   }
1884   {
1885     char device[] = "/dev/sda1";
1886     device[5] = devchar;
1887     char mountpoint[] = "/";
1888     int r;
1889     suppress_error = 0;
1890     r = guestfs_mount (g, device, mountpoint);
1891     if (r == -1)
1892       return -1;
1893   }
1894   /* TestOutput for cp (0) */
1895   char expected[] = "file content";
1896   {
1897     char path[] = "/old";
1898     char content[] = "file content";
1899     int r;
1900     suppress_error = 0;
1901     r = guestfs_write_file (g, path, content, 0);
1902     if (r == -1)
1903       return -1;
1904   }
1905   {
1906     char src[] = "/old";
1907     char dest[] = "/new";
1908     int r;
1909     suppress_error = 0;
1910     r = guestfs_cp (g, src, dest);
1911     if (r == -1)
1912       return -1;
1913   }
1914   {
1915     char path[] = "/new";
1916     char *r;
1917     suppress_error = 0;
1918     r = guestfs_cat (g, path);
1919     if (r == NULL)
1920       return -1;
1921     if (strcmp (r, expected) != 0) {
1922       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1923       return -1;
1924     }
1925     free (r);
1926   }
1927   return 0;
1928 }
1929
1930 static int test_cp_1 (void)
1931 {
1932   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
1933   {
1934     char device[] = "/dev/sda";
1935     device[5] = devchar;
1936     int r;
1937     suppress_error = 0;
1938     r = guestfs_blockdev_setrw (g, device);
1939     if (r == -1)
1940       return -1;
1941   }
1942   {
1943     int r;
1944     suppress_error = 0;
1945     r = guestfs_umount_all (g);
1946     if (r == -1)
1947       return -1;
1948   }
1949   {
1950     int r;
1951     suppress_error = 0;
1952     r = guestfs_lvm_remove_all (g);
1953     if (r == -1)
1954       return -1;
1955   }
1956   {
1957     char device[] = "/dev/sda";
1958     device[5] = devchar;
1959     char lines_0[] = ",";
1960     char *lines[] = {
1961       lines_0,
1962       NULL
1963     };
1964     int r;
1965     suppress_error = 0;
1966     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1967     if (r == -1)
1968       return -1;
1969   }
1970   {
1971     char fstype[] = "ext2";
1972     char device[] = "/dev/sda1";
1973     device[5] = devchar;
1974     int r;
1975     suppress_error = 0;
1976     r = guestfs_mkfs (g, fstype, device);
1977     if (r == -1)
1978       return -1;
1979   }
1980   {
1981     char device[] = "/dev/sda1";
1982     device[5] = devchar;
1983     char mountpoint[] = "/";
1984     int r;
1985     suppress_error = 0;
1986     r = guestfs_mount (g, device, mountpoint);
1987     if (r == -1)
1988       return -1;
1989   }
1990   /* TestOutputTrue for cp (1) */
1991   {
1992     char path[] = "/old";
1993     char content[] = "file content";
1994     int r;
1995     suppress_error = 0;
1996     r = guestfs_write_file (g, path, content, 0);
1997     if (r == -1)
1998       return -1;
1999   }
2000   {
2001     char src[] = "/old";
2002     char dest[] = "/new";
2003     int r;
2004     suppress_error = 0;
2005     r = guestfs_cp (g, src, dest);
2006     if (r == -1)
2007       return -1;
2008   }
2009   {
2010     char path[] = "/old";
2011     int r;
2012     suppress_error = 0;
2013     r = guestfs_is_file (g, path);
2014     if (r == -1)
2015       return -1;
2016     if (!r) {
2017       fprintf (stderr, "test_cp_1: expected true, got false\n");
2018       return -1;
2019     }
2020   }
2021   return 0;
2022 }
2023
2024 static int test_cp_2 (void)
2025 {
2026   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2027   {
2028     char device[] = "/dev/sda";
2029     device[5] = devchar;
2030     int r;
2031     suppress_error = 0;
2032     r = guestfs_blockdev_setrw (g, device);
2033     if (r == -1)
2034       return -1;
2035   }
2036   {
2037     int r;
2038     suppress_error = 0;
2039     r = guestfs_umount_all (g);
2040     if (r == -1)
2041       return -1;
2042   }
2043   {
2044     int r;
2045     suppress_error = 0;
2046     r = guestfs_lvm_remove_all (g);
2047     if (r == -1)
2048       return -1;
2049   }
2050   {
2051     char device[] = "/dev/sda";
2052     device[5] = devchar;
2053     char lines_0[] = ",";
2054     char *lines[] = {
2055       lines_0,
2056       NULL
2057     };
2058     int r;
2059     suppress_error = 0;
2060     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2061     if (r == -1)
2062       return -1;
2063   }
2064   {
2065     char fstype[] = "ext2";
2066     char device[] = "/dev/sda1";
2067     device[5] = devchar;
2068     int r;
2069     suppress_error = 0;
2070     r = guestfs_mkfs (g, fstype, device);
2071     if (r == -1)
2072       return -1;
2073   }
2074   {
2075     char device[] = "/dev/sda1";
2076     device[5] = devchar;
2077     char mountpoint[] = "/";
2078     int r;
2079     suppress_error = 0;
2080     r = guestfs_mount (g, device, mountpoint);
2081     if (r == -1)
2082       return -1;
2083   }
2084   /* TestOutput for cp (2) */
2085   char expected[] = "file content";
2086   {
2087     char path[] = "/old";
2088     char content[] = "file content";
2089     int r;
2090     suppress_error = 0;
2091     r = guestfs_write_file (g, path, content, 0);
2092     if (r == -1)
2093       return -1;
2094   }
2095   {
2096     char path[] = "/dir";
2097     int r;
2098     suppress_error = 0;
2099     r = guestfs_mkdir (g, path);
2100     if (r == -1)
2101       return -1;
2102   }
2103   {
2104     char src[] = "/old";
2105     char dest[] = "/dir/new";
2106     int r;
2107     suppress_error = 0;
2108     r = guestfs_cp (g, src, dest);
2109     if (r == -1)
2110       return -1;
2111   }
2112   {
2113     char path[] = "/dir/new";
2114     char *r;
2115     suppress_error = 0;
2116     r = guestfs_cat (g, path);
2117     if (r == NULL)
2118       return -1;
2119     if (strcmp (r, expected) != 0) {
2120       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2121       return -1;
2122     }
2123     free (r);
2124   }
2125   return 0;
2126 }
2127
2128 static int test_grub_install_0 (void)
2129 {
2130   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2131   {
2132     char device[] = "/dev/sda";
2133     device[5] = devchar;
2134     int r;
2135     suppress_error = 0;
2136     r = guestfs_blockdev_setrw (g, device);
2137     if (r == -1)
2138       return -1;
2139   }
2140   {
2141     int r;
2142     suppress_error = 0;
2143     r = guestfs_umount_all (g);
2144     if (r == -1)
2145       return -1;
2146   }
2147   {
2148     int r;
2149     suppress_error = 0;
2150     r = guestfs_lvm_remove_all (g);
2151     if (r == -1)
2152       return -1;
2153   }
2154   {
2155     char device[] = "/dev/sda";
2156     device[5] = devchar;
2157     char lines_0[] = ",";
2158     char *lines[] = {
2159       lines_0,
2160       NULL
2161     };
2162     int r;
2163     suppress_error = 0;
2164     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2165     if (r == -1)
2166       return -1;
2167   }
2168   {
2169     char fstype[] = "ext2";
2170     char device[] = "/dev/sda1";
2171     device[5] = devchar;
2172     int r;
2173     suppress_error = 0;
2174     r = guestfs_mkfs (g, fstype, device);
2175     if (r == -1)
2176       return -1;
2177   }
2178   {
2179     char device[] = "/dev/sda1";
2180     device[5] = devchar;
2181     char mountpoint[] = "/";
2182     int r;
2183     suppress_error = 0;
2184     r = guestfs_mount (g, device, mountpoint);
2185     if (r == -1)
2186       return -1;
2187   }
2188   /* TestOutputTrue for grub_install (0) */
2189   {
2190     char root[] = "/";
2191     char device[] = "/dev/sda1";
2192     device[5] = devchar;
2193     int r;
2194     suppress_error = 0;
2195     r = guestfs_grub_install (g, root, device);
2196     if (r == -1)
2197       return -1;
2198   }
2199   {
2200     char path[] = "/boot";
2201     int r;
2202     suppress_error = 0;
2203     r = guestfs_is_dir (g, path);
2204     if (r == -1)
2205       return -1;
2206     if (!r) {
2207       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2208       return -1;
2209     }
2210   }
2211   return 0;
2212 }
2213
2214 static int test_zero_0 (void)
2215 {
2216   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2217   {
2218     char device[] = "/dev/sda";
2219     device[5] = devchar;
2220     int r;
2221     suppress_error = 0;
2222     r = guestfs_blockdev_setrw (g, device);
2223     if (r == -1)
2224       return -1;
2225   }
2226   {
2227     int r;
2228     suppress_error = 0;
2229     r = guestfs_umount_all (g);
2230     if (r == -1)
2231       return -1;
2232   }
2233   {
2234     int r;
2235     suppress_error = 0;
2236     r = guestfs_lvm_remove_all (g);
2237     if (r == -1)
2238       return -1;
2239   }
2240   {
2241     char device[] = "/dev/sda";
2242     device[5] = devchar;
2243     char lines_0[] = ",";
2244     char *lines[] = {
2245       lines_0,
2246       NULL
2247     };
2248     int r;
2249     suppress_error = 0;
2250     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2251     if (r == -1)
2252       return -1;
2253   }
2254   {
2255     char fstype[] = "ext2";
2256     char device[] = "/dev/sda1";
2257     device[5] = devchar;
2258     int r;
2259     suppress_error = 0;
2260     r = guestfs_mkfs (g, fstype, device);
2261     if (r == -1)
2262       return -1;
2263   }
2264   {
2265     char device[] = "/dev/sda1";
2266     device[5] = devchar;
2267     char mountpoint[] = "/";
2268     int r;
2269     suppress_error = 0;
2270     r = guestfs_mount (g, device, mountpoint);
2271     if (r == -1)
2272       return -1;
2273   }
2274   /* TestOutput for zero (0) */
2275   char expected[] = "data";
2276   {
2277     char pathordevice[] = "/dev/sda1";
2278     pathordevice[5] = devchar;
2279     int r;
2280     suppress_error = 0;
2281     r = guestfs_umount (g, pathordevice);
2282     if (r == -1)
2283       return -1;
2284   }
2285   {
2286     char device[] = "/dev/sda1";
2287     device[5] = devchar;
2288     int r;
2289     suppress_error = 0;
2290     r = guestfs_zero (g, device);
2291     if (r == -1)
2292       return -1;
2293   }
2294   {
2295     char path[] = "/dev/sda1";
2296     path[5] = devchar;
2297     char *r;
2298     suppress_error = 0;
2299     r = guestfs_file (g, path);
2300     if (r == NULL)
2301       return -1;
2302     if (strcmp (r, expected) != 0) {
2303       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2304       return -1;
2305     }
2306     free (r);
2307   }
2308   return 0;
2309 }
2310
2311 static int test_fsck_0 (void)
2312 {
2313   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2314   {
2315     char device[] = "/dev/sda";
2316     device[5] = devchar;
2317     int r;
2318     suppress_error = 0;
2319     r = guestfs_blockdev_setrw (g, device);
2320     if (r == -1)
2321       return -1;
2322   }
2323   {
2324     int r;
2325     suppress_error = 0;
2326     r = guestfs_umount_all (g);
2327     if (r == -1)
2328       return -1;
2329   }
2330   {
2331     int r;
2332     suppress_error = 0;
2333     r = guestfs_lvm_remove_all (g);
2334     if (r == -1)
2335       return -1;
2336   }
2337   {
2338     char device[] = "/dev/sda";
2339     device[5] = devchar;
2340     char lines_0[] = ",";
2341     char *lines[] = {
2342       lines_0,
2343       NULL
2344     };
2345     int r;
2346     suppress_error = 0;
2347     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2348     if (r == -1)
2349       return -1;
2350   }
2351   {
2352     char fstype[] = "ext2";
2353     char device[] = "/dev/sda1";
2354     device[5] = devchar;
2355     int r;
2356     suppress_error = 0;
2357     r = guestfs_mkfs (g, fstype, device);
2358     if (r == -1)
2359       return -1;
2360   }
2361   {
2362     char device[] = "/dev/sda1";
2363     device[5] = devchar;
2364     char mountpoint[] = "/";
2365     int r;
2366     suppress_error = 0;
2367     r = guestfs_mount (g, device, mountpoint);
2368     if (r == -1)
2369       return -1;
2370   }
2371   /* TestOutputInt for fsck (0) */
2372   {
2373     char pathordevice[] = "/dev/sda1";
2374     pathordevice[5] = devchar;
2375     int r;
2376     suppress_error = 0;
2377     r = guestfs_umount (g, pathordevice);
2378     if (r == -1)
2379       return -1;
2380   }
2381   {
2382     char fstype[] = "ext2";
2383     char device[] = "/dev/sda1";
2384     device[5] = devchar;
2385     int r;
2386     suppress_error = 0;
2387     r = guestfs_fsck (g, fstype, device);
2388     if (r == -1)
2389       return -1;
2390     if (r != 0) {
2391       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
2392       return -1;
2393     }
2394   }
2395   return 0;
2396 }
2397
2398 static int test_fsck_1 (void)
2399 {
2400   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2401   {
2402     char device[] = "/dev/sda";
2403     device[5] = devchar;
2404     int r;
2405     suppress_error = 0;
2406     r = guestfs_blockdev_setrw (g, device);
2407     if (r == -1)
2408       return -1;
2409   }
2410   {
2411     int r;
2412     suppress_error = 0;
2413     r = guestfs_umount_all (g);
2414     if (r == -1)
2415       return -1;
2416   }
2417   {
2418     int r;
2419     suppress_error = 0;
2420     r = guestfs_lvm_remove_all (g);
2421     if (r == -1)
2422       return -1;
2423   }
2424   {
2425     char device[] = "/dev/sda";
2426     device[5] = devchar;
2427     char lines_0[] = ",";
2428     char *lines[] = {
2429       lines_0,
2430       NULL
2431     };
2432     int r;
2433     suppress_error = 0;
2434     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2435     if (r == -1)
2436       return -1;
2437   }
2438   {
2439     char fstype[] = "ext2";
2440     char device[] = "/dev/sda1";
2441     device[5] = devchar;
2442     int r;
2443     suppress_error = 0;
2444     r = guestfs_mkfs (g, fstype, device);
2445     if (r == -1)
2446       return -1;
2447   }
2448   {
2449     char device[] = "/dev/sda1";
2450     device[5] = devchar;
2451     char mountpoint[] = "/";
2452     int r;
2453     suppress_error = 0;
2454     r = guestfs_mount (g, device, mountpoint);
2455     if (r == -1)
2456       return -1;
2457   }
2458   /* TestOutputInt for fsck (1) */
2459   {
2460     char pathordevice[] = "/dev/sda1";
2461     pathordevice[5] = devchar;
2462     int r;
2463     suppress_error = 0;
2464     r = guestfs_umount (g, pathordevice);
2465     if (r == -1)
2466       return -1;
2467   }
2468   {
2469     char device[] = "/dev/sda1";
2470     device[5] = devchar;
2471     int r;
2472     suppress_error = 0;
2473     r = guestfs_zero (g, device);
2474     if (r == -1)
2475       return -1;
2476   }
2477   {
2478     char fstype[] = "ext2";
2479     char device[] = "/dev/sda1";
2480     device[5] = devchar;
2481     int r;
2482     suppress_error = 0;
2483     r = guestfs_fsck (g, fstype, device);
2484     if (r == -1)
2485       return -1;
2486     if (r != 8) {
2487       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
2488       return -1;
2489     }
2490   }
2491   return 0;
2492 }
2493
2494 static int test_set_e2uuid_0 (void)
2495 {
2496   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2497   {
2498     char device[] = "/dev/sda";
2499     device[5] = devchar;
2500     int r;
2501     suppress_error = 0;
2502     r = guestfs_blockdev_setrw (g, device);
2503     if (r == -1)
2504       return -1;
2505   }
2506   {
2507     int r;
2508     suppress_error = 0;
2509     r = guestfs_umount_all (g);
2510     if (r == -1)
2511       return -1;
2512   }
2513   {
2514     int r;
2515     suppress_error = 0;
2516     r = guestfs_lvm_remove_all (g);
2517     if (r == -1)
2518       return -1;
2519   }
2520   {
2521     char device[] = "/dev/sda";
2522     device[5] = devchar;
2523     char lines_0[] = ",";
2524     char *lines[] = {
2525       lines_0,
2526       NULL
2527     };
2528     int r;
2529     suppress_error = 0;
2530     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2531     if (r == -1)
2532       return -1;
2533   }
2534   {
2535     char fstype[] = "ext2";
2536     char device[] = "/dev/sda1";
2537     device[5] = devchar;
2538     int r;
2539     suppress_error = 0;
2540     r = guestfs_mkfs (g, fstype, device);
2541     if (r == -1)
2542       return -1;
2543   }
2544   {
2545     char device[] = "/dev/sda1";
2546     device[5] = devchar;
2547     char mountpoint[] = "/";
2548     int r;
2549     suppress_error = 0;
2550     r = guestfs_mount (g, device, mountpoint);
2551     if (r == -1)
2552       return -1;
2553   }
2554   /* TestOutput for set_e2uuid (0) */
2555   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2556   {
2557     char device[] = "/dev/sda1";
2558     device[5] = devchar;
2559     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2560     int r;
2561     suppress_error = 0;
2562     r = guestfs_set_e2uuid (g, device, uuid);
2563     if (r == -1)
2564       return -1;
2565   }
2566   {
2567     char device[] = "/dev/sda1";
2568     device[5] = devchar;
2569     char *r;
2570     suppress_error = 0;
2571     r = guestfs_get_e2uuid (g, device);
2572     if (r == NULL)
2573       return -1;
2574     if (strcmp (r, expected) != 0) {
2575       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2576       return -1;
2577     }
2578     free (r);
2579   }
2580   return 0;
2581 }
2582
2583 static int test_set_e2uuid_1 (void)
2584 {
2585   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
2586   {
2587     char device[] = "/dev/sda";
2588     device[5] = devchar;
2589     int r;
2590     suppress_error = 0;
2591     r = guestfs_blockdev_setrw (g, device);
2592     if (r == -1)
2593       return -1;
2594   }
2595   {
2596     int r;
2597     suppress_error = 0;
2598     r = guestfs_umount_all (g);
2599     if (r == -1)
2600       return -1;
2601   }
2602   {
2603     int r;
2604     suppress_error = 0;
2605     r = guestfs_lvm_remove_all (g);
2606     if (r == -1)
2607       return -1;
2608   }
2609   {
2610     char device[] = "/dev/sda";
2611     device[5] = devchar;
2612     char lines_0[] = ",";
2613     char *lines[] = {
2614       lines_0,
2615       NULL
2616     };
2617     int r;
2618     suppress_error = 0;
2619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2620     if (r == -1)
2621       return -1;
2622   }
2623   {
2624     char fstype[] = "ext2";
2625     char device[] = "/dev/sda1";
2626     device[5] = devchar;
2627     int r;
2628     suppress_error = 0;
2629     r = guestfs_mkfs (g, fstype, device);
2630     if (r == -1)
2631       return -1;
2632   }
2633   {
2634     char device[] = "/dev/sda1";
2635     device[5] = devchar;
2636     char mountpoint[] = "/";
2637     int r;
2638     suppress_error = 0;
2639     r = guestfs_mount (g, device, mountpoint);
2640     if (r == -1)
2641       return -1;
2642   }
2643   /* TestOutput for set_e2uuid (1) */
2644   char expected[] = "";
2645   {
2646     char device[] = "/dev/sda1";
2647     device[5] = devchar;
2648     char uuid[] = "clear";
2649     int r;
2650     suppress_error = 0;
2651     r = guestfs_set_e2uuid (g, device, uuid);
2652     if (r == -1)
2653       return -1;
2654   }
2655   {
2656     char device[] = "/dev/sda1";
2657     device[5] = devchar;
2658     char *r;
2659     suppress_error = 0;
2660     r = guestfs_get_e2uuid (g, device);
2661     if (r == NULL)
2662       return -1;
2663     if (strcmp (r, expected) != 0) {
2664       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2665       return -1;
2666     }
2667     free (r);
2668   }
2669   return 0;
2670 }
2671
2672 static int test_set_e2uuid_2 (void)
2673 {
2674   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
2675   {
2676     char device[] = "/dev/sda";
2677     device[5] = devchar;
2678     int r;
2679     suppress_error = 0;
2680     r = guestfs_blockdev_setrw (g, device);
2681     if (r == -1)
2682       return -1;
2683   }
2684   {
2685     int r;
2686     suppress_error = 0;
2687     r = guestfs_umount_all (g);
2688     if (r == -1)
2689       return -1;
2690   }
2691   {
2692     int r;
2693     suppress_error = 0;
2694     r = guestfs_lvm_remove_all (g);
2695     if (r == -1)
2696       return -1;
2697   }
2698   {
2699     char device[] = "/dev/sda";
2700     device[5] = devchar;
2701     char lines_0[] = ",";
2702     char *lines[] = {
2703       lines_0,
2704       NULL
2705     };
2706     int r;
2707     suppress_error = 0;
2708     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2709     if (r == -1)
2710       return -1;
2711   }
2712   {
2713     char fstype[] = "ext2";
2714     char device[] = "/dev/sda1";
2715     device[5] = devchar;
2716     int r;
2717     suppress_error = 0;
2718     r = guestfs_mkfs (g, fstype, device);
2719     if (r == -1)
2720       return -1;
2721   }
2722   {
2723     char device[] = "/dev/sda1";
2724     device[5] = devchar;
2725     char mountpoint[] = "/";
2726     int r;
2727     suppress_error = 0;
2728     r = guestfs_mount (g, device, mountpoint);
2729     if (r == -1)
2730       return -1;
2731   }
2732   /* TestRun for set_e2uuid (2) */
2733   {
2734     char device[] = "/dev/sda1";
2735     device[5] = devchar;
2736     char uuid[] = "random";
2737     int r;
2738     suppress_error = 0;
2739     r = guestfs_set_e2uuid (g, device, uuid);
2740     if (r == -1)
2741       return -1;
2742   }
2743   return 0;
2744 }
2745
2746 static int test_set_e2uuid_3 (void)
2747 {
2748   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
2749   {
2750     char device[] = "/dev/sda";
2751     device[5] = devchar;
2752     int r;
2753     suppress_error = 0;
2754     r = guestfs_blockdev_setrw (g, device);
2755     if (r == -1)
2756       return -1;
2757   }
2758   {
2759     int r;
2760     suppress_error = 0;
2761     r = guestfs_umount_all (g);
2762     if (r == -1)
2763       return -1;
2764   }
2765   {
2766     int r;
2767     suppress_error = 0;
2768     r = guestfs_lvm_remove_all (g);
2769     if (r == -1)
2770       return -1;
2771   }
2772   {
2773     char device[] = "/dev/sda";
2774     device[5] = devchar;
2775     char lines_0[] = ",";
2776     char *lines[] = {
2777       lines_0,
2778       NULL
2779     };
2780     int r;
2781     suppress_error = 0;
2782     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2783     if (r == -1)
2784       return -1;
2785   }
2786   {
2787     char fstype[] = "ext2";
2788     char device[] = "/dev/sda1";
2789     device[5] = devchar;
2790     int r;
2791     suppress_error = 0;
2792     r = guestfs_mkfs (g, fstype, device);
2793     if (r == -1)
2794       return -1;
2795   }
2796   {
2797     char device[] = "/dev/sda1";
2798     device[5] = devchar;
2799     char mountpoint[] = "/";
2800     int r;
2801     suppress_error = 0;
2802     r = guestfs_mount (g, device, mountpoint);
2803     if (r == -1)
2804       return -1;
2805   }
2806   /* TestRun for set_e2uuid (3) */
2807   {
2808     char device[] = "/dev/sda1";
2809     device[5] = devchar;
2810     char uuid[] = "time";
2811     int r;
2812     suppress_error = 0;
2813     r = guestfs_set_e2uuid (g, device, uuid);
2814     if (r == -1)
2815       return -1;
2816   }
2817   return 0;
2818 }
2819
2820 static int test_set_e2label_0 (void)
2821 {
2822   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
2823   {
2824     char device[] = "/dev/sda";
2825     device[5] = devchar;
2826     int r;
2827     suppress_error = 0;
2828     r = guestfs_blockdev_setrw (g, device);
2829     if (r == -1)
2830       return -1;
2831   }
2832   {
2833     int r;
2834     suppress_error = 0;
2835     r = guestfs_umount_all (g);
2836     if (r == -1)
2837       return -1;
2838   }
2839   {
2840     int r;
2841     suppress_error = 0;
2842     r = guestfs_lvm_remove_all (g);
2843     if (r == -1)
2844       return -1;
2845   }
2846   {
2847     char device[] = "/dev/sda";
2848     device[5] = devchar;
2849     char lines_0[] = ",";
2850     char *lines[] = {
2851       lines_0,
2852       NULL
2853     };
2854     int r;
2855     suppress_error = 0;
2856     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2857     if (r == -1)
2858       return -1;
2859   }
2860   {
2861     char fstype[] = "ext2";
2862     char device[] = "/dev/sda1";
2863     device[5] = devchar;
2864     int r;
2865     suppress_error = 0;
2866     r = guestfs_mkfs (g, fstype, device);
2867     if (r == -1)
2868       return -1;
2869   }
2870   {
2871     char device[] = "/dev/sda1";
2872     device[5] = devchar;
2873     char mountpoint[] = "/";
2874     int r;
2875     suppress_error = 0;
2876     r = guestfs_mount (g, device, mountpoint);
2877     if (r == -1)
2878       return -1;
2879   }
2880   /* TestOutput for set_e2label (0) */
2881   char expected[] = "testlabel";
2882   {
2883     char device[] = "/dev/sda1";
2884     device[5] = devchar;
2885     char label[] = "testlabel";
2886     int r;
2887     suppress_error = 0;
2888     r = guestfs_set_e2label (g, device, label);
2889     if (r == -1)
2890       return -1;
2891   }
2892   {
2893     char device[] = "/dev/sda1";
2894     device[5] = devchar;
2895     char *r;
2896     suppress_error = 0;
2897     r = guestfs_get_e2label (g, device);
2898     if (r == NULL)
2899       return -1;
2900     if (strcmp (r, expected) != 0) {
2901       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2902       return -1;
2903     }
2904     free (r);
2905   }
2906   return 0;
2907 }
2908
2909 static int test_pvremove_0 (void)
2910 {
2911   /* InitNone|InitEmpty for test_pvremove_0 */
2912   {
2913     char device[] = "/dev/sda";
2914     device[5] = devchar;
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_blockdev_setrw (g, device);
2918     if (r == -1)
2919       return -1;
2920   }
2921   {
2922     int r;
2923     suppress_error = 0;
2924     r = guestfs_umount_all (g);
2925     if (r == -1)
2926       return -1;
2927   }
2928   {
2929     int r;
2930     suppress_error = 0;
2931     r = guestfs_lvm_remove_all (g);
2932     if (r == -1)
2933       return -1;
2934   }
2935   /* TestOutputList for pvremove (0) */
2936   {
2937     char device[] = "/dev/sda";
2938     device[5] = devchar;
2939     int r;
2940     suppress_error = 0;
2941     r = guestfs_pvcreate (g, device);
2942     if (r == -1)
2943       return -1;
2944   }
2945   {
2946     char volgroup[] = "VG";
2947     char physvols_0[] = "/dev/sda";
2948     physvols_0[5] = devchar;
2949     char *physvols[] = {
2950       physvols_0,
2951       NULL
2952     };
2953     int r;
2954     suppress_error = 0;
2955     r = guestfs_vgcreate (g, volgroup, physvols);
2956     if (r == -1)
2957       return -1;
2958   }
2959   {
2960     char logvol[] = "LV1";
2961     char volgroup[] = "VG";
2962     int r;
2963     suppress_error = 0;
2964     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2965     if (r == -1)
2966       return -1;
2967   }
2968   {
2969     char logvol[] = "LV2";
2970     char volgroup[] = "VG";
2971     int r;
2972     suppress_error = 0;
2973     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2974     if (r == -1)
2975       return -1;
2976   }
2977   {
2978     char vgname[] = "VG";
2979     int r;
2980     suppress_error = 0;
2981     r = guestfs_vgremove (g, vgname);
2982     if (r == -1)
2983       return -1;
2984   }
2985   {
2986     char device[] = "/dev/sda";
2987     device[5] = devchar;
2988     int r;
2989     suppress_error = 0;
2990     r = guestfs_pvremove (g, device);
2991     if (r == -1)
2992       return -1;
2993   }
2994   {
2995     char **r;
2996     int i;
2997     suppress_error = 0;
2998     r = guestfs_lvs (g);
2999     if (r == NULL)
3000       return -1;
3001     if (r[0] != NULL) {
3002       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3003       print_strings (r);
3004       return -1;
3005     }
3006     for (i = 0; r[i] != NULL; ++i)
3007       free (r[i]);
3008     free (r);
3009   }
3010   return 0;
3011 }
3012
3013 static int test_pvremove_1 (void)
3014 {
3015   /* InitNone|InitEmpty for test_pvremove_1 */
3016   {
3017     char device[] = "/dev/sda";
3018     device[5] = devchar;
3019     int r;
3020     suppress_error = 0;
3021     r = guestfs_blockdev_setrw (g, device);
3022     if (r == -1)
3023       return -1;
3024   }
3025   {
3026     int r;
3027     suppress_error = 0;
3028     r = guestfs_umount_all (g);
3029     if (r == -1)
3030       return -1;
3031   }
3032   {
3033     int r;
3034     suppress_error = 0;
3035     r = guestfs_lvm_remove_all (g);
3036     if (r == -1)
3037       return -1;
3038   }
3039   /* TestOutputList for pvremove (1) */
3040   {
3041     char device[] = "/dev/sda";
3042     device[5] = devchar;
3043     int r;
3044     suppress_error = 0;
3045     r = guestfs_pvcreate (g, device);
3046     if (r == -1)
3047       return -1;
3048   }
3049   {
3050     char volgroup[] = "VG";
3051     char physvols_0[] = "/dev/sda";
3052     physvols_0[5] = devchar;
3053     char *physvols[] = {
3054       physvols_0,
3055       NULL
3056     };
3057     int r;
3058     suppress_error = 0;
3059     r = guestfs_vgcreate (g, volgroup, physvols);
3060     if (r == -1)
3061       return -1;
3062   }
3063   {
3064     char logvol[] = "LV1";
3065     char volgroup[] = "VG";
3066     int r;
3067     suppress_error = 0;
3068     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3069     if (r == -1)
3070       return -1;
3071   }
3072   {
3073     char logvol[] = "LV2";
3074     char volgroup[] = "VG";
3075     int r;
3076     suppress_error = 0;
3077     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3078     if (r == -1)
3079       return -1;
3080   }
3081   {
3082     char vgname[] = "VG";
3083     int r;
3084     suppress_error = 0;
3085     r = guestfs_vgremove (g, vgname);
3086     if (r == -1)
3087       return -1;
3088   }
3089   {
3090     char device[] = "/dev/sda";
3091     device[5] = devchar;
3092     int r;
3093     suppress_error = 0;
3094     r = guestfs_pvremove (g, device);
3095     if (r == -1)
3096       return -1;
3097   }
3098   {
3099     char **r;
3100     int i;
3101     suppress_error = 0;
3102     r = guestfs_vgs (g);
3103     if (r == NULL)
3104       return -1;
3105     if (r[0] != NULL) {
3106       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3107       print_strings (r);
3108       return -1;
3109     }
3110     for (i = 0; r[i] != NULL; ++i)
3111       free (r[i]);
3112     free (r);
3113   }
3114   return 0;
3115 }
3116
3117 static int test_pvremove_2 (void)
3118 {
3119   /* InitNone|InitEmpty for test_pvremove_2 */
3120   {
3121     char device[] = "/dev/sda";
3122     device[5] = devchar;
3123     int r;
3124     suppress_error = 0;
3125     r = guestfs_blockdev_setrw (g, device);
3126     if (r == -1)
3127       return -1;
3128   }
3129   {
3130     int r;
3131     suppress_error = 0;
3132     r = guestfs_umount_all (g);
3133     if (r == -1)
3134       return -1;
3135   }
3136   {
3137     int r;
3138     suppress_error = 0;
3139     r = guestfs_lvm_remove_all (g);
3140     if (r == -1)
3141       return -1;
3142   }
3143   /* TestOutputList for pvremove (2) */
3144   {
3145     char device[] = "/dev/sda";
3146     device[5] = devchar;
3147     int r;
3148     suppress_error = 0;
3149     r = guestfs_pvcreate (g, device);
3150     if (r == -1)
3151       return -1;
3152   }
3153   {
3154     char volgroup[] = "VG";
3155     char physvols_0[] = "/dev/sda";
3156     physvols_0[5] = devchar;
3157     char *physvols[] = {
3158       physvols_0,
3159       NULL
3160     };
3161     int r;
3162     suppress_error = 0;
3163     r = guestfs_vgcreate (g, volgroup, physvols);
3164     if (r == -1)
3165       return -1;
3166   }
3167   {
3168     char logvol[] = "LV1";
3169     char volgroup[] = "VG";
3170     int r;
3171     suppress_error = 0;
3172     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3173     if (r == -1)
3174       return -1;
3175   }
3176   {
3177     char logvol[] = "LV2";
3178     char volgroup[] = "VG";
3179     int r;
3180     suppress_error = 0;
3181     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3182     if (r == -1)
3183       return -1;
3184   }
3185   {
3186     char vgname[] = "VG";
3187     int r;
3188     suppress_error = 0;
3189     r = guestfs_vgremove (g, vgname);
3190     if (r == -1)
3191       return -1;
3192   }
3193   {
3194     char device[] = "/dev/sda";
3195     device[5] = devchar;
3196     int r;
3197     suppress_error = 0;
3198     r = guestfs_pvremove (g, device);
3199     if (r == -1)
3200       return -1;
3201   }
3202   {
3203     char **r;
3204     int i;
3205     suppress_error = 0;
3206     r = guestfs_pvs (g);
3207     if (r == NULL)
3208       return -1;
3209     if (r[0] != NULL) {
3210       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3211       print_strings (r);
3212       return -1;
3213     }
3214     for (i = 0; r[i] != NULL; ++i)
3215       free (r[i]);
3216     free (r);
3217   }
3218   return 0;
3219 }
3220
3221 static int test_vgremove_0 (void)
3222 {
3223   /* InitNone|InitEmpty for test_vgremove_0 */
3224   {
3225     char device[] = "/dev/sda";
3226     device[5] = devchar;
3227     int r;
3228     suppress_error = 0;
3229     r = guestfs_blockdev_setrw (g, device);
3230     if (r == -1)
3231       return -1;
3232   }
3233   {
3234     int r;
3235     suppress_error = 0;
3236     r = guestfs_umount_all (g);
3237     if (r == -1)
3238       return -1;
3239   }
3240   {
3241     int r;
3242     suppress_error = 0;
3243     r = guestfs_lvm_remove_all (g);
3244     if (r == -1)
3245       return -1;
3246   }
3247   /* TestOutputList for vgremove (0) */
3248   {
3249     char device[] = "/dev/sda";
3250     device[5] = devchar;
3251     int r;
3252     suppress_error = 0;
3253     r = guestfs_pvcreate (g, device);
3254     if (r == -1)
3255       return -1;
3256   }
3257   {
3258     char volgroup[] = "VG";
3259     char physvols_0[] = "/dev/sda";
3260     physvols_0[5] = devchar;
3261     char *physvols[] = {
3262       physvols_0,
3263       NULL
3264     };
3265     int r;
3266     suppress_error = 0;
3267     r = guestfs_vgcreate (g, volgroup, physvols);
3268     if (r == -1)
3269       return -1;
3270   }
3271   {
3272     char logvol[] = "LV1";
3273     char volgroup[] = "VG";
3274     int r;
3275     suppress_error = 0;
3276     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3277     if (r == -1)
3278       return -1;
3279   }
3280   {
3281     char logvol[] = "LV2";
3282     char volgroup[] = "VG";
3283     int r;
3284     suppress_error = 0;
3285     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3286     if (r == -1)
3287       return -1;
3288   }
3289   {
3290     char vgname[] = "VG";
3291     int r;
3292     suppress_error = 0;
3293     r = guestfs_vgremove (g, vgname);
3294     if (r == -1)
3295       return -1;
3296   }
3297   {
3298     char **r;
3299     int i;
3300     suppress_error = 0;
3301     r = guestfs_lvs (g);
3302     if (r == NULL)
3303       return -1;
3304     if (r[0] != NULL) {
3305       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3306       print_strings (r);
3307       return -1;
3308     }
3309     for (i = 0; r[i] != NULL; ++i)
3310       free (r[i]);
3311     free (r);
3312   }
3313   return 0;
3314 }
3315
3316 static int test_vgremove_1 (void)
3317 {
3318   /* InitNone|InitEmpty for test_vgremove_1 */
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   /* TestOutputList for vgremove (1) */
3343   {
3344     char device[] = "/dev/sda";
3345     device[5] = devchar;
3346     int r;
3347     suppress_error = 0;
3348     r = guestfs_pvcreate (g, device);
3349     if (r == -1)
3350       return -1;
3351   }
3352   {
3353     char volgroup[] = "VG";
3354     char physvols_0[] = "/dev/sda";
3355     physvols_0[5] = devchar;
3356     char *physvols[] = {
3357       physvols_0,
3358       NULL
3359     };
3360     int r;
3361     suppress_error = 0;
3362     r = guestfs_vgcreate (g, volgroup, physvols);
3363     if (r == -1)
3364       return -1;
3365   }
3366   {
3367     char logvol[] = "LV1";
3368     char volgroup[] = "VG";
3369     int r;
3370     suppress_error = 0;
3371     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3372     if (r == -1)
3373       return -1;
3374   }
3375   {
3376     char logvol[] = "LV2";
3377     char volgroup[] = "VG";
3378     int r;
3379     suppress_error = 0;
3380     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3381     if (r == -1)
3382       return -1;
3383   }
3384   {
3385     char vgname[] = "VG";
3386     int r;
3387     suppress_error = 0;
3388     r = guestfs_vgremove (g, vgname);
3389     if (r == -1)
3390       return -1;
3391   }
3392   {
3393     char **r;
3394     int i;
3395     suppress_error = 0;
3396     r = guestfs_vgs (g);
3397     if (r == NULL)
3398       return -1;
3399     if (r[0] != NULL) {
3400       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
3401       print_strings (r);
3402       return -1;
3403     }
3404     for (i = 0; r[i] != NULL; ++i)
3405       free (r[i]);
3406     free (r);
3407   }
3408   return 0;
3409 }
3410
3411 static int test_lvremove_0 (void)
3412 {
3413   /* InitNone|InitEmpty for test_lvremove_0 */
3414   {
3415     char device[] = "/dev/sda";
3416     device[5] = devchar;
3417     int r;
3418     suppress_error = 0;
3419     r = guestfs_blockdev_setrw (g, device);
3420     if (r == -1)
3421       return -1;
3422   }
3423   {
3424     int r;
3425     suppress_error = 0;
3426     r = guestfs_umount_all (g);
3427     if (r == -1)
3428       return -1;
3429   }
3430   {
3431     int r;
3432     suppress_error = 0;
3433     r = guestfs_lvm_remove_all (g);
3434     if (r == -1)
3435       return -1;
3436   }
3437   /* TestOutputList for lvremove (0) */
3438   {
3439     char device[] = "/dev/sda";
3440     device[5] = devchar;
3441     int r;
3442     suppress_error = 0;
3443     r = guestfs_pvcreate (g, device);
3444     if (r == -1)
3445       return -1;
3446   }
3447   {
3448     char volgroup[] = "VG";
3449     char physvols_0[] = "/dev/sda";
3450     physvols_0[5] = devchar;
3451     char *physvols[] = {
3452       physvols_0,
3453       NULL
3454     };
3455     int r;
3456     suppress_error = 0;
3457     r = guestfs_vgcreate (g, volgroup, physvols);
3458     if (r == -1)
3459       return -1;
3460   }
3461   {
3462     char logvol[] = "LV1";
3463     char volgroup[] = "VG";
3464     int r;
3465     suppress_error = 0;
3466     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3467     if (r == -1)
3468       return -1;
3469   }
3470   {
3471     char logvol[] = "LV2";
3472     char volgroup[] = "VG";
3473     int r;
3474     suppress_error = 0;
3475     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3476     if (r == -1)
3477       return -1;
3478   }
3479   {
3480     char device[] = "/dev/VG/LV1";
3481     int r;
3482     suppress_error = 0;
3483     r = guestfs_lvremove (g, device);
3484     if (r == -1)
3485       return -1;
3486   }
3487   {
3488     char **r;
3489     int i;
3490     suppress_error = 0;
3491     r = guestfs_lvs (g);
3492     if (r == NULL)
3493       return -1;
3494     if (!r[0]) {
3495       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
3496       print_strings (r);
3497       return -1;
3498     }
3499     {
3500       char expected[] = "/dev/VG/LV2";
3501       if (strcmp (r[0], expected) != 0) {
3502         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3503         return -1;
3504       }
3505     }
3506     if (r[1] != NULL) {
3507       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
3508       print_strings (r);
3509       return -1;
3510     }
3511     for (i = 0; r[i] != NULL; ++i)
3512       free (r[i]);
3513     free (r);
3514   }
3515   return 0;
3516 }
3517
3518 static int test_lvremove_1 (void)
3519 {
3520   /* InitNone|InitEmpty for test_lvremove_1 */
3521   {
3522     char device[] = "/dev/sda";
3523     device[5] = devchar;
3524     int r;
3525     suppress_error = 0;
3526     r = guestfs_blockdev_setrw (g, device);
3527     if (r == -1)
3528       return -1;
3529   }
3530   {
3531     int r;
3532     suppress_error = 0;
3533     r = guestfs_umount_all (g);
3534     if (r == -1)
3535       return -1;
3536   }
3537   {
3538     int r;
3539     suppress_error = 0;
3540     r = guestfs_lvm_remove_all (g);
3541     if (r == -1)
3542       return -1;
3543   }
3544   /* TestOutputList for lvremove (1) */
3545   {
3546     char device[] = "/dev/sda";
3547     device[5] = devchar;
3548     int r;
3549     suppress_error = 0;
3550     r = guestfs_pvcreate (g, device);
3551     if (r == -1)
3552       return -1;
3553   }
3554   {
3555     char volgroup[] = "VG";
3556     char physvols_0[] = "/dev/sda";
3557     physvols_0[5] = devchar;
3558     char *physvols[] = {
3559       physvols_0,
3560       NULL
3561     };
3562     int r;
3563     suppress_error = 0;
3564     r = guestfs_vgcreate (g, volgroup, physvols);
3565     if (r == -1)
3566       return -1;
3567   }
3568   {
3569     char logvol[] = "LV1";
3570     char volgroup[] = "VG";
3571     int r;
3572     suppress_error = 0;
3573     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3574     if (r == -1)
3575       return -1;
3576   }
3577   {
3578     char logvol[] = "LV2";
3579     char volgroup[] = "VG";
3580     int r;
3581     suppress_error = 0;
3582     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3583     if (r == -1)
3584       return -1;
3585   }
3586   {
3587     char device[] = "/dev/VG";
3588     int r;
3589     suppress_error = 0;
3590     r = guestfs_lvremove (g, device);
3591     if (r == -1)
3592       return -1;
3593   }
3594   {
3595     char **r;
3596     int i;
3597     suppress_error = 0;
3598     r = guestfs_lvs (g);
3599     if (r == NULL)
3600       return -1;
3601     if (r[0] != NULL) {
3602       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3603       print_strings (r);
3604       return -1;
3605     }
3606     for (i = 0; r[i] != NULL; ++i)
3607       free (r[i]);
3608     free (r);
3609   }
3610   return 0;
3611 }
3612
3613 static int test_lvremove_2 (void)
3614 {
3615   /* InitNone|InitEmpty for test_lvremove_2 */
3616   {
3617     char device[] = "/dev/sda";
3618     device[5] = devchar;
3619     int r;
3620     suppress_error = 0;
3621     r = guestfs_blockdev_setrw (g, device);
3622     if (r == -1)
3623       return -1;
3624   }
3625   {
3626     int r;
3627     suppress_error = 0;
3628     r = guestfs_umount_all (g);
3629     if (r == -1)
3630       return -1;
3631   }
3632   {
3633     int r;
3634     suppress_error = 0;
3635     r = guestfs_lvm_remove_all (g);
3636     if (r == -1)
3637       return -1;
3638   }
3639   /* TestOutputList for lvremove (2) */
3640   {
3641     char device[] = "/dev/sda";
3642     device[5] = devchar;
3643     int r;
3644     suppress_error = 0;
3645     r = guestfs_pvcreate (g, device);
3646     if (r == -1)
3647       return -1;
3648   }
3649   {
3650     char volgroup[] = "VG";
3651     char physvols_0[] = "/dev/sda";
3652     physvols_0[5] = devchar;
3653     char *physvols[] = {
3654       physvols_0,
3655       NULL
3656     };
3657     int r;
3658     suppress_error = 0;
3659     r = guestfs_vgcreate (g, volgroup, physvols);
3660     if (r == -1)
3661       return -1;
3662   }
3663   {
3664     char logvol[] = "LV1";
3665     char volgroup[] = "VG";
3666     int r;
3667     suppress_error = 0;
3668     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3669     if (r == -1)
3670       return -1;
3671   }
3672   {
3673     char logvol[] = "LV2";
3674     char volgroup[] = "VG";
3675     int r;
3676     suppress_error = 0;
3677     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3678     if (r == -1)
3679       return -1;
3680   }
3681   {
3682     char device[] = "/dev/VG";
3683     int r;
3684     suppress_error = 0;
3685     r = guestfs_lvremove (g, device);
3686     if (r == -1)
3687       return -1;
3688   }
3689   {
3690     char **r;
3691     int i;
3692     suppress_error = 0;
3693     r = guestfs_vgs (g);
3694     if (r == NULL)
3695       return -1;
3696     if (!r[0]) {
3697       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3698       print_strings (r);
3699       return -1;
3700     }
3701     {
3702       char expected[] = "VG";
3703       if (strcmp (r[0], expected) != 0) {
3704         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3705         return -1;
3706       }
3707     }
3708     if (r[1] != NULL) {
3709       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3710       print_strings (r);
3711       return -1;
3712     }
3713     for (i = 0; r[i] != NULL; ++i)
3714       free (r[i]);
3715     free (r);
3716   }
3717   return 0;
3718 }
3719
3720 static int test_mount_ro_0 (void)
3721 {
3722   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
3723   {
3724     char device[] = "/dev/sda";
3725     device[5] = devchar;
3726     int r;
3727     suppress_error = 0;
3728     r = guestfs_blockdev_setrw (g, device);
3729     if (r == -1)
3730       return -1;
3731   }
3732   {
3733     int r;
3734     suppress_error = 0;
3735     r = guestfs_umount_all (g);
3736     if (r == -1)
3737       return -1;
3738   }
3739   {
3740     int r;
3741     suppress_error = 0;
3742     r = guestfs_lvm_remove_all (g);
3743     if (r == -1)
3744       return -1;
3745   }
3746   {
3747     char device[] = "/dev/sda";
3748     device[5] = devchar;
3749     char lines_0[] = ",";
3750     char *lines[] = {
3751       lines_0,
3752       NULL
3753     };
3754     int r;
3755     suppress_error = 0;
3756     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3757     if (r == -1)
3758       return -1;
3759   }
3760   {
3761     char fstype[] = "ext2";
3762     char device[] = "/dev/sda1";
3763     device[5] = devchar;
3764     int r;
3765     suppress_error = 0;
3766     r = guestfs_mkfs (g, fstype, device);
3767     if (r == -1)
3768       return -1;
3769   }
3770   {
3771     char device[] = "/dev/sda1";
3772     device[5] = devchar;
3773     char mountpoint[] = "/";
3774     int r;
3775     suppress_error = 0;
3776     r = guestfs_mount (g, device, mountpoint);
3777     if (r == -1)
3778       return -1;
3779   }
3780   /* TestLastFail for mount_ro (0) */
3781   {
3782     char pathordevice[] = "/";
3783     int r;
3784     suppress_error = 0;
3785     r = guestfs_umount (g, pathordevice);
3786     if (r == -1)
3787       return -1;
3788   }
3789   {
3790     char device[] = "/dev/sda1";
3791     device[5] = devchar;
3792     char mountpoint[] = "/";
3793     int r;
3794     suppress_error = 0;
3795     r = guestfs_mount_ro (g, device, mountpoint);
3796     if (r == -1)
3797       return -1;
3798   }
3799   {
3800     char path[] = "/new";
3801     int r;
3802     suppress_error = 1;
3803     r = guestfs_touch (g, path);
3804     if (r != -1)
3805       return -1;
3806   }
3807   return 0;
3808 }
3809
3810 static int test_mount_ro_1 (void)
3811 {
3812   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
3813   {
3814     char device[] = "/dev/sda";
3815     device[5] = devchar;
3816     int r;
3817     suppress_error = 0;
3818     r = guestfs_blockdev_setrw (g, device);
3819     if (r == -1)
3820       return -1;
3821   }
3822   {
3823     int r;
3824     suppress_error = 0;
3825     r = guestfs_umount_all (g);
3826     if (r == -1)
3827       return -1;
3828   }
3829   {
3830     int r;
3831     suppress_error = 0;
3832     r = guestfs_lvm_remove_all (g);
3833     if (r == -1)
3834       return -1;
3835   }
3836   {
3837     char device[] = "/dev/sda";
3838     device[5] = devchar;
3839     char lines_0[] = ",";
3840     char *lines[] = {
3841       lines_0,
3842       NULL
3843     };
3844     int r;
3845     suppress_error = 0;
3846     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3847     if (r == -1)
3848       return -1;
3849   }
3850   {
3851     char fstype[] = "ext2";
3852     char device[] = "/dev/sda1";
3853     device[5] = devchar;
3854     int r;
3855     suppress_error = 0;
3856     r = guestfs_mkfs (g, fstype, device);
3857     if (r == -1)
3858       return -1;
3859   }
3860   {
3861     char device[] = "/dev/sda1";
3862     device[5] = devchar;
3863     char mountpoint[] = "/";
3864     int r;
3865     suppress_error = 0;
3866     r = guestfs_mount (g, device, mountpoint);
3867     if (r == -1)
3868       return -1;
3869   }
3870   /* TestOutput for mount_ro (1) */
3871   char expected[] = "data";
3872   {
3873     char path[] = "/new";
3874     char content[] = "data";
3875     int r;
3876     suppress_error = 0;
3877     r = guestfs_write_file (g, path, content, 0);
3878     if (r == -1)
3879       return -1;
3880   }
3881   {
3882     char pathordevice[] = "/";
3883     int r;
3884     suppress_error = 0;
3885     r = guestfs_umount (g, pathordevice);
3886     if (r == -1)
3887       return -1;
3888   }
3889   {
3890     char device[] = "/dev/sda1";
3891     device[5] = devchar;
3892     char mountpoint[] = "/";
3893     int r;
3894     suppress_error = 0;
3895     r = guestfs_mount_ro (g, device, mountpoint);
3896     if (r == -1)
3897       return -1;
3898   }
3899   {
3900     char path[] = "/new";
3901     char *r;
3902     suppress_error = 0;
3903     r = guestfs_cat (g, path);
3904     if (r == NULL)
3905       return -1;
3906     if (strcmp (r, expected) != 0) {
3907       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3908       return -1;
3909     }
3910     free (r);
3911   }
3912   return 0;
3913 }
3914
3915 static int test_tgz_in_0 (void)
3916 {
3917   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
3918   {
3919     char device[] = "/dev/sda";
3920     device[5] = devchar;
3921     int r;
3922     suppress_error = 0;
3923     r = guestfs_blockdev_setrw (g, device);
3924     if (r == -1)
3925       return -1;
3926   }
3927   {
3928     int r;
3929     suppress_error = 0;
3930     r = guestfs_umount_all (g);
3931     if (r == -1)
3932       return -1;
3933   }
3934   {
3935     int r;
3936     suppress_error = 0;
3937     r = guestfs_lvm_remove_all (g);
3938     if (r == -1)
3939       return -1;
3940   }
3941   {
3942     char device[] = "/dev/sda";
3943     device[5] = devchar;
3944     char lines_0[] = ",";
3945     char *lines[] = {
3946       lines_0,
3947       NULL
3948     };
3949     int r;
3950     suppress_error = 0;
3951     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3952     if (r == -1)
3953       return -1;
3954   }
3955   {
3956     char fstype[] = "ext2";
3957     char device[] = "/dev/sda1";
3958     device[5] = devchar;
3959     int r;
3960     suppress_error = 0;
3961     r = guestfs_mkfs (g, fstype, device);
3962     if (r == -1)
3963       return -1;
3964   }
3965   {
3966     char device[] = "/dev/sda1";
3967     device[5] = devchar;
3968     char mountpoint[] = "/";
3969     int r;
3970     suppress_error = 0;
3971     r = guestfs_mount (g, device, mountpoint);
3972     if (r == -1)
3973       return -1;
3974   }
3975   /* TestOutput for tgz_in (0) */
3976   char expected[] = "hello\n";
3977   {
3978     char directory[] = "/";
3979     int r;
3980     suppress_error = 0;
3981     r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3982     if (r == -1)
3983       return -1;
3984   }
3985   {
3986     char path[] = "/hello";
3987     char *r;
3988     suppress_error = 0;
3989     r = guestfs_cat (g, path);
3990     if (r == NULL)
3991       return -1;
3992     if (strcmp (r, expected) != 0) {
3993       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3994       return -1;
3995     }
3996     free (r);
3997   }
3998   return 0;
3999 }
4000
4001 static int test_tar_in_0 (void)
4002 {
4003   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4004   {
4005     char device[] = "/dev/sda";
4006     device[5] = devchar;
4007     int r;
4008     suppress_error = 0;
4009     r = guestfs_blockdev_setrw (g, device);
4010     if (r == -1)
4011       return -1;
4012   }
4013   {
4014     int r;
4015     suppress_error = 0;
4016     r = guestfs_umount_all (g);
4017     if (r == -1)
4018       return -1;
4019   }
4020   {
4021     int r;
4022     suppress_error = 0;
4023     r = guestfs_lvm_remove_all (g);
4024     if (r == -1)
4025       return -1;
4026   }
4027   {
4028     char device[] = "/dev/sda";
4029     device[5] = devchar;
4030     char lines_0[] = ",";
4031     char *lines[] = {
4032       lines_0,
4033       NULL
4034     };
4035     int r;
4036     suppress_error = 0;
4037     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4038     if (r == -1)
4039       return -1;
4040   }
4041   {
4042     char fstype[] = "ext2";
4043     char device[] = "/dev/sda1";
4044     device[5] = devchar;
4045     int r;
4046     suppress_error = 0;
4047     r = guestfs_mkfs (g, fstype, device);
4048     if (r == -1)
4049       return -1;
4050   }
4051   {
4052     char device[] = "/dev/sda1";
4053     device[5] = devchar;
4054     char mountpoint[] = "/";
4055     int r;
4056     suppress_error = 0;
4057     r = guestfs_mount (g, device, mountpoint);
4058     if (r == -1)
4059       return -1;
4060   }
4061   /* TestOutput for tar_in (0) */
4062   char expected[] = "hello\n";
4063   {
4064     char directory[] = "/";
4065     int r;
4066     suppress_error = 0;
4067     r = guestfs_tar_in (g, "images/helloworld.tar", directory);
4068     if (r == -1)
4069       return -1;
4070   }
4071   {
4072     char path[] = "/hello";
4073     char *r;
4074     suppress_error = 0;
4075     r = guestfs_cat (g, path);
4076     if (r == NULL)
4077       return -1;
4078     if (strcmp (r, expected) != 0) {
4079       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4080       return -1;
4081     }
4082     free (r);
4083   }
4084   return 0;
4085 }
4086
4087 static int test_checksum_0 (void)
4088 {
4089   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4090   {
4091     char device[] = "/dev/sda";
4092     device[5] = devchar;
4093     int r;
4094     suppress_error = 0;
4095     r = guestfs_blockdev_setrw (g, device);
4096     if (r == -1)
4097       return -1;
4098   }
4099   {
4100     int r;
4101     suppress_error = 0;
4102     r = guestfs_umount_all (g);
4103     if (r == -1)
4104       return -1;
4105   }
4106   {
4107     int r;
4108     suppress_error = 0;
4109     r = guestfs_lvm_remove_all (g);
4110     if (r == -1)
4111       return -1;
4112   }
4113   {
4114     char device[] = "/dev/sda";
4115     device[5] = devchar;
4116     char lines_0[] = ",";
4117     char *lines[] = {
4118       lines_0,
4119       NULL
4120     };
4121     int r;
4122     suppress_error = 0;
4123     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4124     if (r == -1)
4125       return -1;
4126   }
4127   {
4128     char fstype[] = "ext2";
4129     char device[] = "/dev/sda1";
4130     device[5] = devchar;
4131     int r;
4132     suppress_error = 0;
4133     r = guestfs_mkfs (g, fstype, device);
4134     if (r == -1)
4135       return -1;
4136   }
4137   {
4138     char device[] = "/dev/sda1";
4139     device[5] = devchar;
4140     char mountpoint[] = "/";
4141     int r;
4142     suppress_error = 0;
4143     r = guestfs_mount (g, device, mountpoint);
4144     if (r == -1)
4145       return -1;
4146   }
4147   /* TestOutput for checksum (0) */
4148   char expected[] = "935282863";
4149   {
4150     char path[] = "/new";
4151     char content[] = "test\n";
4152     int r;
4153     suppress_error = 0;
4154     r = guestfs_write_file (g, path, content, 0);
4155     if (r == -1)
4156       return -1;
4157   }
4158   {
4159     char csumtype[] = "crc";
4160     char path[] = "/new";
4161     char *r;
4162     suppress_error = 0;
4163     r = guestfs_checksum (g, csumtype, path);
4164     if (r == NULL)
4165       return -1;
4166     if (strcmp (r, expected) != 0) {
4167       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
4168       return -1;
4169     }
4170     free (r);
4171   }
4172   return 0;
4173 }
4174
4175 static int test_checksum_1 (void)
4176 {
4177   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
4178   {
4179     char device[] = "/dev/sda";
4180     device[5] = devchar;
4181     int r;
4182     suppress_error = 0;
4183     r = guestfs_blockdev_setrw (g, device);
4184     if (r == -1)
4185       return -1;
4186   }
4187   {
4188     int r;
4189     suppress_error = 0;
4190     r = guestfs_umount_all (g);
4191     if (r == -1)
4192       return -1;
4193   }
4194   {
4195     int r;
4196     suppress_error = 0;
4197     r = guestfs_lvm_remove_all (g);
4198     if (r == -1)
4199       return -1;
4200   }
4201   {
4202     char device[] = "/dev/sda";
4203     device[5] = devchar;
4204     char lines_0[] = ",";
4205     char *lines[] = {
4206       lines_0,
4207       NULL
4208     };
4209     int r;
4210     suppress_error = 0;
4211     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4212     if (r == -1)
4213       return -1;
4214   }
4215   {
4216     char fstype[] = "ext2";
4217     char device[] = "/dev/sda1";
4218     device[5] = devchar;
4219     int r;
4220     suppress_error = 0;
4221     r = guestfs_mkfs (g, fstype, device);
4222     if (r == -1)
4223       return -1;
4224   }
4225   {
4226     char device[] = "/dev/sda1";
4227     device[5] = devchar;
4228     char mountpoint[] = "/";
4229     int r;
4230     suppress_error = 0;
4231     r = guestfs_mount (g, device, mountpoint);
4232     if (r == -1)
4233       return -1;
4234   }
4235   /* TestLastFail for checksum (1) */
4236   {
4237     char csumtype[] = "crc";
4238     char path[] = "/new";
4239     char *r;
4240     suppress_error = 1;
4241     r = guestfs_checksum (g, csumtype, path);
4242     if (r != NULL)
4243       return -1;
4244     free (r);
4245   }
4246   return 0;
4247 }
4248
4249 static int test_checksum_2 (void)
4250 {
4251   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
4252   {
4253     char device[] = "/dev/sda";
4254     device[5] = devchar;
4255     int r;
4256     suppress_error = 0;
4257     r = guestfs_blockdev_setrw (g, device);
4258     if (r == -1)
4259       return -1;
4260   }
4261   {
4262     int r;
4263     suppress_error = 0;
4264     r = guestfs_umount_all (g);
4265     if (r == -1)
4266       return -1;
4267   }
4268   {
4269     int r;
4270     suppress_error = 0;
4271     r = guestfs_lvm_remove_all (g);
4272     if (r == -1)
4273       return -1;
4274   }
4275   {
4276     char device[] = "/dev/sda";
4277     device[5] = devchar;
4278     char lines_0[] = ",";
4279     char *lines[] = {
4280       lines_0,
4281       NULL
4282     };
4283     int r;
4284     suppress_error = 0;
4285     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4286     if (r == -1)
4287       return -1;
4288   }
4289   {
4290     char fstype[] = "ext2";
4291     char device[] = "/dev/sda1";
4292     device[5] = devchar;
4293     int r;
4294     suppress_error = 0;
4295     r = guestfs_mkfs (g, fstype, device);
4296     if (r == -1)
4297       return -1;
4298   }
4299   {
4300     char device[] = "/dev/sda1";
4301     device[5] = devchar;
4302     char mountpoint[] = "/";
4303     int r;
4304     suppress_error = 0;
4305     r = guestfs_mount (g, device, mountpoint);
4306     if (r == -1)
4307       return -1;
4308   }
4309   /* TestOutput for checksum (2) */
4310   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
4311   {
4312     char path[] = "/new";
4313     char content[] = "test\n";
4314     int r;
4315     suppress_error = 0;
4316     r = guestfs_write_file (g, path, content, 0);
4317     if (r == -1)
4318       return -1;
4319   }
4320   {
4321     char csumtype[] = "md5";
4322     char path[] = "/new";
4323     char *r;
4324     suppress_error = 0;
4325     r = guestfs_checksum (g, csumtype, path);
4326     if (r == NULL)
4327       return -1;
4328     if (strcmp (r, expected) != 0) {
4329       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
4330       return -1;
4331     }
4332     free (r);
4333   }
4334   return 0;
4335 }
4336
4337 static int test_checksum_3 (void)
4338 {
4339   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
4340   {
4341     char device[] = "/dev/sda";
4342     device[5] = devchar;
4343     int r;
4344     suppress_error = 0;
4345     r = guestfs_blockdev_setrw (g, device);
4346     if (r == -1)
4347       return -1;
4348   }
4349   {
4350     int r;
4351     suppress_error = 0;
4352     r = guestfs_umount_all (g);
4353     if (r == -1)
4354       return -1;
4355   }
4356   {
4357     int r;
4358     suppress_error = 0;
4359     r = guestfs_lvm_remove_all (g);
4360     if (r == -1)
4361       return -1;
4362   }
4363   {
4364     char device[] = "/dev/sda";
4365     device[5] = devchar;
4366     char lines_0[] = ",";
4367     char *lines[] = {
4368       lines_0,
4369       NULL
4370     };
4371     int r;
4372     suppress_error = 0;
4373     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4374     if (r == -1)
4375       return -1;
4376   }
4377   {
4378     char fstype[] = "ext2";
4379     char device[] = "/dev/sda1";
4380     device[5] = devchar;
4381     int r;
4382     suppress_error = 0;
4383     r = guestfs_mkfs (g, fstype, device);
4384     if (r == -1)
4385       return -1;
4386   }
4387   {
4388     char device[] = "/dev/sda1";
4389     device[5] = devchar;
4390     char mountpoint[] = "/";
4391     int r;
4392     suppress_error = 0;
4393     r = guestfs_mount (g, device, mountpoint);
4394     if (r == -1)
4395       return -1;
4396   }
4397   /* TestOutput for checksum (3) */
4398   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
4399   {
4400     char path[] = "/new";
4401     char content[] = "test\n";
4402     int r;
4403     suppress_error = 0;
4404     r = guestfs_write_file (g, path, content, 0);
4405     if (r == -1)
4406       return -1;
4407   }
4408   {
4409     char csumtype[] = "sha1";
4410     char path[] = "/new";
4411     char *r;
4412     suppress_error = 0;
4413     r = guestfs_checksum (g, csumtype, path);
4414     if (r == NULL)
4415       return -1;
4416     if (strcmp (r, expected) != 0) {
4417       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
4418       return -1;
4419     }
4420     free (r);
4421   }
4422   return 0;
4423 }
4424
4425 static int test_checksum_4 (void)
4426 {
4427   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
4428   {
4429     char device[] = "/dev/sda";
4430     device[5] = devchar;
4431     int r;
4432     suppress_error = 0;
4433     r = guestfs_blockdev_setrw (g, device);
4434     if (r == -1)
4435       return -1;
4436   }
4437   {
4438     int r;
4439     suppress_error = 0;
4440     r = guestfs_umount_all (g);
4441     if (r == -1)
4442       return -1;
4443   }
4444   {
4445     int r;
4446     suppress_error = 0;
4447     r = guestfs_lvm_remove_all (g);
4448     if (r == -1)
4449       return -1;
4450   }
4451   {
4452     char device[] = "/dev/sda";
4453     device[5] = devchar;
4454     char lines_0[] = ",";
4455     char *lines[] = {
4456       lines_0,
4457       NULL
4458     };
4459     int r;
4460     suppress_error = 0;
4461     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4462     if (r == -1)
4463       return -1;
4464   }
4465   {
4466     char fstype[] = "ext2";
4467     char device[] = "/dev/sda1";
4468     device[5] = devchar;
4469     int r;
4470     suppress_error = 0;
4471     r = guestfs_mkfs (g, fstype, device);
4472     if (r == -1)
4473       return -1;
4474   }
4475   {
4476     char device[] = "/dev/sda1";
4477     device[5] = devchar;
4478     char mountpoint[] = "/";
4479     int r;
4480     suppress_error = 0;
4481     r = guestfs_mount (g, device, mountpoint);
4482     if (r == -1)
4483       return -1;
4484   }
4485   /* TestOutput for checksum (4) */
4486   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
4487   {
4488     char path[] = "/new";
4489     char content[] = "test\n";
4490     int r;
4491     suppress_error = 0;
4492     r = guestfs_write_file (g, path, content, 0);
4493     if (r == -1)
4494       return -1;
4495   }
4496   {
4497     char csumtype[] = "sha224";
4498     char path[] = "/new";
4499     char *r;
4500     suppress_error = 0;
4501     r = guestfs_checksum (g, csumtype, path);
4502     if (r == NULL)
4503       return -1;
4504     if (strcmp (r, expected) != 0) {
4505       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
4506       return -1;
4507     }
4508     free (r);
4509   }
4510   return 0;
4511 }
4512
4513 static int test_checksum_5 (void)
4514 {
4515   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
4516   {
4517     char device[] = "/dev/sda";
4518     device[5] = devchar;
4519     int r;
4520     suppress_error = 0;
4521     r = guestfs_blockdev_setrw (g, device);
4522     if (r == -1)
4523       return -1;
4524   }
4525   {
4526     int r;
4527     suppress_error = 0;
4528     r = guestfs_umount_all (g);
4529     if (r == -1)
4530       return -1;
4531   }
4532   {
4533     int r;
4534     suppress_error = 0;
4535     r = guestfs_lvm_remove_all (g);
4536     if (r == -1)
4537       return -1;
4538   }
4539   {
4540     char device[] = "/dev/sda";
4541     device[5] = devchar;
4542     char lines_0[] = ",";
4543     char *lines[] = {
4544       lines_0,
4545       NULL
4546     };
4547     int r;
4548     suppress_error = 0;
4549     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4550     if (r == -1)
4551       return -1;
4552   }
4553   {
4554     char fstype[] = "ext2";
4555     char device[] = "/dev/sda1";
4556     device[5] = devchar;
4557     int r;
4558     suppress_error = 0;
4559     r = guestfs_mkfs (g, fstype, device);
4560     if (r == -1)
4561       return -1;
4562   }
4563   {
4564     char device[] = "/dev/sda1";
4565     device[5] = devchar;
4566     char mountpoint[] = "/";
4567     int r;
4568     suppress_error = 0;
4569     r = guestfs_mount (g, device, mountpoint);
4570     if (r == -1)
4571       return -1;
4572   }
4573   /* TestOutput for checksum (5) */
4574   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4575   {
4576     char path[] = "/new";
4577     char content[] = "test\n";
4578     int r;
4579     suppress_error = 0;
4580     r = guestfs_write_file (g, path, content, 0);
4581     if (r == -1)
4582       return -1;
4583   }
4584   {
4585     char csumtype[] = "sha256";
4586     char path[] = "/new";
4587     char *r;
4588     suppress_error = 0;
4589     r = guestfs_checksum (g, csumtype, path);
4590     if (r == NULL)
4591       return -1;
4592     if (strcmp (r, expected) != 0) {
4593       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4594       return -1;
4595     }
4596     free (r);
4597   }
4598   return 0;
4599 }
4600
4601 static int test_checksum_6 (void)
4602 {
4603   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
4604   {
4605     char device[] = "/dev/sda";
4606     device[5] = devchar;
4607     int r;
4608     suppress_error = 0;
4609     r = guestfs_blockdev_setrw (g, device);
4610     if (r == -1)
4611       return -1;
4612   }
4613   {
4614     int r;
4615     suppress_error = 0;
4616     r = guestfs_umount_all (g);
4617     if (r == -1)
4618       return -1;
4619   }
4620   {
4621     int r;
4622     suppress_error = 0;
4623     r = guestfs_lvm_remove_all (g);
4624     if (r == -1)
4625       return -1;
4626   }
4627   {
4628     char device[] = "/dev/sda";
4629     device[5] = devchar;
4630     char lines_0[] = ",";
4631     char *lines[] = {
4632       lines_0,
4633       NULL
4634     };
4635     int r;
4636     suppress_error = 0;
4637     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4638     if (r == -1)
4639       return -1;
4640   }
4641   {
4642     char fstype[] = "ext2";
4643     char device[] = "/dev/sda1";
4644     device[5] = devchar;
4645     int r;
4646     suppress_error = 0;
4647     r = guestfs_mkfs (g, fstype, device);
4648     if (r == -1)
4649       return -1;
4650   }
4651   {
4652     char device[] = "/dev/sda1";
4653     device[5] = devchar;
4654     char mountpoint[] = "/";
4655     int r;
4656     suppress_error = 0;
4657     r = guestfs_mount (g, device, mountpoint);
4658     if (r == -1)
4659       return -1;
4660   }
4661   /* TestOutput for checksum (6) */
4662   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4663   {
4664     char path[] = "/new";
4665     char content[] = "test\n";
4666     int r;
4667     suppress_error = 0;
4668     r = guestfs_write_file (g, path, content, 0);
4669     if (r == -1)
4670       return -1;
4671   }
4672   {
4673     char csumtype[] = "sha384";
4674     char path[] = "/new";
4675     char *r;
4676     suppress_error = 0;
4677     r = guestfs_checksum (g, csumtype, path);
4678     if (r == NULL)
4679       return -1;
4680     if (strcmp (r, expected) != 0) {
4681       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4682       return -1;
4683     }
4684     free (r);
4685   }
4686   return 0;
4687 }
4688
4689 static int test_checksum_7 (void)
4690 {
4691   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
4692   {
4693     char device[] = "/dev/sda";
4694     device[5] = devchar;
4695     int r;
4696     suppress_error = 0;
4697     r = guestfs_blockdev_setrw (g, device);
4698     if (r == -1)
4699       return -1;
4700   }
4701   {
4702     int r;
4703     suppress_error = 0;
4704     r = guestfs_umount_all (g);
4705     if (r == -1)
4706       return -1;
4707   }
4708   {
4709     int r;
4710     suppress_error = 0;
4711     r = guestfs_lvm_remove_all (g);
4712     if (r == -1)
4713       return -1;
4714   }
4715   {
4716     char device[] = "/dev/sda";
4717     device[5] = devchar;
4718     char lines_0[] = ",";
4719     char *lines[] = {
4720       lines_0,
4721       NULL
4722     };
4723     int r;
4724     suppress_error = 0;
4725     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4726     if (r == -1)
4727       return -1;
4728   }
4729   {
4730     char fstype[] = "ext2";
4731     char device[] = "/dev/sda1";
4732     device[5] = devchar;
4733     int r;
4734     suppress_error = 0;
4735     r = guestfs_mkfs (g, fstype, device);
4736     if (r == -1)
4737       return -1;
4738   }
4739   {
4740     char device[] = "/dev/sda1";
4741     device[5] = devchar;
4742     char mountpoint[] = "/";
4743     int r;
4744     suppress_error = 0;
4745     r = guestfs_mount (g, device, mountpoint);
4746     if (r == -1)
4747       return -1;
4748   }
4749   /* TestOutput for checksum (7) */
4750   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4751   {
4752     char path[] = "/new";
4753     char content[] = "test\n";
4754     int r;
4755     suppress_error = 0;
4756     r = guestfs_write_file (g, path, content, 0);
4757     if (r == -1)
4758       return -1;
4759   }
4760   {
4761     char csumtype[] = "sha512";
4762     char path[] = "/new";
4763     char *r;
4764     suppress_error = 0;
4765     r = guestfs_checksum (g, csumtype, path);
4766     if (r == NULL)
4767       return -1;
4768     if (strcmp (r, expected) != 0) {
4769       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4770       return -1;
4771     }
4772     free (r);
4773   }
4774   return 0;
4775 }
4776
4777 static int test_download_0 (void)
4778 {
4779   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
4780   {
4781     char device[] = "/dev/sda";
4782     device[5] = devchar;
4783     int r;
4784     suppress_error = 0;
4785     r = guestfs_blockdev_setrw (g, device);
4786     if (r == -1)
4787       return -1;
4788   }
4789   {
4790     int r;
4791     suppress_error = 0;
4792     r = guestfs_umount_all (g);
4793     if (r == -1)
4794       return -1;
4795   }
4796   {
4797     int r;
4798     suppress_error = 0;
4799     r = guestfs_lvm_remove_all (g);
4800     if (r == -1)
4801       return -1;
4802   }
4803   {
4804     char device[] = "/dev/sda";
4805     device[5] = devchar;
4806     char lines_0[] = ",";
4807     char *lines[] = {
4808       lines_0,
4809       NULL
4810     };
4811     int r;
4812     suppress_error = 0;
4813     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4814     if (r == -1)
4815       return -1;
4816   }
4817   {
4818     char fstype[] = "ext2";
4819     char device[] = "/dev/sda1";
4820     device[5] = devchar;
4821     int r;
4822     suppress_error = 0;
4823     r = guestfs_mkfs (g, fstype, device);
4824     if (r == -1)
4825       return -1;
4826   }
4827   {
4828     char device[] = "/dev/sda1";
4829     device[5] = devchar;
4830     char mountpoint[] = "/";
4831     int r;
4832     suppress_error = 0;
4833     r = guestfs_mount (g, device, mountpoint);
4834     if (r == -1)
4835       return -1;
4836   }
4837   /* TestOutput for download (0) */
4838   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4839   {
4840     char remotefilename[] = "/COPYING.LIB";
4841     int r;
4842     suppress_error = 0;
4843     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4844     if (r == -1)
4845       return -1;
4846   }
4847   {
4848     char remotefilename[] = "/COPYING.LIB";
4849     int r;
4850     suppress_error = 0;
4851     r = guestfs_download (g, remotefilename, "testdownload.tmp");
4852     if (r == -1)
4853       return -1;
4854   }
4855   {
4856     char remotefilename[] = "/upload";
4857     int r;
4858     suppress_error = 0;
4859     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4860     if (r == -1)
4861       return -1;
4862   }
4863   {
4864     char csumtype[] = "md5";
4865     char path[] = "/upload";
4866     char *r;
4867     suppress_error = 0;
4868     r = guestfs_checksum (g, csumtype, path);
4869     if (r == NULL)
4870       return -1;
4871     if (strcmp (r, expected) != 0) {
4872       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4873       return -1;
4874     }
4875     free (r);
4876   }
4877   return 0;
4878 }
4879
4880 static int test_upload_0 (void)
4881 {
4882   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
4883   {
4884     char device[] = "/dev/sda";
4885     device[5] = devchar;
4886     int r;
4887     suppress_error = 0;
4888     r = guestfs_blockdev_setrw (g, device);
4889     if (r == -1)
4890       return -1;
4891   }
4892   {
4893     int r;
4894     suppress_error = 0;
4895     r = guestfs_umount_all (g);
4896     if (r == -1)
4897       return -1;
4898   }
4899   {
4900     int r;
4901     suppress_error = 0;
4902     r = guestfs_lvm_remove_all (g);
4903     if (r == -1)
4904       return -1;
4905   }
4906   {
4907     char device[] = "/dev/sda";
4908     device[5] = devchar;
4909     char lines_0[] = ",";
4910     char *lines[] = {
4911       lines_0,
4912       NULL
4913     };
4914     int r;
4915     suppress_error = 0;
4916     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4917     if (r == -1)
4918       return -1;
4919   }
4920   {
4921     char fstype[] = "ext2";
4922     char device[] = "/dev/sda1";
4923     device[5] = devchar;
4924     int r;
4925     suppress_error = 0;
4926     r = guestfs_mkfs (g, fstype, device);
4927     if (r == -1)
4928       return -1;
4929   }
4930   {
4931     char device[] = "/dev/sda1";
4932     device[5] = devchar;
4933     char mountpoint[] = "/";
4934     int r;
4935     suppress_error = 0;
4936     r = guestfs_mount (g, device, mountpoint);
4937     if (r == -1)
4938       return -1;
4939   }
4940   /* TestOutput for upload (0) */
4941   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4942   {
4943     char remotefilename[] = "/COPYING.LIB";
4944     int r;
4945     suppress_error = 0;
4946     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4947     if (r == -1)
4948       return -1;
4949   }
4950   {
4951     char csumtype[] = "md5";
4952     char path[] = "/COPYING.LIB";
4953     char *r;
4954     suppress_error = 0;
4955     r = guestfs_checksum (g, csumtype, path);
4956     if (r == NULL)
4957       return -1;
4958     if (strcmp (r, expected) != 0) {
4959       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4960       return -1;
4961     }
4962     free (r);
4963   }
4964   return 0;
4965 }
4966
4967 static int test_blockdev_rereadpt_0 (void)
4968 {
4969   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
4970   {
4971     char device[] = "/dev/sda";
4972     device[5] = devchar;
4973     int r;
4974     suppress_error = 0;
4975     r = guestfs_blockdev_setrw (g, device);
4976     if (r == -1)
4977       return -1;
4978   }
4979   {
4980     int r;
4981     suppress_error = 0;
4982     r = guestfs_umount_all (g);
4983     if (r == -1)
4984       return -1;
4985   }
4986   {
4987     int r;
4988     suppress_error = 0;
4989     r = guestfs_lvm_remove_all (g);
4990     if (r == -1)
4991       return -1;
4992   }
4993   /* TestRun for blockdev_rereadpt (0) */
4994   {
4995     char device[] = "/dev/sda";
4996     device[5] = devchar;
4997     int r;
4998     suppress_error = 0;
4999     r = guestfs_blockdev_rereadpt (g, device);
5000     if (r == -1)
5001       return -1;
5002   }
5003   return 0;
5004 }
5005
5006 static int test_blockdev_flushbufs_0 (void)
5007 {
5008   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
5009   {
5010     char device[] = "/dev/sda";
5011     device[5] = devchar;
5012     int r;
5013     suppress_error = 0;
5014     r = guestfs_blockdev_setrw (g, device);
5015     if (r == -1)
5016       return -1;
5017   }
5018   {
5019     int r;
5020     suppress_error = 0;
5021     r = guestfs_umount_all (g);
5022     if (r == -1)
5023       return -1;
5024   }
5025   {
5026     int r;
5027     suppress_error = 0;
5028     r = guestfs_lvm_remove_all (g);
5029     if (r == -1)
5030       return -1;
5031   }
5032   /* TestRun for blockdev_flushbufs (0) */
5033   {
5034     char device[] = "/dev/sda";
5035     device[5] = devchar;
5036     int r;
5037     suppress_error = 0;
5038     r = guestfs_blockdev_flushbufs (g, device);
5039     if (r == -1)
5040       return -1;
5041   }
5042   return 0;
5043 }
5044
5045 static int test_blockdev_getsize64_0 (void)
5046 {
5047   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
5048   {
5049     char device[] = "/dev/sda";
5050     device[5] = devchar;
5051     int r;
5052     suppress_error = 0;
5053     r = guestfs_blockdev_setrw (g, device);
5054     if (r == -1)
5055       return -1;
5056   }
5057   {
5058     int r;
5059     suppress_error = 0;
5060     r = guestfs_umount_all (g);
5061     if (r == -1)
5062       return -1;
5063   }
5064   {
5065     int r;
5066     suppress_error = 0;
5067     r = guestfs_lvm_remove_all (g);
5068     if (r == -1)
5069       return -1;
5070   }
5071   /* TestOutputInt for blockdev_getsize64 (0) */
5072   {
5073     char device[] = "/dev/sda";
5074     device[5] = devchar;
5075     int64_t r;
5076     suppress_error = 0;
5077     r = guestfs_blockdev_getsize64 (g, device);
5078     if (r == -1)
5079       return -1;
5080     if (r != 524288000) {
5081       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
5082       return -1;
5083     }
5084   }
5085   return 0;
5086 }
5087
5088 static int test_blockdev_getsz_0 (void)
5089 {
5090   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
5091   {
5092     char device[] = "/dev/sda";
5093     device[5] = devchar;
5094     int r;
5095     suppress_error = 0;
5096     r = guestfs_blockdev_setrw (g, device);
5097     if (r == -1)
5098       return -1;
5099   }
5100   {
5101     int r;
5102     suppress_error = 0;
5103     r = guestfs_umount_all (g);
5104     if (r == -1)
5105       return -1;
5106   }
5107   {
5108     int r;
5109     suppress_error = 0;
5110     r = guestfs_lvm_remove_all (g);
5111     if (r == -1)
5112       return -1;
5113   }
5114   /* TestOutputInt for blockdev_getsz (0) */
5115   {
5116     char device[] = "/dev/sda";
5117     device[5] = devchar;
5118     int64_t r;
5119     suppress_error = 0;
5120     r = guestfs_blockdev_getsz (g, device);
5121     if (r == -1)
5122       return -1;
5123     if (r != 1024000) {
5124       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
5125       return -1;
5126     }
5127   }
5128   return 0;
5129 }
5130
5131 static int test_blockdev_getbsz_0 (void)
5132 {
5133   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
5134   {
5135     char device[] = "/dev/sda";
5136     device[5] = devchar;
5137     int r;
5138     suppress_error = 0;
5139     r = guestfs_blockdev_setrw (g, device);
5140     if (r == -1)
5141       return -1;
5142   }
5143   {
5144     int r;
5145     suppress_error = 0;
5146     r = guestfs_umount_all (g);
5147     if (r == -1)
5148       return -1;
5149   }
5150   {
5151     int r;
5152     suppress_error = 0;
5153     r = guestfs_lvm_remove_all (g);
5154     if (r == -1)
5155       return -1;
5156   }
5157   /* TestOutputInt for blockdev_getbsz (0) */
5158   {
5159     char device[] = "/dev/sda";
5160     device[5] = devchar;
5161     int r;
5162     suppress_error = 0;
5163     r = guestfs_blockdev_getbsz (g, device);
5164     if (r == -1)
5165       return -1;
5166     if (r != 4096) {
5167       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
5168       return -1;
5169     }
5170   }
5171   return 0;
5172 }
5173
5174 static int test_blockdev_getss_0 (void)
5175 {
5176   /* InitNone|InitEmpty for test_blockdev_getss_0 */
5177   {
5178     char device[] = "/dev/sda";
5179     device[5] = devchar;
5180     int r;
5181     suppress_error = 0;
5182     r = guestfs_blockdev_setrw (g, device);
5183     if (r == -1)
5184       return -1;
5185   }
5186   {
5187     int r;
5188     suppress_error = 0;
5189     r = guestfs_umount_all (g);
5190     if (r == -1)
5191       return -1;
5192   }
5193   {
5194     int r;
5195     suppress_error = 0;
5196     r = guestfs_lvm_remove_all (g);
5197     if (r == -1)
5198       return -1;
5199   }
5200   /* TestOutputInt for blockdev_getss (0) */
5201   {
5202     char device[] = "/dev/sda";
5203     device[5] = devchar;
5204     int r;
5205     suppress_error = 0;
5206     r = guestfs_blockdev_getss (g, device);
5207     if (r == -1)
5208       return -1;
5209     if (r != 512) {
5210       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
5211       return -1;
5212     }
5213   }
5214   return 0;
5215 }
5216
5217 static int test_blockdev_getro_0 (void)
5218 {
5219   /* InitNone|InitEmpty for test_blockdev_getro_0 */
5220   {
5221     char device[] = "/dev/sda";
5222     device[5] = devchar;
5223     int r;
5224     suppress_error = 0;
5225     r = guestfs_blockdev_setrw (g, device);
5226     if (r == -1)
5227       return -1;
5228   }
5229   {
5230     int r;
5231     suppress_error = 0;
5232     r = guestfs_umount_all (g);
5233     if (r == -1)
5234       return -1;
5235   }
5236   {
5237     int r;
5238     suppress_error = 0;
5239     r = guestfs_lvm_remove_all (g);
5240     if (r == -1)
5241       return -1;
5242   }
5243   /* TestOutputTrue for blockdev_getro (0) */
5244   {
5245     char device[] = "/dev/sda";
5246     device[5] = devchar;
5247     int r;
5248     suppress_error = 0;
5249     r = guestfs_blockdev_setro (g, device);
5250     if (r == -1)
5251       return -1;
5252   }
5253   {
5254     char device[] = "/dev/sda";
5255     device[5] = devchar;
5256     int r;
5257     suppress_error = 0;
5258     r = guestfs_blockdev_getro (g, device);
5259     if (r == -1)
5260       return -1;
5261     if (!r) {
5262       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
5263       return -1;
5264     }
5265   }
5266   return 0;
5267 }
5268
5269 static int test_blockdev_setrw_0 (void)
5270 {
5271   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
5272   {
5273     char device[] = "/dev/sda";
5274     device[5] = devchar;
5275     int r;
5276     suppress_error = 0;
5277     r = guestfs_blockdev_setrw (g, device);
5278     if (r == -1)
5279       return -1;
5280   }
5281   {
5282     int r;
5283     suppress_error = 0;
5284     r = guestfs_umount_all (g);
5285     if (r == -1)
5286       return -1;
5287   }
5288   {
5289     int r;
5290     suppress_error = 0;
5291     r = guestfs_lvm_remove_all (g);
5292     if (r == -1)
5293       return -1;
5294   }
5295   /* TestOutputFalse for blockdev_setrw (0) */
5296   {
5297     char device[] = "/dev/sda";
5298     device[5] = devchar;
5299     int r;
5300     suppress_error = 0;
5301     r = guestfs_blockdev_setrw (g, device);
5302     if (r == -1)
5303       return -1;
5304   }
5305   {
5306     char device[] = "/dev/sda";
5307     device[5] = devchar;
5308     int r;
5309     suppress_error = 0;
5310     r = guestfs_blockdev_getro (g, device);
5311     if (r == -1)
5312       return -1;
5313     if (r) {
5314       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
5315       return -1;
5316     }
5317   }
5318   return 0;
5319 }
5320
5321 static int test_blockdev_setro_0 (void)
5322 {
5323   /* InitNone|InitEmpty for test_blockdev_setro_0 */
5324   {
5325     char device[] = "/dev/sda";
5326     device[5] = devchar;
5327     int r;
5328     suppress_error = 0;
5329     r = guestfs_blockdev_setrw (g, device);
5330     if (r == -1)
5331       return -1;
5332   }
5333   {
5334     int r;
5335     suppress_error = 0;
5336     r = guestfs_umount_all (g);
5337     if (r == -1)
5338       return -1;
5339   }
5340   {
5341     int r;
5342     suppress_error = 0;
5343     r = guestfs_lvm_remove_all (g);
5344     if (r == -1)
5345       return -1;
5346   }
5347   /* TestOutputTrue for blockdev_setro (0) */
5348   {
5349     char device[] = "/dev/sda";
5350     device[5] = devchar;
5351     int r;
5352     suppress_error = 0;
5353     r = guestfs_blockdev_setro (g, device);
5354     if (r == -1)
5355       return -1;
5356   }
5357   {
5358     char device[] = "/dev/sda";
5359     device[5] = devchar;
5360     int r;
5361     suppress_error = 0;
5362     r = guestfs_blockdev_getro (g, device);
5363     if (r == -1)
5364       return -1;
5365     if (!r) {
5366       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
5367       return -1;
5368     }
5369   }
5370   return 0;
5371 }
5372
5373 static int test_statvfs_0 (void)
5374 {
5375   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
5376   {
5377     char device[] = "/dev/sda";
5378     device[5] = devchar;
5379     int r;
5380     suppress_error = 0;
5381     r = guestfs_blockdev_setrw (g, device);
5382     if (r == -1)
5383       return -1;
5384   }
5385   {
5386     int r;
5387     suppress_error = 0;
5388     r = guestfs_umount_all (g);
5389     if (r == -1)
5390       return -1;
5391   }
5392   {
5393     int r;
5394     suppress_error = 0;
5395     r = guestfs_lvm_remove_all (g);
5396     if (r == -1)
5397       return -1;
5398   }
5399   {
5400     char device[] = "/dev/sda";
5401     device[5] = devchar;
5402     char lines_0[] = ",";
5403     char *lines[] = {
5404       lines_0,
5405       NULL
5406     };
5407     int r;
5408     suppress_error = 0;
5409     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5410     if (r == -1)
5411       return -1;
5412   }
5413   {
5414     char fstype[] = "ext2";
5415     char device[] = "/dev/sda1";
5416     device[5] = devchar;
5417     int r;
5418     suppress_error = 0;
5419     r = guestfs_mkfs (g, fstype, device);
5420     if (r == -1)
5421       return -1;
5422   }
5423   {
5424     char device[] = "/dev/sda1";
5425     device[5] = devchar;
5426     char mountpoint[] = "/";
5427     int r;
5428     suppress_error = 0;
5429     r = guestfs_mount (g, device, mountpoint);
5430     if (r == -1)
5431       return -1;
5432   }
5433   /* TestOutputStruct for statvfs (0) */
5434   {
5435     char path[] = "/";
5436     struct guestfs_statvfs *r;
5437     suppress_error = 0;
5438     r = guestfs_statvfs (g, path);
5439     if (r == NULL)
5440       return -1;
5441     if (r->bfree != 487702) {
5442       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
5443                (int) r->bfree);
5444       return -1;
5445     }
5446     if (r->blocks != 490020) {
5447       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
5448                (int) r->blocks);
5449       return -1;
5450     }
5451     if (r->bsize != 1024) {
5452       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
5453                (int) r->bsize);
5454       return -1;
5455     }
5456     free (r);
5457   }
5458   return 0;
5459 }
5460
5461 static int test_lstat_0 (void)
5462 {
5463   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
5464   {
5465     char device[] = "/dev/sda";
5466     device[5] = devchar;
5467     int r;
5468     suppress_error = 0;
5469     r = guestfs_blockdev_setrw (g, device);
5470     if (r == -1)
5471       return -1;
5472   }
5473   {
5474     int r;
5475     suppress_error = 0;
5476     r = guestfs_umount_all (g);
5477     if (r == -1)
5478       return -1;
5479   }
5480   {
5481     int r;
5482     suppress_error = 0;
5483     r = guestfs_lvm_remove_all (g);
5484     if (r == -1)
5485       return -1;
5486   }
5487   {
5488     char device[] = "/dev/sda";
5489     device[5] = devchar;
5490     char lines_0[] = ",";
5491     char *lines[] = {
5492       lines_0,
5493       NULL
5494     };
5495     int r;
5496     suppress_error = 0;
5497     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5498     if (r == -1)
5499       return -1;
5500   }
5501   {
5502     char fstype[] = "ext2";
5503     char device[] = "/dev/sda1";
5504     device[5] = devchar;
5505     int r;
5506     suppress_error = 0;
5507     r = guestfs_mkfs (g, fstype, device);
5508     if (r == -1)
5509       return -1;
5510   }
5511   {
5512     char device[] = "/dev/sda1";
5513     device[5] = devchar;
5514     char mountpoint[] = "/";
5515     int r;
5516     suppress_error = 0;
5517     r = guestfs_mount (g, device, mountpoint);
5518     if (r == -1)
5519       return -1;
5520   }
5521   /* TestOutputStruct for lstat (0) */
5522   {
5523     char path[] = "/new";
5524     int r;
5525     suppress_error = 0;
5526     r = guestfs_touch (g, path);
5527     if (r == -1)
5528       return -1;
5529   }
5530   {
5531     char path[] = "/new";
5532     struct guestfs_stat *r;
5533     suppress_error = 0;
5534     r = guestfs_lstat (g, path);
5535     if (r == NULL)
5536       return -1;
5537     if (r->size != 0) {
5538       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
5539                (int) r->size);
5540       return -1;
5541     }
5542     free (r);
5543   }
5544   return 0;
5545 }
5546
5547 static int test_stat_0 (void)
5548 {
5549   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
5550   {
5551     char device[] = "/dev/sda";
5552     device[5] = devchar;
5553     int r;
5554     suppress_error = 0;
5555     r = guestfs_blockdev_setrw (g, device);
5556     if (r == -1)
5557       return -1;
5558   }
5559   {
5560     int r;
5561     suppress_error = 0;
5562     r = guestfs_umount_all (g);
5563     if (r == -1)
5564       return -1;
5565   }
5566   {
5567     int r;
5568     suppress_error = 0;
5569     r = guestfs_lvm_remove_all (g);
5570     if (r == -1)
5571       return -1;
5572   }
5573   {
5574     char device[] = "/dev/sda";
5575     device[5] = devchar;
5576     char lines_0[] = ",";
5577     char *lines[] = {
5578       lines_0,
5579       NULL
5580     };
5581     int r;
5582     suppress_error = 0;
5583     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5584     if (r == -1)
5585       return -1;
5586   }
5587   {
5588     char fstype[] = "ext2";
5589     char device[] = "/dev/sda1";
5590     device[5] = devchar;
5591     int r;
5592     suppress_error = 0;
5593     r = guestfs_mkfs (g, fstype, device);
5594     if (r == -1)
5595       return -1;
5596   }
5597   {
5598     char device[] = "/dev/sda1";
5599     device[5] = devchar;
5600     char mountpoint[] = "/";
5601     int r;
5602     suppress_error = 0;
5603     r = guestfs_mount (g, device, mountpoint);
5604     if (r == -1)
5605       return -1;
5606   }
5607   /* TestOutputStruct for stat (0) */
5608   {
5609     char path[] = "/new";
5610     int r;
5611     suppress_error = 0;
5612     r = guestfs_touch (g, path);
5613     if (r == -1)
5614       return -1;
5615   }
5616   {
5617     char path[] = "/new";
5618     struct guestfs_stat *r;
5619     suppress_error = 0;
5620     r = guestfs_stat (g, path);
5621     if (r == NULL)
5622       return -1;
5623     if (r->size != 0) {
5624       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5625                (int) r->size);
5626       return -1;
5627     }
5628     free (r);
5629   }
5630   return 0;
5631 }
5632
5633 static int test_command_lines_0_prereq (void)
5634 {
5635   const char *str = getenv ("SKIP_TEST_COMMAND");
5636   return str && strcmp (str, "1") == 0;
5637 }
5638
5639 static int test_command_lines_0 (void)
5640 {
5641   if (! test_command_lines_0_prereq ()) {
5642   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
5643   {
5644     char device[] = "/dev/sda";
5645     device[5] = devchar;
5646     int r;
5647     suppress_error = 0;
5648     r = guestfs_blockdev_setrw (g, device);
5649     if (r == -1)
5650       return -1;
5651   }
5652   {
5653     int r;
5654     suppress_error = 0;
5655     r = guestfs_umount_all (g);
5656     if (r == -1)
5657       return -1;
5658   }
5659   {
5660     int r;
5661     suppress_error = 0;
5662     r = guestfs_lvm_remove_all (g);
5663     if (r == -1)
5664       return -1;
5665   }
5666   {
5667     char device[] = "/dev/sda";
5668     device[5] = devchar;
5669     char lines_0[] = ",";
5670     char *lines[] = {
5671       lines_0,
5672       NULL
5673     };
5674     int r;
5675     suppress_error = 0;
5676     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5677     if (r == -1)
5678       return -1;
5679   }
5680   {
5681     char fstype[] = "ext2";
5682     char device[] = "/dev/sda1";
5683     device[5] = devchar;
5684     int r;
5685     suppress_error = 0;
5686     r = guestfs_mkfs (g, fstype, device);
5687     if (r == -1)
5688       return -1;
5689   }
5690   {
5691     char device[] = "/dev/sda1";
5692     device[5] = devchar;
5693     char mountpoint[] = "/";
5694     int r;
5695     suppress_error = 0;
5696     r = guestfs_mount (g, device, mountpoint);
5697     if (r == -1)
5698       return -1;
5699   }
5700   /* TestOutputList for command_lines (0) */
5701   {
5702     char remotefilename[] = "/test-command";
5703     int r;
5704     suppress_error = 0;
5705     r = guestfs_upload (g, "test-command", remotefilename);
5706     if (r == -1)
5707       return -1;
5708   }
5709   {
5710     char path[] = "/test-command";
5711     int r;
5712     suppress_error = 0;
5713     r = guestfs_chmod (g, 493, path);
5714     if (r == -1)
5715       return -1;
5716   }
5717   {
5718     char arguments_0[] = "/test-command";
5719     char arguments_1[] = "1";
5720     char *arguments[] = {
5721       arguments_0,
5722       arguments_1,
5723       NULL
5724     };
5725     char **r;
5726     int i;
5727     suppress_error = 0;
5728     r = guestfs_command_lines (g, arguments);
5729     if (r == NULL)
5730       return -1;
5731     if (!r[0]) {
5732       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5733       print_strings (r);
5734       return -1;
5735     }
5736     {
5737       char expected[] = "Result1";
5738       if (strcmp (r[0], expected) != 0) {
5739         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5740         return -1;
5741       }
5742     }
5743     if (r[1] != NULL) {
5744       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5745       print_strings (r);
5746       return -1;
5747     }
5748     for (i = 0; r[i] != NULL; ++i)
5749       free (r[i]);
5750     free (r);
5751   }
5752   } else
5753     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5754   return 0;
5755 }
5756
5757 static int test_command_lines_1_prereq (void)
5758 {
5759   const char *str = getenv ("SKIP_TEST_COMMAND");
5760   return str && strcmp (str, "1") == 0;
5761 }
5762
5763 static int test_command_lines_1 (void)
5764 {
5765   if (! test_command_lines_1_prereq ()) {
5766   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
5767   {
5768     char device[] = "/dev/sda";
5769     device[5] = devchar;
5770     int r;
5771     suppress_error = 0;
5772     r = guestfs_blockdev_setrw (g, device);
5773     if (r == -1)
5774       return -1;
5775   }
5776   {
5777     int r;
5778     suppress_error = 0;
5779     r = guestfs_umount_all (g);
5780     if (r == -1)
5781       return -1;
5782   }
5783   {
5784     int r;
5785     suppress_error = 0;
5786     r = guestfs_lvm_remove_all (g);
5787     if (r == -1)
5788       return -1;
5789   }
5790   {
5791     char device[] = "/dev/sda";
5792     device[5] = devchar;
5793     char lines_0[] = ",";
5794     char *lines[] = {
5795       lines_0,
5796       NULL
5797     };
5798     int r;
5799     suppress_error = 0;
5800     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5801     if (r == -1)
5802       return -1;
5803   }
5804   {
5805     char fstype[] = "ext2";
5806     char device[] = "/dev/sda1";
5807     device[5] = devchar;
5808     int r;
5809     suppress_error = 0;
5810     r = guestfs_mkfs (g, fstype, device);
5811     if (r == -1)
5812       return -1;
5813   }
5814   {
5815     char device[] = "/dev/sda1";
5816     device[5] = devchar;
5817     char mountpoint[] = "/";
5818     int r;
5819     suppress_error = 0;
5820     r = guestfs_mount (g, device, mountpoint);
5821     if (r == -1)
5822       return -1;
5823   }
5824   /* TestOutputList for command_lines (1) */
5825   {
5826     char remotefilename[] = "/test-command";
5827     int r;
5828     suppress_error = 0;
5829     r = guestfs_upload (g, "test-command", remotefilename);
5830     if (r == -1)
5831       return -1;
5832   }
5833   {
5834     char path[] = "/test-command";
5835     int r;
5836     suppress_error = 0;
5837     r = guestfs_chmod (g, 493, path);
5838     if (r == -1)
5839       return -1;
5840   }
5841   {
5842     char arguments_0[] = "/test-command";
5843     char arguments_1[] = "2";
5844     char *arguments[] = {
5845       arguments_0,
5846       arguments_1,
5847       NULL
5848     };
5849     char **r;
5850     int i;
5851     suppress_error = 0;
5852     r = guestfs_command_lines (g, arguments);
5853     if (r == NULL)
5854       return -1;
5855     if (!r[0]) {
5856       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5857       print_strings (r);
5858       return -1;
5859     }
5860     {
5861       char expected[] = "Result2";
5862       if (strcmp (r[0], expected) != 0) {
5863         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5864         return -1;
5865       }
5866     }
5867     if (r[1] != NULL) {
5868       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5869       print_strings (r);
5870       return -1;
5871     }
5872     for (i = 0; r[i] != NULL; ++i)
5873       free (r[i]);
5874     free (r);
5875   }
5876   } else
5877     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5878   return 0;
5879 }
5880
5881 static int test_command_lines_2_prereq (void)
5882 {
5883   const char *str = getenv ("SKIP_TEST_COMMAND");
5884   return str && strcmp (str, "1") == 0;
5885 }
5886
5887 static int test_command_lines_2 (void)
5888 {
5889   if (! test_command_lines_2_prereq ()) {
5890   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
5891   {
5892     char device[] = "/dev/sda";
5893     device[5] = devchar;
5894     int r;
5895     suppress_error = 0;
5896     r = guestfs_blockdev_setrw (g, device);
5897     if (r == -1)
5898       return -1;
5899   }
5900   {
5901     int r;
5902     suppress_error = 0;
5903     r = guestfs_umount_all (g);
5904     if (r == -1)
5905       return -1;
5906   }
5907   {
5908     int r;
5909     suppress_error = 0;
5910     r = guestfs_lvm_remove_all (g);
5911     if (r == -1)
5912       return -1;
5913   }
5914   {
5915     char device[] = "/dev/sda";
5916     device[5] = devchar;
5917     char lines_0[] = ",";
5918     char *lines[] = {
5919       lines_0,
5920       NULL
5921     };
5922     int r;
5923     suppress_error = 0;
5924     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5925     if (r == -1)
5926       return -1;
5927   }
5928   {
5929     char fstype[] = "ext2";
5930     char device[] = "/dev/sda1";
5931     device[5] = devchar;
5932     int r;
5933     suppress_error = 0;
5934     r = guestfs_mkfs (g, fstype, device);
5935     if (r == -1)
5936       return -1;
5937   }
5938   {
5939     char device[] = "/dev/sda1";
5940     device[5] = devchar;
5941     char mountpoint[] = "/";
5942     int r;
5943     suppress_error = 0;
5944     r = guestfs_mount (g, device, mountpoint);
5945     if (r == -1)
5946       return -1;
5947   }
5948   /* TestOutputList for command_lines (2) */
5949   {
5950     char remotefilename[] = "/test-command";
5951     int r;
5952     suppress_error = 0;
5953     r = guestfs_upload (g, "test-command", remotefilename);
5954     if (r == -1)
5955       return -1;
5956   }
5957   {
5958     char path[] = "/test-command";
5959     int r;
5960     suppress_error = 0;
5961     r = guestfs_chmod (g, 493, path);
5962     if (r == -1)
5963       return -1;
5964   }
5965   {
5966     char arguments_0[] = "/test-command";
5967     char arguments_1[] = "3";
5968     char *arguments[] = {
5969       arguments_0,
5970       arguments_1,
5971       NULL
5972     };
5973     char **r;
5974     int i;
5975     suppress_error = 0;
5976     r = guestfs_command_lines (g, arguments);
5977     if (r == NULL)
5978       return -1;
5979     if (!r[0]) {
5980       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5981       print_strings (r);
5982       return -1;
5983     }
5984     {
5985       char expected[] = "";
5986       if (strcmp (r[0], expected) != 0) {
5987         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5988         return -1;
5989       }
5990     }
5991     if (!r[1]) {
5992       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5993       print_strings (r);
5994       return -1;
5995     }
5996     {
5997       char expected[] = "Result3";
5998       if (strcmp (r[1], expected) != 0) {
5999         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6000         return -1;
6001       }
6002     }
6003     if (r[2] != NULL) {
6004       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
6005       print_strings (r);
6006       return -1;
6007     }
6008     for (i = 0; r[i] != NULL; ++i)
6009       free (r[i]);
6010     free (r);
6011   }
6012   } else
6013     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
6014   return 0;
6015 }
6016
6017 static int test_command_lines_3_prereq (void)
6018 {
6019   const char *str = getenv ("SKIP_TEST_COMMAND");
6020   return str && strcmp (str, "1") == 0;
6021 }
6022
6023 static int test_command_lines_3 (void)
6024 {
6025   if (! test_command_lines_3_prereq ()) {
6026   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
6027   {
6028     char device[] = "/dev/sda";
6029     device[5] = devchar;
6030     int r;
6031     suppress_error = 0;
6032     r = guestfs_blockdev_setrw (g, device);
6033     if (r == -1)
6034       return -1;
6035   }
6036   {
6037     int r;
6038     suppress_error = 0;
6039     r = guestfs_umount_all (g);
6040     if (r == -1)
6041       return -1;
6042   }
6043   {
6044     int r;
6045     suppress_error = 0;
6046     r = guestfs_lvm_remove_all (g);
6047     if (r == -1)
6048       return -1;
6049   }
6050   {
6051     char device[] = "/dev/sda";
6052     device[5] = devchar;
6053     char lines_0[] = ",";
6054     char *lines[] = {
6055       lines_0,
6056       NULL
6057     };
6058     int r;
6059     suppress_error = 0;
6060     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6061     if (r == -1)
6062       return -1;
6063   }
6064   {
6065     char fstype[] = "ext2";
6066     char device[] = "/dev/sda1";
6067     device[5] = devchar;
6068     int r;
6069     suppress_error = 0;
6070     r = guestfs_mkfs (g, fstype, device);
6071     if (r == -1)
6072       return -1;
6073   }
6074   {
6075     char device[] = "/dev/sda1";
6076     device[5] = devchar;
6077     char mountpoint[] = "/";
6078     int r;
6079     suppress_error = 0;
6080     r = guestfs_mount (g, device, mountpoint);
6081     if (r == -1)
6082       return -1;
6083   }
6084   /* TestOutputList for command_lines (3) */
6085   {
6086     char remotefilename[] = "/test-command";
6087     int r;
6088     suppress_error = 0;
6089     r = guestfs_upload (g, "test-command", remotefilename);
6090     if (r == -1)
6091       return -1;
6092   }
6093   {
6094     char path[] = "/test-command";
6095     int r;
6096     suppress_error = 0;
6097     r = guestfs_chmod (g, 493, path);
6098     if (r == -1)
6099       return -1;
6100   }
6101   {
6102     char arguments_0[] = "/test-command";
6103     char arguments_1[] = "4";
6104     char *arguments[] = {
6105       arguments_0,
6106       arguments_1,
6107       NULL
6108     };
6109     char **r;
6110     int i;
6111     suppress_error = 0;
6112     r = guestfs_command_lines (g, arguments);
6113     if (r == NULL)
6114       return -1;
6115     if (!r[0]) {
6116       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6117       print_strings (r);
6118       return -1;
6119     }
6120     {
6121       char expected[] = "";
6122       if (strcmp (r[0], expected) != 0) {
6123         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6124         return -1;
6125       }
6126     }
6127     if (!r[1]) {
6128       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6129       print_strings (r);
6130       return -1;
6131     }
6132     {
6133       char expected[] = "Result4";
6134       if (strcmp (r[1], expected) != 0) {
6135         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6136         return -1;
6137       }
6138     }
6139     if (r[2] != NULL) {
6140       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
6141       print_strings (r);
6142       return -1;
6143     }
6144     for (i = 0; r[i] != NULL; ++i)
6145       free (r[i]);
6146     free (r);
6147   }
6148   } else
6149     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
6150   return 0;
6151 }
6152
6153 static int test_command_lines_4_prereq (void)
6154 {
6155   const char *str = getenv ("SKIP_TEST_COMMAND");
6156   return str && strcmp (str, "1") == 0;
6157 }
6158
6159 static int test_command_lines_4 (void)
6160 {
6161   if (! test_command_lines_4_prereq ()) {
6162   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
6163   {
6164     char device[] = "/dev/sda";
6165     device[5] = devchar;
6166     int r;
6167     suppress_error = 0;
6168     r = guestfs_blockdev_setrw (g, device);
6169     if (r == -1)
6170       return -1;
6171   }
6172   {
6173     int r;
6174     suppress_error = 0;
6175     r = guestfs_umount_all (g);
6176     if (r == -1)
6177       return -1;
6178   }
6179   {
6180     int r;
6181     suppress_error = 0;
6182     r = guestfs_lvm_remove_all (g);
6183     if (r == -1)
6184       return -1;
6185   }
6186   {
6187     char device[] = "/dev/sda";
6188     device[5] = devchar;
6189     char lines_0[] = ",";
6190     char *lines[] = {
6191       lines_0,
6192       NULL
6193     };
6194     int r;
6195     suppress_error = 0;
6196     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6197     if (r == -1)
6198       return -1;
6199   }
6200   {
6201     char fstype[] = "ext2";
6202     char device[] = "/dev/sda1";
6203     device[5] = devchar;
6204     int r;
6205     suppress_error = 0;
6206     r = guestfs_mkfs (g, fstype, device);
6207     if (r == -1)
6208       return -1;
6209   }
6210   {
6211     char device[] = "/dev/sda1";
6212     device[5] = devchar;
6213     char mountpoint[] = "/";
6214     int r;
6215     suppress_error = 0;
6216     r = guestfs_mount (g, device, mountpoint);
6217     if (r == -1)
6218       return -1;
6219   }
6220   /* TestOutputList for command_lines (4) */
6221   {
6222     char remotefilename[] = "/test-command";
6223     int r;
6224     suppress_error = 0;
6225     r = guestfs_upload (g, "test-command", remotefilename);
6226     if (r == -1)
6227       return -1;
6228   }
6229   {
6230     char path[] = "/test-command";
6231     int r;
6232     suppress_error = 0;
6233     r = guestfs_chmod (g, 493, path);
6234     if (r == -1)
6235       return -1;
6236   }
6237   {
6238     char arguments_0[] = "/test-command";
6239     char arguments_1[] = "5";
6240     char *arguments[] = {
6241       arguments_0,
6242       arguments_1,
6243       NULL
6244     };
6245     char **r;
6246     int i;
6247     suppress_error = 0;
6248     r = guestfs_command_lines (g, arguments);
6249     if (r == NULL)
6250       return -1;
6251     if (!r[0]) {
6252       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6253       print_strings (r);
6254       return -1;
6255     }
6256     {
6257       char expected[] = "";
6258       if (strcmp (r[0], expected) != 0) {
6259         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6260         return -1;
6261       }
6262     }
6263     if (!r[1]) {
6264       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6265       print_strings (r);
6266       return -1;
6267     }
6268     {
6269       char expected[] = "Result5";
6270       if (strcmp (r[1], expected) != 0) {
6271         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6272         return -1;
6273       }
6274     }
6275     if (!r[2]) {
6276       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6277       print_strings (r);
6278       return -1;
6279     }
6280     {
6281       char expected[] = "";
6282       if (strcmp (r[2], expected) != 0) {
6283         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6284         return -1;
6285       }
6286     }
6287     if (r[3] != NULL) {
6288       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
6289       print_strings (r);
6290       return -1;
6291     }
6292     for (i = 0; r[i] != NULL; ++i)
6293       free (r[i]);
6294     free (r);
6295   }
6296   } else
6297     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
6298   return 0;
6299 }
6300
6301 static int test_command_lines_5_prereq (void)
6302 {
6303   const char *str = getenv ("SKIP_TEST_COMMAND");
6304   return str && strcmp (str, "1") == 0;
6305 }
6306
6307 static int test_command_lines_5 (void)
6308 {
6309   if (! test_command_lines_5_prereq ()) {
6310   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
6311   {
6312     char device[] = "/dev/sda";
6313     device[5] = devchar;
6314     int r;
6315     suppress_error = 0;
6316     r = guestfs_blockdev_setrw (g, device);
6317     if (r == -1)
6318       return -1;
6319   }
6320   {
6321     int r;
6322     suppress_error = 0;
6323     r = guestfs_umount_all (g);
6324     if (r == -1)
6325       return -1;
6326   }
6327   {
6328     int r;
6329     suppress_error = 0;
6330     r = guestfs_lvm_remove_all (g);
6331     if (r == -1)
6332       return -1;
6333   }
6334   {
6335     char device[] = "/dev/sda";
6336     device[5] = devchar;
6337     char lines_0[] = ",";
6338     char *lines[] = {
6339       lines_0,
6340       NULL
6341     };
6342     int r;
6343     suppress_error = 0;
6344     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6345     if (r == -1)
6346       return -1;
6347   }
6348   {
6349     char fstype[] = "ext2";
6350     char device[] = "/dev/sda1";
6351     device[5] = devchar;
6352     int r;
6353     suppress_error = 0;
6354     r = guestfs_mkfs (g, fstype, device);
6355     if (r == -1)
6356       return -1;
6357   }
6358   {
6359     char device[] = "/dev/sda1";
6360     device[5] = devchar;
6361     char mountpoint[] = "/";
6362     int r;
6363     suppress_error = 0;
6364     r = guestfs_mount (g, device, mountpoint);
6365     if (r == -1)
6366       return -1;
6367   }
6368   /* TestOutputList for command_lines (5) */
6369   {
6370     char remotefilename[] = "/test-command";
6371     int r;
6372     suppress_error = 0;
6373     r = guestfs_upload (g, "test-command", remotefilename);
6374     if (r == -1)
6375       return -1;
6376   }
6377   {
6378     char path[] = "/test-command";
6379     int r;
6380     suppress_error = 0;
6381     r = guestfs_chmod (g, 493, path);
6382     if (r == -1)
6383       return -1;
6384   }
6385   {
6386     char arguments_0[] = "/test-command";
6387     char arguments_1[] = "6";
6388     char *arguments[] = {
6389       arguments_0,
6390       arguments_1,
6391       NULL
6392     };
6393     char **r;
6394     int i;
6395     suppress_error = 0;
6396     r = guestfs_command_lines (g, arguments);
6397     if (r == NULL)
6398       return -1;
6399     if (!r[0]) {
6400       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6401       print_strings (r);
6402       return -1;
6403     }
6404     {
6405       char expected[] = "";
6406       if (strcmp (r[0], expected) != 0) {
6407         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6408         return -1;
6409       }
6410     }
6411     if (!r[1]) {
6412       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6413       print_strings (r);
6414       return -1;
6415     }
6416     {
6417       char expected[] = "";
6418       if (strcmp (r[1], expected) != 0) {
6419         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6420         return -1;
6421       }
6422     }
6423     if (!r[2]) {
6424       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6425       print_strings (r);
6426       return -1;
6427     }
6428     {
6429       char expected[] = "Result6";
6430       if (strcmp (r[2], expected) != 0) {
6431         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6432         return -1;
6433       }
6434     }
6435     if (!r[3]) {
6436       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6437       print_strings (r);
6438       return -1;
6439     }
6440     {
6441       char expected[] = "";
6442       if (strcmp (r[3], expected) != 0) {
6443         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
6444         return -1;
6445       }
6446     }
6447     if (r[4] != NULL) {
6448       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
6449       print_strings (r);
6450       return -1;
6451     }
6452     for (i = 0; r[i] != NULL; ++i)
6453       free (r[i]);
6454     free (r);
6455   }
6456   } else
6457     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
6458   return 0;
6459 }
6460
6461 static int test_command_lines_6_prereq (void)
6462 {
6463   const char *str = getenv ("SKIP_TEST_COMMAND");
6464   return str && strcmp (str, "1") == 0;
6465 }
6466
6467 static int test_command_lines_6 (void)
6468 {
6469   if (! test_command_lines_6_prereq ()) {
6470   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
6471   {
6472     char device[] = "/dev/sda";
6473     device[5] = devchar;
6474     int r;
6475     suppress_error = 0;
6476     r = guestfs_blockdev_setrw (g, device);
6477     if (r == -1)
6478       return -1;
6479   }
6480   {
6481     int r;
6482     suppress_error = 0;
6483     r = guestfs_umount_all (g);
6484     if (r == -1)
6485       return -1;
6486   }
6487   {
6488     int r;
6489     suppress_error = 0;
6490     r = guestfs_lvm_remove_all (g);
6491     if (r == -1)
6492       return -1;
6493   }
6494   {
6495     char device[] = "/dev/sda";
6496     device[5] = devchar;
6497     char lines_0[] = ",";
6498     char *lines[] = {
6499       lines_0,
6500       NULL
6501     };
6502     int r;
6503     suppress_error = 0;
6504     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6505     if (r == -1)
6506       return -1;
6507   }
6508   {
6509     char fstype[] = "ext2";
6510     char device[] = "/dev/sda1";
6511     device[5] = devchar;
6512     int r;
6513     suppress_error = 0;
6514     r = guestfs_mkfs (g, fstype, device);
6515     if (r == -1)
6516       return -1;
6517   }
6518   {
6519     char device[] = "/dev/sda1";
6520     device[5] = devchar;
6521     char mountpoint[] = "/";
6522     int r;
6523     suppress_error = 0;
6524     r = guestfs_mount (g, device, mountpoint);
6525     if (r == -1)
6526       return -1;
6527   }
6528   /* TestOutputList for command_lines (6) */
6529   {
6530     char remotefilename[] = "/test-command";
6531     int r;
6532     suppress_error = 0;
6533     r = guestfs_upload (g, "test-command", remotefilename);
6534     if (r == -1)
6535       return -1;
6536   }
6537   {
6538     char path[] = "/test-command";
6539     int r;
6540     suppress_error = 0;
6541     r = guestfs_chmod (g, 493, path);
6542     if (r == -1)
6543       return -1;
6544   }
6545   {
6546     char arguments_0[] = "/test-command";
6547     char arguments_1[] = "7";
6548     char *arguments[] = {
6549       arguments_0,
6550       arguments_1,
6551       NULL
6552     };
6553     char **r;
6554     int i;
6555     suppress_error = 0;
6556     r = guestfs_command_lines (g, arguments);
6557     if (r == NULL)
6558       return -1;
6559     if (r[0] != NULL) {
6560       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6561       print_strings (r);
6562       return -1;
6563     }
6564     for (i = 0; r[i] != NULL; ++i)
6565       free (r[i]);
6566     free (r);
6567   }
6568   } else
6569     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6570   return 0;
6571 }
6572
6573 static int test_command_lines_7_prereq (void)
6574 {
6575   const char *str = getenv ("SKIP_TEST_COMMAND");
6576   return str && strcmp (str, "1") == 0;
6577 }
6578
6579 static int test_command_lines_7 (void)
6580 {
6581   if (! test_command_lines_7_prereq ()) {
6582   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
6583   {
6584     char device[] = "/dev/sda";
6585     device[5] = devchar;
6586     int r;
6587     suppress_error = 0;
6588     r = guestfs_blockdev_setrw (g, device);
6589     if (r == -1)
6590       return -1;
6591   }
6592   {
6593     int r;
6594     suppress_error = 0;
6595     r = guestfs_umount_all (g);
6596     if (r == -1)
6597       return -1;
6598   }
6599   {
6600     int r;
6601     suppress_error = 0;
6602     r = guestfs_lvm_remove_all (g);
6603     if (r == -1)
6604       return -1;
6605   }
6606   {
6607     char device[] = "/dev/sda";
6608     device[5] = devchar;
6609     char lines_0[] = ",";
6610     char *lines[] = {
6611       lines_0,
6612       NULL
6613     };
6614     int r;
6615     suppress_error = 0;
6616     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6617     if (r == -1)
6618       return -1;
6619   }
6620   {
6621     char fstype[] = "ext2";
6622     char device[] = "/dev/sda1";
6623     device[5] = devchar;
6624     int r;
6625     suppress_error = 0;
6626     r = guestfs_mkfs (g, fstype, device);
6627     if (r == -1)
6628       return -1;
6629   }
6630   {
6631     char device[] = "/dev/sda1";
6632     device[5] = devchar;
6633     char mountpoint[] = "/";
6634     int r;
6635     suppress_error = 0;
6636     r = guestfs_mount (g, device, mountpoint);
6637     if (r == -1)
6638       return -1;
6639   }
6640   /* TestOutputList for command_lines (7) */
6641   {
6642     char remotefilename[] = "/test-command";
6643     int r;
6644     suppress_error = 0;
6645     r = guestfs_upload (g, "test-command", remotefilename);
6646     if (r == -1)
6647       return -1;
6648   }
6649   {
6650     char path[] = "/test-command";
6651     int r;
6652     suppress_error = 0;
6653     r = guestfs_chmod (g, 493, path);
6654     if (r == -1)
6655       return -1;
6656   }
6657   {
6658     char arguments_0[] = "/test-command";
6659     char arguments_1[] = "8";
6660     char *arguments[] = {
6661       arguments_0,
6662       arguments_1,
6663       NULL
6664     };
6665     char **r;
6666     int i;
6667     suppress_error = 0;
6668     r = guestfs_command_lines (g, arguments);
6669     if (r == NULL)
6670       return -1;
6671     if (!r[0]) {
6672       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6673       print_strings (r);
6674       return -1;
6675     }
6676     {
6677       char expected[] = "";
6678       if (strcmp (r[0], expected) != 0) {
6679         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6680         return -1;
6681       }
6682     }
6683     if (r[1] != NULL) {
6684       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6685       print_strings (r);
6686       return -1;
6687     }
6688     for (i = 0; r[i] != NULL; ++i)
6689       free (r[i]);
6690     free (r);
6691   }
6692   } else
6693     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6694   return 0;
6695 }
6696
6697 static int test_command_lines_8_prereq (void)
6698 {
6699   const char *str = getenv ("SKIP_TEST_COMMAND");
6700   return str && strcmp (str, "1") == 0;
6701 }
6702
6703 static int test_command_lines_8 (void)
6704 {
6705   if (! test_command_lines_8_prereq ()) {
6706   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
6707   {
6708     char device[] = "/dev/sda";
6709     device[5] = devchar;
6710     int r;
6711     suppress_error = 0;
6712     r = guestfs_blockdev_setrw (g, device);
6713     if (r == -1)
6714       return -1;
6715   }
6716   {
6717     int r;
6718     suppress_error = 0;
6719     r = guestfs_umount_all (g);
6720     if (r == -1)
6721       return -1;
6722   }
6723   {
6724     int r;
6725     suppress_error = 0;
6726     r = guestfs_lvm_remove_all (g);
6727     if (r == -1)
6728       return -1;
6729   }
6730   {
6731     char device[] = "/dev/sda";
6732     device[5] = devchar;
6733     char lines_0[] = ",";
6734     char *lines[] = {
6735       lines_0,
6736       NULL
6737     };
6738     int r;
6739     suppress_error = 0;
6740     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6741     if (r == -1)
6742       return -1;
6743   }
6744   {
6745     char fstype[] = "ext2";
6746     char device[] = "/dev/sda1";
6747     device[5] = devchar;
6748     int r;
6749     suppress_error = 0;
6750     r = guestfs_mkfs (g, fstype, device);
6751     if (r == -1)
6752       return -1;
6753   }
6754   {
6755     char device[] = "/dev/sda1";
6756     device[5] = devchar;
6757     char mountpoint[] = "/";
6758     int r;
6759     suppress_error = 0;
6760     r = guestfs_mount (g, device, mountpoint);
6761     if (r == -1)
6762       return -1;
6763   }
6764   /* TestOutputList for command_lines (8) */
6765   {
6766     char remotefilename[] = "/test-command";
6767     int r;
6768     suppress_error = 0;
6769     r = guestfs_upload (g, "test-command", remotefilename);
6770     if (r == -1)
6771       return -1;
6772   }
6773   {
6774     char path[] = "/test-command";
6775     int r;
6776     suppress_error = 0;
6777     r = guestfs_chmod (g, 493, path);
6778     if (r == -1)
6779       return -1;
6780   }
6781   {
6782     char arguments_0[] = "/test-command";
6783     char arguments_1[] = "9";
6784     char *arguments[] = {
6785       arguments_0,
6786       arguments_1,
6787       NULL
6788     };
6789     char **r;
6790     int i;
6791     suppress_error = 0;
6792     r = guestfs_command_lines (g, arguments);
6793     if (r == NULL)
6794       return -1;
6795     if (!r[0]) {
6796       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6797       print_strings (r);
6798       return -1;
6799     }
6800     {
6801       char expected[] = "";
6802       if (strcmp (r[0], expected) != 0) {
6803         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6804         return -1;
6805       }
6806     }
6807     if (!r[1]) {
6808       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6809       print_strings (r);
6810       return -1;
6811     }
6812     {
6813       char expected[] = "";
6814       if (strcmp (r[1], expected) != 0) {
6815         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6816         return -1;
6817       }
6818     }
6819     if (r[2] != NULL) {
6820       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6821       print_strings (r);
6822       return -1;
6823     }
6824     for (i = 0; r[i] != NULL; ++i)
6825       free (r[i]);
6826     free (r);
6827   }
6828   } else
6829     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6830   return 0;
6831 }
6832
6833 static int test_command_lines_9_prereq (void)
6834 {
6835   const char *str = getenv ("SKIP_TEST_COMMAND");
6836   return str && strcmp (str, "1") == 0;
6837 }
6838
6839 static int test_command_lines_9 (void)
6840 {
6841   if (! test_command_lines_9_prereq ()) {
6842   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
6843   {
6844     char device[] = "/dev/sda";
6845     device[5] = devchar;
6846     int r;
6847     suppress_error = 0;
6848     r = guestfs_blockdev_setrw (g, device);
6849     if (r == -1)
6850       return -1;
6851   }
6852   {
6853     int r;
6854     suppress_error = 0;
6855     r = guestfs_umount_all (g);
6856     if (r == -1)
6857       return -1;
6858   }
6859   {
6860     int r;
6861     suppress_error = 0;
6862     r = guestfs_lvm_remove_all (g);
6863     if (r == -1)
6864       return -1;
6865   }
6866   {
6867     char device[] = "/dev/sda";
6868     device[5] = devchar;
6869     char lines_0[] = ",";
6870     char *lines[] = {
6871       lines_0,
6872       NULL
6873     };
6874     int r;
6875     suppress_error = 0;
6876     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6877     if (r == -1)
6878       return -1;
6879   }
6880   {
6881     char fstype[] = "ext2";
6882     char device[] = "/dev/sda1";
6883     device[5] = devchar;
6884     int r;
6885     suppress_error = 0;
6886     r = guestfs_mkfs (g, fstype, device);
6887     if (r == -1)
6888       return -1;
6889   }
6890   {
6891     char device[] = "/dev/sda1";
6892     device[5] = devchar;
6893     char mountpoint[] = "/";
6894     int r;
6895     suppress_error = 0;
6896     r = guestfs_mount (g, device, mountpoint);
6897     if (r == -1)
6898       return -1;
6899   }
6900   /* TestOutputList for command_lines (9) */
6901   {
6902     char remotefilename[] = "/test-command";
6903     int r;
6904     suppress_error = 0;
6905     r = guestfs_upload (g, "test-command", remotefilename);
6906     if (r == -1)
6907       return -1;
6908   }
6909   {
6910     char path[] = "/test-command";
6911     int r;
6912     suppress_error = 0;
6913     r = guestfs_chmod (g, 493, path);
6914     if (r == -1)
6915       return -1;
6916   }
6917   {
6918     char arguments_0[] = "/test-command";
6919     char arguments_1[] = "10";
6920     char *arguments[] = {
6921       arguments_0,
6922       arguments_1,
6923       NULL
6924     };
6925     char **r;
6926     int i;
6927     suppress_error = 0;
6928     r = guestfs_command_lines (g, arguments);
6929     if (r == NULL)
6930       return -1;
6931     if (!r[0]) {
6932       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6933       print_strings (r);
6934       return -1;
6935     }
6936     {
6937       char expected[] = "Result10-1";
6938       if (strcmp (r[0], expected) != 0) {
6939         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6940         return -1;
6941       }
6942     }
6943     if (!r[1]) {
6944       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6945       print_strings (r);
6946       return -1;
6947     }
6948     {
6949       char expected[] = "Result10-2";
6950       if (strcmp (r[1], expected) != 0) {
6951         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6952         return -1;
6953       }
6954     }
6955     if (r[2] != NULL) {
6956       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6957       print_strings (r);
6958       return -1;
6959     }
6960     for (i = 0; r[i] != NULL; ++i)
6961       free (r[i]);
6962     free (r);
6963   }
6964   } else
6965     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
6966   return 0;
6967 }
6968
6969 static int test_command_lines_10_prereq (void)
6970 {
6971   const char *str = getenv ("SKIP_TEST_COMMAND");
6972   return str && strcmp (str, "1") == 0;
6973 }
6974
6975 static int test_command_lines_10 (void)
6976 {
6977   if (! test_command_lines_10_prereq ()) {
6978   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
6979   {
6980     char device[] = "/dev/sda";
6981     device[5] = devchar;
6982     int r;
6983     suppress_error = 0;
6984     r = guestfs_blockdev_setrw (g, device);
6985     if (r == -1)
6986       return -1;
6987   }
6988   {
6989     int r;
6990     suppress_error = 0;
6991     r = guestfs_umount_all (g);
6992     if (r == -1)
6993       return -1;
6994   }
6995   {
6996     int r;
6997     suppress_error = 0;
6998     r = guestfs_lvm_remove_all (g);
6999     if (r == -1)
7000       return -1;
7001   }
7002   {
7003     char device[] = "/dev/sda";
7004     device[5] = devchar;
7005     char lines_0[] = ",";
7006     char *lines[] = {
7007       lines_0,
7008       NULL
7009     };
7010     int r;
7011     suppress_error = 0;
7012     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7013     if (r == -1)
7014       return -1;
7015   }
7016   {
7017     char fstype[] = "ext2";
7018     char device[] = "/dev/sda1";
7019     device[5] = devchar;
7020     int r;
7021     suppress_error = 0;
7022     r = guestfs_mkfs (g, fstype, device);
7023     if (r == -1)
7024       return -1;
7025   }
7026   {
7027     char device[] = "/dev/sda1";
7028     device[5] = devchar;
7029     char mountpoint[] = "/";
7030     int r;
7031     suppress_error = 0;
7032     r = guestfs_mount (g, device, mountpoint);
7033     if (r == -1)
7034       return -1;
7035   }
7036   /* TestOutputList for command_lines (10) */
7037   {
7038     char remotefilename[] = "/test-command";
7039     int r;
7040     suppress_error = 0;
7041     r = guestfs_upload (g, "test-command", remotefilename);
7042     if (r == -1)
7043       return -1;
7044   }
7045   {
7046     char path[] = "/test-command";
7047     int r;
7048     suppress_error = 0;
7049     r = guestfs_chmod (g, 493, path);
7050     if (r == -1)
7051       return -1;
7052   }
7053   {
7054     char arguments_0[] = "/test-command";
7055     char arguments_1[] = "11";
7056     char *arguments[] = {
7057       arguments_0,
7058       arguments_1,
7059       NULL
7060     };
7061     char **r;
7062     int i;
7063     suppress_error = 0;
7064     r = guestfs_command_lines (g, arguments);
7065     if (r == NULL)
7066       return -1;
7067     if (!r[0]) {
7068       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7069       print_strings (r);
7070       return -1;
7071     }
7072     {
7073       char expected[] = "Result11-1";
7074       if (strcmp (r[0], expected) != 0) {
7075         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7076         return -1;
7077       }
7078     }
7079     if (!r[1]) {
7080       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7081       print_strings (r);
7082       return -1;
7083     }
7084     {
7085       char expected[] = "Result11-2";
7086       if (strcmp (r[1], expected) != 0) {
7087         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7088         return -1;
7089       }
7090     }
7091     if (r[2] != NULL) {
7092       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
7093       print_strings (r);
7094       return -1;
7095     }
7096     for (i = 0; r[i] != NULL; ++i)
7097       free (r[i]);
7098     free (r);
7099   }
7100   } else
7101     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
7102   return 0;
7103 }
7104
7105 static int test_command_0_prereq (void)
7106 {
7107   const char *str = getenv ("SKIP_TEST_COMMAND");
7108   return str && strcmp (str, "1") == 0;
7109 }
7110
7111 static int test_command_0 (void)
7112 {
7113   if (! test_command_0_prereq ()) {
7114   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
7115   {
7116     char device[] = "/dev/sda";
7117     device[5] = devchar;
7118     int r;
7119     suppress_error = 0;
7120     r = guestfs_blockdev_setrw (g, device);
7121     if (r == -1)
7122       return -1;
7123   }
7124   {
7125     int r;
7126     suppress_error = 0;
7127     r = guestfs_umount_all (g);
7128     if (r == -1)
7129       return -1;
7130   }
7131   {
7132     int r;
7133     suppress_error = 0;
7134     r = guestfs_lvm_remove_all (g);
7135     if (r == -1)
7136       return -1;
7137   }
7138   {
7139     char device[] = "/dev/sda";
7140     device[5] = devchar;
7141     char lines_0[] = ",";
7142     char *lines[] = {
7143       lines_0,
7144       NULL
7145     };
7146     int r;
7147     suppress_error = 0;
7148     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7149     if (r == -1)
7150       return -1;
7151   }
7152   {
7153     char fstype[] = "ext2";
7154     char device[] = "/dev/sda1";
7155     device[5] = devchar;
7156     int r;
7157     suppress_error = 0;
7158     r = guestfs_mkfs (g, fstype, device);
7159     if (r == -1)
7160       return -1;
7161   }
7162   {
7163     char device[] = "/dev/sda1";
7164     device[5] = devchar;
7165     char mountpoint[] = "/";
7166     int r;
7167     suppress_error = 0;
7168     r = guestfs_mount (g, device, mountpoint);
7169     if (r == -1)
7170       return -1;
7171   }
7172   /* TestOutput for command (0) */
7173   char expected[] = "Result1";
7174   {
7175     char remotefilename[] = "/test-command";
7176     int r;
7177     suppress_error = 0;
7178     r = guestfs_upload (g, "test-command", remotefilename);
7179     if (r == -1)
7180       return -1;
7181   }
7182   {
7183     char path[] = "/test-command";
7184     int r;
7185     suppress_error = 0;
7186     r = guestfs_chmod (g, 493, path);
7187     if (r == -1)
7188       return -1;
7189   }
7190   {
7191     char arguments_0[] = "/test-command";
7192     char arguments_1[] = "1";
7193     char *arguments[] = {
7194       arguments_0,
7195       arguments_1,
7196       NULL
7197     };
7198     char *r;
7199     suppress_error = 0;
7200     r = guestfs_command (g, arguments);
7201     if (r == NULL)
7202       return -1;
7203     if (strcmp (r, expected) != 0) {
7204       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
7205       return -1;
7206     }
7207     free (r);
7208   }
7209   } else
7210     printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
7211   return 0;
7212 }
7213
7214 static int test_command_1_prereq (void)
7215 {
7216   const char *str = getenv ("SKIP_TEST_COMMAND");
7217   return str && strcmp (str, "1") == 0;
7218 }
7219
7220 static int test_command_1 (void)
7221 {
7222   if (! test_command_1_prereq ()) {
7223   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
7224   {
7225     char device[] = "/dev/sda";
7226     device[5] = devchar;
7227     int r;
7228     suppress_error = 0;
7229     r = guestfs_blockdev_setrw (g, device);
7230     if (r == -1)
7231       return -1;
7232   }
7233   {
7234     int r;
7235     suppress_error = 0;
7236     r = guestfs_umount_all (g);
7237     if (r == -1)
7238       return -1;
7239   }
7240   {
7241     int r;
7242     suppress_error = 0;
7243     r = guestfs_lvm_remove_all (g);
7244     if (r == -1)
7245       return -1;
7246   }
7247   {
7248     char device[] = "/dev/sda";
7249     device[5] = devchar;
7250     char lines_0[] = ",";
7251     char *lines[] = {
7252       lines_0,
7253       NULL
7254     };
7255     int r;
7256     suppress_error = 0;
7257     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7258     if (r == -1)
7259       return -1;
7260   }
7261   {
7262     char fstype[] = "ext2";
7263     char device[] = "/dev/sda1";
7264     device[5] = devchar;
7265     int r;
7266     suppress_error = 0;
7267     r = guestfs_mkfs (g, fstype, device);
7268     if (r == -1)
7269       return -1;
7270   }
7271   {
7272     char device[] = "/dev/sda1";
7273     device[5] = devchar;
7274     char mountpoint[] = "/";
7275     int r;
7276     suppress_error = 0;
7277     r = guestfs_mount (g, device, mountpoint);
7278     if (r == -1)
7279       return -1;
7280   }
7281   /* TestOutput for command (1) */
7282   char expected[] = "Result2\n";
7283   {
7284     char remotefilename[] = "/test-command";
7285     int r;
7286     suppress_error = 0;
7287     r = guestfs_upload (g, "test-command", remotefilename);
7288     if (r == -1)
7289       return -1;
7290   }
7291   {
7292     char path[] = "/test-command";
7293     int r;
7294     suppress_error = 0;
7295     r = guestfs_chmod (g, 493, path);
7296     if (r == -1)
7297       return -1;
7298   }
7299   {
7300     char arguments_0[] = "/test-command";
7301     char arguments_1[] = "2";
7302     char *arguments[] = {
7303       arguments_0,
7304       arguments_1,
7305       NULL
7306     };
7307     char *r;
7308     suppress_error = 0;
7309     r = guestfs_command (g, arguments);
7310     if (r == NULL)
7311       return -1;
7312     if (strcmp (r, expected) != 0) {
7313       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
7314       return -1;
7315     }
7316     free (r);
7317   }
7318   } else
7319     printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
7320   return 0;
7321 }
7322
7323 static int test_command_2_prereq (void)
7324 {
7325   const char *str = getenv ("SKIP_TEST_COMMAND");
7326   return str && strcmp (str, "1") == 0;
7327 }
7328
7329 static int test_command_2 (void)
7330 {
7331   if (! test_command_2_prereq ()) {
7332   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
7333   {
7334     char device[] = "/dev/sda";
7335     device[5] = devchar;
7336     int r;
7337     suppress_error = 0;
7338     r = guestfs_blockdev_setrw (g, device);
7339     if (r == -1)
7340       return -1;
7341   }
7342   {
7343     int r;
7344     suppress_error = 0;
7345     r = guestfs_umount_all (g);
7346     if (r == -1)
7347       return -1;
7348   }
7349   {
7350     int r;
7351     suppress_error = 0;
7352     r = guestfs_lvm_remove_all (g);
7353     if (r == -1)
7354       return -1;
7355   }
7356   {
7357     char device[] = "/dev/sda";
7358     device[5] = devchar;
7359     char lines_0[] = ",";
7360     char *lines[] = {
7361       lines_0,
7362       NULL
7363     };
7364     int r;
7365     suppress_error = 0;
7366     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7367     if (r == -1)
7368       return -1;
7369   }
7370   {
7371     char fstype[] = "ext2";
7372     char device[] = "/dev/sda1";
7373     device[5] = devchar;
7374     int r;
7375     suppress_error = 0;
7376     r = guestfs_mkfs (g, fstype, device);
7377     if (r == -1)
7378       return -1;
7379   }
7380   {
7381     char device[] = "/dev/sda1";
7382     device[5] = devchar;
7383     char mountpoint[] = "/";
7384     int r;
7385     suppress_error = 0;
7386     r = guestfs_mount (g, device, mountpoint);
7387     if (r == -1)
7388       return -1;
7389   }
7390   /* TestOutput for command (2) */
7391   char expected[] = "\nResult3";
7392   {
7393     char remotefilename[] = "/test-command";
7394     int r;
7395     suppress_error = 0;
7396     r = guestfs_upload (g, "test-command", remotefilename);
7397     if (r == -1)
7398       return -1;
7399   }
7400   {
7401     char path[] = "/test-command";
7402     int r;
7403     suppress_error = 0;
7404     r = guestfs_chmod (g, 493, path);
7405     if (r == -1)
7406       return -1;
7407   }
7408   {
7409     char arguments_0[] = "/test-command";
7410     char arguments_1[] = "3";
7411     char *arguments[] = {
7412       arguments_0,
7413       arguments_1,
7414       NULL
7415     };
7416     char *r;
7417     suppress_error = 0;
7418     r = guestfs_command (g, arguments);
7419     if (r == NULL)
7420       return -1;
7421     if (strcmp (r, expected) != 0) {
7422       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
7423       return -1;
7424     }
7425     free (r);
7426   }
7427   } else
7428     printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
7429   return 0;
7430 }
7431
7432 static int test_command_3_prereq (void)
7433 {
7434   const char *str = getenv ("SKIP_TEST_COMMAND");
7435   return str && strcmp (str, "1") == 0;
7436 }
7437
7438 static int test_command_3 (void)
7439 {
7440   if (! test_command_3_prereq ()) {
7441   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
7442   {
7443     char device[] = "/dev/sda";
7444     device[5] = devchar;
7445     int r;
7446     suppress_error = 0;
7447     r = guestfs_blockdev_setrw (g, device);
7448     if (r == -1)
7449       return -1;
7450   }
7451   {
7452     int r;
7453     suppress_error = 0;
7454     r = guestfs_umount_all (g);
7455     if (r == -1)
7456       return -1;
7457   }
7458   {
7459     int r;
7460     suppress_error = 0;
7461     r = guestfs_lvm_remove_all (g);
7462     if (r == -1)
7463       return -1;
7464   }
7465   {
7466     char device[] = "/dev/sda";
7467     device[5] = devchar;
7468     char lines_0[] = ",";
7469     char *lines[] = {
7470       lines_0,
7471       NULL
7472     };
7473     int r;
7474     suppress_error = 0;
7475     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7476     if (r == -1)
7477       return -1;
7478   }
7479   {
7480     char fstype[] = "ext2";
7481     char device[] = "/dev/sda1";
7482     device[5] = devchar;
7483     int r;
7484     suppress_error = 0;
7485     r = guestfs_mkfs (g, fstype, device);
7486     if (r == -1)
7487       return -1;
7488   }
7489   {
7490     char device[] = "/dev/sda1";
7491     device[5] = devchar;
7492     char mountpoint[] = "/";
7493     int r;
7494     suppress_error = 0;
7495     r = guestfs_mount (g, device, mountpoint);
7496     if (r == -1)
7497       return -1;
7498   }
7499   /* TestOutput for command (3) */
7500   char expected[] = "\nResult4\n";
7501   {
7502     char remotefilename[] = "/test-command";
7503     int r;
7504     suppress_error = 0;
7505     r = guestfs_upload (g, "test-command", remotefilename);
7506     if (r == -1)
7507       return -1;
7508   }
7509   {
7510     char path[] = "/test-command";
7511     int r;
7512     suppress_error = 0;
7513     r = guestfs_chmod (g, 493, path);
7514     if (r == -1)
7515       return -1;
7516   }
7517   {
7518     char arguments_0[] = "/test-command";
7519     char arguments_1[] = "4";
7520     char *arguments[] = {
7521       arguments_0,
7522       arguments_1,
7523       NULL
7524     };
7525     char *r;
7526     suppress_error = 0;
7527     r = guestfs_command (g, arguments);
7528     if (r == NULL)
7529       return -1;
7530     if (strcmp (r, expected) != 0) {
7531       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
7532       return -1;
7533     }
7534     free (r);
7535   }
7536   } else
7537     printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
7538   return 0;
7539 }
7540
7541 static int test_command_4_prereq (void)
7542 {
7543   const char *str = getenv ("SKIP_TEST_COMMAND");
7544   return str && strcmp (str, "1") == 0;
7545 }
7546
7547 static int test_command_4 (void)
7548 {
7549   if (! test_command_4_prereq ()) {
7550   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
7551   {
7552     char device[] = "/dev/sda";
7553     device[5] = devchar;
7554     int r;
7555     suppress_error = 0;
7556     r = guestfs_blockdev_setrw (g, device);
7557     if (r == -1)
7558       return -1;
7559   }
7560   {
7561     int r;
7562     suppress_error = 0;
7563     r = guestfs_umount_all (g);
7564     if (r == -1)
7565       return -1;
7566   }
7567   {
7568     int r;
7569     suppress_error = 0;
7570     r = guestfs_lvm_remove_all (g);
7571     if (r == -1)
7572       return -1;
7573   }
7574   {
7575     char device[] = "/dev/sda";
7576     device[5] = devchar;
7577     char lines_0[] = ",";
7578     char *lines[] = {
7579       lines_0,
7580       NULL
7581     };
7582     int r;
7583     suppress_error = 0;
7584     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7585     if (r == -1)
7586       return -1;
7587   }
7588   {
7589     char fstype[] = "ext2";
7590     char device[] = "/dev/sda1";
7591     device[5] = devchar;
7592     int r;
7593     suppress_error = 0;
7594     r = guestfs_mkfs (g, fstype, device);
7595     if (r == -1)
7596       return -1;
7597   }
7598   {
7599     char device[] = "/dev/sda1";
7600     device[5] = devchar;
7601     char mountpoint[] = "/";
7602     int r;
7603     suppress_error = 0;
7604     r = guestfs_mount (g, device, mountpoint);
7605     if (r == -1)
7606       return -1;
7607   }
7608   /* TestOutput for command (4) */
7609   char expected[] = "\nResult5\n\n";
7610   {
7611     char remotefilename[] = "/test-command";
7612     int r;
7613     suppress_error = 0;
7614     r = guestfs_upload (g, "test-command", remotefilename);
7615     if (r == -1)
7616       return -1;
7617   }
7618   {
7619     char path[] = "/test-command";
7620     int r;
7621     suppress_error = 0;
7622     r = guestfs_chmod (g, 493, path);
7623     if (r == -1)
7624       return -1;
7625   }
7626   {
7627     char arguments_0[] = "/test-command";
7628     char arguments_1[] = "5";
7629     char *arguments[] = {
7630       arguments_0,
7631       arguments_1,
7632       NULL
7633     };
7634     char *r;
7635     suppress_error = 0;
7636     r = guestfs_command (g, arguments);
7637     if (r == NULL)
7638       return -1;
7639     if (strcmp (r, expected) != 0) {
7640       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7641       return -1;
7642     }
7643     free (r);
7644   }
7645   } else
7646     printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7647   return 0;
7648 }
7649
7650 static int test_command_5_prereq (void)
7651 {
7652   const char *str = getenv ("SKIP_TEST_COMMAND");
7653   return str && strcmp (str, "1") == 0;
7654 }
7655
7656 static int test_command_5 (void)
7657 {
7658   if (! test_command_5_prereq ()) {
7659   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
7660   {
7661     char device[] = "/dev/sda";
7662     device[5] = devchar;
7663     int r;
7664     suppress_error = 0;
7665     r = guestfs_blockdev_setrw (g, device);
7666     if (r == -1)
7667       return -1;
7668   }
7669   {
7670     int r;
7671     suppress_error = 0;
7672     r = guestfs_umount_all (g);
7673     if (r == -1)
7674       return -1;
7675   }
7676   {
7677     int r;
7678     suppress_error = 0;
7679     r = guestfs_lvm_remove_all (g);
7680     if (r == -1)
7681       return -1;
7682   }
7683   {
7684     char device[] = "/dev/sda";
7685     device[5] = devchar;
7686     char lines_0[] = ",";
7687     char *lines[] = {
7688       lines_0,
7689       NULL
7690     };
7691     int r;
7692     suppress_error = 0;
7693     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7694     if (r == -1)
7695       return -1;
7696   }
7697   {
7698     char fstype[] = "ext2";
7699     char device[] = "/dev/sda1";
7700     device[5] = devchar;
7701     int r;
7702     suppress_error = 0;
7703     r = guestfs_mkfs (g, fstype, device);
7704     if (r == -1)
7705       return -1;
7706   }
7707   {
7708     char device[] = "/dev/sda1";
7709     device[5] = devchar;
7710     char mountpoint[] = "/";
7711     int r;
7712     suppress_error = 0;
7713     r = guestfs_mount (g, device, mountpoint);
7714     if (r == -1)
7715       return -1;
7716   }
7717   /* TestOutput for command (5) */
7718   char expected[] = "\n\nResult6\n\n";
7719   {
7720     char remotefilename[] = "/test-command";
7721     int r;
7722     suppress_error = 0;
7723     r = guestfs_upload (g, "test-command", remotefilename);
7724     if (r == -1)
7725       return -1;
7726   }
7727   {
7728     char path[] = "/test-command";
7729     int r;
7730     suppress_error = 0;
7731     r = guestfs_chmod (g, 493, path);
7732     if (r == -1)
7733       return -1;
7734   }
7735   {
7736     char arguments_0[] = "/test-command";
7737     char arguments_1[] = "6";
7738     char *arguments[] = {
7739       arguments_0,
7740       arguments_1,
7741       NULL
7742     };
7743     char *r;
7744     suppress_error = 0;
7745     r = guestfs_command (g, arguments);
7746     if (r == NULL)
7747       return -1;
7748     if (strcmp (r, expected) != 0) {
7749       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7750       return -1;
7751     }
7752     free (r);
7753   }
7754   } else
7755     printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7756   return 0;
7757 }
7758
7759 static int test_command_6_prereq (void)
7760 {
7761   const char *str = getenv ("SKIP_TEST_COMMAND");
7762   return str && strcmp (str, "1") == 0;
7763 }
7764
7765 static int test_command_6 (void)
7766 {
7767   if (! test_command_6_prereq ()) {
7768   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
7769   {
7770     char device[] = "/dev/sda";
7771     device[5] = devchar;
7772     int r;
7773     suppress_error = 0;
7774     r = guestfs_blockdev_setrw (g, device);
7775     if (r == -1)
7776       return -1;
7777   }
7778   {
7779     int r;
7780     suppress_error = 0;
7781     r = guestfs_umount_all (g);
7782     if (r == -1)
7783       return -1;
7784   }
7785   {
7786     int r;
7787     suppress_error = 0;
7788     r = guestfs_lvm_remove_all (g);
7789     if (r == -1)
7790       return -1;
7791   }
7792   {
7793     char device[] = "/dev/sda";
7794     device[5] = devchar;
7795     char lines_0[] = ",";
7796     char *lines[] = {
7797       lines_0,
7798       NULL
7799     };
7800     int r;
7801     suppress_error = 0;
7802     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7803     if (r == -1)
7804       return -1;
7805   }
7806   {
7807     char fstype[] = "ext2";
7808     char device[] = "/dev/sda1";
7809     device[5] = devchar;
7810     int r;
7811     suppress_error = 0;
7812     r = guestfs_mkfs (g, fstype, device);
7813     if (r == -1)
7814       return -1;
7815   }
7816   {
7817     char device[] = "/dev/sda1";
7818     device[5] = devchar;
7819     char mountpoint[] = "/";
7820     int r;
7821     suppress_error = 0;
7822     r = guestfs_mount (g, device, mountpoint);
7823     if (r == -1)
7824       return -1;
7825   }
7826   /* TestOutput for command (6) */
7827   char expected[] = "";
7828   {
7829     char remotefilename[] = "/test-command";
7830     int r;
7831     suppress_error = 0;
7832     r = guestfs_upload (g, "test-command", remotefilename);
7833     if (r == -1)
7834       return -1;
7835   }
7836   {
7837     char path[] = "/test-command";
7838     int r;
7839     suppress_error = 0;
7840     r = guestfs_chmod (g, 493, path);
7841     if (r == -1)
7842       return -1;
7843   }
7844   {
7845     char arguments_0[] = "/test-command";
7846     char arguments_1[] = "7";
7847     char *arguments[] = {
7848       arguments_0,
7849       arguments_1,
7850       NULL
7851     };
7852     char *r;
7853     suppress_error = 0;
7854     r = guestfs_command (g, arguments);
7855     if (r == NULL)
7856       return -1;
7857     if (strcmp (r, expected) != 0) {
7858       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7859       return -1;
7860     }
7861     free (r);
7862   }
7863   } else
7864     printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7865   return 0;
7866 }
7867
7868 static int test_command_7_prereq (void)
7869 {
7870   const char *str = getenv ("SKIP_TEST_COMMAND");
7871   return str && strcmp (str, "1") == 0;
7872 }
7873
7874 static int test_command_7 (void)
7875 {
7876   if (! test_command_7_prereq ()) {
7877   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
7878   {
7879     char device[] = "/dev/sda";
7880     device[5] = devchar;
7881     int r;
7882     suppress_error = 0;
7883     r = guestfs_blockdev_setrw (g, device);
7884     if (r == -1)
7885       return -1;
7886   }
7887   {
7888     int r;
7889     suppress_error = 0;
7890     r = guestfs_umount_all (g);
7891     if (r == -1)
7892       return -1;
7893   }
7894   {
7895     int r;
7896     suppress_error = 0;
7897     r = guestfs_lvm_remove_all (g);
7898     if (r == -1)
7899       return -1;
7900   }
7901   {
7902     char device[] = "/dev/sda";
7903     device[5] = devchar;
7904     char lines_0[] = ",";
7905     char *lines[] = {
7906       lines_0,
7907       NULL
7908     };
7909     int r;
7910     suppress_error = 0;
7911     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7912     if (r == -1)
7913       return -1;
7914   }
7915   {
7916     char fstype[] = "ext2";
7917     char device[] = "/dev/sda1";
7918     device[5] = devchar;
7919     int r;
7920     suppress_error = 0;
7921     r = guestfs_mkfs (g, fstype, device);
7922     if (r == -1)
7923       return -1;
7924   }
7925   {
7926     char device[] = "/dev/sda1";
7927     device[5] = devchar;
7928     char mountpoint[] = "/";
7929     int r;
7930     suppress_error = 0;
7931     r = guestfs_mount (g, device, mountpoint);
7932     if (r == -1)
7933       return -1;
7934   }
7935   /* TestOutput for command (7) */
7936   char expected[] = "\n";
7937   {
7938     char remotefilename[] = "/test-command";
7939     int r;
7940     suppress_error = 0;
7941     r = guestfs_upload (g, "test-command", remotefilename);
7942     if (r == -1)
7943       return -1;
7944   }
7945   {
7946     char path[] = "/test-command";
7947     int r;
7948     suppress_error = 0;
7949     r = guestfs_chmod (g, 493, path);
7950     if (r == -1)
7951       return -1;
7952   }
7953   {
7954     char arguments_0[] = "/test-command";
7955     char arguments_1[] = "8";
7956     char *arguments[] = {
7957       arguments_0,
7958       arguments_1,
7959       NULL
7960     };
7961     char *r;
7962     suppress_error = 0;
7963     r = guestfs_command (g, arguments);
7964     if (r == NULL)
7965       return -1;
7966     if (strcmp (r, expected) != 0) {
7967       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7968       return -1;
7969     }
7970     free (r);
7971   }
7972   } else
7973     printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
7974   return 0;
7975 }
7976
7977 static int test_command_8_prereq (void)
7978 {
7979   const char *str = getenv ("SKIP_TEST_COMMAND");
7980   return str && strcmp (str, "1") == 0;
7981 }
7982
7983 static int test_command_8 (void)
7984 {
7985   if (! test_command_8_prereq ()) {
7986   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
7987   {
7988     char device[] = "/dev/sda";
7989     device[5] = devchar;
7990     int r;
7991     suppress_error = 0;
7992     r = guestfs_blockdev_setrw (g, device);
7993     if (r == -1)
7994       return -1;
7995   }
7996   {
7997     int r;
7998     suppress_error = 0;
7999     r = guestfs_umount_all (g);
8000     if (r == -1)
8001       return -1;
8002   }
8003   {
8004     int r;
8005     suppress_error = 0;
8006     r = guestfs_lvm_remove_all (g);
8007     if (r == -1)
8008       return -1;
8009   }
8010   {
8011     char device[] = "/dev/sda";
8012     device[5] = devchar;
8013     char lines_0[] = ",";
8014     char *lines[] = {
8015       lines_0,
8016       NULL
8017     };
8018     int r;
8019     suppress_error = 0;
8020     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8021     if (r == -1)
8022       return -1;
8023   }
8024   {
8025     char fstype[] = "ext2";
8026     char device[] = "/dev/sda1";
8027     device[5] = devchar;
8028     int r;
8029     suppress_error = 0;
8030     r = guestfs_mkfs (g, fstype, device);
8031     if (r == -1)
8032       return -1;
8033   }
8034   {
8035     char device[] = "/dev/sda1";
8036     device[5] = devchar;
8037     char mountpoint[] = "/";
8038     int r;
8039     suppress_error = 0;
8040     r = guestfs_mount (g, device, mountpoint);
8041     if (r == -1)
8042       return -1;
8043   }
8044   /* TestOutput for command (8) */
8045   char expected[] = "\n\n";
8046   {
8047     char remotefilename[] = "/test-command";
8048     int r;
8049     suppress_error = 0;
8050     r = guestfs_upload (g, "test-command", remotefilename);
8051     if (r == -1)
8052       return -1;
8053   }
8054   {
8055     char path[] = "/test-command";
8056     int r;
8057     suppress_error = 0;
8058     r = guestfs_chmod (g, 493, path);
8059     if (r == -1)
8060       return -1;
8061   }
8062   {
8063     char arguments_0[] = "/test-command";
8064     char arguments_1[] = "9";
8065     char *arguments[] = {
8066       arguments_0,
8067       arguments_1,
8068       NULL
8069     };
8070     char *r;
8071     suppress_error = 0;
8072     r = guestfs_command (g, arguments);
8073     if (r == NULL)
8074       return -1;
8075     if (strcmp (r, expected) != 0) {
8076       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
8077       return -1;
8078     }
8079     free (r);
8080   }
8081   } else
8082     printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
8083   return 0;
8084 }
8085
8086 static int test_command_9_prereq (void)
8087 {
8088   const char *str = getenv ("SKIP_TEST_COMMAND");
8089   return str && strcmp (str, "1") == 0;
8090 }
8091
8092 static int test_command_9 (void)
8093 {
8094   if (! test_command_9_prereq ()) {
8095   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
8096   {
8097     char device[] = "/dev/sda";
8098     device[5] = devchar;
8099     int r;
8100     suppress_error = 0;
8101     r = guestfs_blockdev_setrw (g, device);
8102     if (r == -1)
8103       return -1;
8104   }
8105   {
8106     int r;
8107     suppress_error = 0;
8108     r = guestfs_umount_all (g);
8109     if (r == -1)
8110       return -1;
8111   }
8112   {
8113     int r;
8114     suppress_error = 0;
8115     r = guestfs_lvm_remove_all (g);
8116     if (r == -1)
8117       return -1;
8118   }
8119   {
8120     char device[] = "/dev/sda";
8121     device[5] = devchar;
8122     char lines_0[] = ",";
8123     char *lines[] = {
8124       lines_0,
8125       NULL
8126     };
8127     int r;
8128     suppress_error = 0;
8129     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8130     if (r == -1)
8131       return -1;
8132   }
8133   {
8134     char fstype[] = "ext2";
8135     char device[] = "/dev/sda1";
8136     device[5] = devchar;
8137     int r;
8138     suppress_error = 0;
8139     r = guestfs_mkfs (g, fstype, device);
8140     if (r == -1)
8141       return -1;
8142   }
8143   {
8144     char device[] = "/dev/sda1";
8145     device[5] = devchar;
8146     char mountpoint[] = "/";
8147     int r;
8148     suppress_error = 0;
8149     r = guestfs_mount (g, device, mountpoint);
8150     if (r == -1)
8151       return -1;
8152   }
8153   /* TestOutput for command (9) */
8154   char expected[] = "Result10-1\nResult10-2\n";
8155   {
8156     char remotefilename[] = "/test-command";
8157     int r;
8158     suppress_error = 0;
8159     r = guestfs_upload (g, "test-command", remotefilename);
8160     if (r == -1)
8161       return -1;
8162   }
8163   {
8164     char path[] = "/test-command";
8165     int r;
8166     suppress_error = 0;
8167     r = guestfs_chmod (g, 493, path);
8168     if (r == -1)
8169       return -1;
8170   }
8171   {
8172     char arguments_0[] = "/test-command";
8173     char arguments_1[] = "10";
8174     char *arguments[] = {
8175       arguments_0,
8176       arguments_1,
8177       NULL
8178     };
8179     char *r;
8180     suppress_error = 0;
8181     r = guestfs_command (g, arguments);
8182     if (r == NULL)
8183       return -1;
8184     if (strcmp (r, expected) != 0) {
8185       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
8186       return -1;
8187     }
8188     free (r);
8189   }
8190   } else
8191     printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
8192   return 0;
8193 }
8194
8195 static int test_command_10_prereq (void)
8196 {
8197   const char *str = getenv ("SKIP_TEST_COMMAND");
8198   return str && strcmp (str, "1") == 0;
8199 }
8200
8201 static int test_command_10 (void)
8202 {
8203   if (! test_command_10_prereq ()) {
8204   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
8205   {
8206     char device[] = "/dev/sda";
8207     device[5] = devchar;
8208     int r;
8209     suppress_error = 0;
8210     r = guestfs_blockdev_setrw (g, device);
8211     if (r == -1)
8212       return -1;
8213   }
8214   {
8215     int r;
8216     suppress_error = 0;
8217     r = guestfs_umount_all (g);
8218     if (r == -1)
8219       return -1;
8220   }
8221   {
8222     int r;
8223     suppress_error = 0;
8224     r = guestfs_lvm_remove_all (g);
8225     if (r == -1)
8226       return -1;
8227   }
8228   {
8229     char device[] = "/dev/sda";
8230     device[5] = devchar;
8231     char lines_0[] = ",";
8232     char *lines[] = {
8233       lines_0,
8234       NULL
8235     };
8236     int r;
8237     suppress_error = 0;
8238     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8239     if (r == -1)
8240       return -1;
8241   }
8242   {
8243     char fstype[] = "ext2";
8244     char device[] = "/dev/sda1";
8245     device[5] = devchar;
8246     int r;
8247     suppress_error = 0;
8248     r = guestfs_mkfs (g, fstype, device);
8249     if (r == -1)
8250       return -1;
8251   }
8252   {
8253     char device[] = "/dev/sda1";
8254     device[5] = devchar;
8255     char mountpoint[] = "/";
8256     int r;
8257     suppress_error = 0;
8258     r = guestfs_mount (g, device, mountpoint);
8259     if (r == -1)
8260       return -1;
8261   }
8262   /* TestOutput for command (10) */
8263   char expected[] = "Result11-1\nResult11-2";
8264   {
8265     char remotefilename[] = "/test-command";
8266     int r;
8267     suppress_error = 0;
8268     r = guestfs_upload (g, "test-command", remotefilename);
8269     if (r == -1)
8270       return -1;
8271   }
8272   {
8273     char path[] = "/test-command";
8274     int r;
8275     suppress_error = 0;
8276     r = guestfs_chmod (g, 493, path);
8277     if (r == -1)
8278       return -1;
8279   }
8280   {
8281     char arguments_0[] = "/test-command";
8282     char arguments_1[] = "11";
8283     char *arguments[] = {
8284       arguments_0,
8285       arguments_1,
8286       NULL
8287     };
8288     char *r;
8289     suppress_error = 0;
8290     r = guestfs_command (g, arguments);
8291     if (r == NULL)
8292       return -1;
8293     if (strcmp (r, expected) != 0) {
8294       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
8295       return -1;
8296     }
8297     free (r);
8298   }
8299   } else
8300     printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
8301   return 0;
8302 }
8303
8304 static int test_command_11_prereq (void)
8305 {
8306   const char *str = getenv ("SKIP_TEST_COMMAND");
8307   return str && strcmp (str, "1") == 0;
8308 }
8309
8310 static int test_command_11 (void)
8311 {
8312   if (! test_command_11_prereq ()) {
8313   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
8314   {
8315     char device[] = "/dev/sda";
8316     device[5] = devchar;
8317     int r;
8318     suppress_error = 0;
8319     r = guestfs_blockdev_setrw (g, device);
8320     if (r == -1)
8321       return -1;
8322   }
8323   {
8324     int r;
8325     suppress_error = 0;
8326     r = guestfs_umount_all (g);
8327     if (r == -1)
8328       return -1;
8329   }
8330   {
8331     int r;
8332     suppress_error = 0;
8333     r = guestfs_lvm_remove_all (g);
8334     if (r == -1)
8335       return -1;
8336   }
8337   {
8338     char device[] = "/dev/sda";
8339     device[5] = devchar;
8340     char lines_0[] = ",";
8341     char *lines[] = {
8342       lines_0,
8343       NULL
8344     };
8345     int r;
8346     suppress_error = 0;
8347     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8348     if (r == -1)
8349       return -1;
8350   }
8351   {
8352     char fstype[] = "ext2";
8353     char device[] = "/dev/sda1";
8354     device[5] = devchar;
8355     int r;
8356     suppress_error = 0;
8357     r = guestfs_mkfs (g, fstype, device);
8358     if (r == -1)
8359       return -1;
8360   }
8361   {
8362     char device[] = "/dev/sda1";
8363     device[5] = devchar;
8364     char mountpoint[] = "/";
8365     int r;
8366     suppress_error = 0;
8367     r = guestfs_mount (g, device, mountpoint);
8368     if (r == -1)
8369       return -1;
8370   }
8371   /* TestLastFail for command (11) */
8372   {
8373     char remotefilename[] = "/test-command";
8374     int r;
8375     suppress_error = 0;
8376     r = guestfs_upload (g, "test-command", remotefilename);
8377     if (r == -1)
8378       return -1;
8379   }
8380   {
8381     char path[] = "/test-command";
8382     int r;
8383     suppress_error = 0;
8384     r = guestfs_chmod (g, 493, path);
8385     if (r == -1)
8386       return -1;
8387   }
8388   {
8389     char arguments_0[] = "/test-command";
8390     char *arguments[] = {
8391       arguments_0,
8392       NULL
8393     };
8394     char *r;
8395     suppress_error = 1;
8396     r = guestfs_command (g, arguments);
8397     if (r != NULL)
8398       return -1;
8399     free (r);
8400   }
8401   } else
8402     printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
8403   return 0;
8404 }
8405
8406 static int test_file_0 (void)
8407 {
8408   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
8409   {
8410     char device[] = "/dev/sda";
8411     device[5] = devchar;
8412     int r;
8413     suppress_error = 0;
8414     r = guestfs_blockdev_setrw (g, device);
8415     if (r == -1)
8416       return -1;
8417   }
8418   {
8419     int r;
8420     suppress_error = 0;
8421     r = guestfs_umount_all (g);
8422     if (r == -1)
8423       return -1;
8424   }
8425   {
8426     int r;
8427     suppress_error = 0;
8428     r = guestfs_lvm_remove_all (g);
8429     if (r == -1)
8430       return -1;
8431   }
8432   {
8433     char device[] = "/dev/sda";
8434     device[5] = devchar;
8435     char lines_0[] = ",";
8436     char *lines[] = {
8437       lines_0,
8438       NULL
8439     };
8440     int r;
8441     suppress_error = 0;
8442     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8443     if (r == -1)
8444       return -1;
8445   }
8446   {
8447     char fstype[] = "ext2";
8448     char device[] = "/dev/sda1";
8449     device[5] = devchar;
8450     int r;
8451     suppress_error = 0;
8452     r = guestfs_mkfs (g, fstype, device);
8453     if (r == -1)
8454       return -1;
8455   }
8456   {
8457     char device[] = "/dev/sda1";
8458     device[5] = devchar;
8459     char mountpoint[] = "/";
8460     int r;
8461     suppress_error = 0;
8462     r = guestfs_mount (g, device, mountpoint);
8463     if (r == -1)
8464       return -1;
8465   }
8466   /* TestOutput for file (0) */
8467   char expected[] = "empty";
8468   {
8469     char path[] = "/new";
8470     int r;
8471     suppress_error = 0;
8472     r = guestfs_touch (g, path);
8473     if (r == -1)
8474       return -1;
8475   }
8476   {
8477     char path[] = "/new";
8478     char *r;
8479     suppress_error = 0;
8480     r = guestfs_file (g, path);
8481     if (r == NULL)
8482       return -1;
8483     if (strcmp (r, expected) != 0) {
8484       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8485       return -1;
8486     }
8487     free (r);
8488   }
8489   return 0;
8490 }
8491
8492 static int test_file_1 (void)
8493 {
8494   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
8495   {
8496     char device[] = "/dev/sda";
8497     device[5] = devchar;
8498     int r;
8499     suppress_error = 0;
8500     r = guestfs_blockdev_setrw (g, device);
8501     if (r == -1)
8502       return -1;
8503   }
8504   {
8505     int r;
8506     suppress_error = 0;
8507     r = guestfs_umount_all (g);
8508     if (r == -1)
8509       return -1;
8510   }
8511   {
8512     int r;
8513     suppress_error = 0;
8514     r = guestfs_lvm_remove_all (g);
8515     if (r == -1)
8516       return -1;
8517   }
8518   {
8519     char device[] = "/dev/sda";
8520     device[5] = devchar;
8521     char lines_0[] = ",";
8522     char *lines[] = {
8523       lines_0,
8524       NULL
8525     };
8526     int r;
8527     suppress_error = 0;
8528     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8529     if (r == -1)
8530       return -1;
8531   }
8532   {
8533     char fstype[] = "ext2";
8534     char device[] = "/dev/sda1";
8535     device[5] = devchar;
8536     int r;
8537     suppress_error = 0;
8538     r = guestfs_mkfs (g, fstype, device);
8539     if (r == -1)
8540       return -1;
8541   }
8542   {
8543     char device[] = "/dev/sda1";
8544     device[5] = devchar;
8545     char mountpoint[] = "/";
8546     int r;
8547     suppress_error = 0;
8548     r = guestfs_mount (g, device, mountpoint);
8549     if (r == -1)
8550       return -1;
8551   }
8552   /* TestOutput for file (1) */
8553   char expected[] = "ASCII text";
8554   {
8555     char path[] = "/new";
8556     char content[] = "some content\n";
8557     int r;
8558     suppress_error = 0;
8559     r = guestfs_write_file (g, path, content, 0);
8560     if (r == -1)
8561       return -1;
8562   }
8563   {
8564     char path[] = "/new";
8565     char *r;
8566     suppress_error = 0;
8567     r = guestfs_file (g, path);
8568     if (r == NULL)
8569       return -1;
8570     if (strcmp (r, expected) != 0) {
8571       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8572       return -1;
8573     }
8574     free (r);
8575   }
8576   return 0;
8577 }
8578
8579 static int test_file_2 (void)
8580 {
8581   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
8582   {
8583     char device[] = "/dev/sda";
8584     device[5] = devchar;
8585     int r;
8586     suppress_error = 0;
8587     r = guestfs_blockdev_setrw (g, device);
8588     if (r == -1)
8589       return -1;
8590   }
8591   {
8592     int r;
8593     suppress_error = 0;
8594     r = guestfs_umount_all (g);
8595     if (r == -1)
8596       return -1;
8597   }
8598   {
8599     int r;
8600     suppress_error = 0;
8601     r = guestfs_lvm_remove_all (g);
8602     if (r == -1)
8603       return -1;
8604   }
8605   {
8606     char device[] = "/dev/sda";
8607     device[5] = devchar;
8608     char lines_0[] = ",";
8609     char *lines[] = {
8610       lines_0,
8611       NULL
8612     };
8613     int r;
8614     suppress_error = 0;
8615     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8616     if (r == -1)
8617       return -1;
8618   }
8619   {
8620     char fstype[] = "ext2";
8621     char device[] = "/dev/sda1";
8622     device[5] = devchar;
8623     int r;
8624     suppress_error = 0;
8625     r = guestfs_mkfs (g, fstype, device);
8626     if (r == -1)
8627       return -1;
8628   }
8629   {
8630     char device[] = "/dev/sda1";
8631     device[5] = devchar;
8632     char mountpoint[] = "/";
8633     int r;
8634     suppress_error = 0;
8635     r = guestfs_mount (g, device, mountpoint);
8636     if (r == -1)
8637       return -1;
8638   }
8639   /* TestLastFail for file (2) */
8640   {
8641     char path[] = "/nofile";
8642     char *r;
8643     suppress_error = 1;
8644     r = guestfs_file (g, path);
8645     if (r != NULL)
8646       return -1;
8647     free (r);
8648   }
8649   return 0;
8650 }
8651
8652 static int test_umount_all_0 (void)
8653 {
8654   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
8655   {
8656     char device[] = "/dev/sda";
8657     device[5] = devchar;
8658     int r;
8659     suppress_error = 0;
8660     r = guestfs_blockdev_setrw (g, device);
8661     if (r == -1)
8662       return -1;
8663   }
8664   {
8665     int r;
8666     suppress_error = 0;
8667     r = guestfs_umount_all (g);
8668     if (r == -1)
8669       return -1;
8670   }
8671   {
8672     int r;
8673     suppress_error = 0;
8674     r = guestfs_lvm_remove_all (g);
8675     if (r == -1)
8676       return -1;
8677   }
8678   {
8679     char device[] = "/dev/sda";
8680     device[5] = devchar;
8681     char lines_0[] = ",";
8682     char *lines[] = {
8683       lines_0,
8684       NULL
8685     };
8686     int r;
8687     suppress_error = 0;
8688     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8689     if (r == -1)
8690       return -1;
8691   }
8692   {
8693     char fstype[] = "ext2";
8694     char device[] = "/dev/sda1";
8695     device[5] = devchar;
8696     int r;
8697     suppress_error = 0;
8698     r = guestfs_mkfs (g, fstype, device);
8699     if (r == -1)
8700       return -1;
8701   }
8702   {
8703     char device[] = "/dev/sda1";
8704     device[5] = devchar;
8705     char mountpoint[] = "/";
8706     int r;
8707     suppress_error = 0;
8708     r = guestfs_mount (g, device, mountpoint);
8709     if (r == -1)
8710       return -1;
8711   }
8712   /* TestOutputList for umount_all (0) */
8713   {
8714     int r;
8715     suppress_error = 0;
8716     r = guestfs_umount_all (g);
8717     if (r == -1)
8718       return -1;
8719   }
8720   {
8721     char **r;
8722     int i;
8723     suppress_error = 0;
8724     r = guestfs_mounts (g);
8725     if (r == NULL)
8726       return -1;
8727     if (r[0] != NULL) {
8728       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8729       print_strings (r);
8730       return -1;
8731     }
8732     for (i = 0; r[i] != NULL; ++i)
8733       free (r[i]);
8734     free (r);
8735   }
8736   return 0;
8737 }
8738
8739 static int test_umount_all_1 (void)
8740 {
8741   /* InitNone|InitEmpty for test_umount_all_1 */
8742   {
8743     char device[] = "/dev/sda";
8744     device[5] = devchar;
8745     int r;
8746     suppress_error = 0;
8747     r = guestfs_blockdev_setrw (g, device);
8748     if (r == -1)
8749       return -1;
8750   }
8751   {
8752     int r;
8753     suppress_error = 0;
8754     r = guestfs_umount_all (g);
8755     if (r == -1)
8756       return -1;
8757   }
8758   {
8759     int r;
8760     suppress_error = 0;
8761     r = guestfs_lvm_remove_all (g);
8762     if (r == -1)
8763       return -1;
8764   }
8765   /* TestOutputList for umount_all (1) */
8766   {
8767     char device[] = "/dev/sda";
8768     device[5] = devchar;
8769     char lines_0[] = ",10";
8770     char lines_1[] = ",20";
8771     char lines_2[] = ",";
8772     char *lines[] = {
8773       lines_0,
8774       lines_1,
8775       lines_2,
8776       NULL
8777     };
8778     int r;
8779     suppress_error = 0;
8780     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8781     if (r == -1)
8782       return -1;
8783   }
8784   {
8785     char fstype[] = "ext2";
8786     char device[] = "/dev/sda1";
8787     device[5] = devchar;
8788     int r;
8789     suppress_error = 0;
8790     r = guestfs_mkfs (g, fstype, device);
8791     if (r == -1)
8792       return -1;
8793   }
8794   {
8795     char fstype[] = "ext2";
8796     char device[] = "/dev/sda2";
8797     device[5] = devchar;
8798     int r;
8799     suppress_error = 0;
8800     r = guestfs_mkfs (g, fstype, device);
8801     if (r == -1)
8802       return -1;
8803   }
8804   {
8805     char fstype[] = "ext2";
8806     char device[] = "/dev/sda3";
8807     device[5] = devchar;
8808     int r;
8809     suppress_error = 0;
8810     r = guestfs_mkfs (g, fstype, device);
8811     if (r == -1)
8812       return -1;
8813   }
8814   {
8815     char device[] = "/dev/sda1";
8816     device[5] = devchar;
8817     char mountpoint[] = "/";
8818     int r;
8819     suppress_error = 0;
8820     r = guestfs_mount (g, device, mountpoint);
8821     if (r == -1)
8822       return -1;
8823   }
8824   {
8825     char path[] = "/mp1";
8826     int r;
8827     suppress_error = 0;
8828     r = guestfs_mkdir (g, path);
8829     if (r == -1)
8830       return -1;
8831   }
8832   {
8833     char device[] = "/dev/sda2";
8834     device[5] = devchar;
8835     char mountpoint[] = "/mp1";
8836     int r;
8837     suppress_error = 0;
8838     r = guestfs_mount (g, device, mountpoint);
8839     if (r == -1)
8840       return -1;
8841   }
8842   {
8843     char path[] = "/mp1/mp2";
8844     int r;
8845     suppress_error = 0;
8846     r = guestfs_mkdir (g, path);
8847     if (r == -1)
8848       return -1;
8849   }
8850   {
8851     char device[] = "/dev/sda3";
8852     device[5] = devchar;
8853     char mountpoint[] = "/mp1/mp2";
8854     int r;
8855     suppress_error = 0;
8856     r = guestfs_mount (g, device, mountpoint);
8857     if (r == -1)
8858       return -1;
8859   }
8860   {
8861     char path[] = "/mp1/mp2/mp3";
8862     int r;
8863     suppress_error = 0;
8864     r = guestfs_mkdir (g, path);
8865     if (r == -1)
8866       return -1;
8867   }
8868   {
8869     int r;
8870     suppress_error = 0;
8871     r = guestfs_umount_all (g);
8872     if (r == -1)
8873       return -1;
8874   }
8875   {
8876     char **r;
8877     int i;
8878     suppress_error = 0;
8879     r = guestfs_mounts (g);
8880     if (r == NULL)
8881       return -1;
8882     if (r[0] != NULL) {
8883       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8884       print_strings (r);
8885       return -1;
8886     }
8887     for (i = 0; r[i] != NULL; ++i)
8888       free (r[i]);
8889     free (r);
8890   }
8891   return 0;
8892 }
8893
8894 static int test_mounts_0 (void)
8895 {
8896   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
8897   {
8898     char device[] = "/dev/sda";
8899     device[5] = devchar;
8900     int r;
8901     suppress_error = 0;
8902     r = guestfs_blockdev_setrw (g, device);
8903     if (r == -1)
8904       return -1;
8905   }
8906   {
8907     int r;
8908     suppress_error = 0;
8909     r = guestfs_umount_all (g);
8910     if (r == -1)
8911       return -1;
8912   }
8913   {
8914     int r;
8915     suppress_error = 0;
8916     r = guestfs_lvm_remove_all (g);
8917     if (r == -1)
8918       return -1;
8919   }
8920   {
8921     char device[] = "/dev/sda";
8922     device[5] = devchar;
8923     char lines_0[] = ",";
8924     char *lines[] = {
8925       lines_0,
8926       NULL
8927     };
8928     int r;
8929     suppress_error = 0;
8930     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8931     if (r == -1)
8932       return -1;
8933   }
8934   {
8935     char fstype[] = "ext2";
8936     char device[] = "/dev/sda1";
8937     device[5] = devchar;
8938     int r;
8939     suppress_error = 0;
8940     r = guestfs_mkfs (g, fstype, device);
8941     if (r == -1)
8942       return -1;
8943   }
8944   {
8945     char device[] = "/dev/sda1";
8946     device[5] = devchar;
8947     char mountpoint[] = "/";
8948     int r;
8949     suppress_error = 0;
8950     r = guestfs_mount (g, device, mountpoint);
8951     if (r == -1)
8952       return -1;
8953   }
8954   /* TestOutputList for mounts (0) */
8955   {
8956     char **r;
8957     int i;
8958     suppress_error = 0;
8959     r = guestfs_mounts (g);
8960     if (r == NULL)
8961       return -1;
8962     if (!r[0]) {
8963       fprintf (stderr, "test_mounts_0: short list returned from command\n");
8964       print_strings (r);
8965       return -1;
8966     }
8967     {
8968       char expected[] = "/dev/sda1";
8969       expected[5] = devchar;
8970       if (strcmp (r[0], expected) != 0) {
8971         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8972         return -1;
8973       }
8974     }
8975     if (r[1] != NULL) {
8976       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8977       print_strings (r);
8978       return -1;
8979     }
8980     for (i = 0; r[i] != NULL; ++i)
8981       free (r[i]);
8982     free (r);
8983   }
8984   return 0;
8985 }
8986
8987 static int test_umount_0 (void)
8988 {
8989   /* InitNone|InitEmpty for test_umount_0 */
8990   {
8991     char device[] = "/dev/sda";
8992     device[5] = devchar;
8993     int r;
8994     suppress_error = 0;
8995     r = guestfs_blockdev_setrw (g, device);
8996     if (r == -1)
8997       return -1;
8998   }
8999   {
9000     int r;
9001     suppress_error = 0;
9002     r = guestfs_umount_all (g);
9003     if (r == -1)
9004       return -1;
9005   }
9006   {
9007     int r;
9008     suppress_error = 0;
9009     r = guestfs_lvm_remove_all (g);
9010     if (r == -1)
9011       return -1;
9012   }
9013   /* TestOutputList for umount (0) */
9014   {
9015     char device[] = "/dev/sda";
9016     device[5] = devchar;
9017     char lines_0[] = ",";
9018     char *lines[] = {
9019       lines_0,
9020       NULL
9021     };
9022     int r;
9023     suppress_error = 0;
9024     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9025     if (r == -1)
9026       return -1;
9027   }
9028   {
9029     char fstype[] = "ext2";
9030     char device[] = "/dev/sda1";
9031     device[5] = devchar;
9032     int r;
9033     suppress_error = 0;
9034     r = guestfs_mkfs (g, fstype, device);
9035     if (r == -1)
9036       return -1;
9037   }
9038   {
9039     char device[] = "/dev/sda1";
9040     device[5] = devchar;
9041     char mountpoint[] = "/";
9042     int r;
9043     suppress_error = 0;
9044     r = guestfs_mount (g, device, mountpoint);
9045     if (r == -1)
9046       return -1;
9047   }
9048   {
9049     char **r;
9050     int i;
9051     suppress_error = 0;
9052     r = guestfs_mounts (g);
9053     if (r == NULL)
9054       return -1;
9055     if (!r[0]) {
9056       fprintf (stderr, "test_umount_0: short list returned from command\n");
9057       print_strings (r);
9058       return -1;
9059     }
9060     {
9061       char expected[] = "/dev/sda1";
9062       expected[5] = devchar;
9063       if (strcmp (r[0], expected) != 0) {
9064         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9065         return -1;
9066       }
9067     }
9068     if (r[1] != NULL) {
9069       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
9070       print_strings (r);
9071       return -1;
9072     }
9073     for (i = 0; r[i] != NULL; ++i)
9074       free (r[i]);
9075     free (r);
9076   }
9077   return 0;
9078 }
9079
9080 static int test_umount_1 (void)
9081 {
9082   /* InitNone|InitEmpty for test_umount_1 */
9083   {
9084     char device[] = "/dev/sda";
9085     device[5] = devchar;
9086     int r;
9087     suppress_error = 0;
9088     r = guestfs_blockdev_setrw (g, device);
9089     if (r == -1)
9090       return -1;
9091   }
9092   {
9093     int r;
9094     suppress_error = 0;
9095     r = guestfs_umount_all (g);
9096     if (r == -1)
9097       return -1;
9098   }
9099   {
9100     int r;
9101     suppress_error = 0;
9102     r = guestfs_lvm_remove_all (g);
9103     if (r == -1)
9104       return -1;
9105   }
9106   /* TestOutputList for umount (1) */
9107   {
9108     char device[] = "/dev/sda";
9109     device[5] = devchar;
9110     char lines_0[] = ",";
9111     char *lines[] = {
9112       lines_0,
9113       NULL
9114     };
9115     int r;
9116     suppress_error = 0;
9117     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9118     if (r == -1)
9119       return -1;
9120   }
9121   {
9122     char fstype[] = "ext2";
9123     char device[] = "/dev/sda1";
9124     device[5] = devchar;
9125     int r;
9126     suppress_error = 0;
9127     r = guestfs_mkfs (g, fstype, device);
9128     if (r == -1)
9129       return -1;
9130   }
9131   {
9132     char device[] = "/dev/sda1";
9133     device[5] = devchar;
9134     char mountpoint[] = "/";
9135     int r;
9136     suppress_error = 0;
9137     r = guestfs_mount (g, device, mountpoint);
9138     if (r == -1)
9139       return -1;
9140   }
9141   {
9142     char pathordevice[] = "/";
9143     int r;
9144     suppress_error = 0;
9145     r = guestfs_umount (g, pathordevice);
9146     if (r == -1)
9147       return -1;
9148   }
9149   {
9150     char **r;
9151     int i;
9152     suppress_error = 0;
9153     r = guestfs_mounts (g);
9154     if (r == NULL)
9155       return -1;
9156     if (r[0] != NULL) {
9157       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
9158       print_strings (r);
9159       return -1;
9160     }
9161     for (i = 0; r[i] != NULL; ++i)
9162       free (r[i]);
9163     free (r);
9164   }
9165   return 0;
9166 }
9167
9168 static int test_write_file_0 (void)
9169 {
9170   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
9171   {
9172     char device[] = "/dev/sda";
9173     device[5] = devchar;
9174     int r;
9175     suppress_error = 0;
9176     r = guestfs_blockdev_setrw (g, device);
9177     if (r == -1)
9178       return -1;
9179   }
9180   {
9181     int r;
9182     suppress_error = 0;
9183     r = guestfs_umount_all (g);
9184     if (r == -1)
9185       return -1;
9186   }
9187   {
9188     int r;
9189     suppress_error = 0;
9190     r = guestfs_lvm_remove_all (g);
9191     if (r == -1)
9192       return -1;
9193   }
9194   {
9195     char device[] = "/dev/sda";
9196     device[5] = devchar;
9197     char lines_0[] = ",";
9198     char *lines[] = {
9199       lines_0,
9200       NULL
9201     };
9202     int r;
9203     suppress_error = 0;
9204     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9205     if (r == -1)
9206       return -1;
9207   }
9208   {
9209     char fstype[] = "ext2";
9210     char device[] = "/dev/sda1";
9211     device[5] = devchar;
9212     int r;
9213     suppress_error = 0;
9214     r = guestfs_mkfs (g, fstype, device);
9215     if (r == -1)
9216       return -1;
9217   }
9218   {
9219     char device[] = "/dev/sda1";
9220     device[5] = devchar;
9221     char mountpoint[] = "/";
9222     int r;
9223     suppress_error = 0;
9224     r = guestfs_mount (g, device, mountpoint);
9225     if (r == -1)
9226       return -1;
9227   }
9228   /* TestOutput for write_file (0) */
9229   char expected[] = "new file contents";
9230   {
9231     char path[] = "/new";
9232     char content[] = "new file contents";
9233     int r;
9234     suppress_error = 0;
9235     r = guestfs_write_file (g, path, content, 0);
9236     if (r == -1)
9237       return -1;
9238   }
9239   {
9240     char path[] = "/new";
9241     char *r;
9242     suppress_error = 0;
9243     r = guestfs_cat (g, path);
9244     if (r == NULL)
9245       return -1;
9246     if (strcmp (r, expected) != 0) {
9247       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9248       return -1;
9249     }
9250     free (r);
9251   }
9252   return 0;
9253 }
9254
9255 static int test_write_file_1 (void)
9256 {
9257   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
9258   {
9259     char device[] = "/dev/sda";
9260     device[5] = devchar;
9261     int r;
9262     suppress_error = 0;
9263     r = guestfs_blockdev_setrw (g, device);
9264     if (r == -1)
9265       return -1;
9266   }
9267   {
9268     int r;
9269     suppress_error = 0;
9270     r = guestfs_umount_all (g);
9271     if (r == -1)
9272       return -1;
9273   }
9274   {
9275     int r;
9276     suppress_error = 0;
9277     r = guestfs_lvm_remove_all (g);
9278     if (r == -1)
9279       return -1;
9280   }
9281   {
9282     char device[] = "/dev/sda";
9283     device[5] = devchar;
9284     char lines_0[] = ",";
9285     char *lines[] = {
9286       lines_0,
9287       NULL
9288     };
9289     int r;
9290     suppress_error = 0;
9291     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9292     if (r == -1)
9293       return -1;
9294   }
9295   {
9296     char fstype[] = "ext2";
9297     char device[] = "/dev/sda1";
9298     device[5] = devchar;
9299     int r;
9300     suppress_error = 0;
9301     r = guestfs_mkfs (g, fstype, device);
9302     if (r == -1)
9303       return -1;
9304   }
9305   {
9306     char device[] = "/dev/sda1";
9307     device[5] = devchar;
9308     char mountpoint[] = "/";
9309     int r;
9310     suppress_error = 0;
9311     r = guestfs_mount (g, device, mountpoint);
9312     if (r == -1)
9313       return -1;
9314   }
9315   /* TestOutput for write_file (1) */
9316   char expected[] = "\nnew file contents\n";
9317   {
9318     char path[] = "/new";
9319     char content[] = "\nnew file contents\n";
9320     int r;
9321     suppress_error = 0;
9322     r = guestfs_write_file (g, path, content, 0);
9323     if (r == -1)
9324       return -1;
9325   }
9326   {
9327     char path[] = "/new";
9328     char *r;
9329     suppress_error = 0;
9330     r = guestfs_cat (g, path);
9331     if (r == NULL)
9332       return -1;
9333     if (strcmp (r, expected) != 0) {
9334       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9335       return -1;
9336     }
9337     free (r);
9338   }
9339   return 0;
9340 }
9341
9342 static int test_write_file_2 (void)
9343 {
9344   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
9345   {
9346     char device[] = "/dev/sda";
9347     device[5] = devchar;
9348     int r;
9349     suppress_error = 0;
9350     r = guestfs_blockdev_setrw (g, device);
9351     if (r == -1)
9352       return -1;
9353   }
9354   {
9355     int r;
9356     suppress_error = 0;
9357     r = guestfs_umount_all (g);
9358     if (r == -1)
9359       return -1;
9360   }
9361   {
9362     int r;
9363     suppress_error = 0;
9364     r = guestfs_lvm_remove_all (g);
9365     if (r == -1)
9366       return -1;
9367   }
9368   {
9369     char device[] = "/dev/sda";
9370     device[5] = devchar;
9371     char lines_0[] = ",";
9372     char *lines[] = {
9373       lines_0,
9374       NULL
9375     };
9376     int r;
9377     suppress_error = 0;
9378     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9379     if (r == -1)
9380       return -1;
9381   }
9382   {
9383     char fstype[] = "ext2";
9384     char device[] = "/dev/sda1";
9385     device[5] = devchar;
9386     int r;
9387     suppress_error = 0;
9388     r = guestfs_mkfs (g, fstype, device);
9389     if (r == -1)
9390       return -1;
9391   }
9392   {
9393     char device[] = "/dev/sda1";
9394     device[5] = devchar;
9395     char mountpoint[] = "/";
9396     int r;
9397     suppress_error = 0;
9398     r = guestfs_mount (g, device, mountpoint);
9399     if (r == -1)
9400       return -1;
9401   }
9402   /* TestOutput for write_file (2) */
9403   char expected[] = "\n\n";
9404   {
9405     char path[] = "/new";
9406     char content[] = "\n\n";
9407     int r;
9408     suppress_error = 0;
9409     r = guestfs_write_file (g, path, content, 0);
9410     if (r == -1)
9411       return -1;
9412   }
9413   {
9414     char path[] = "/new";
9415     char *r;
9416     suppress_error = 0;
9417     r = guestfs_cat (g, path);
9418     if (r == NULL)
9419       return -1;
9420     if (strcmp (r, expected) != 0) {
9421       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
9422       return -1;
9423     }
9424     free (r);
9425   }
9426   return 0;
9427 }
9428
9429 static int test_write_file_3 (void)
9430 {
9431   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
9432   {
9433     char device[] = "/dev/sda";
9434     device[5] = devchar;
9435     int r;
9436     suppress_error = 0;
9437     r = guestfs_blockdev_setrw (g, device);
9438     if (r == -1)
9439       return -1;
9440   }
9441   {
9442     int r;
9443     suppress_error = 0;
9444     r = guestfs_umount_all (g);
9445     if (r == -1)
9446       return -1;
9447   }
9448   {
9449     int r;
9450     suppress_error = 0;
9451     r = guestfs_lvm_remove_all (g);
9452     if (r == -1)
9453       return -1;
9454   }
9455   {
9456     char device[] = "/dev/sda";
9457     device[5] = devchar;
9458     char lines_0[] = ",";
9459     char *lines[] = {
9460       lines_0,
9461       NULL
9462     };
9463     int r;
9464     suppress_error = 0;
9465     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9466     if (r == -1)
9467       return -1;
9468   }
9469   {
9470     char fstype[] = "ext2";
9471     char device[] = "/dev/sda1";
9472     device[5] = devchar;
9473     int r;
9474     suppress_error = 0;
9475     r = guestfs_mkfs (g, fstype, device);
9476     if (r == -1)
9477       return -1;
9478   }
9479   {
9480     char device[] = "/dev/sda1";
9481     device[5] = devchar;
9482     char mountpoint[] = "/";
9483     int r;
9484     suppress_error = 0;
9485     r = guestfs_mount (g, device, mountpoint);
9486     if (r == -1)
9487       return -1;
9488   }
9489   /* TestOutput for write_file (3) */
9490   char expected[] = "";
9491   {
9492     char path[] = "/new";
9493     char content[] = "";
9494     int r;
9495     suppress_error = 0;
9496     r = guestfs_write_file (g, path, content, 0);
9497     if (r == -1)
9498       return -1;
9499   }
9500   {
9501     char path[] = "/new";
9502     char *r;
9503     suppress_error = 0;
9504     r = guestfs_cat (g, path);
9505     if (r == NULL)
9506       return -1;
9507     if (strcmp (r, expected) != 0) {
9508       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
9509       return -1;
9510     }
9511     free (r);
9512   }
9513   return 0;
9514 }
9515
9516 static int test_write_file_4 (void)
9517 {
9518   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
9519   {
9520     char device[] = "/dev/sda";
9521     device[5] = devchar;
9522     int r;
9523     suppress_error = 0;
9524     r = guestfs_blockdev_setrw (g, device);
9525     if (r == -1)
9526       return -1;
9527   }
9528   {
9529     int r;
9530     suppress_error = 0;
9531     r = guestfs_umount_all (g);
9532     if (r == -1)
9533       return -1;
9534   }
9535   {
9536     int r;
9537     suppress_error = 0;
9538     r = guestfs_lvm_remove_all (g);
9539     if (r == -1)
9540       return -1;
9541   }
9542   {
9543     char device[] = "/dev/sda";
9544     device[5] = devchar;
9545     char lines_0[] = ",";
9546     char *lines[] = {
9547       lines_0,
9548       NULL
9549     };
9550     int r;
9551     suppress_error = 0;
9552     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9553     if (r == -1)
9554       return -1;
9555   }
9556   {
9557     char fstype[] = "ext2";
9558     char device[] = "/dev/sda1";
9559     device[5] = devchar;
9560     int r;
9561     suppress_error = 0;
9562     r = guestfs_mkfs (g, fstype, device);
9563     if (r == -1)
9564       return -1;
9565   }
9566   {
9567     char device[] = "/dev/sda1";
9568     device[5] = devchar;
9569     char mountpoint[] = "/";
9570     int r;
9571     suppress_error = 0;
9572     r = guestfs_mount (g, device, mountpoint);
9573     if (r == -1)
9574       return -1;
9575   }
9576   /* TestOutput for write_file (4) */
9577   char expected[] = "\n\n\n";
9578   {
9579     char path[] = "/new";
9580     char content[] = "\n\n\n";
9581     int r;
9582     suppress_error = 0;
9583     r = guestfs_write_file (g, path, content, 0);
9584     if (r == -1)
9585       return -1;
9586   }
9587   {
9588     char path[] = "/new";
9589     char *r;
9590     suppress_error = 0;
9591     r = guestfs_cat (g, path);
9592     if (r == NULL)
9593       return -1;
9594     if (strcmp (r, expected) != 0) {
9595       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9596       return -1;
9597     }
9598     free (r);
9599   }
9600   return 0;
9601 }
9602
9603 static int test_write_file_5 (void)
9604 {
9605   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
9606   {
9607     char device[] = "/dev/sda";
9608     device[5] = devchar;
9609     int r;
9610     suppress_error = 0;
9611     r = guestfs_blockdev_setrw (g, device);
9612     if (r == -1)
9613       return -1;
9614   }
9615   {
9616     int r;
9617     suppress_error = 0;
9618     r = guestfs_umount_all (g);
9619     if (r == -1)
9620       return -1;
9621   }
9622   {
9623     int r;
9624     suppress_error = 0;
9625     r = guestfs_lvm_remove_all (g);
9626     if (r == -1)
9627       return -1;
9628   }
9629   {
9630     char device[] = "/dev/sda";
9631     device[5] = devchar;
9632     char lines_0[] = ",";
9633     char *lines[] = {
9634       lines_0,
9635       NULL
9636     };
9637     int r;
9638     suppress_error = 0;
9639     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9640     if (r == -1)
9641       return -1;
9642   }
9643   {
9644     char fstype[] = "ext2";
9645     char device[] = "/dev/sda1";
9646     device[5] = devchar;
9647     int r;
9648     suppress_error = 0;
9649     r = guestfs_mkfs (g, fstype, device);
9650     if (r == -1)
9651       return -1;
9652   }
9653   {
9654     char device[] = "/dev/sda1";
9655     device[5] = devchar;
9656     char mountpoint[] = "/";
9657     int r;
9658     suppress_error = 0;
9659     r = guestfs_mount (g, device, mountpoint);
9660     if (r == -1)
9661       return -1;
9662   }
9663   /* TestOutput for write_file (5) */
9664   char expected[] = "\n";
9665   {
9666     char path[] = "/new";
9667     char content[] = "\n";
9668     int r;
9669     suppress_error = 0;
9670     r = guestfs_write_file (g, path, content, 0);
9671     if (r == -1)
9672       return -1;
9673   }
9674   {
9675     char path[] = "/new";
9676     char *r;
9677     suppress_error = 0;
9678     r = guestfs_cat (g, path);
9679     if (r == NULL)
9680       return -1;
9681     if (strcmp (r, expected) != 0) {
9682       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9683       return -1;
9684     }
9685     free (r);
9686   }
9687   return 0;
9688 }
9689
9690 static int test_mkfs_0 (void)
9691 {
9692   /* InitNone|InitEmpty for test_mkfs_0 */
9693   {
9694     char device[] = "/dev/sda";
9695     device[5] = devchar;
9696     int r;
9697     suppress_error = 0;
9698     r = guestfs_blockdev_setrw (g, device);
9699     if (r == -1)
9700       return -1;
9701   }
9702   {
9703     int r;
9704     suppress_error = 0;
9705     r = guestfs_umount_all (g);
9706     if (r == -1)
9707       return -1;
9708   }
9709   {
9710     int r;
9711     suppress_error = 0;
9712     r = guestfs_lvm_remove_all (g);
9713     if (r == -1)
9714       return -1;
9715   }
9716   /* TestOutput for mkfs (0) */
9717   char expected[] = "new file contents";
9718   {
9719     char device[] = "/dev/sda";
9720     device[5] = devchar;
9721     char lines_0[] = ",";
9722     char *lines[] = {
9723       lines_0,
9724       NULL
9725     };
9726     int r;
9727     suppress_error = 0;
9728     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9729     if (r == -1)
9730       return -1;
9731   }
9732   {
9733     char fstype[] = "ext2";
9734     char device[] = "/dev/sda1";
9735     device[5] = devchar;
9736     int r;
9737     suppress_error = 0;
9738     r = guestfs_mkfs (g, fstype, device);
9739     if (r == -1)
9740       return -1;
9741   }
9742   {
9743     char device[] = "/dev/sda1";
9744     device[5] = devchar;
9745     char mountpoint[] = "/";
9746     int r;
9747     suppress_error = 0;
9748     r = guestfs_mount (g, device, mountpoint);
9749     if (r == -1)
9750       return -1;
9751   }
9752   {
9753     char path[] = "/new";
9754     char content[] = "new file contents";
9755     int r;
9756     suppress_error = 0;
9757     r = guestfs_write_file (g, path, content, 0);
9758     if (r == -1)
9759       return -1;
9760   }
9761   {
9762     char path[] = "/new";
9763     char *r;
9764     suppress_error = 0;
9765     r = guestfs_cat (g, path);
9766     if (r == NULL)
9767       return -1;
9768     if (strcmp (r, expected) != 0) {
9769       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9770       return -1;
9771     }
9772     free (r);
9773   }
9774   return 0;
9775 }
9776
9777 static int test_lvcreate_0 (void)
9778 {
9779   /* InitNone|InitEmpty for test_lvcreate_0 */
9780   {
9781     char device[] = "/dev/sda";
9782     device[5] = devchar;
9783     int r;
9784     suppress_error = 0;
9785     r = guestfs_blockdev_setrw (g, device);
9786     if (r == -1)
9787       return -1;
9788   }
9789   {
9790     int r;
9791     suppress_error = 0;
9792     r = guestfs_umount_all (g);
9793     if (r == -1)
9794       return -1;
9795   }
9796   {
9797     int r;
9798     suppress_error = 0;
9799     r = guestfs_lvm_remove_all (g);
9800     if (r == -1)
9801       return -1;
9802   }
9803   /* TestOutputList for lvcreate (0) */
9804   {
9805     char device[] = "/dev/sda";
9806     device[5] = devchar;
9807     char lines_0[] = ",10";
9808     char lines_1[] = ",20";
9809     char lines_2[] = ",";
9810     char *lines[] = {
9811       lines_0,
9812       lines_1,
9813       lines_2,
9814       NULL
9815     };
9816     int r;
9817     suppress_error = 0;
9818     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9819     if (r == -1)
9820       return -1;
9821   }
9822   {
9823     char device[] = "/dev/sda1";
9824     device[5] = devchar;
9825     int r;
9826     suppress_error = 0;
9827     r = guestfs_pvcreate (g, device);
9828     if (r == -1)
9829       return -1;
9830   }
9831   {
9832     char device[] = "/dev/sda2";
9833     device[5] = devchar;
9834     int r;
9835     suppress_error = 0;
9836     r = guestfs_pvcreate (g, device);
9837     if (r == -1)
9838       return -1;
9839   }
9840   {
9841     char device[] = "/dev/sda3";
9842     device[5] = devchar;
9843     int r;
9844     suppress_error = 0;
9845     r = guestfs_pvcreate (g, device);
9846     if (r == -1)
9847       return -1;
9848   }
9849   {
9850     char volgroup[] = "VG1";
9851     char physvols_0[] = "/dev/sda1";
9852     physvols_0[5] = devchar;
9853     char physvols_1[] = "/dev/sda2";
9854     physvols_1[5] = devchar;
9855     char *physvols[] = {
9856       physvols_0,
9857       physvols_1,
9858       NULL
9859     };
9860     int r;
9861     suppress_error = 0;
9862     r = guestfs_vgcreate (g, volgroup, physvols);
9863     if (r == -1)
9864       return -1;
9865   }
9866   {
9867     char volgroup[] = "VG2";
9868     char physvols_0[] = "/dev/sda3";
9869     physvols_0[5] = devchar;
9870     char *physvols[] = {
9871       physvols_0,
9872       NULL
9873     };
9874     int r;
9875     suppress_error = 0;
9876     r = guestfs_vgcreate (g, volgroup, physvols);
9877     if (r == -1)
9878       return -1;
9879   }
9880   {
9881     char logvol[] = "LV1";
9882     char volgroup[] = "VG1";
9883     int r;
9884     suppress_error = 0;
9885     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9886     if (r == -1)
9887       return -1;
9888   }
9889   {
9890     char logvol[] = "LV2";
9891     char volgroup[] = "VG1";
9892     int r;
9893     suppress_error = 0;
9894     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9895     if (r == -1)
9896       return -1;
9897   }
9898   {
9899     char logvol[] = "LV3";
9900     char volgroup[] = "VG2";
9901     int r;
9902     suppress_error = 0;
9903     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9904     if (r == -1)
9905       return -1;
9906   }
9907   {
9908     char logvol[] = "LV4";
9909     char volgroup[] = "VG2";
9910     int r;
9911     suppress_error = 0;
9912     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9913     if (r == -1)
9914       return -1;
9915   }
9916   {
9917     char logvol[] = "LV5";
9918     char volgroup[] = "VG2";
9919     int r;
9920     suppress_error = 0;
9921     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9922     if (r == -1)
9923       return -1;
9924   }
9925   {
9926     char **r;
9927     int i;
9928     suppress_error = 0;
9929     r = guestfs_lvs (g);
9930     if (r == NULL)
9931       return -1;
9932     if (!r[0]) {
9933       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9934       print_strings (r);
9935       return -1;
9936     }
9937     {
9938       char expected[] = "/dev/VG1/LV1";
9939       if (strcmp (r[0], expected) != 0) {
9940         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9941         return -1;
9942       }
9943     }
9944     if (!r[1]) {
9945       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9946       print_strings (r);
9947       return -1;
9948     }
9949     {
9950       char expected[] = "/dev/VG1/LV2";
9951       if (strcmp (r[1], expected) != 0) {
9952         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9953         return -1;
9954       }
9955     }
9956     if (!r[2]) {
9957       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9958       print_strings (r);
9959       return -1;
9960     }
9961     {
9962       char expected[] = "/dev/VG2/LV3";
9963       if (strcmp (r[2], expected) != 0) {
9964         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9965         return -1;
9966       }
9967     }
9968     if (!r[3]) {
9969       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9970       print_strings (r);
9971       return -1;
9972     }
9973     {
9974       char expected[] = "/dev/VG2/LV4";
9975       if (strcmp (r[3], expected) != 0) {
9976         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9977         return -1;
9978       }
9979     }
9980     if (!r[4]) {
9981       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9982       print_strings (r);
9983       return -1;
9984     }
9985     {
9986       char expected[] = "/dev/VG2/LV5";
9987       if (strcmp (r[4], expected) != 0) {
9988         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9989         return -1;
9990       }
9991     }
9992     if (r[5] != NULL) {
9993       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9994       print_strings (r);
9995       return -1;
9996     }
9997     for (i = 0; r[i] != NULL; ++i)
9998       free (r[i]);
9999     free (r);
10000   }
10001   return 0;
10002 }
10003
10004 static int test_vgcreate_0 (void)
10005 {
10006   /* InitNone|InitEmpty for test_vgcreate_0 */
10007   {
10008     char device[] = "/dev/sda";
10009     device[5] = devchar;
10010     int r;
10011     suppress_error = 0;
10012     r = guestfs_blockdev_setrw (g, device);
10013     if (r == -1)
10014       return -1;
10015   }
10016   {
10017     int r;
10018     suppress_error = 0;
10019     r = guestfs_umount_all (g);
10020     if (r == -1)
10021       return -1;
10022   }
10023   {
10024     int r;
10025     suppress_error = 0;
10026     r = guestfs_lvm_remove_all (g);
10027     if (r == -1)
10028       return -1;
10029   }
10030   /* TestOutputList for vgcreate (0) */
10031   {
10032     char device[] = "/dev/sda";
10033     device[5] = devchar;
10034     char lines_0[] = ",10";
10035     char lines_1[] = ",20";
10036     char lines_2[] = ",";
10037     char *lines[] = {
10038       lines_0,
10039       lines_1,
10040       lines_2,
10041       NULL
10042     };
10043     int r;
10044     suppress_error = 0;
10045     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10046     if (r == -1)
10047       return -1;
10048   }
10049   {
10050     char device[] = "/dev/sda1";
10051     device[5] = devchar;
10052     int r;
10053     suppress_error = 0;
10054     r = guestfs_pvcreate (g, device);
10055     if (r == -1)
10056       return -1;
10057   }
10058   {
10059     char device[] = "/dev/sda2";
10060     device[5] = devchar;
10061     int r;
10062     suppress_error = 0;
10063     r = guestfs_pvcreate (g, device);
10064     if (r == -1)
10065       return -1;
10066   }
10067   {
10068     char device[] = "/dev/sda3";
10069     device[5] = devchar;
10070     int r;
10071     suppress_error = 0;
10072     r = guestfs_pvcreate (g, device);
10073     if (r == -1)
10074       return -1;
10075   }
10076   {
10077     char volgroup[] = "VG1";
10078     char physvols_0[] = "/dev/sda1";
10079     physvols_0[5] = devchar;
10080     char physvols_1[] = "/dev/sda2";
10081     physvols_1[5] = devchar;
10082     char *physvols[] = {
10083       physvols_0,
10084       physvols_1,
10085       NULL
10086     };
10087     int r;
10088     suppress_error = 0;
10089     r = guestfs_vgcreate (g, volgroup, physvols);
10090     if (r == -1)
10091       return -1;
10092   }
10093   {
10094     char volgroup[] = "VG2";
10095     char physvols_0[] = "/dev/sda3";
10096     physvols_0[5] = devchar;
10097     char *physvols[] = {
10098       physvols_0,
10099       NULL
10100     };
10101     int r;
10102     suppress_error = 0;
10103     r = guestfs_vgcreate (g, volgroup, physvols);
10104     if (r == -1)
10105       return -1;
10106   }
10107   {
10108     char **r;
10109     int i;
10110     suppress_error = 0;
10111     r = guestfs_vgs (g);
10112     if (r == NULL)
10113       return -1;
10114     if (!r[0]) {
10115       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10116       print_strings (r);
10117       return -1;
10118     }
10119     {
10120       char expected[] = "VG1";
10121       if (strcmp (r[0], expected) != 0) {
10122         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10123         return -1;
10124       }
10125     }
10126     if (!r[1]) {
10127       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10128       print_strings (r);
10129       return -1;
10130     }
10131     {
10132       char expected[] = "VG2";
10133       if (strcmp (r[1], expected) != 0) {
10134         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10135         return -1;
10136       }
10137     }
10138     if (r[2] != NULL) {
10139       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
10140       print_strings (r);
10141       return -1;
10142     }
10143     for (i = 0; r[i] != NULL; ++i)
10144       free (r[i]);
10145     free (r);
10146   }
10147   return 0;
10148 }
10149
10150 static int test_pvcreate_0 (void)
10151 {
10152   /* InitNone|InitEmpty for test_pvcreate_0 */
10153   {
10154     char device[] = "/dev/sda";
10155     device[5] = devchar;
10156     int r;
10157     suppress_error = 0;
10158     r = guestfs_blockdev_setrw (g, device);
10159     if (r == -1)
10160       return -1;
10161   }
10162   {
10163     int r;
10164     suppress_error = 0;
10165     r = guestfs_umount_all (g);
10166     if (r == -1)
10167       return -1;
10168   }
10169   {
10170     int r;
10171     suppress_error = 0;
10172     r = guestfs_lvm_remove_all (g);
10173     if (r == -1)
10174       return -1;
10175   }
10176   /* TestOutputList for pvcreate (0) */
10177   {
10178     char device[] = "/dev/sda";
10179     device[5] = devchar;
10180     char lines_0[] = ",10";
10181     char lines_1[] = ",20";
10182     char lines_2[] = ",";
10183     char *lines[] = {
10184       lines_0,
10185       lines_1,
10186       lines_2,
10187       NULL
10188     };
10189     int r;
10190     suppress_error = 0;
10191     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10192     if (r == -1)
10193       return -1;
10194   }
10195   {
10196     char device[] = "/dev/sda1";
10197     device[5] = devchar;
10198     int r;
10199     suppress_error = 0;
10200     r = guestfs_pvcreate (g, device);
10201     if (r == -1)
10202       return -1;
10203   }
10204   {
10205     char device[] = "/dev/sda2";
10206     device[5] = devchar;
10207     int r;
10208     suppress_error = 0;
10209     r = guestfs_pvcreate (g, device);
10210     if (r == -1)
10211       return -1;
10212   }
10213   {
10214     char device[] = "/dev/sda3";
10215     device[5] = devchar;
10216     int r;
10217     suppress_error = 0;
10218     r = guestfs_pvcreate (g, device);
10219     if (r == -1)
10220       return -1;
10221   }
10222   {
10223     char **r;
10224     int i;
10225     suppress_error = 0;
10226     r = guestfs_pvs (g);
10227     if (r == NULL)
10228       return -1;
10229     if (!r[0]) {
10230       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10231       print_strings (r);
10232       return -1;
10233     }
10234     {
10235       char expected[] = "/dev/sda1";
10236       expected[5] = devchar;
10237       if (strcmp (r[0], expected) != 0) {
10238         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10239         return -1;
10240       }
10241     }
10242     if (!r[1]) {
10243       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10244       print_strings (r);
10245       return -1;
10246     }
10247     {
10248       char expected[] = "/dev/sda2";
10249       expected[5] = devchar;
10250       if (strcmp (r[1], expected) != 0) {
10251         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10252         return -1;
10253       }
10254     }
10255     if (!r[2]) {
10256       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10257       print_strings (r);
10258       return -1;
10259     }
10260     {
10261       char expected[] = "/dev/sda3";
10262       expected[5] = devchar;
10263       if (strcmp (r[2], expected) != 0) {
10264         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10265         return -1;
10266       }
10267     }
10268     if (r[3] != NULL) {
10269       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
10270       print_strings (r);
10271       return -1;
10272     }
10273     for (i = 0; r[i] != NULL; ++i)
10274       free (r[i]);
10275     free (r);
10276   }
10277   return 0;
10278 }
10279
10280 static int test_is_dir_0 (void)
10281 {
10282   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
10283   {
10284     char device[] = "/dev/sda";
10285     device[5] = devchar;
10286     int r;
10287     suppress_error = 0;
10288     r = guestfs_blockdev_setrw (g, device);
10289     if (r == -1)
10290       return -1;
10291   }
10292   {
10293     int r;
10294     suppress_error = 0;
10295     r = guestfs_umount_all (g);
10296     if (r == -1)
10297       return -1;
10298   }
10299   {
10300     int r;
10301     suppress_error = 0;
10302     r = guestfs_lvm_remove_all (g);
10303     if (r == -1)
10304       return -1;
10305   }
10306   {
10307     char device[] = "/dev/sda";
10308     device[5] = devchar;
10309     char lines_0[] = ",";
10310     char *lines[] = {
10311       lines_0,
10312       NULL
10313     };
10314     int r;
10315     suppress_error = 0;
10316     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10317     if (r == -1)
10318       return -1;
10319   }
10320   {
10321     char fstype[] = "ext2";
10322     char device[] = "/dev/sda1";
10323     device[5] = devchar;
10324     int r;
10325     suppress_error = 0;
10326     r = guestfs_mkfs (g, fstype, device);
10327     if (r == -1)
10328       return -1;
10329   }
10330   {
10331     char device[] = "/dev/sda1";
10332     device[5] = devchar;
10333     char mountpoint[] = "/";
10334     int r;
10335     suppress_error = 0;
10336     r = guestfs_mount (g, device, mountpoint);
10337     if (r == -1)
10338       return -1;
10339   }
10340   /* TestOutputFalse for is_dir (0) */
10341   {
10342     char path[] = "/new";
10343     int r;
10344     suppress_error = 0;
10345     r = guestfs_touch (g, path);
10346     if (r == -1)
10347       return -1;
10348   }
10349   {
10350     char path[] = "/new";
10351     int r;
10352     suppress_error = 0;
10353     r = guestfs_is_dir (g, path);
10354     if (r == -1)
10355       return -1;
10356     if (r) {
10357       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
10358       return -1;
10359     }
10360   }
10361   return 0;
10362 }
10363
10364 static int test_is_dir_1 (void)
10365 {
10366   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
10367   {
10368     char device[] = "/dev/sda";
10369     device[5] = devchar;
10370     int r;
10371     suppress_error = 0;
10372     r = guestfs_blockdev_setrw (g, device);
10373     if (r == -1)
10374       return -1;
10375   }
10376   {
10377     int r;
10378     suppress_error = 0;
10379     r = guestfs_umount_all (g);
10380     if (r == -1)
10381       return -1;
10382   }
10383   {
10384     int r;
10385     suppress_error = 0;
10386     r = guestfs_lvm_remove_all (g);
10387     if (r == -1)
10388       return -1;
10389   }
10390   {
10391     char device[] = "/dev/sda";
10392     device[5] = devchar;
10393     char lines_0[] = ",";
10394     char *lines[] = {
10395       lines_0,
10396       NULL
10397     };
10398     int r;
10399     suppress_error = 0;
10400     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10401     if (r == -1)
10402       return -1;
10403   }
10404   {
10405     char fstype[] = "ext2";
10406     char device[] = "/dev/sda1";
10407     device[5] = devchar;
10408     int r;
10409     suppress_error = 0;
10410     r = guestfs_mkfs (g, fstype, device);
10411     if (r == -1)
10412       return -1;
10413   }
10414   {
10415     char device[] = "/dev/sda1";
10416     device[5] = devchar;
10417     char mountpoint[] = "/";
10418     int r;
10419     suppress_error = 0;
10420     r = guestfs_mount (g, device, mountpoint);
10421     if (r == -1)
10422       return -1;
10423   }
10424   /* TestOutputTrue for is_dir (1) */
10425   {
10426     char path[] = "/new";
10427     int r;
10428     suppress_error = 0;
10429     r = guestfs_mkdir (g, path);
10430     if (r == -1)
10431       return -1;
10432   }
10433   {
10434     char path[] = "/new";
10435     int r;
10436     suppress_error = 0;
10437     r = guestfs_is_dir (g, path);
10438     if (r == -1)
10439       return -1;
10440     if (!r) {
10441       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
10442       return -1;
10443     }
10444   }
10445   return 0;
10446 }
10447
10448 static int test_is_file_0 (void)
10449 {
10450   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
10451   {
10452     char device[] = "/dev/sda";
10453     device[5] = devchar;
10454     int r;
10455     suppress_error = 0;
10456     r = guestfs_blockdev_setrw (g, device);
10457     if (r == -1)
10458       return -1;
10459   }
10460   {
10461     int r;
10462     suppress_error = 0;
10463     r = guestfs_umount_all (g);
10464     if (r == -1)
10465       return -1;
10466   }
10467   {
10468     int r;
10469     suppress_error = 0;
10470     r = guestfs_lvm_remove_all (g);
10471     if (r == -1)
10472       return -1;
10473   }
10474   {
10475     char device[] = "/dev/sda";
10476     device[5] = devchar;
10477     char lines_0[] = ",";
10478     char *lines[] = {
10479       lines_0,
10480       NULL
10481     };
10482     int r;
10483     suppress_error = 0;
10484     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10485     if (r == -1)
10486       return -1;
10487   }
10488   {
10489     char fstype[] = "ext2";
10490     char device[] = "/dev/sda1";
10491     device[5] = devchar;
10492     int r;
10493     suppress_error = 0;
10494     r = guestfs_mkfs (g, fstype, device);
10495     if (r == -1)
10496       return -1;
10497   }
10498   {
10499     char device[] = "/dev/sda1";
10500     device[5] = devchar;
10501     char mountpoint[] = "/";
10502     int r;
10503     suppress_error = 0;
10504     r = guestfs_mount (g, device, mountpoint);
10505     if (r == -1)
10506       return -1;
10507   }
10508   /* TestOutputTrue for is_file (0) */
10509   {
10510     char path[] = "/new";
10511     int r;
10512     suppress_error = 0;
10513     r = guestfs_touch (g, path);
10514     if (r == -1)
10515       return -1;
10516   }
10517   {
10518     char path[] = "/new";
10519     int r;
10520     suppress_error = 0;
10521     r = guestfs_is_file (g, path);
10522     if (r == -1)
10523       return -1;
10524     if (!r) {
10525       fprintf (stderr, "test_is_file_0: expected true, got false\n");
10526       return -1;
10527     }
10528   }
10529   return 0;
10530 }
10531
10532 static int test_is_file_1 (void)
10533 {
10534   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
10535   {
10536     char device[] = "/dev/sda";
10537     device[5] = devchar;
10538     int r;
10539     suppress_error = 0;
10540     r = guestfs_blockdev_setrw (g, device);
10541     if (r == -1)
10542       return -1;
10543   }
10544   {
10545     int r;
10546     suppress_error = 0;
10547     r = guestfs_umount_all (g);
10548     if (r == -1)
10549       return -1;
10550   }
10551   {
10552     int r;
10553     suppress_error = 0;
10554     r = guestfs_lvm_remove_all (g);
10555     if (r == -1)
10556       return -1;
10557   }
10558   {
10559     char device[] = "/dev/sda";
10560     device[5] = devchar;
10561     char lines_0[] = ",";
10562     char *lines[] = {
10563       lines_0,
10564       NULL
10565     };
10566     int r;
10567     suppress_error = 0;
10568     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10569     if (r == -1)
10570       return -1;
10571   }
10572   {
10573     char fstype[] = "ext2";
10574     char device[] = "/dev/sda1";
10575     device[5] = devchar;
10576     int r;
10577     suppress_error = 0;
10578     r = guestfs_mkfs (g, fstype, device);
10579     if (r == -1)
10580       return -1;
10581   }
10582   {
10583     char device[] = "/dev/sda1";
10584     device[5] = devchar;
10585     char mountpoint[] = "/";
10586     int r;
10587     suppress_error = 0;
10588     r = guestfs_mount (g, device, mountpoint);
10589     if (r == -1)
10590       return -1;
10591   }
10592   /* TestOutputFalse for is_file (1) */
10593   {
10594     char path[] = "/new";
10595     int r;
10596     suppress_error = 0;
10597     r = guestfs_mkdir (g, path);
10598     if (r == -1)
10599       return -1;
10600   }
10601   {
10602     char path[] = "/new";
10603     int r;
10604     suppress_error = 0;
10605     r = guestfs_is_file (g, path);
10606     if (r == -1)
10607       return -1;
10608     if (r) {
10609       fprintf (stderr, "test_is_file_1: expected false, got true\n");
10610       return -1;
10611     }
10612   }
10613   return 0;
10614 }
10615
10616 static int test_exists_0 (void)
10617 {
10618   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
10619   {
10620     char device[] = "/dev/sda";
10621     device[5] = devchar;
10622     int r;
10623     suppress_error = 0;
10624     r = guestfs_blockdev_setrw (g, device);
10625     if (r == -1)
10626       return -1;
10627   }
10628   {
10629     int r;
10630     suppress_error = 0;
10631     r = guestfs_umount_all (g);
10632     if (r == -1)
10633       return -1;
10634   }
10635   {
10636     int r;
10637     suppress_error = 0;
10638     r = guestfs_lvm_remove_all (g);
10639     if (r == -1)
10640       return -1;
10641   }
10642   {
10643     char device[] = "/dev/sda";
10644     device[5] = devchar;
10645     char lines_0[] = ",";
10646     char *lines[] = {
10647       lines_0,
10648       NULL
10649     };
10650     int r;
10651     suppress_error = 0;
10652     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10653     if (r == -1)
10654       return -1;
10655   }
10656   {
10657     char fstype[] = "ext2";
10658     char device[] = "/dev/sda1";
10659     device[5] = devchar;
10660     int r;
10661     suppress_error = 0;
10662     r = guestfs_mkfs (g, fstype, device);
10663     if (r == -1)
10664       return -1;
10665   }
10666   {
10667     char device[] = "/dev/sda1";
10668     device[5] = devchar;
10669     char mountpoint[] = "/";
10670     int r;
10671     suppress_error = 0;
10672     r = guestfs_mount (g, device, mountpoint);
10673     if (r == -1)
10674       return -1;
10675   }
10676   /* TestOutputTrue for exists (0) */
10677   {
10678     char path[] = "/new";
10679     int r;
10680     suppress_error = 0;
10681     r = guestfs_touch (g, path);
10682     if (r == -1)
10683       return -1;
10684   }
10685   {
10686     char path[] = "/new";
10687     int r;
10688     suppress_error = 0;
10689     r = guestfs_exists (g, path);
10690     if (r == -1)
10691       return -1;
10692     if (!r) {
10693       fprintf (stderr, "test_exists_0: expected true, got false\n");
10694       return -1;
10695     }
10696   }
10697   return 0;
10698 }
10699
10700 static int test_exists_1 (void)
10701 {
10702   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
10703   {
10704     char device[] = "/dev/sda";
10705     device[5] = devchar;
10706     int r;
10707     suppress_error = 0;
10708     r = guestfs_blockdev_setrw (g, device);
10709     if (r == -1)
10710       return -1;
10711   }
10712   {
10713     int r;
10714     suppress_error = 0;
10715     r = guestfs_umount_all (g);
10716     if (r == -1)
10717       return -1;
10718   }
10719   {
10720     int r;
10721     suppress_error = 0;
10722     r = guestfs_lvm_remove_all (g);
10723     if (r == -1)
10724       return -1;
10725   }
10726   {
10727     char device[] = "/dev/sda";
10728     device[5] = devchar;
10729     char lines_0[] = ",";
10730     char *lines[] = {
10731       lines_0,
10732       NULL
10733     };
10734     int r;
10735     suppress_error = 0;
10736     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10737     if (r == -1)
10738       return -1;
10739   }
10740   {
10741     char fstype[] = "ext2";
10742     char device[] = "/dev/sda1";
10743     device[5] = devchar;
10744     int r;
10745     suppress_error = 0;
10746     r = guestfs_mkfs (g, fstype, device);
10747     if (r == -1)
10748       return -1;
10749   }
10750   {
10751     char device[] = "/dev/sda1";
10752     device[5] = devchar;
10753     char mountpoint[] = "/";
10754     int r;
10755     suppress_error = 0;
10756     r = guestfs_mount (g, device, mountpoint);
10757     if (r == -1)
10758       return -1;
10759   }
10760   /* TestOutputTrue for exists (1) */
10761   {
10762     char path[] = "/new";
10763     int r;
10764     suppress_error = 0;
10765     r = guestfs_mkdir (g, path);
10766     if (r == -1)
10767       return -1;
10768   }
10769   {
10770     char path[] = "/new";
10771     int r;
10772     suppress_error = 0;
10773     r = guestfs_exists (g, path);
10774     if (r == -1)
10775       return -1;
10776     if (!r) {
10777       fprintf (stderr, "test_exists_1: expected true, got false\n");
10778       return -1;
10779     }
10780   }
10781   return 0;
10782 }
10783
10784 static int test_mkdir_p_0 (void)
10785 {
10786   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
10787   {
10788     char device[] = "/dev/sda";
10789     device[5] = devchar;
10790     int r;
10791     suppress_error = 0;
10792     r = guestfs_blockdev_setrw (g, device);
10793     if (r == -1)
10794       return -1;
10795   }
10796   {
10797     int r;
10798     suppress_error = 0;
10799     r = guestfs_umount_all (g);
10800     if (r == -1)
10801       return -1;
10802   }
10803   {
10804     int r;
10805     suppress_error = 0;
10806     r = guestfs_lvm_remove_all (g);
10807     if (r == -1)
10808       return -1;
10809   }
10810   {
10811     char device[] = "/dev/sda";
10812     device[5] = devchar;
10813     char lines_0[] = ",";
10814     char *lines[] = {
10815       lines_0,
10816       NULL
10817     };
10818     int r;
10819     suppress_error = 0;
10820     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10821     if (r == -1)
10822       return -1;
10823   }
10824   {
10825     char fstype[] = "ext2";
10826     char device[] = "/dev/sda1";
10827     device[5] = devchar;
10828     int r;
10829     suppress_error = 0;
10830     r = guestfs_mkfs (g, fstype, device);
10831     if (r == -1)
10832       return -1;
10833   }
10834   {
10835     char device[] = "/dev/sda1";
10836     device[5] = devchar;
10837     char mountpoint[] = "/";
10838     int r;
10839     suppress_error = 0;
10840     r = guestfs_mount (g, device, mountpoint);
10841     if (r == -1)
10842       return -1;
10843   }
10844   /* TestOutputTrue for mkdir_p (0) */
10845   {
10846     char path[] = "/new/foo/bar";
10847     int r;
10848     suppress_error = 0;
10849     r = guestfs_mkdir_p (g, path);
10850     if (r == -1)
10851       return -1;
10852   }
10853   {
10854     char path[] = "/new/foo/bar";
10855     int r;
10856     suppress_error = 0;
10857     r = guestfs_is_dir (g, path);
10858     if (r == -1)
10859       return -1;
10860     if (!r) {
10861       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10862       return -1;
10863     }
10864   }
10865   return 0;
10866 }
10867
10868 static int test_mkdir_p_1 (void)
10869 {
10870   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
10871   {
10872     char device[] = "/dev/sda";
10873     device[5] = devchar;
10874     int r;
10875     suppress_error = 0;
10876     r = guestfs_blockdev_setrw (g, device);
10877     if (r == -1)
10878       return -1;
10879   }
10880   {
10881     int r;
10882     suppress_error = 0;
10883     r = guestfs_umount_all (g);
10884     if (r == -1)
10885       return -1;
10886   }
10887   {
10888     int r;
10889     suppress_error = 0;
10890     r = guestfs_lvm_remove_all (g);
10891     if (r == -1)
10892       return -1;
10893   }
10894   {
10895     char device[] = "/dev/sda";
10896     device[5] = devchar;
10897     char lines_0[] = ",";
10898     char *lines[] = {
10899       lines_0,
10900       NULL
10901     };
10902     int r;
10903     suppress_error = 0;
10904     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10905     if (r == -1)
10906       return -1;
10907   }
10908   {
10909     char fstype[] = "ext2";
10910     char device[] = "/dev/sda1";
10911     device[5] = devchar;
10912     int r;
10913     suppress_error = 0;
10914     r = guestfs_mkfs (g, fstype, device);
10915     if (r == -1)
10916       return -1;
10917   }
10918   {
10919     char device[] = "/dev/sda1";
10920     device[5] = devchar;
10921     char mountpoint[] = "/";
10922     int r;
10923     suppress_error = 0;
10924     r = guestfs_mount (g, device, mountpoint);
10925     if (r == -1)
10926       return -1;
10927   }
10928   /* TestOutputTrue for mkdir_p (1) */
10929   {
10930     char path[] = "/new/foo/bar";
10931     int r;
10932     suppress_error = 0;
10933     r = guestfs_mkdir_p (g, path);
10934     if (r == -1)
10935       return -1;
10936   }
10937   {
10938     char path[] = "/new/foo";
10939     int r;
10940     suppress_error = 0;
10941     r = guestfs_is_dir (g, path);
10942     if (r == -1)
10943       return -1;
10944     if (!r) {
10945       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10946       return -1;
10947     }
10948   }
10949   return 0;
10950 }
10951
10952 static int test_mkdir_p_2 (void)
10953 {
10954   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
10955   {
10956     char device[] = "/dev/sda";
10957     device[5] = devchar;
10958     int r;
10959     suppress_error = 0;
10960     r = guestfs_blockdev_setrw (g, device);
10961     if (r == -1)
10962       return -1;
10963   }
10964   {
10965     int r;
10966     suppress_error = 0;
10967     r = guestfs_umount_all (g);
10968     if (r == -1)
10969       return -1;
10970   }
10971   {
10972     int r;
10973     suppress_error = 0;
10974     r = guestfs_lvm_remove_all (g);
10975     if (r == -1)
10976       return -1;
10977   }
10978   {
10979     char device[] = "/dev/sda";
10980     device[5] = devchar;
10981     char lines_0[] = ",";
10982     char *lines[] = {
10983       lines_0,
10984       NULL
10985     };
10986     int r;
10987     suppress_error = 0;
10988     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10989     if (r == -1)
10990       return -1;
10991   }
10992   {
10993     char fstype[] = "ext2";
10994     char device[] = "/dev/sda1";
10995     device[5] = devchar;
10996     int r;
10997     suppress_error = 0;
10998     r = guestfs_mkfs (g, fstype, device);
10999     if (r == -1)
11000       return -1;
11001   }
11002   {
11003     char device[] = "/dev/sda1";
11004     device[5] = devchar;
11005     char mountpoint[] = "/";
11006     int r;
11007     suppress_error = 0;
11008     r = guestfs_mount (g, device, mountpoint);
11009     if (r == -1)
11010       return -1;
11011   }
11012   /* TestOutputTrue for mkdir_p (2) */
11013   {
11014     char path[] = "/new/foo/bar";
11015     int r;
11016     suppress_error = 0;
11017     r = guestfs_mkdir_p (g, path);
11018     if (r == -1)
11019       return -1;
11020   }
11021   {
11022     char path[] = "/new";
11023     int r;
11024     suppress_error = 0;
11025     r = guestfs_is_dir (g, path);
11026     if (r == -1)
11027       return -1;
11028     if (!r) {
11029       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
11030       return -1;
11031     }
11032   }
11033   return 0;
11034 }
11035
11036 static int test_mkdir_0 (void)
11037 {
11038   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
11039   {
11040     char device[] = "/dev/sda";
11041     device[5] = devchar;
11042     int r;
11043     suppress_error = 0;
11044     r = guestfs_blockdev_setrw (g, device);
11045     if (r == -1)
11046       return -1;
11047   }
11048   {
11049     int r;
11050     suppress_error = 0;
11051     r = guestfs_umount_all (g);
11052     if (r == -1)
11053       return -1;
11054   }
11055   {
11056     int r;
11057     suppress_error = 0;
11058     r = guestfs_lvm_remove_all (g);
11059     if (r == -1)
11060       return -1;
11061   }
11062   {
11063     char device[] = "/dev/sda";
11064     device[5] = devchar;
11065     char lines_0[] = ",";
11066     char *lines[] = {
11067       lines_0,
11068       NULL
11069     };
11070     int r;
11071     suppress_error = 0;
11072     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11073     if (r == -1)
11074       return -1;
11075   }
11076   {
11077     char fstype[] = "ext2";
11078     char device[] = "/dev/sda1";
11079     device[5] = devchar;
11080     int r;
11081     suppress_error = 0;
11082     r = guestfs_mkfs (g, fstype, device);
11083     if (r == -1)
11084       return -1;
11085   }
11086   {
11087     char device[] = "/dev/sda1";
11088     device[5] = devchar;
11089     char mountpoint[] = "/";
11090     int r;
11091     suppress_error = 0;
11092     r = guestfs_mount (g, device, mountpoint);
11093     if (r == -1)
11094       return -1;
11095   }
11096   /* TestOutputTrue for mkdir (0) */
11097   {
11098     char path[] = "/new";
11099     int r;
11100     suppress_error = 0;
11101     r = guestfs_mkdir (g, path);
11102     if (r == -1)
11103       return -1;
11104   }
11105   {
11106     char path[] = "/new";
11107     int r;
11108     suppress_error = 0;
11109     r = guestfs_is_dir (g, path);
11110     if (r == -1)
11111       return -1;
11112     if (!r) {
11113       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
11114       return -1;
11115     }
11116   }
11117   return 0;
11118 }
11119
11120 static int test_mkdir_1 (void)
11121 {
11122   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
11123   {
11124     char device[] = "/dev/sda";
11125     device[5] = devchar;
11126     int r;
11127     suppress_error = 0;
11128     r = guestfs_blockdev_setrw (g, device);
11129     if (r == -1)
11130       return -1;
11131   }
11132   {
11133     int r;
11134     suppress_error = 0;
11135     r = guestfs_umount_all (g);
11136     if (r == -1)
11137       return -1;
11138   }
11139   {
11140     int r;
11141     suppress_error = 0;
11142     r = guestfs_lvm_remove_all (g);
11143     if (r == -1)
11144       return -1;
11145   }
11146   {
11147     char device[] = "/dev/sda";
11148     device[5] = devchar;
11149     char lines_0[] = ",";
11150     char *lines[] = {
11151       lines_0,
11152       NULL
11153     };
11154     int r;
11155     suppress_error = 0;
11156     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11157     if (r == -1)
11158       return -1;
11159   }
11160   {
11161     char fstype[] = "ext2";
11162     char device[] = "/dev/sda1";
11163     device[5] = devchar;
11164     int r;
11165     suppress_error = 0;
11166     r = guestfs_mkfs (g, fstype, device);
11167     if (r == -1)
11168       return -1;
11169   }
11170   {
11171     char device[] = "/dev/sda1";
11172     device[5] = devchar;
11173     char mountpoint[] = "/";
11174     int r;
11175     suppress_error = 0;
11176     r = guestfs_mount (g, device, mountpoint);
11177     if (r == -1)
11178       return -1;
11179   }
11180   /* TestLastFail for mkdir (1) */
11181   {
11182     char path[] = "/new/foo/bar";
11183     int r;
11184     suppress_error = 1;
11185     r = guestfs_mkdir (g, path);
11186     if (r != -1)
11187       return -1;
11188   }
11189   return 0;
11190 }
11191
11192 static int test_rm_rf_0 (void)
11193 {
11194   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
11195   {
11196     char device[] = "/dev/sda";
11197     device[5] = devchar;
11198     int r;
11199     suppress_error = 0;
11200     r = guestfs_blockdev_setrw (g, device);
11201     if (r == -1)
11202       return -1;
11203   }
11204   {
11205     int r;
11206     suppress_error = 0;
11207     r = guestfs_umount_all (g);
11208     if (r == -1)
11209       return -1;
11210   }
11211   {
11212     int r;
11213     suppress_error = 0;
11214     r = guestfs_lvm_remove_all (g);
11215     if (r == -1)
11216       return -1;
11217   }
11218   {
11219     char device[] = "/dev/sda";
11220     device[5] = devchar;
11221     char lines_0[] = ",";
11222     char *lines[] = {
11223       lines_0,
11224       NULL
11225     };
11226     int r;
11227     suppress_error = 0;
11228     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11229     if (r == -1)
11230       return -1;
11231   }
11232   {
11233     char fstype[] = "ext2";
11234     char device[] = "/dev/sda1";
11235     device[5] = devchar;
11236     int r;
11237     suppress_error = 0;
11238     r = guestfs_mkfs (g, fstype, device);
11239     if (r == -1)
11240       return -1;
11241   }
11242   {
11243     char device[] = "/dev/sda1";
11244     device[5] = devchar;
11245     char mountpoint[] = "/";
11246     int r;
11247     suppress_error = 0;
11248     r = guestfs_mount (g, device, mountpoint);
11249     if (r == -1)
11250       return -1;
11251   }
11252   /* TestOutputFalse for rm_rf (0) */
11253   {
11254     char path[] = "/new";
11255     int r;
11256     suppress_error = 0;
11257     r = guestfs_mkdir (g, path);
11258     if (r == -1)
11259       return -1;
11260   }
11261   {
11262     char path[] = "/new/foo";
11263     int r;
11264     suppress_error = 0;
11265     r = guestfs_mkdir (g, path);
11266     if (r == -1)
11267       return -1;
11268   }
11269   {
11270     char path[] = "/new/foo/bar";
11271     int r;
11272     suppress_error = 0;
11273     r = guestfs_touch (g, path);
11274     if (r == -1)
11275       return -1;
11276   }
11277   {
11278     char path[] = "/new";
11279     int r;
11280     suppress_error = 0;
11281     r = guestfs_rm_rf (g, path);
11282     if (r == -1)
11283       return -1;
11284   }
11285   {
11286     char path[] = "/new";
11287     int r;
11288     suppress_error = 0;
11289     r = guestfs_exists (g, path);
11290     if (r == -1)
11291       return -1;
11292     if (r) {
11293       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
11294       return -1;
11295     }
11296   }
11297   return 0;
11298 }
11299
11300 static int test_rmdir_0 (void)
11301 {
11302   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
11303   {
11304     char device[] = "/dev/sda";
11305     device[5] = devchar;
11306     int r;
11307     suppress_error = 0;
11308     r = guestfs_blockdev_setrw (g, device);
11309     if (r == -1)
11310       return -1;
11311   }
11312   {
11313     int r;
11314     suppress_error = 0;
11315     r = guestfs_umount_all (g);
11316     if (r == -1)
11317       return -1;
11318   }
11319   {
11320     int r;
11321     suppress_error = 0;
11322     r = guestfs_lvm_remove_all (g);
11323     if (r == -1)
11324       return -1;
11325   }
11326   {
11327     char device[] = "/dev/sda";
11328     device[5] = devchar;
11329     char lines_0[] = ",";
11330     char *lines[] = {
11331       lines_0,
11332       NULL
11333     };
11334     int r;
11335     suppress_error = 0;
11336     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11337     if (r == -1)
11338       return -1;
11339   }
11340   {
11341     char fstype[] = "ext2";
11342     char device[] = "/dev/sda1";
11343     device[5] = devchar;
11344     int r;
11345     suppress_error = 0;
11346     r = guestfs_mkfs (g, fstype, device);
11347     if (r == -1)
11348       return -1;
11349   }
11350   {
11351     char device[] = "/dev/sda1";
11352     device[5] = devchar;
11353     char mountpoint[] = "/";
11354     int r;
11355     suppress_error = 0;
11356     r = guestfs_mount (g, device, mountpoint);
11357     if (r == -1)
11358       return -1;
11359   }
11360   /* TestRun for rmdir (0) */
11361   {
11362     char path[] = "/new";
11363     int r;
11364     suppress_error = 0;
11365     r = guestfs_mkdir (g, path);
11366     if (r == -1)
11367       return -1;
11368   }
11369   {
11370     char path[] = "/new";
11371     int r;
11372     suppress_error = 0;
11373     r = guestfs_rmdir (g, path);
11374     if (r == -1)
11375       return -1;
11376   }
11377   return 0;
11378 }
11379
11380 static int test_rmdir_1 (void)
11381 {
11382   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
11383   {
11384     char device[] = "/dev/sda";
11385     device[5] = devchar;
11386     int r;
11387     suppress_error = 0;
11388     r = guestfs_blockdev_setrw (g, device);
11389     if (r == -1)
11390       return -1;
11391   }
11392   {
11393     int r;
11394     suppress_error = 0;
11395     r = guestfs_umount_all (g);
11396     if (r == -1)
11397       return -1;
11398   }
11399   {
11400     int r;
11401     suppress_error = 0;
11402     r = guestfs_lvm_remove_all (g);
11403     if (r == -1)
11404       return -1;
11405   }
11406   {
11407     char device[] = "/dev/sda";
11408     device[5] = devchar;
11409     char lines_0[] = ",";
11410     char *lines[] = {
11411       lines_0,
11412       NULL
11413     };
11414     int r;
11415     suppress_error = 0;
11416     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11417     if (r == -1)
11418       return -1;
11419   }
11420   {
11421     char fstype[] = "ext2";
11422     char device[] = "/dev/sda1";
11423     device[5] = devchar;
11424     int r;
11425     suppress_error = 0;
11426     r = guestfs_mkfs (g, fstype, device);
11427     if (r == -1)
11428       return -1;
11429   }
11430   {
11431     char device[] = "/dev/sda1";
11432     device[5] = devchar;
11433     char mountpoint[] = "/";
11434     int r;
11435     suppress_error = 0;
11436     r = guestfs_mount (g, device, mountpoint);
11437     if (r == -1)
11438       return -1;
11439   }
11440   /* TestLastFail for rmdir (1) */
11441   {
11442     char path[] = "/new";
11443     int r;
11444     suppress_error = 1;
11445     r = guestfs_rmdir (g, path);
11446     if (r != -1)
11447       return -1;
11448   }
11449   return 0;
11450 }
11451
11452 static int test_rmdir_2 (void)
11453 {
11454   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
11455   {
11456     char device[] = "/dev/sda";
11457     device[5] = devchar;
11458     int r;
11459     suppress_error = 0;
11460     r = guestfs_blockdev_setrw (g, device);
11461     if (r == -1)
11462       return -1;
11463   }
11464   {
11465     int r;
11466     suppress_error = 0;
11467     r = guestfs_umount_all (g);
11468     if (r == -1)
11469       return -1;
11470   }
11471   {
11472     int r;
11473     suppress_error = 0;
11474     r = guestfs_lvm_remove_all (g);
11475     if (r == -1)
11476       return -1;
11477   }
11478   {
11479     char device[] = "/dev/sda";
11480     device[5] = devchar;
11481     char lines_0[] = ",";
11482     char *lines[] = {
11483       lines_0,
11484       NULL
11485     };
11486     int r;
11487     suppress_error = 0;
11488     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11489     if (r == -1)
11490       return -1;
11491   }
11492   {
11493     char fstype[] = "ext2";
11494     char device[] = "/dev/sda1";
11495     device[5] = devchar;
11496     int r;
11497     suppress_error = 0;
11498     r = guestfs_mkfs (g, fstype, device);
11499     if (r == -1)
11500       return -1;
11501   }
11502   {
11503     char device[] = "/dev/sda1";
11504     device[5] = devchar;
11505     char mountpoint[] = "/";
11506     int r;
11507     suppress_error = 0;
11508     r = guestfs_mount (g, device, mountpoint);
11509     if (r == -1)
11510       return -1;
11511   }
11512   /* TestLastFail for rmdir (2) */
11513   {
11514     char path[] = "/new";
11515     int r;
11516     suppress_error = 0;
11517     r = guestfs_touch (g, path);
11518     if (r == -1)
11519       return -1;
11520   }
11521   {
11522     char path[] = "/new";
11523     int r;
11524     suppress_error = 1;
11525     r = guestfs_rmdir (g, path);
11526     if (r != -1)
11527       return -1;
11528   }
11529   return 0;
11530 }
11531
11532 static int test_rm_0 (void)
11533 {
11534   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
11535   {
11536     char device[] = "/dev/sda";
11537     device[5] = devchar;
11538     int r;
11539     suppress_error = 0;
11540     r = guestfs_blockdev_setrw (g, device);
11541     if (r == -1)
11542       return -1;
11543   }
11544   {
11545     int r;
11546     suppress_error = 0;
11547     r = guestfs_umount_all (g);
11548     if (r == -1)
11549       return -1;
11550   }
11551   {
11552     int r;
11553     suppress_error = 0;
11554     r = guestfs_lvm_remove_all (g);
11555     if (r == -1)
11556       return -1;
11557   }
11558   {
11559     char device[] = "/dev/sda";
11560     device[5] = devchar;
11561     char lines_0[] = ",";
11562     char *lines[] = {
11563       lines_0,
11564       NULL
11565     };
11566     int r;
11567     suppress_error = 0;
11568     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11569     if (r == -1)
11570       return -1;
11571   }
11572   {
11573     char fstype[] = "ext2";
11574     char device[] = "/dev/sda1";
11575     device[5] = devchar;
11576     int r;
11577     suppress_error = 0;
11578     r = guestfs_mkfs (g, fstype, device);
11579     if (r == -1)
11580       return -1;
11581   }
11582   {
11583     char device[] = "/dev/sda1";
11584     device[5] = devchar;
11585     char mountpoint[] = "/";
11586     int r;
11587     suppress_error = 0;
11588     r = guestfs_mount (g, device, mountpoint);
11589     if (r == -1)
11590       return -1;
11591   }
11592   /* TestRun for rm (0) */
11593   {
11594     char path[] = "/new";
11595     int r;
11596     suppress_error = 0;
11597     r = guestfs_touch (g, path);
11598     if (r == -1)
11599       return -1;
11600   }
11601   {
11602     char path[] = "/new";
11603     int r;
11604     suppress_error = 0;
11605     r = guestfs_rm (g, path);
11606     if (r == -1)
11607       return -1;
11608   }
11609   return 0;
11610 }
11611
11612 static int test_rm_1 (void)
11613 {
11614   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
11615   {
11616     char device[] = "/dev/sda";
11617     device[5] = devchar;
11618     int r;
11619     suppress_error = 0;
11620     r = guestfs_blockdev_setrw (g, device);
11621     if (r == -1)
11622       return -1;
11623   }
11624   {
11625     int r;
11626     suppress_error = 0;
11627     r = guestfs_umount_all (g);
11628     if (r == -1)
11629       return -1;
11630   }
11631   {
11632     int r;
11633     suppress_error = 0;
11634     r = guestfs_lvm_remove_all (g);
11635     if (r == -1)
11636       return -1;
11637   }
11638   {
11639     char device[] = "/dev/sda";
11640     device[5] = devchar;
11641     char lines_0[] = ",";
11642     char *lines[] = {
11643       lines_0,
11644       NULL
11645     };
11646     int r;
11647     suppress_error = 0;
11648     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11649     if (r == -1)
11650       return -1;
11651   }
11652   {
11653     char fstype[] = "ext2";
11654     char device[] = "/dev/sda1";
11655     device[5] = devchar;
11656     int r;
11657     suppress_error = 0;
11658     r = guestfs_mkfs (g, fstype, device);
11659     if (r == -1)
11660       return -1;
11661   }
11662   {
11663     char device[] = "/dev/sda1";
11664     device[5] = devchar;
11665     char mountpoint[] = "/";
11666     int r;
11667     suppress_error = 0;
11668     r = guestfs_mount (g, device, mountpoint);
11669     if (r == -1)
11670       return -1;
11671   }
11672   /* TestLastFail for rm (1) */
11673   {
11674     char path[] = "/new";
11675     int r;
11676     suppress_error = 1;
11677     r = guestfs_rm (g, path);
11678     if (r != -1)
11679       return -1;
11680   }
11681   return 0;
11682 }
11683
11684 static int test_rm_2 (void)
11685 {
11686   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
11687   {
11688     char device[] = "/dev/sda";
11689     device[5] = devchar;
11690     int r;
11691     suppress_error = 0;
11692     r = guestfs_blockdev_setrw (g, device);
11693     if (r == -1)
11694       return -1;
11695   }
11696   {
11697     int r;
11698     suppress_error = 0;
11699     r = guestfs_umount_all (g);
11700     if (r == -1)
11701       return -1;
11702   }
11703   {
11704     int r;
11705     suppress_error = 0;
11706     r = guestfs_lvm_remove_all (g);
11707     if (r == -1)
11708       return -1;
11709   }
11710   {
11711     char device[] = "/dev/sda";
11712     device[5] = devchar;
11713     char lines_0[] = ",";
11714     char *lines[] = {
11715       lines_0,
11716       NULL
11717     };
11718     int r;
11719     suppress_error = 0;
11720     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11721     if (r == -1)
11722       return -1;
11723   }
11724   {
11725     char fstype[] = "ext2";
11726     char device[] = "/dev/sda1";
11727     device[5] = devchar;
11728     int r;
11729     suppress_error = 0;
11730     r = guestfs_mkfs (g, fstype, device);
11731     if (r == -1)
11732       return -1;
11733   }
11734   {
11735     char device[] = "/dev/sda1";
11736     device[5] = devchar;
11737     char mountpoint[] = "/";
11738     int r;
11739     suppress_error = 0;
11740     r = guestfs_mount (g, device, mountpoint);
11741     if (r == -1)
11742       return -1;
11743   }
11744   /* TestLastFail for rm (2) */
11745   {
11746     char path[] = "/new";
11747     int r;
11748     suppress_error = 0;
11749     r = guestfs_mkdir (g, path);
11750     if (r == -1)
11751       return -1;
11752   }
11753   {
11754     char path[] = "/new";
11755     int r;
11756     suppress_error = 1;
11757     r = guestfs_rm (g, path);
11758     if (r != -1)
11759       return -1;
11760   }
11761   return 0;
11762 }
11763
11764 static int test_read_lines_0 (void)
11765 {
11766   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
11767   {
11768     char device[] = "/dev/sda";
11769     device[5] = devchar;
11770     int r;
11771     suppress_error = 0;
11772     r = guestfs_blockdev_setrw (g, device);
11773     if (r == -1)
11774       return -1;
11775   }
11776   {
11777     int r;
11778     suppress_error = 0;
11779     r = guestfs_umount_all (g);
11780     if (r == -1)
11781       return -1;
11782   }
11783   {
11784     int r;
11785     suppress_error = 0;
11786     r = guestfs_lvm_remove_all (g);
11787     if (r == -1)
11788       return -1;
11789   }
11790   {
11791     char device[] = "/dev/sda";
11792     device[5] = devchar;
11793     char lines_0[] = ",";
11794     char *lines[] = {
11795       lines_0,
11796       NULL
11797     };
11798     int r;
11799     suppress_error = 0;
11800     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11801     if (r == -1)
11802       return -1;
11803   }
11804   {
11805     char fstype[] = "ext2";
11806     char device[] = "/dev/sda1";
11807     device[5] = devchar;
11808     int r;
11809     suppress_error = 0;
11810     r = guestfs_mkfs (g, fstype, device);
11811     if (r == -1)
11812       return -1;
11813   }
11814   {
11815     char device[] = "/dev/sda1";
11816     device[5] = devchar;
11817     char mountpoint[] = "/";
11818     int r;
11819     suppress_error = 0;
11820     r = guestfs_mount (g, device, mountpoint);
11821     if (r == -1)
11822       return -1;
11823   }
11824   /* TestOutputList for read_lines (0) */
11825   {
11826     char path[] = "/new";
11827     char content[] = "line1\r\nline2\nline3";
11828     int r;
11829     suppress_error = 0;
11830     r = guestfs_write_file (g, path, content, 0);
11831     if (r == -1)
11832       return -1;
11833   }
11834   {
11835     char path[] = "/new";
11836     char **r;
11837     int i;
11838     suppress_error = 0;
11839     r = guestfs_read_lines (g, path);
11840     if (r == NULL)
11841       return -1;
11842     if (!r[0]) {
11843       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11844       print_strings (r);
11845       return -1;
11846     }
11847     {
11848       char expected[] = "line1";
11849       if (strcmp (r[0], expected) != 0) {
11850         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11851         return -1;
11852       }
11853     }
11854     if (!r[1]) {
11855       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11856       print_strings (r);
11857       return -1;
11858     }
11859     {
11860       char expected[] = "line2";
11861       if (strcmp (r[1], expected) != 0) {
11862         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11863         return -1;
11864       }
11865     }
11866     if (!r[2]) {
11867       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11868       print_strings (r);
11869       return -1;
11870     }
11871     {
11872       char expected[] = "line3";
11873       if (strcmp (r[2], expected) != 0) {
11874         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11875         return -1;
11876       }
11877     }
11878     if (r[3] != NULL) {
11879       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11880       print_strings (r);
11881       return -1;
11882     }
11883     for (i = 0; r[i] != NULL; ++i)
11884       free (r[i]);
11885     free (r);
11886   }
11887   return 0;
11888 }
11889
11890 static int test_read_lines_1 (void)
11891 {
11892   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
11893   {
11894     char device[] = "/dev/sda";
11895     device[5] = devchar;
11896     int r;
11897     suppress_error = 0;
11898     r = guestfs_blockdev_setrw (g, device);
11899     if (r == -1)
11900       return -1;
11901   }
11902   {
11903     int r;
11904     suppress_error = 0;
11905     r = guestfs_umount_all (g);
11906     if (r == -1)
11907       return -1;
11908   }
11909   {
11910     int r;
11911     suppress_error = 0;
11912     r = guestfs_lvm_remove_all (g);
11913     if (r == -1)
11914       return -1;
11915   }
11916   {
11917     char device[] = "/dev/sda";
11918     device[5] = devchar;
11919     char lines_0[] = ",";
11920     char *lines[] = {
11921       lines_0,
11922       NULL
11923     };
11924     int r;
11925     suppress_error = 0;
11926     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11927     if (r == -1)
11928       return -1;
11929   }
11930   {
11931     char fstype[] = "ext2";
11932     char device[] = "/dev/sda1";
11933     device[5] = devchar;
11934     int r;
11935     suppress_error = 0;
11936     r = guestfs_mkfs (g, fstype, device);
11937     if (r == -1)
11938       return -1;
11939   }
11940   {
11941     char device[] = "/dev/sda1";
11942     device[5] = devchar;
11943     char mountpoint[] = "/";
11944     int r;
11945     suppress_error = 0;
11946     r = guestfs_mount (g, device, mountpoint);
11947     if (r == -1)
11948       return -1;
11949   }
11950   /* TestOutputList for read_lines (1) */
11951   {
11952     char path[] = "/new";
11953     char content[] = "";
11954     int r;
11955     suppress_error = 0;
11956     r = guestfs_write_file (g, path, content, 0);
11957     if (r == -1)
11958       return -1;
11959   }
11960   {
11961     char path[] = "/new";
11962     char **r;
11963     int i;
11964     suppress_error = 0;
11965     r = guestfs_read_lines (g, path);
11966     if (r == NULL)
11967       return -1;
11968     if (r[0] != NULL) {
11969       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11970       print_strings (r);
11971       return -1;
11972     }
11973     for (i = 0; r[i] != NULL; ++i)
11974       free (r[i]);
11975     free (r);
11976   }
11977   return 0;
11978 }
11979
11980 static int test_lvs_0 (void)
11981 {
11982   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
11983   {
11984     char device[] = "/dev/sda";
11985     device[5] = devchar;
11986     int r;
11987     suppress_error = 0;
11988     r = guestfs_blockdev_setrw (g, device);
11989     if (r == -1)
11990       return -1;
11991   }
11992   {
11993     int r;
11994     suppress_error = 0;
11995     r = guestfs_umount_all (g);
11996     if (r == -1)
11997       return -1;
11998   }
11999   {
12000     int r;
12001     suppress_error = 0;
12002     r = guestfs_lvm_remove_all (g);
12003     if (r == -1)
12004       return -1;
12005   }
12006   {
12007     char device[] = "/dev/sda";
12008     device[5] = devchar;
12009     char lines_0[] = ",";
12010     char *lines[] = {
12011       lines_0,
12012       NULL
12013     };
12014     int r;
12015     suppress_error = 0;
12016     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12017     if (r == -1)
12018       return -1;
12019   }
12020   {
12021     char device[] = "/dev/sda1";
12022     device[5] = devchar;
12023     int r;
12024     suppress_error = 0;
12025     r = guestfs_pvcreate (g, device);
12026     if (r == -1)
12027       return -1;
12028   }
12029   {
12030     char volgroup[] = "VG";
12031     char physvols_0[] = "/dev/sda1";
12032     physvols_0[5] = devchar;
12033     char *physvols[] = {
12034       physvols_0,
12035       NULL
12036     };
12037     int r;
12038     suppress_error = 0;
12039     r = guestfs_vgcreate (g, volgroup, physvols);
12040     if (r == -1)
12041       return -1;
12042   }
12043   {
12044     char logvol[] = "LV";
12045     char volgroup[] = "VG";
12046     int r;
12047     suppress_error = 0;
12048     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12049     if (r == -1)
12050       return -1;
12051   }
12052   {
12053     char fstype[] = "ext2";
12054     char device[] = "/dev/VG/LV";
12055     int r;
12056     suppress_error = 0;
12057     r = guestfs_mkfs (g, fstype, device);
12058     if (r == -1)
12059       return -1;
12060   }
12061   {
12062     char device[] = "/dev/VG/LV";
12063     char mountpoint[] = "/";
12064     int r;
12065     suppress_error = 0;
12066     r = guestfs_mount (g, device, mountpoint);
12067     if (r == -1)
12068       return -1;
12069   }
12070   /* TestOutputList for lvs (0) */
12071   {
12072     char **r;
12073     int i;
12074     suppress_error = 0;
12075     r = guestfs_lvs (g);
12076     if (r == NULL)
12077       return -1;
12078     if (!r[0]) {
12079       fprintf (stderr, "test_lvs_0: short list returned from command\n");
12080       print_strings (r);
12081       return -1;
12082     }
12083     {
12084       char expected[] = "/dev/VG/LV";
12085       if (strcmp (r[0], expected) != 0) {
12086         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12087         return -1;
12088       }
12089     }
12090     if (r[1] != NULL) {
12091       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
12092       print_strings (r);
12093       return -1;
12094     }
12095     for (i = 0; r[i] != NULL; ++i)
12096       free (r[i]);
12097     free (r);
12098   }
12099   return 0;
12100 }
12101
12102 static int test_lvs_1 (void)
12103 {
12104   /* InitNone|InitEmpty for test_lvs_1 */
12105   {
12106     char device[] = "/dev/sda";
12107     device[5] = devchar;
12108     int r;
12109     suppress_error = 0;
12110     r = guestfs_blockdev_setrw (g, device);
12111     if (r == -1)
12112       return -1;
12113   }
12114   {
12115     int r;
12116     suppress_error = 0;
12117     r = guestfs_umount_all (g);
12118     if (r == -1)
12119       return -1;
12120   }
12121   {
12122     int r;
12123     suppress_error = 0;
12124     r = guestfs_lvm_remove_all (g);
12125     if (r == -1)
12126       return -1;
12127   }
12128   /* TestOutputList for lvs (1) */
12129   {
12130     char device[] = "/dev/sda";
12131     device[5] = devchar;
12132     char lines_0[] = ",10";
12133     char lines_1[] = ",20";
12134     char lines_2[] = ",";
12135     char *lines[] = {
12136       lines_0,
12137       lines_1,
12138       lines_2,
12139       NULL
12140     };
12141     int r;
12142     suppress_error = 0;
12143     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12144     if (r == -1)
12145       return -1;
12146   }
12147   {
12148     char device[] = "/dev/sda1";
12149     device[5] = devchar;
12150     int r;
12151     suppress_error = 0;
12152     r = guestfs_pvcreate (g, device);
12153     if (r == -1)
12154       return -1;
12155   }
12156   {
12157     char device[] = "/dev/sda2";
12158     device[5] = devchar;
12159     int r;
12160     suppress_error = 0;
12161     r = guestfs_pvcreate (g, device);
12162     if (r == -1)
12163       return -1;
12164   }
12165   {
12166     char device[] = "/dev/sda3";
12167     device[5] = devchar;
12168     int r;
12169     suppress_error = 0;
12170     r = guestfs_pvcreate (g, device);
12171     if (r == -1)
12172       return -1;
12173   }
12174   {
12175     char volgroup[] = "VG1";
12176     char physvols_0[] = "/dev/sda1";
12177     physvols_0[5] = devchar;
12178     char physvols_1[] = "/dev/sda2";
12179     physvols_1[5] = devchar;
12180     char *physvols[] = {
12181       physvols_0,
12182       physvols_1,
12183       NULL
12184     };
12185     int r;
12186     suppress_error = 0;
12187     r = guestfs_vgcreate (g, volgroup, physvols);
12188     if (r == -1)
12189       return -1;
12190   }
12191   {
12192     char volgroup[] = "VG2";
12193     char physvols_0[] = "/dev/sda3";
12194     physvols_0[5] = devchar;
12195     char *physvols[] = {
12196       physvols_0,
12197       NULL
12198     };
12199     int r;
12200     suppress_error = 0;
12201     r = guestfs_vgcreate (g, volgroup, physvols);
12202     if (r == -1)
12203       return -1;
12204   }
12205   {
12206     char logvol[] = "LV1";
12207     char volgroup[] = "VG1";
12208     int r;
12209     suppress_error = 0;
12210     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12211     if (r == -1)
12212       return -1;
12213   }
12214   {
12215     char logvol[] = "LV2";
12216     char volgroup[] = "VG1";
12217     int r;
12218     suppress_error = 0;
12219     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12220     if (r == -1)
12221       return -1;
12222   }
12223   {
12224     char logvol[] = "LV3";
12225     char volgroup[] = "VG2";
12226     int r;
12227     suppress_error = 0;
12228     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12229     if (r == -1)
12230       return -1;
12231   }
12232   {
12233     char **r;
12234     int i;
12235     suppress_error = 0;
12236     r = guestfs_lvs (g);
12237     if (r == NULL)
12238       return -1;
12239     if (!r[0]) {
12240       fprintf (stderr, "test_lvs_1: short list returned from command\n");
12241       print_strings (r);
12242       return -1;
12243     }
12244     {
12245       char expected[] = "/dev/VG1/LV1";
12246       if (strcmp (r[0], expected) != 0) {
12247         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12248         return -1;
12249       }
12250     }
12251     if (!r[1]) {
12252       fprintf (stderr, "test_lvs_1: short list returned from command\n");
12253       print_strings (r);
12254       return -1;
12255     }
12256     {
12257       char expected[] = "/dev/VG1/LV2";
12258       if (strcmp (r[1], expected) != 0) {
12259         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12260         return -1;
12261       }
12262     }
12263     if (!r[2]) {
12264       fprintf (stderr, "test_lvs_1: short list returned from command\n");
12265       print_strings (r);
12266       return -1;
12267     }
12268     {
12269       char expected[] = "/dev/VG2/LV3";
12270       if (strcmp (r[2], expected) != 0) {
12271         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12272         return -1;
12273       }
12274     }
12275     if (r[3] != NULL) {
12276       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
12277       print_strings (r);
12278       return -1;
12279     }
12280     for (i = 0; r[i] != NULL; ++i)
12281       free (r[i]);
12282     free (r);
12283   }
12284   return 0;
12285 }
12286
12287 static int test_vgs_0 (void)
12288 {
12289   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
12290   {
12291     char device[] = "/dev/sda";
12292     device[5] = devchar;
12293     int r;
12294     suppress_error = 0;
12295     r = guestfs_blockdev_setrw (g, device);
12296     if (r == -1)
12297       return -1;
12298   }
12299   {
12300     int r;
12301     suppress_error = 0;
12302     r = guestfs_umount_all (g);
12303     if (r == -1)
12304       return -1;
12305   }
12306   {
12307     int r;
12308     suppress_error = 0;
12309     r = guestfs_lvm_remove_all (g);
12310     if (r == -1)
12311       return -1;
12312   }
12313   {
12314     char device[] = "/dev/sda";
12315     device[5] = devchar;
12316     char lines_0[] = ",";
12317     char *lines[] = {
12318       lines_0,
12319       NULL
12320     };
12321     int r;
12322     suppress_error = 0;
12323     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12324     if (r == -1)
12325       return -1;
12326   }
12327   {
12328     char device[] = "/dev/sda1";
12329     device[5] = devchar;
12330     int r;
12331     suppress_error = 0;
12332     r = guestfs_pvcreate (g, device);
12333     if (r == -1)
12334       return -1;
12335   }
12336   {
12337     char volgroup[] = "VG";
12338     char physvols_0[] = "/dev/sda1";
12339     physvols_0[5] = devchar;
12340     char *physvols[] = {
12341       physvols_0,
12342       NULL
12343     };
12344     int r;
12345     suppress_error = 0;
12346     r = guestfs_vgcreate (g, volgroup, physvols);
12347     if (r == -1)
12348       return -1;
12349   }
12350   {
12351     char logvol[] = "LV";
12352     char volgroup[] = "VG";
12353     int r;
12354     suppress_error = 0;
12355     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12356     if (r == -1)
12357       return -1;
12358   }
12359   {
12360     char fstype[] = "ext2";
12361     char device[] = "/dev/VG/LV";
12362     int r;
12363     suppress_error = 0;
12364     r = guestfs_mkfs (g, fstype, device);
12365     if (r == -1)
12366       return -1;
12367   }
12368   {
12369     char device[] = "/dev/VG/LV";
12370     char mountpoint[] = "/";
12371     int r;
12372     suppress_error = 0;
12373     r = guestfs_mount (g, device, mountpoint);
12374     if (r == -1)
12375       return -1;
12376   }
12377   /* TestOutputList for vgs (0) */
12378   {
12379     char **r;
12380     int i;
12381     suppress_error = 0;
12382     r = guestfs_vgs (g);
12383     if (r == NULL)
12384       return -1;
12385     if (!r[0]) {
12386       fprintf (stderr, "test_vgs_0: short list returned from command\n");
12387       print_strings (r);
12388       return -1;
12389     }
12390     {
12391       char expected[] = "VG";
12392       if (strcmp (r[0], expected) != 0) {
12393         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12394         return -1;
12395       }
12396     }
12397     if (r[1] != NULL) {
12398       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
12399       print_strings (r);
12400       return -1;
12401     }
12402     for (i = 0; r[i] != NULL; ++i)
12403       free (r[i]);
12404     free (r);
12405   }
12406   return 0;
12407 }
12408
12409 static int test_vgs_1 (void)
12410 {
12411   /* InitNone|InitEmpty for test_vgs_1 */
12412   {
12413     char device[] = "/dev/sda";
12414     device[5] = devchar;
12415     int r;
12416     suppress_error = 0;
12417     r = guestfs_blockdev_setrw (g, device);
12418     if (r == -1)
12419       return -1;
12420   }
12421   {
12422     int r;
12423     suppress_error = 0;
12424     r = guestfs_umount_all (g);
12425     if (r == -1)
12426       return -1;
12427   }
12428   {
12429     int r;
12430     suppress_error = 0;
12431     r = guestfs_lvm_remove_all (g);
12432     if (r == -1)
12433       return -1;
12434   }
12435   /* TestOutputList for vgs (1) */
12436   {
12437     char device[] = "/dev/sda";
12438     device[5] = devchar;
12439     char lines_0[] = ",10";
12440     char lines_1[] = ",20";
12441     char lines_2[] = ",";
12442     char *lines[] = {
12443       lines_0,
12444       lines_1,
12445       lines_2,
12446       NULL
12447     };
12448     int r;
12449     suppress_error = 0;
12450     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12451     if (r == -1)
12452       return -1;
12453   }
12454   {
12455     char device[] = "/dev/sda1";
12456     device[5] = devchar;
12457     int r;
12458     suppress_error = 0;
12459     r = guestfs_pvcreate (g, device);
12460     if (r == -1)
12461       return -1;
12462   }
12463   {
12464     char device[] = "/dev/sda2";
12465     device[5] = devchar;
12466     int r;
12467     suppress_error = 0;
12468     r = guestfs_pvcreate (g, device);
12469     if (r == -1)
12470       return -1;
12471   }
12472   {
12473     char device[] = "/dev/sda3";
12474     device[5] = devchar;
12475     int r;
12476     suppress_error = 0;
12477     r = guestfs_pvcreate (g, device);
12478     if (r == -1)
12479       return -1;
12480   }
12481   {
12482     char volgroup[] = "VG1";
12483     char physvols_0[] = "/dev/sda1";
12484     physvols_0[5] = devchar;
12485     char physvols_1[] = "/dev/sda2";
12486     physvols_1[5] = devchar;
12487     char *physvols[] = {
12488       physvols_0,
12489       physvols_1,
12490       NULL
12491     };
12492     int r;
12493     suppress_error = 0;
12494     r = guestfs_vgcreate (g, volgroup, physvols);
12495     if (r == -1)
12496       return -1;
12497   }
12498   {
12499     char volgroup[] = "VG2";
12500     char physvols_0[] = "/dev/sda3";
12501     physvols_0[5] = devchar;
12502     char *physvols[] = {
12503       physvols_0,
12504       NULL
12505     };
12506     int r;
12507     suppress_error = 0;
12508     r = guestfs_vgcreate (g, volgroup, physvols);
12509     if (r == -1)
12510       return -1;
12511   }
12512   {
12513     char **r;
12514     int i;
12515     suppress_error = 0;
12516     r = guestfs_vgs (g);
12517     if (r == NULL)
12518       return -1;
12519     if (!r[0]) {
12520       fprintf (stderr, "test_vgs_1: short list returned from command\n");
12521       print_strings (r);
12522       return -1;
12523     }
12524     {
12525       char expected[] = "VG1";
12526       if (strcmp (r[0], expected) != 0) {
12527         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12528         return -1;
12529       }
12530     }
12531     if (!r[1]) {
12532       fprintf (stderr, "test_vgs_1: short list returned from command\n");
12533       print_strings (r);
12534       return -1;
12535     }
12536     {
12537       char expected[] = "VG2";
12538       if (strcmp (r[1], expected) != 0) {
12539         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12540         return -1;
12541       }
12542     }
12543     if (r[2] != NULL) {
12544       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
12545       print_strings (r);
12546       return -1;
12547     }
12548     for (i = 0; r[i] != NULL; ++i)
12549       free (r[i]);
12550     free (r);
12551   }
12552   return 0;
12553 }
12554
12555 static int test_pvs_0 (void)
12556 {
12557   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
12558   {
12559     char device[] = "/dev/sda";
12560     device[5] = devchar;
12561     int r;
12562     suppress_error = 0;
12563     r = guestfs_blockdev_setrw (g, device);
12564     if (r == -1)
12565       return -1;
12566   }
12567   {
12568     int r;
12569     suppress_error = 0;
12570     r = guestfs_umount_all (g);
12571     if (r == -1)
12572       return -1;
12573   }
12574   {
12575     int r;
12576     suppress_error = 0;
12577     r = guestfs_lvm_remove_all (g);
12578     if (r == -1)
12579       return -1;
12580   }
12581   {
12582     char device[] = "/dev/sda";
12583     device[5] = devchar;
12584     char lines_0[] = ",";
12585     char *lines[] = {
12586       lines_0,
12587       NULL
12588     };
12589     int r;
12590     suppress_error = 0;
12591     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12592     if (r == -1)
12593       return -1;
12594   }
12595   {
12596     char device[] = "/dev/sda1";
12597     device[5] = devchar;
12598     int r;
12599     suppress_error = 0;
12600     r = guestfs_pvcreate (g, device);
12601     if (r == -1)
12602       return -1;
12603   }
12604   {
12605     char volgroup[] = "VG";
12606     char physvols_0[] = "/dev/sda1";
12607     physvols_0[5] = devchar;
12608     char *physvols[] = {
12609       physvols_0,
12610       NULL
12611     };
12612     int r;
12613     suppress_error = 0;
12614     r = guestfs_vgcreate (g, volgroup, physvols);
12615     if (r == -1)
12616       return -1;
12617   }
12618   {
12619     char logvol[] = "LV";
12620     char volgroup[] = "VG";
12621     int r;
12622     suppress_error = 0;
12623     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12624     if (r == -1)
12625       return -1;
12626   }
12627   {
12628     char fstype[] = "ext2";
12629     char device[] = "/dev/VG/LV";
12630     int r;
12631     suppress_error = 0;
12632     r = guestfs_mkfs (g, fstype, device);
12633     if (r == -1)
12634       return -1;
12635   }
12636   {
12637     char device[] = "/dev/VG/LV";
12638     char mountpoint[] = "/";
12639     int r;
12640     suppress_error = 0;
12641     r = guestfs_mount (g, device, mountpoint);
12642     if (r == -1)
12643       return -1;
12644   }
12645   /* TestOutputList for pvs (0) */
12646   {
12647     char **r;
12648     int i;
12649     suppress_error = 0;
12650     r = guestfs_pvs (g);
12651     if (r == NULL)
12652       return -1;
12653     if (!r[0]) {
12654       fprintf (stderr, "test_pvs_0: short list returned from command\n");
12655       print_strings (r);
12656       return -1;
12657     }
12658     {
12659       char expected[] = "/dev/sda1";
12660       expected[5] = devchar;
12661       if (strcmp (r[0], expected) != 0) {
12662         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12663         return -1;
12664       }
12665     }
12666     if (r[1] != NULL) {
12667       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12668       print_strings (r);
12669       return -1;
12670     }
12671     for (i = 0; r[i] != NULL; ++i)
12672       free (r[i]);
12673     free (r);
12674   }
12675   return 0;
12676 }
12677
12678 static int test_pvs_1 (void)
12679 {
12680   /* InitNone|InitEmpty for test_pvs_1 */
12681   {
12682     char device[] = "/dev/sda";
12683     device[5] = devchar;
12684     int r;
12685     suppress_error = 0;
12686     r = guestfs_blockdev_setrw (g, device);
12687     if (r == -1)
12688       return -1;
12689   }
12690   {
12691     int r;
12692     suppress_error = 0;
12693     r = guestfs_umount_all (g);
12694     if (r == -1)
12695       return -1;
12696   }
12697   {
12698     int r;
12699     suppress_error = 0;
12700     r = guestfs_lvm_remove_all (g);
12701     if (r == -1)
12702       return -1;
12703   }
12704   /* TestOutputList for pvs (1) */
12705   {
12706     char device[] = "/dev/sda";
12707     device[5] = devchar;
12708     char lines_0[] = ",10";
12709     char lines_1[] = ",20";
12710     char lines_2[] = ",";
12711     char *lines[] = {
12712       lines_0,
12713       lines_1,
12714       lines_2,
12715       NULL
12716     };
12717     int r;
12718     suppress_error = 0;
12719     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12720     if (r == -1)
12721       return -1;
12722   }
12723   {
12724     char device[] = "/dev/sda1";
12725     device[5] = devchar;
12726     int r;
12727     suppress_error = 0;
12728     r = guestfs_pvcreate (g, device);
12729     if (r == -1)
12730       return -1;
12731   }
12732   {
12733     char device[] = "/dev/sda2";
12734     device[5] = devchar;
12735     int r;
12736     suppress_error = 0;
12737     r = guestfs_pvcreate (g, device);
12738     if (r == -1)
12739       return -1;
12740   }
12741   {
12742     char device[] = "/dev/sda3";
12743     device[5] = devchar;
12744     int r;
12745     suppress_error = 0;
12746     r = guestfs_pvcreate (g, device);
12747     if (r == -1)
12748       return -1;
12749   }
12750   {
12751     char **r;
12752     int i;
12753     suppress_error = 0;
12754     r = guestfs_pvs (g);
12755     if (r == NULL)
12756       return -1;
12757     if (!r[0]) {
12758       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12759       print_strings (r);
12760       return -1;
12761     }
12762     {
12763       char expected[] = "/dev/sda1";
12764       expected[5] = devchar;
12765       if (strcmp (r[0], expected) != 0) {
12766         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12767         return -1;
12768       }
12769     }
12770     if (!r[1]) {
12771       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12772       print_strings (r);
12773       return -1;
12774     }
12775     {
12776       char expected[] = "/dev/sda2";
12777       expected[5] = devchar;
12778       if (strcmp (r[1], expected) != 0) {
12779         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12780         return -1;
12781       }
12782     }
12783     if (!r[2]) {
12784       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12785       print_strings (r);
12786       return -1;
12787     }
12788     {
12789       char expected[] = "/dev/sda3";
12790       expected[5] = devchar;
12791       if (strcmp (r[2], expected) != 0) {
12792         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12793         return -1;
12794       }
12795     }
12796     if (r[3] != NULL) {
12797       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12798       print_strings (r);
12799       return -1;
12800     }
12801     for (i = 0; r[i] != NULL; ++i)
12802       free (r[i]);
12803     free (r);
12804   }
12805   return 0;
12806 }
12807
12808 static int test_list_partitions_0 (void)
12809 {
12810   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
12811   {
12812     char device[] = "/dev/sda";
12813     device[5] = devchar;
12814     int r;
12815     suppress_error = 0;
12816     r = guestfs_blockdev_setrw (g, device);
12817     if (r == -1)
12818       return -1;
12819   }
12820   {
12821     int r;
12822     suppress_error = 0;
12823     r = guestfs_umount_all (g);
12824     if (r == -1)
12825       return -1;
12826   }
12827   {
12828     int r;
12829     suppress_error = 0;
12830     r = guestfs_lvm_remove_all (g);
12831     if (r == -1)
12832       return -1;
12833   }
12834   {
12835     char device[] = "/dev/sda";
12836     device[5] = devchar;
12837     char lines_0[] = ",";
12838     char *lines[] = {
12839       lines_0,
12840       NULL
12841     };
12842     int r;
12843     suppress_error = 0;
12844     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12845     if (r == -1)
12846       return -1;
12847   }
12848   {
12849     char fstype[] = "ext2";
12850     char device[] = "/dev/sda1";
12851     device[5] = devchar;
12852     int r;
12853     suppress_error = 0;
12854     r = guestfs_mkfs (g, fstype, device);
12855     if (r == -1)
12856       return -1;
12857   }
12858   {
12859     char device[] = "/dev/sda1";
12860     device[5] = devchar;
12861     char mountpoint[] = "/";
12862     int r;
12863     suppress_error = 0;
12864     r = guestfs_mount (g, device, mountpoint);
12865     if (r == -1)
12866       return -1;
12867   }
12868   /* TestOutputList for list_partitions (0) */
12869   {
12870     char **r;
12871     int i;
12872     suppress_error = 0;
12873     r = guestfs_list_partitions (g);
12874     if (r == NULL)
12875       return -1;
12876     if (!r[0]) {
12877       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12878       print_strings (r);
12879       return -1;
12880     }
12881     {
12882       char expected[] = "/dev/sda1";
12883       expected[5] = devchar;
12884       if (strcmp (r[0], expected) != 0) {
12885         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12886         return -1;
12887       }
12888     }
12889     if (r[1] != NULL) {
12890       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12891       print_strings (r);
12892       return -1;
12893     }
12894     for (i = 0; r[i] != NULL; ++i)
12895       free (r[i]);
12896     free (r);
12897   }
12898   return 0;
12899 }
12900
12901 static int test_list_partitions_1 (void)
12902 {
12903   /* InitNone|InitEmpty for test_list_partitions_1 */
12904   {
12905     char device[] = "/dev/sda";
12906     device[5] = devchar;
12907     int r;
12908     suppress_error = 0;
12909     r = guestfs_blockdev_setrw (g, device);
12910     if (r == -1)
12911       return -1;
12912   }
12913   {
12914     int r;
12915     suppress_error = 0;
12916     r = guestfs_umount_all (g);
12917     if (r == -1)
12918       return -1;
12919   }
12920   {
12921     int r;
12922     suppress_error = 0;
12923     r = guestfs_lvm_remove_all (g);
12924     if (r == -1)
12925       return -1;
12926   }
12927   /* TestOutputList for list_partitions (1) */
12928   {
12929     char device[] = "/dev/sda";
12930     device[5] = devchar;
12931     char lines_0[] = ",10";
12932     char lines_1[] = ",20";
12933     char lines_2[] = ",";
12934     char *lines[] = {
12935       lines_0,
12936       lines_1,
12937       lines_2,
12938       NULL
12939     };
12940     int r;
12941     suppress_error = 0;
12942     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12943     if (r == -1)
12944       return -1;
12945   }
12946   {
12947     char **r;
12948     int i;
12949     suppress_error = 0;
12950     r = guestfs_list_partitions (g);
12951     if (r == NULL)
12952       return -1;
12953     if (!r[0]) {
12954       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12955       print_strings (r);
12956       return -1;
12957     }
12958     {
12959       char expected[] = "/dev/sda1";
12960       expected[5] = devchar;
12961       if (strcmp (r[0], expected) != 0) {
12962         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12963         return -1;
12964       }
12965     }
12966     if (!r[1]) {
12967       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12968       print_strings (r);
12969       return -1;
12970     }
12971     {
12972       char expected[] = "/dev/sda2";
12973       expected[5] = devchar;
12974       if (strcmp (r[1], expected) != 0) {
12975         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12976         return -1;
12977       }
12978     }
12979     if (!r[2]) {
12980       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12981       print_strings (r);
12982       return -1;
12983     }
12984     {
12985       char expected[] = "/dev/sda3";
12986       expected[5] = devchar;
12987       if (strcmp (r[2], expected) != 0) {
12988         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12989         return -1;
12990       }
12991     }
12992     if (r[3] != NULL) {
12993       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12994       print_strings (r);
12995       return -1;
12996     }
12997     for (i = 0; r[i] != NULL; ++i)
12998       free (r[i]);
12999     free (r);
13000   }
13001   return 0;
13002 }
13003
13004 static int test_list_devices_0 (void)
13005 {
13006   /* InitNone|InitEmpty for test_list_devices_0 */
13007   {
13008     char device[] = "/dev/sda";
13009     device[5] = devchar;
13010     int r;
13011     suppress_error = 0;
13012     r = guestfs_blockdev_setrw (g, device);
13013     if (r == -1)
13014       return -1;
13015   }
13016   {
13017     int r;
13018     suppress_error = 0;
13019     r = guestfs_umount_all (g);
13020     if (r == -1)
13021       return -1;
13022   }
13023   {
13024     int r;
13025     suppress_error = 0;
13026     r = guestfs_lvm_remove_all (g);
13027     if (r == -1)
13028       return -1;
13029   }
13030   /* TestOutputList for list_devices (0) */
13031   {
13032     char **r;
13033     int i;
13034     suppress_error = 0;
13035     r = guestfs_list_devices (g);
13036     if (r == NULL)
13037       return -1;
13038     if (!r[0]) {
13039       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13040       print_strings (r);
13041       return -1;
13042     }
13043     {
13044       char expected[] = "/dev/sda";
13045       expected[5] = devchar;
13046       if (strcmp (r[0], expected) != 0) {
13047         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13048         return -1;
13049       }
13050     }
13051     if (!r[1]) {
13052       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13053       print_strings (r);
13054       return -1;
13055     }
13056     {
13057       char expected[] = "/dev/sdb";
13058       expected[5] = devchar;
13059       if (strcmp (r[1], expected) != 0) {
13060         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13061         return -1;
13062       }
13063     }
13064     if (!r[2]) {
13065       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13066       print_strings (r);
13067       return -1;
13068     }
13069     {
13070       char expected[] = "/dev/sdc";
13071       expected[5] = devchar;
13072       if (strcmp (r[2], expected) != 0) {
13073         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13074         return -1;
13075       }
13076     }
13077     if (r[3] != NULL) {
13078       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
13079       print_strings (r);
13080       return -1;
13081     }
13082     for (i = 0; r[i] != NULL; ++i)
13083       free (r[i]);
13084     free (r);
13085   }
13086   return 0;
13087 }
13088
13089 static int test_ls_0 (void)
13090 {
13091   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
13092   {
13093     char device[] = "/dev/sda";
13094     device[5] = devchar;
13095     int r;
13096     suppress_error = 0;
13097     r = guestfs_blockdev_setrw (g, device);
13098     if (r == -1)
13099       return -1;
13100   }
13101   {
13102     int r;
13103     suppress_error = 0;
13104     r = guestfs_umount_all (g);
13105     if (r == -1)
13106       return -1;
13107   }
13108   {
13109     int r;
13110     suppress_error = 0;
13111     r = guestfs_lvm_remove_all (g);
13112     if (r == -1)
13113       return -1;
13114   }
13115   {
13116     char device[] = "/dev/sda";
13117     device[5] = devchar;
13118     char lines_0[] = ",";
13119     char *lines[] = {
13120       lines_0,
13121       NULL
13122     };
13123     int r;
13124     suppress_error = 0;
13125     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13126     if (r == -1)
13127       return -1;
13128   }
13129   {
13130     char fstype[] = "ext2";
13131     char device[] = "/dev/sda1";
13132     device[5] = devchar;
13133     int r;
13134     suppress_error = 0;
13135     r = guestfs_mkfs (g, fstype, device);
13136     if (r == -1)
13137       return -1;
13138   }
13139   {
13140     char device[] = "/dev/sda1";
13141     device[5] = devchar;
13142     char mountpoint[] = "/";
13143     int r;
13144     suppress_error = 0;
13145     r = guestfs_mount (g, device, mountpoint);
13146     if (r == -1)
13147       return -1;
13148   }
13149   /* TestOutputList for ls (0) */
13150   {
13151     char path[] = "/new";
13152     int r;
13153     suppress_error = 0;
13154     r = guestfs_touch (g, path);
13155     if (r == -1)
13156       return -1;
13157   }
13158   {
13159     char path[] = "/newer";
13160     int r;
13161     suppress_error = 0;
13162     r = guestfs_touch (g, path);
13163     if (r == -1)
13164       return -1;
13165   }
13166   {
13167     char path[] = "/newest";
13168     int r;
13169     suppress_error = 0;
13170     r = guestfs_touch (g, path);
13171     if (r == -1)
13172       return -1;
13173   }
13174   {
13175     char directory[] = "/";
13176     char **r;
13177     int i;
13178     suppress_error = 0;
13179     r = guestfs_ls (g, directory);
13180     if (r == NULL)
13181       return -1;
13182     if (!r[0]) {
13183       fprintf (stderr, "test_ls_0: short list returned from command\n");
13184       print_strings (r);
13185       return -1;
13186     }
13187     {
13188       char expected[] = "lost+found";
13189       if (strcmp (r[0], expected) != 0) {
13190         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13191         return -1;
13192       }
13193     }
13194     if (!r[1]) {
13195       fprintf (stderr, "test_ls_0: short list returned from command\n");
13196       print_strings (r);
13197       return -1;
13198     }
13199     {
13200       char expected[] = "new";
13201       if (strcmp (r[1], expected) != 0) {
13202         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13203         return -1;
13204       }
13205     }
13206     if (!r[2]) {
13207       fprintf (stderr, "test_ls_0: short list returned from command\n");
13208       print_strings (r);
13209       return -1;
13210     }
13211     {
13212       char expected[] = "newer";
13213       if (strcmp (r[2], expected) != 0) {
13214         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13215         return -1;
13216       }
13217     }
13218     if (!r[3]) {
13219       fprintf (stderr, "test_ls_0: short list returned from command\n");
13220       print_strings (r);
13221       return -1;
13222     }
13223     {
13224       char expected[] = "newest";
13225       if (strcmp (r[3], expected) != 0) {
13226         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
13227         return -1;
13228       }
13229     }
13230     if (r[4] != NULL) {
13231       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
13232       print_strings (r);
13233       return -1;
13234     }
13235     for (i = 0; r[i] != NULL; ++i)
13236       free (r[i]);
13237     free (r);
13238   }
13239   return 0;
13240 }
13241
13242 static int test_cat_0 (void)
13243 {
13244   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
13245   {
13246     char device[] = "/dev/sda";
13247     device[5] = devchar;
13248     int r;
13249     suppress_error = 0;
13250     r = guestfs_blockdev_setrw (g, device);
13251     if (r == -1)
13252       return -1;
13253   }
13254   {
13255     int r;
13256     suppress_error = 0;
13257     r = guestfs_umount_all (g);
13258     if (r == -1)
13259       return -1;
13260   }
13261   {
13262     int r;
13263     suppress_error = 0;
13264     r = guestfs_lvm_remove_all (g);
13265     if (r == -1)
13266       return -1;
13267   }
13268   {
13269     char device[] = "/dev/sda";
13270     device[5] = devchar;
13271     char lines_0[] = ",";
13272     char *lines[] = {
13273       lines_0,
13274       NULL
13275     };
13276     int r;
13277     suppress_error = 0;
13278     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13279     if (r == -1)
13280       return -1;
13281   }
13282   {
13283     char fstype[] = "ext2";
13284     char device[] = "/dev/sda1";
13285     device[5] = devchar;
13286     int r;
13287     suppress_error = 0;
13288     r = guestfs_mkfs (g, fstype, device);
13289     if (r == -1)
13290       return -1;
13291   }
13292   {
13293     char device[] = "/dev/sda1";
13294     device[5] = devchar;
13295     char mountpoint[] = "/";
13296     int r;
13297     suppress_error = 0;
13298     r = guestfs_mount (g, device, mountpoint);
13299     if (r == -1)
13300       return -1;
13301   }
13302   /* TestOutput for cat (0) */
13303   char expected[] = "new file contents";
13304   {
13305     char path[] = "/new";
13306     char content[] = "new file contents";
13307     int r;
13308     suppress_error = 0;
13309     r = guestfs_write_file (g, path, content, 0);
13310     if (r == -1)
13311       return -1;
13312   }
13313   {
13314     char path[] = "/new";
13315     char *r;
13316     suppress_error = 0;
13317     r = guestfs_cat (g, path);
13318     if (r == NULL)
13319       return -1;
13320     if (strcmp (r, expected) != 0) {
13321       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
13322       return -1;
13323     }
13324     free (r);
13325   }
13326   return 0;
13327 }
13328
13329 static int test_touch_0 (void)
13330 {
13331   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
13332   {
13333     char device[] = "/dev/sda";
13334     device[5] = devchar;
13335     int r;
13336     suppress_error = 0;
13337     r = guestfs_blockdev_setrw (g, device);
13338     if (r == -1)
13339       return -1;
13340   }
13341   {
13342     int r;
13343     suppress_error = 0;
13344     r = guestfs_umount_all (g);
13345     if (r == -1)
13346       return -1;
13347   }
13348   {
13349     int r;
13350     suppress_error = 0;
13351     r = guestfs_lvm_remove_all (g);
13352     if (r == -1)
13353       return -1;
13354   }
13355   {
13356     char device[] = "/dev/sda";
13357     device[5] = devchar;
13358     char lines_0[] = ",";
13359     char *lines[] = {
13360       lines_0,
13361       NULL
13362     };
13363     int r;
13364     suppress_error = 0;
13365     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13366     if (r == -1)
13367       return -1;
13368   }
13369   {
13370     char fstype[] = "ext2";
13371     char device[] = "/dev/sda1";
13372     device[5] = devchar;
13373     int r;
13374     suppress_error = 0;
13375     r = guestfs_mkfs (g, fstype, device);
13376     if (r == -1)
13377       return -1;
13378   }
13379   {
13380     char device[] = "/dev/sda1";
13381     device[5] = devchar;
13382     char mountpoint[] = "/";
13383     int r;
13384     suppress_error = 0;
13385     r = guestfs_mount (g, device, mountpoint);
13386     if (r == -1)
13387       return -1;
13388   }
13389   /* TestOutputTrue for touch (0) */
13390   {
13391     char path[] = "/new";
13392     int r;
13393     suppress_error = 0;
13394     r = guestfs_touch (g, path);
13395     if (r == -1)
13396       return -1;
13397   }
13398   {
13399     char path[] = "/new";
13400     int r;
13401     suppress_error = 0;
13402     r = guestfs_exists (g, path);
13403     if (r == -1)
13404       return -1;
13405     if (!r) {
13406       fprintf (stderr, "test_touch_0: expected true, got false\n");
13407       return -1;
13408     }
13409   }
13410   return 0;
13411 }
13412
13413 static int test_sync_0 (void)
13414 {
13415   /* InitNone|InitEmpty for test_sync_0 */
13416   {
13417     char device[] = "/dev/sda";
13418     device[5] = devchar;
13419     int r;
13420     suppress_error = 0;
13421     r = guestfs_blockdev_setrw (g, device);
13422     if (r == -1)
13423       return -1;
13424   }
13425   {
13426     int r;
13427     suppress_error = 0;
13428     r = guestfs_umount_all (g);
13429     if (r == -1)
13430       return -1;
13431   }
13432   {
13433     int r;
13434     suppress_error = 0;
13435     r = guestfs_lvm_remove_all (g);
13436     if (r == -1)
13437       return -1;
13438   }
13439   /* TestRun for sync (0) */
13440   {
13441     int r;
13442     suppress_error = 0;
13443     r = guestfs_sync (g);
13444     if (r == -1)
13445       return -1;
13446   }
13447   return 0;
13448 }
13449
13450 static int test_mount_0 (void)
13451 {
13452   /* InitNone|InitEmpty for test_mount_0 */
13453   {
13454     char device[] = "/dev/sda";
13455     device[5] = devchar;
13456     int r;
13457     suppress_error = 0;
13458     r = guestfs_blockdev_setrw (g, device);
13459     if (r == -1)
13460       return -1;
13461   }
13462   {
13463     int r;
13464     suppress_error = 0;
13465     r = guestfs_umount_all (g);
13466     if (r == -1)
13467       return -1;
13468   }
13469   {
13470     int r;
13471     suppress_error = 0;
13472     r = guestfs_lvm_remove_all (g);
13473     if (r == -1)
13474       return -1;
13475   }
13476   /* TestOutput for mount (0) */
13477   char expected[] = "new file contents";
13478   {
13479     char device[] = "/dev/sda";
13480     device[5] = devchar;
13481     char lines_0[] = ",";
13482     char *lines[] = {
13483       lines_0,
13484       NULL
13485     };
13486     int r;
13487     suppress_error = 0;
13488     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13489     if (r == -1)
13490       return -1;
13491   }
13492   {
13493     char fstype[] = "ext2";
13494     char device[] = "/dev/sda1";
13495     device[5] = devchar;
13496     int r;
13497     suppress_error = 0;
13498     r = guestfs_mkfs (g, fstype, device);
13499     if (r == -1)
13500       return -1;
13501   }
13502   {
13503     char device[] = "/dev/sda1";
13504     device[5] = devchar;
13505     char mountpoint[] = "/";
13506     int r;
13507     suppress_error = 0;
13508     r = guestfs_mount (g, device, mountpoint);
13509     if (r == -1)
13510       return -1;
13511   }
13512   {
13513     char path[] = "/new";
13514     char content[] = "new file contents";
13515     int r;
13516     suppress_error = 0;
13517     r = guestfs_write_file (g, path, content, 0);
13518     if (r == -1)
13519       return -1;
13520   }
13521   {
13522     char path[] = "/new";
13523     char *r;
13524     suppress_error = 0;
13525     r = guestfs_cat (g, path);
13526     if (r == NULL)
13527       return -1;
13528     if (strcmp (r, expected) != 0) {
13529       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
13530       return -1;
13531     }
13532     free (r);
13533   }
13534   return 0;
13535 }
13536
13537 int main (int argc, char *argv[])
13538 {
13539   char c = 0;
13540   int failed = 0;
13541   const char *srcdir;
13542   const char *filename;
13543   int fd, i;
13544   int nr_tests, test_num = 0;
13545   char **devs;
13546
13547   no_test_warnings ();
13548
13549   g = guestfs_create ();
13550   if (g == NULL) {
13551     printf ("guestfs_create FAILED\n");
13552     exit (1);
13553   }
13554
13555   guestfs_set_error_handler (g, print_error, NULL);
13556
13557   srcdir = getenv ("srcdir");
13558   if (!srcdir) srcdir = ".";
13559   chdir (srcdir);
13560   guestfs_set_path (g, ".");
13561
13562   filename = "test1.img";
13563   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13564   if (fd == -1) {
13565     perror (filename);
13566     exit (1);
13567   }
13568   if (lseek (fd, 524288000, SEEK_SET) == -1) {
13569     perror ("lseek");
13570     close (fd);
13571     unlink (filename);
13572     exit (1);
13573   }
13574   if (write (fd, &c, 1) == -1) {
13575     perror ("write");
13576     close (fd);
13577     unlink (filename);
13578     exit (1);
13579   }
13580   if (close (fd) == -1) {
13581     perror (filename);
13582     unlink (filename);
13583     exit (1);
13584   }
13585   if (guestfs_add_drive (g, filename) == -1) {
13586     printf ("guestfs_add_drive %s FAILED\n", filename);
13587     exit (1);
13588   }
13589
13590   filename = "test2.img";
13591   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13592   if (fd == -1) {
13593     perror (filename);
13594     exit (1);
13595   }
13596   if (lseek (fd, 52428800, SEEK_SET) == -1) {
13597     perror ("lseek");
13598     close (fd);
13599     unlink (filename);
13600     exit (1);
13601   }
13602   if (write (fd, &c, 1) == -1) {
13603     perror ("write");
13604     close (fd);
13605     unlink (filename);
13606     exit (1);
13607   }
13608   if (close (fd) == -1) {
13609     perror (filename);
13610     unlink (filename);
13611     exit (1);
13612   }
13613   if (guestfs_add_drive (g, filename) == -1) {
13614     printf ("guestfs_add_drive %s FAILED\n", filename);
13615     exit (1);
13616   }
13617
13618   filename = "test3.img";
13619   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13620   if (fd == -1) {
13621     perror (filename);
13622     exit (1);
13623   }
13624   if (lseek (fd, 10485760, SEEK_SET) == -1) {
13625     perror ("lseek");
13626     close (fd);
13627     unlink (filename);
13628     exit (1);
13629   }
13630   if (write (fd, &c, 1) == -1) {
13631     perror ("write");
13632     close (fd);
13633     unlink (filename);
13634     exit (1);
13635   }
13636   if (close (fd) == -1) {
13637     perror (filename);
13638     unlink (filename);
13639     exit (1);
13640   }
13641   if (guestfs_add_drive (g, filename) == -1) {
13642     printf ("guestfs_add_drive %s FAILED\n", filename);
13643     exit (1);
13644   }
13645
13646   if (guestfs_launch (g) == -1) {
13647     printf ("guestfs_launch FAILED\n");
13648     exit (1);
13649   }
13650   if (guestfs_wait_ready (g) == -1) {
13651     printf ("guestfs_wait_ready FAILED\n");
13652     exit (1);
13653   }
13654
13655   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13656    * names.  This changed between RHEL 5 and RHEL 6 so we have to
13657    * support both.
13658    */
13659   devs = guestfs_list_devices (g);
13660   if (devs == NULL || devs[0] == NULL) {
13661     printf ("guestfs_list_devices FAILED\n");
13662     exit (1);
13663   }
13664   if (strncmp (devs[0], "/dev/sd", 7) == 0)
13665     devchar = 's';
13666   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13667     devchar = 'h';
13668   else {
13669     printf ("guestfs_list_devices returned unexpected string '%s'\n",
13670             devs[0]);
13671     exit (1);
13672   }
13673   for (i = 0; devs[i] != NULL; ++i)
13674     free (devs[i]);
13675   free (devs);
13676
13677   nr_tests = 140;
13678
13679   test_num++;
13680   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
13681   if (test_find_0 () == -1) {
13682     printf ("test_find_0 FAILED\n");
13683     failed++;
13684   }
13685   test_num++;
13686   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
13687   if (test_find_1 () == -1) {
13688     printf ("test_find_1 FAILED\n");
13689     failed++;
13690   }
13691   test_num++;
13692   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
13693   if (test_find_2 () == -1) {
13694     printf ("test_find_2 FAILED\n");
13695     failed++;
13696   }
13697   test_num++;
13698   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
13699   if (test_lvresize_0 () == -1) {
13700     printf ("test_lvresize_0 FAILED\n");
13701     failed++;
13702   }
13703   test_num++;
13704   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13705   if (test_zerofree_0 () == -1) {
13706     printf ("test_zerofree_0 FAILED\n");
13707     failed++;
13708   }
13709   test_num++;
13710   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13711   if (test_hexdump_0 () == -1) {
13712     printf ("test_hexdump_0 FAILED\n");
13713     failed++;
13714   }
13715   test_num++;
13716   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13717   if (test_strings_e_0 () == -1) {
13718     printf ("test_strings_e_0 FAILED\n");
13719     failed++;
13720   }
13721   test_num++;
13722   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13723   if (test_strings_e_1 () == -1) {
13724     printf ("test_strings_e_1 FAILED\n");
13725     failed++;
13726   }
13727   test_num++;
13728   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13729   if (test_strings_0 () == -1) {
13730     printf ("test_strings_0 FAILED\n");
13731     failed++;
13732   }
13733   test_num++;
13734   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13735   if (test_strings_1 () == -1) {
13736     printf ("test_strings_1 FAILED\n");
13737     failed++;
13738   }
13739   test_num++;
13740   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13741   if (test_equal_0 () == -1) {
13742     printf ("test_equal_0 FAILED\n");
13743     failed++;
13744   }
13745   test_num++;
13746   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13747   if (test_equal_1 () == -1) {
13748     printf ("test_equal_1 FAILED\n");
13749     failed++;
13750   }
13751   test_num++;
13752   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13753   if (test_equal_2 () == -1) {
13754     printf ("test_equal_2 FAILED\n");
13755     failed++;
13756   }
13757   test_num++;
13758   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13759   if (test_ping_daemon_0 () == -1) {
13760     printf ("test_ping_daemon_0 FAILED\n");
13761     failed++;
13762   }
13763   test_num++;
13764   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13765   if (test_dmesg_0 () == -1) {
13766     printf ("test_dmesg_0 FAILED\n");
13767     failed++;
13768   }
13769   test_num++;
13770   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13771   if (test_drop_caches_0 () == -1) {
13772     printf ("test_drop_caches_0 FAILED\n");
13773     failed++;
13774   }
13775   test_num++;
13776   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13777   if (test_mv_0 () == -1) {
13778     printf ("test_mv_0 FAILED\n");
13779     failed++;
13780   }
13781   test_num++;
13782   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13783   if (test_mv_1 () == -1) {
13784     printf ("test_mv_1 FAILED\n");
13785     failed++;
13786   }
13787   test_num++;
13788   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13789   if (test_cp_a_0 () == -1) {
13790     printf ("test_cp_a_0 FAILED\n");
13791     failed++;
13792   }
13793   test_num++;
13794   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13795   if (test_cp_0 () == -1) {
13796     printf ("test_cp_0 FAILED\n");
13797     failed++;
13798   }
13799   test_num++;
13800   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13801   if (test_cp_1 () == -1) {
13802     printf ("test_cp_1 FAILED\n");
13803     failed++;
13804   }
13805   test_num++;
13806   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13807   if (test_cp_2 () == -1) {
13808     printf ("test_cp_2 FAILED\n");
13809     failed++;
13810   }
13811   test_num++;
13812   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13813   if (test_grub_install_0 () == -1) {
13814     printf ("test_grub_install_0 FAILED\n");
13815     failed++;
13816   }
13817   test_num++;
13818   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13819   if (test_zero_0 () == -1) {
13820     printf ("test_zero_0 FAILED\n");
13821     failed++;
13822   }
13823   test_num++;
13824   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13825   if (test_fsck_0 () == -1) {
13826     printf ("test_fsck_0 FAILED\n");
13827     failed++;
13828   }
13829   test_num++;
13830   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13831   if (test_fsck_1 () == -1) {
13832     printf ("test_fsck_1 FAILED\n");
13833     failed++;
13834   }
13835   test_num++;
13836   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13837   if (test_set_e2uuid_0 () == -1) {
13838     printf ("test_set_e2uuid_0 FAILED\n");
13839     failed++;
13840   }
13841   test_num++;
13842   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13843   if (test_set_e2uuid_1 () == -1) {
13844     printf ("test_set_e2uuid_1 FAILED\n");
13845     failed++;
13846   }
13847   test_num++;
13848   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13849   if (test_set_e2uuid_2 () == -1) {
13850     printf ("test_set_e2uuid_2 FAILED\n");
13851     failed++;
13852   }
13853   test_num++;
13854   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13855   if (test_set_e2uuid_3 () == -1) {
13856     printf ("test_set_e2uuid_3 FAILED\n");
13857     failed++;
13858   }
13859   test_num++;
13860   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13861   if (test_set_e2label_0 () == -1) {
13862     printf ("test_set_e2label_0 FAILED\n");
13863     failed++;
13864   }
13865   test_num++;
13866   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13867   if (test_pvremove_0 () == -1) {
13868     printf ("test_pvremove_0 FAILED\n");
13869     failed++;
13870   }
13871   test_num++;
13872   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13873   if (test_pvremove_1 () == -1) {
13874     printf ("test_pvremove_1 FAILED\n");
13875     failed++;
13876   }
13877   test_num++;
13878   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13879   if (test_pvremove_2 () == -1) {
13880     printf ("test_pvremove_2 FAILED\n");
13881     failed++;
13882   }
13883   test_num++;
13884   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13885   if (test_vgremove_0 () == -1) {
13886     printf ("test_vgremove_0 FAILED\n");
13887     failed++;
13888   }
13889   test_num++;
13890   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13891   if (test_vgremove_1 () == -1) {
13892     printf ("test_vgremove_1 FAILED\n");
13893     failed++;
13894   }
13895   test_num++;
13896   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13897   if (test_lvremove_0 () == -1) {
13898     printf ("test_lvremove_0 FAILED\n");
13899     failed++;
13900   }
13901   test_num++;
13902   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13903   if (test_lvremove_1 () == -1) {
13904     printf ("test_lvremove_1 FAILED\n");
13905     failed++;
13906   }
13907   test_num++;
13908   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13909   if (test_lvremove_2 () == -1) {
13910     printf ("test_lvremove_2 FAILED\n");
13911     failed++;
13912   }
13913   test_num++;
13914   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13915   if (test_mount_ro_0 () == -1) {
13916     printf ("test_mount_ro_0 FAILED\n");
13917     failed++;
13918   }
13919   test_num++;
13920   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13921   if (test_mount_ro_1 () == -1) {
13922     printf ("test_mount_ro_1 FAILED\n");
13923     failed++;
13924   }
13925   test_num++;
13926   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13927   if (test_tgz_in_0 () == -1) {
13928     printf ("test_tgz_in_0 FAILED\n");
13929     failed++;
13930   }
13931   test_num++;
13932   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13933   if (test_tar_in_0 () == -1) {
13934     printf ("test_tar_in_0 FAILED\n");
13935     failed++;
13936   }
13937   test_num++;
13938   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13939   if (test_checksum_0 () == -1) {
13940     printf ("test_checksum_0 FAILED\n");
13941     failed++;
13942   }
13943   test_num++;
13944   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13945   if (test_checksum_1 () == -1) {
13946     printf ("test_checksum_1 FAILED\n");
13947     failed++;
13948   }
13949   test_num++;
13950   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13951   if (test_checksum_2 () == -1) {
13952     printf ("test_checksum_2 FAILED\n");
13953     failed++;
13954   }
13955   test_num++;
13956   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13957   if (test_checksum_3 () == -1) {
13958     printf ("test_checksum_3 FAILED\n");
13959     failed++;
13960   }
13961   test_num++;
13962   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13963   if (test_checksum_4 () == -1) {
13964     printf ("test_checksum_4 FAILED\n");
13965     failed++;
13966   }
13967   test_num++;
13968   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13969   if (test_checksum_5 () == -1) {
13970     printf ("test_checksum_5 FAILED\n");
13971     failed++;
13972   }
13973   test_num++;
13974   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13975   if (test_checksum_6 () == -1) {
13976     printf ("test_checksum_6 FAILED\n");
13977     failed++;
13978   }
13979   test_num++;
13980   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13981   if (test_checksum_7 () == -1) {
13982     printf ("test_checksum_7 FAILED\n");
13983     failed++;
13984   }
13985   test_num++;
13986   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13987   if (test_download_0 () == -1) {
13988     printf ("test_download_0 FAILED\n");
13989     failed++;
13990   }
13991   test_num++;
13992   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13993   if (test_upload_0 () == -1) {
13994     printf ("test_upload_0 FAILED\n");
13995     failed++;
13996   }
13997   test_num++;
13998   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13999   if (test_blockdev_rereadpt_0 () == -1) {
14000     printf ("test_blockdev_rereadpt_0 FAILED\n");
14001     failed++;
14002   }
14003   test_num++;
14004   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
14005   if (test_blockdev_flushbufs_0 () == -1) {
14006     printf ("test_blockdev_flushbufs_0 FAILED\n");
14007     failed++;
14008   }
14009   test_num++;
14010   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
14011   if (test_blockdev_getsize64_0 () == -1) {
14012     printf ("test_blockdev_getsize64_0 FAILED\n");
14013     failed++;
14014   }
14015   test_num++;
14016   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
14017   if (test_blockdev_getsz_0 () == -1) {
14018     printf ("test_blockdev_getsz_0 FAILED\n");
14019     failed++;
14020   }
14021   test_num++;
14022   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
14023   if (test_blockdev_getbsz_0 () == -1) {
14024     printf ("test_blockdev_getbsz_0 FAILED\n");
14025     failed++;
14026   }
14027   test_num++;
14028   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
14029   if (test_blockdev_getss_0 () == -1) {
14030     printf ("test_blockdev_getss_0 FAILED\n");
14031     failed++;
14032   }
14033   test_num++;
14034   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
14035   if (test_blockdev_getro_0 () == -1) {
14036     printf ("test_blockdev_getro_0 FAILED\n");
14037     failed++;
14038   }
14039   test_num++;
14040   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
14041   if (test_blockdev_setrw_0 () == -1) {
14042     printf ("test_blockdev_setrw_0 FAILED\n");
14043     failed++;
14044   }
14045   test_num++;
14046   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
14047   if (test_blockdev_setro_0 () == -1) {
14048     printf ("test_blockdev_setro_0 FAILED\n");
14049     failed++;
14050   }
14051   test_num++;
14052   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
14053   if (test_statvfs_0 () == -1) {
14054     printf ("test_statvfs_0 FAILED\n");
14055     failed++;
14056   }
14057   test_num++;
14058   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
14059   if (test_lstat_0 () == -1) {
14060     printf ("test_lstat_0 FAILED\n");
14061     failed++;
14062   }
14063   test_num++;
14064   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
14065   if (test_stat_0 () == -1) {
14066     printf ("test_stat_0 FAILED\n");
14067     failed++;
14068   }
14069   test_num++;
14070   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
14071   if (test_command_lines_0 () == -1) {
14072     printf ("test_command_lines_0 FAILED\n");
14073     failed++;
14074   }
14075   test_num++;
14076   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
14077   if (test_command_lines_1 () == -1) {
14078     printf ("test_command_lines_1 FAILED\n");
14079     failed++;
14080   }
14081   test_num++;
14082   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
14083   if (test_command_lines_2 () == -1) {
14084     printf ("test_command_lines_2 FAILED\n");
14085     failed++;
14086   }
14087   test_num++;
14088   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
14089   if (test_command_lines_3 () == -1) {
14090     printf ("test_command_lines_3 FAILED\n");
14091     failed++;
14092   }
14093   test_num++;
14094   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
14095   if (test_command_lines_4 () == -1) {
14096     printf ("test_command_lines_4 FAILED\n");
14097     failed++;
14098   }
14099   test_num++;
14100   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
14101   if (test_command_lines_5 () == -1) {
14102     printf ("test_command_lines_5 FAILED\n");
14103     failed++;
14104   }
14105   test_num++;
14106   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
14107   if (test_command_lines_6 () == -1) {
14108     printf ("test_command_lines_6 FAILED\n");
14109     failed++;
14110   }
14111   test_num++;
14112   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
14113   if (test_command_lines_7 () == -1) {
14114     printf ("test_command_lines_7 FAILED\n");
14115     failed++;
14116   }
14117   test_num++;
14118   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
14119   if (test_command_lines_8 () == -1) {
14120     printf ("test_command_lines_8 FAILED\n");
14121     failed++;
14122   }
14123   test_num++;
14124   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
14125   if (test_command_lines_9 () == -1) {
14126     printf ("test_command_lines_9 FAILED\n");
14127     failed++;
14128   }
14129   test_num++;
14130   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
14131   if (test_command_lines_10 () == -1) {
14132     printf ("test_command_lines_10 FAILED\n");
14133     failed++;
14134   }
14135   test_num++;
14136   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
14137   if (test_command_0 () == -1) {
14138     printf ("test_command_0 FAILED\n");
14139     failed++;
14140   }
14141   test_num++;
14142   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
14143   if (test_command_1 () == -1) {
14144     printf ("test_command_1 FAILED\n");
14145     failed++;
14146   }
14147   test_num++;
14148   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
14149   if (test_command_2 () == -1) {
14150     printf ("test_command_2 FAILED\n");
14151     failed++;
14152   }
14153   test_num++;
14154   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
14155   if (test_command_3 () == -1) {
14156     printf ("test_command_3 FAILED\n");
14157     failed++;
14158   }
14159   test_num++;
14160   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
14161   if (test_command_4 () == -1) {
14162     printf ("test_command_4 FAILED\n");
14163     failed++;
14164   }
14165   test_num++;
14166   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
14167   if (test_command_5 () == -1) {
14168     printf ("test_command_5 FAILED\n");
14169     failed++;
14170   }
14171   test_num++;
14172   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
14173   if (test_command_6 () == -1) {
14174     printf ("test_command_6 FAILED\n");
14175     failed++;
14176   }
14177   test_num++;
14178   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
14179   if (test_command_7 () == -1) {
14180     printf ("test_command_7 FAILED\n");
14181     failed++;
14182   }
14183   test_num++;
14184   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
14185   if (test_command_8 () == -1) {
14186     printf ("test_command_8 FAILED\n");
14187     failed++;
14188   }
14189   test_num++;
14190   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
14191   if (test_command_9 () == -1) {
14192     printf ("test_command_9 FAILED\n");
14193     failed++;
14194   }
14195   test_num++;
14196   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
14197   if (test_command_10 () == -1) {
14198     printf ("test_command_10 FAILED\n");
14199     failed++;
14200   }
14201   test_num++;
14202   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
14203   if (test_command_11 () == -1) {
14204     printf ("test_command_11 FAILED\n");
14205     failed++;
14206   }
14207   test_num++;
14208   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
14209   if (test_file_0 () == -1) {
14210     printf ("test_file_0 FAILED\n");
14211     failed++;
14212   }
14213   test_num++;
14214   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
14215   if (test_file_1 () == -1) {
14216     printf ("test_file_1 FAILED\n");
14217     failed++;
14218   }
14219   test_num++;
14220   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
14221   if (test_file_2 () == -1) {
14222     printf ("test_file_2 FAILED\n");
14223     failed++;
14224   }
14225   test_num++;
14226   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
14227   if (test_umount_all_0 () == -1) {
14228     printf ("test_umount_all_0 FAILED\n");
14229     failed++;
14230   }
14231   test_num++;
14232   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
14233   if (test_umount_all_1 () == -1) {
14234     printf ("test_umount_all_1 FAILED\n");
14235     failed++;
14236   }
14237   test_num++;
14238   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
14239   if (test_mounts_0 () == -1) {
14240     printf ("test_mounts_0 FAILED\n");
14241     failed++;
14242   }
14243   test_num++;
14244   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
14245   if (test_umount_0 () == -1) {
14246     printf ("test_umount_0 FAILED\n");
14247     failed++;
14248   }
14249   test_num++;
14250   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
14251   if (test_umount_1 () == -1) {
14252     printf ("test_umount_1 FAILED\n");
14253     failed++;
14254   }
14255   test_num++;
14256   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
14257   if (test_write_file_0 () == -1) {
14258     printf ("test_write_file_0 FAILED\n");
14259     failed++;
14260   }
14261   test_num++;
14262   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
14263   if (test_write_file_1 () == -1) {
14264     printf ("test_write_file_1 FAILED\n");
14265     failed++;
14266   }
14267   test_num++;
14268   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
14269   if (test_write_file_2 () == -1) {
14270     printf ("test_write_file_2 FAILED\n");
14271     failed++;
14272   }
14273   test_num++;
14274   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
14275   if (test_write_file_3 () == -1) {
14276     printf ("test_write_file_3 FAILED\n");
14277     failed++;
14278   }
14279   test_num++;
14280   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
14281   if (test_write_file_4 () == -1) {
14282     printf ("test_write_file_4 FAILED\n");
14283     failed++;
14284   }
14285   test_num++;
14286   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
14287   if (test_write_file_5 () == -1) {
14288     printf ("test_write_file_5 FAILED\n");
14289     failed++;
14290   }
14291   test_num++;
14292   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
14293   if (test_mkfs_0 () == -1) {
14294     printf ("test_mkfs_0 FAILED\n");
14295     failed++;
14296   }
14297   test_num++;
14298   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
14299   if (test_lvcreate_0 () == -1) {
14300     printf ("test_lvcreate_0 FAILED\n");
14301     failed++;
14302   }
14303   test_num++;
14304   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
14305   if (test_vgcreate_0 () == -1) {
14306     printf ("test_vgcreate_0 FAILED\n");
14307     failed++;
14308   }
14309   test_num++;
14310   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
14311   if (test_pvcreate_0 () == -1) {
14312     printf ("test_pvcreate_0 FAILED\n");
14313     failed++;
14314   }
14315   test_num++;
14316   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
14317   if (test_is_dir_0 () == -1) {
14318     printf ("test_is_dir_0 FAILED\n");
14319     failed++;
14320   }
14321   test_num++;
14322   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
14323   if (test_is_dir_1 () == -1) {
14324     printf ("test_is_dir_1 FAILED\n");
14325     failed++;
14326   }
14327   test_num++;
14328   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
14329   if (test_is_file_0 () == -1) {
14330     printf ("test_is_file_0 FAILED\n");
14331     failed++;
14332   }
14333   test_num++;
14334   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
14335   if (test_is_file_1 () == -1) {
14336     printf ("test_is_file_1 FAILED\n");
14337     failed++;
14338   }
14339   test_num++;
14340   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
14341   if (test_exists_0 () == -1) {
14342     printf ("test_exists_0 FAILED\n");
14343     failed++;
14344   }
14345   test_num++;
14346   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
14347   if (test_exists_1 () == -1) {
14348     printf ("test_exists_1 FAILED\n");
14349     failed++;
14350   }
14351   test_num++;
14352   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
14353   if (test_mkdir_p_0 () == -1) {
14354     printf ("test_mkdir_p_0 FAILED\n");
14355     failed++;
14356   }
14357   test_num++;
14358   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
14359   if (test_mkdir_p_1 () == -1) {
14360     printf ("test_mkdir_p_1 FAILED\n");
14361     failed++;
14362   }
14363   test_num++;
14364   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
14365   if (test_mkdir_p_2 () == -1) {
14366     printf ("test_mkdir_p_2 FAILED\n");
14367     failed++;
14368   }
14369   test_num++;
14370   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
14371   if (test_mkdir_0 () == -1) {
14372     printf ("test_mkdir_0 FAILED\n");
14373     failed++;
14374   }
14375   test_num++;
14376   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
14377   if (test_mkdir_1 () == -1) {
14378     printf ("test_mkdir_1 FAILED\n");
14379     failed++;
14380   }
14381   test_num++;
14382   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
14383   if (test_rm_rf_0 () == -1) {
14384     printf ("test_rm_rf_0 FAILED\n");
14385     failed++;
14386   }
14387   test_num++;
14388   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
14389   if (test_rmdir_0 () == -1) {
14390     printf ("test_rmdir_0 FAILED\n");
14391     failed++;
14392   }
14393   test_num++;
14394   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
14395   if (test_rmdir_1 () == -1) {
14396     printf ("test_rmdir_1 FAILED\n");
14397     failed++;
14398   }
14399   test_num++;
14400   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
14401   if (test_rmdir_2 () == -1) {
14402     printf ("test_rmdir_2 FAILED\n");
14403     failed++;
14404   }
14405   test_num++;
14406   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
14407   if (test_rm_0 () == -1) {
14408     printf ("test_rm_0 FAILED\n");
14409     failed++;
14410   }
14411   test_num++;
14412   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
14413   if (test_rm_1 () == -1) {
14414     printf ("test_rm_1 FAILED\n");
14415     failed++;
14416   }
14417   test_num++;
14418   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
14419   if (test_rm_2 () == -1) {
14420     printf ("test_rm_2 FAILED\n");
14421     failed++;
14422   }
14423   test_num++;
14424   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
14425   if (test_read_lines_0 () == -1) {
14426     printf ("test_read_lines_0 FAILED\n");
14427     failed++;
14428   }
14429   test_num++;
14430   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
14431   if (test_read_lines_1 () == -1) {
14432     printf ("test_read_lines_1 FAILED\n");
14433     failed++;
14434   }
14435   test_num++;
14436   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
14437   if (test_lvs_0 () == -1) {
14438     printf ("test_lvs_0 FAILED\n");
14439     failed++;
14440   }
14441   test_num++;
14442   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
14443   if (test_lvs_1 () == -1) {
14444     printf ("test_lvs_1 FAILED\n");
14445     failed++;
14446   }
14447   test_num++;
14448   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
14449   if (test_vgs_0 () == -1) {
14450     printf ("test_vgs_0 FAILED\n");
14451     failed++;
14452   }
14453   test_num++;
14454   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
14455   if (test_vgs_1 () == -1) {
14456     printf ("test_vgs_1 FAILED\n");
14457     failed++;
14458   }
14459   test_num++;
14460   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
14461   if (test_pvs_0 () == -1) {
14462     printf ("test_pvs_0 FAILED\n");
14463     failed++;
14464   }
14465   test_num++;
14466   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
14467   if (test_pvs_1 () == -1) {
14468     printf ("test_pvs_1 FAILED\n");
14469     failed++;
14470   }
14471   test_num++;
14472   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
14473   if (test_list_partitions_0 () == -1) {
14474     printf ("test_list_partitions_0 FAILED\n");
14475     failed++;
14476   }
14477   test_num++;
14478   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
14479   if (test_list_partitions_1 () == -1) {
14480     printf ("test_list_partitions_1 FAILED\n");
14481     failed++;
14482   }
14483   test_num++;
14484   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
14485   if (test_list_devices_0 () == -1) {
14486     printf ("test_list_devices_0 FAILED\n");
14487     failed++;
14488   }
14489   test_num++;
14490   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
14491   if (test_ls_0 () == -1) {
14492     printf ("test_ls_0 FAILED\n");
14493     failed++;
14494   }
14495   test_num++;
14496   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
14497   if (test_cat_0 () == -1) {
14498     printf ("test_cat_0 FAILED\n");
14499     failed++;
14500   }
14501   test_num++;
14502   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
14503   if (test_touch_0 () == -1) {
14504     printf ("test_touch_0 FAILED\n");
14505     failed++;
14506   }
14507   test_num++;
14508   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
14509   if (test_sync_0 () == -1) {
14510     printf ("test_sync_0 FAILED\n");
14511     failed++;
14512   }
14513   test_num++;
14514   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
14515   if (test_mount_0 () == -1) {
14516     printf ("test_mount_0 FAILED\n");
14517     failed++;
14518   }
14519
14520   guestfs_close (g);
14521   unlink ("test1.img");
14522   unlink ("test2.img");
14523   unlink ("test3.img");
14524
14525   if (failed > 0) {
14526     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
14527     exit (1);
14528   }
14529
14530   exit (0);
14531 }