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