tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 /* This will be 's' or 'h' depending on whether the guest kernel
  35  * names IDE devices /dev/sd* or /dev/hd*.
  36  */
  37 static char devchar = 's';
  38
  39 static void print_error (guestfs_h *g, void *data, const char *msg)
  40 {
  41   if (!suppress_error)
  42     fprintf (stderr, "%s\n", msg);
  43 }
  44
  45 static void print_strings (char * const * const argv)
  46 {
  47   int argc;
  48
  49   for (argc = 0; argv[argc] != NULL; ++argc)
  50     printf ("\t%s\n", argv[argc]);
  51 }
  52
  53 /*
  54 static void print_table (char * const * const argv)
  55 {
  56   int i;
  57
  58   for (i = 0; argv[i] != NULL; i += 2)
  59     printf ("%s: %s\n", argv[i], argv[i+1]);
  60 }
  61 */
  62
  63 static void no_test_warnings (void)
  64 {
  65   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 128 }
 129
 130 static int test_find_0 (void)
 131 {
 132   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 133   {
 134     char device[] = "/dev/sda";
 135     device[5] = devchar;
 136     int r;
 137     suppress_error = 0;
 138     r = guestfs_blockdev_setrw (g, device);
 139     if (r == -1)
 140       return -1;
 141   }
 142   {
 143     int r;
 144     suppress_error = 0;
 145     r = guestfs_umount_all (g);
 146     if (r == -1)
 147       return -1;
 148   }
 149   {
 150     int r;
 151     suppress_error = 0;
 152     r = guestfs_lvm_remove_all (g);
 153     if (r == -1)
 154       return -1;
 155   }
 156   {
 157     char device[] = "/dev/sda";
 158     device[5] = devchar;
 159     char lines_0[] = ",";
 160     char *lines[] = {
 161       lines_0,
 162       NULL
 163     };
 164     int r;
 165     suppress_error = 0;
 166     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 167     if (r == -1)
 168       return -1;
 169   }
 170   {
 171     char fstype[] = "ext2";
 172     char device[] = "/dev/sda1";
 173     device[5] = devchar;
 174     int r;
 175     suppress_error = 0;
 176     r = guestfs_mkfs (g, fstype, device);
 177     if (r == -1)
 178       return -1;
 179   }
 180   {
 181     char device[] = "/dev/sda1";
 182     device[5] = devchar;
 183     char mountpoint[] = "/";
 184     int r;
 185     suppress_error = 0;
 186     r = guestfs_mount (g, device, mountpoint);
 187     if (r == -1)
 188       return -1;
 189   }
 190   /* TestOutputList for find (0) */
 191   {
 192     char directory[] = "/";
 193     char **r;
 194     int i;
 195     suppress_error = 0;
 196     r = guestfs_find (g, directory);
 197     if (r == NULL)
 198       return -1;
 199     if (!r[0]) {
 200       fprintf (stderr, "test_find_0: short list returned from command\n");
 201       print_strings (r);
 202       return -1;
 203     }
 204     {
 205       char expected[] = "lost+found";
 206       if (strcmp (r[0], expected) != 0) {
 207         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 208         return -1;
 209       }
 210     }
 211     if (r[1] != NULL) {
 212       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 213       print_strings (r);
 214       return -1;
 215     }
 216     for (i = 0; r[i] != NULL; ++i)
 217       free (r[i]);
 218     free (r);
 219   }
 220   return 0;
 221 }
 222
 223 static int test_find_1 (void)
 224 {
 225   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
 226   {
 227     char device[] = "/dev/sda";
 228     device[5] = devchar;
 229     int r;
 230     suppress_error = 0;
 231     r = guestfs_blockdev_setrw (g, device);
 232     if (r == -1)
 233       return -1;
 234   }
 235   {
 236     int r;
 237     suppress_error = 0;
 238     r = guestfs_umount_all (g);
 239     if (r == -1)
 240       return -1;
 241   }
 242   {
 243     int r;
 244     suppress_error = 0;
 245     r = guestfs_lvm_remove_all (g);
 246     if (r == -1)
 247       return -1;
 248   }
 249   {
 250     char device[] = "/dev/sda";
 251     device[5] = devchar;
 252     char lines_0[] = ",";
 253     char *lines[] = {
 254       lines_0,
 255       NULL
 256     };
 257     int r;
 258     suppress_error = 0;
 259     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 260     if (r == -1)
 261       return -1;
 262   }
 263   {
 264     char fstype[] = "ext2";
 265     char device[] = "/dev/sda1";
 266     device[5] = devchar;
 267     int r;
 268     suppress_error = 0;
 269     r = guestfs_mkfs (g, fstype, device);
 270     if (r == -1)
 271       return -1;
 272   }
 273   {
 274     char device[] = "/dev/sda1";
 275     device[5] = devchar;
 276     char mountpoint[] = "/";
 277     int r;
 278     suppress_error = 0;
 279     r = guestfs_mount (g, device, mountpoint);
 280     if (r == -1)
 281       return -1;
 282   }
 283   /* TestOutputList for find (1) */
 284   {
 285     char path[] = "/a";
 286     int r;
 287     suppress_error = 0;
 288     r = guestfs_touch (g, path);
 289     if (r == -1)
 290       return -1;
 291   }
 292   {
 293     char path[] = "/b";
 294     int r;
 295     suppress_error = 0;
 296     r = guestfs_mkdir (g, path);
 297     if (r == -1)
 298       return -1;
 299   }
 300   {
 301     char path[] = "/b/c";
 302     int r;
 303     suppress_error = 0;
 304     r = guestfs_touch (g, path);
 305     if (r == -1)
 306       return -1;
 307   }
 308   {
 309     char directory[] = "/";
 310     char **r;
 311     int i;
 312     suppress_error = 0;
 313     r = guestfs_find (g, directory);
 314     if (r == NULL)
 315       return -1;
 316     if (!r[0]) {
 317       fprintf (stderr, "test_find_1: short list returned from command\n");
 318       print_strings (r);
 319       return -1;
 320     }
 321     {
 322       char expected[] = "a";
 323       if (strcmp (r[0], expected) != 0) {
 324         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 325         return -1;
 326       }
 327     }
 328     if (!r[1]) {
 329       fprintf (stderr, "test_find_1: short list returned from command\n");
 330       print_strings (r);
 331       return -1;
 332     }
 333     {
 334       char expected[] = "b";
 335       if (strcmp (r[1], expected) != 0) {
 336         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 337         return -1;
 338       }
 339     }
 340     if (!r[2]) {
 341       fprintf (stderr, "test_find_1: short list returned from command\n");
 342       print_strings (r);
 343       return -1;
 344     }
 345     {
 346       char expected[] = "b/c";
 347       if (strcmp (r[2], expected) != 0) {
 348         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 349         return -1;
 350       }
 351     }
 352     if (!r[3]) {
 353       fprintf (stderr, "test_find_1: short list returned from command\n");
 354       print_strings (r);
 355       return -1;
 356     }
 357     {
 358       char expected[] = "lost+found";
 359       if (strcmp (r[3], expected) != 0) {
 360         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 361         return -1;
 362       }
 363     }
 364     if (r[4] != NULL) {
 365       fprintf (stderr, "test_find_1: extra elements returned from command\n");
 366       print_strings (r);
 367       return -1;
 368     }
 369     for (i = 0; r[i] != NULL; ++i)
 370       free (r[i]);
 371     free (r);
 372   }
 373   return 0;
 374 }
 375
 376 static int test_find_2 (void)
 377 {
 378   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
 379   {
 380     char device[] = "/dev/sda";
 381     device[5] = devchar;
 382     int r;
 383     suppress_error = 0;
 384     r = guestfs_blockdev_setrw (g, device);
 385     if (r == -1)
 386       return -1;
 387   }
 388   {
 389     int r;
 390     suppress_error = 0;
 391     r = guestfs_umount_all (g);
 392     if (r == -1)
 393       return -1;
 394   }
 395   {
 396     int r;
 397     suppress_error = 0;
 398     r = guestfs_lvm_remove_all (g);
 399     if (r == -1)
 400       return -1;
 401   }
 402   {
 403     char device[] = "/dev/sda";
 404     device[5] = devchar;
 405     char lines_0[] = ",";
 406     char *lines[] = {
 407       lines_0,
 408       NULL
 409     };
 410     int r;
 411     suppress_error = 0;
 412     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 413     if (r == -1)
 414       return -1;
 415   }
 416   {
 417     char fstype[] = "ext2";
 418     char device[] = "/dev/sda1";
 419     device[5] = devchar;
 420     int r;
 421     suppress_error = 0;
 422     r = guestfs_mkfs (g, fstype, device);
 423     if (r == -1)
 424       return -1;
 425   }
 426   {
 427     char device[] = "/dev/sda1";
 428     device[5] = devchar;
 429     char mountpoint[] = "/";
 430     int r;
 431     suppress_error = 0;
 432     r = guestfs_mount (g, device, mountpoint);
 433     if (r == -1)
 434       return -1;
 435   }
 436   /* TestOutputList for find (2) */
 437   {
 438     char path[] = "/a/b/c";
 439     int r;
 440     suppress_error = 0;
 441     r = guestfs_mkdir_p (g, path);
 442     if (r == -1)
 443       return -1;
 444   }
 445   {
 446     char path[] = "/a/b/c/d";
 447     int r;
 448     suppress_error = 0;
 449     r = guestfs_touch (g, path);
 450     if (r == -1)
 451       return -1;
 452   }
 453   {
 454     char directory[] = "/a/b/";
 455     char **r;
 456     int i;
 457     suppress_error = 0;
 458     r = guestfs_find (g, directory);
 459     if (r == NULL)
 460       return -1;
 461     if (!r[0]) {
 462       fprintf (stderr, "test_find_2: short list returned from command\n");
 463       print_strings (r);
 464       return -1;
 465     }
 466     {
 467       char expected[] = "c";
 468       if (strcmp (r[0], expected) != 0) {
 469         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 470         return -1;
 471       }
 472     }
 473     if (!r[1]) {
 474       fprintf (stderr, "test_find_2: short list returned from command\n");
 475       print_strings (r);
 476       return -1;
 477     }
 478     {
 479       char expected[] = "c/d";
 480       if (strcmp (r[1], expected) != 0) {
 481         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 482         return -1;
 483       }
 484     }
 485     if (r[2] != NULL) {
 486       fprintf (stderr, "test_find_2: extra elements returned from command\n");
 487       print_strings (r);
 488       return -1;
 489     }
 490     for (i = 0; r[i] != NULL; ++i)
 491       free (r[i]);
 492     free (r);
 493   }
 494   return 0;
 495 }
 496
 497 static int test_lvresize_0 (void)
 498 {
 499   /* InitNone|InitEmpty for test_lvresize_0 */
 500   {
 501     char device[] = "/dev/sda";
 502     device[5] = devchar;
 503     int r;
 504     suppress_error = 0;
 505     r = guestfs_blockdev_setrw (g, device);
 506     if (r == -1)
 507       return -1;
 508   }
 509   {
 510     int r;
 511     suppress_error = 0;
 512     r = guestfs_umount_all (g);
 513     if (r == -1)
 514       return -1;
 515   }
 516   {
 517     int r;
 518     suppress_error = 0;
 519     r = guestfs_lvm_remove_all (g);
 520     if (r == -1)
 521       return -1;
 522   }
 523   /* TestOutput for lvresize (0) */
 524   char expected[] = "test content";
 525   {
 526     char device[] = "/dev/sda";
 527     device[5] = devchar;
 528     char lines_0[] = ",";
 529     char *lines[] = {
 530       lines_0,
 531       NULL
 532     };
 533     int r;
 534     suppress_error = 0;
 535     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 536     if (r == -1)
 537       return -1;
 538   }
 539   {
 540     char device[] = "/dev/sda1";
 541     device[5] = devchar;
 542     int r;
 543     suppress_error = 0;
 544     r = guestfs_pvcreate (g, device);
 545     if (r == -1)
 546       return -1;
 547   }
 548   {
 549     char volgroup[] = "VG";
 550     char physvols_0[] = "/dev/sda1";
 551     physvols_0[5] = devchar;
 552     char *physvols[] = {
 553       physvols_0,
 554       NULL
 555     };
 556     int r;
 557     suppress_error = 0;
 558     r = guestfs_vgcreate (g, volgroup, physvols);
 559     if (r == -1)
 560       return -1;
 561   }
 562   {
 563     char logvol[] = "LV";
 564     char volgroup[] = "VG";
 565     int r;
 566     suppress_error = 0;
 567     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 568     if (r == -1)
 569       return -1;
 570   }
 571   {
 572     char fstype[] = "ext2";
 573     char device[] = "/dev/VG/LV";
 574     int r;
 575     suppress_error = 0;
 576     r = guestfs_mkfs (g, fstype, device);
 577     if (r == -1)
 578       return -1;
 579   }
 580   {
 581     char device[] = "/dev/VG/LV";
 582     char mountpoint[] = "/";
 583     int r;
 584     suppress_error = 0;
 585     r = guestfs_mount (g, device, mountpoint);
 586     if (r == -1)
 587       return -1;
 588   }
 589   {
 590     char path[] = "/new";
 591     char content[] = "test content";
 592     int r;
 593     suppress_error = 0;
 594     r = guestfs_write_file (g, path, content, 0);
 595     if (r == -1)
 596       return -1;
 597   }
 598   {
 599     char pathordevice[] = "/";
 600     int r;
 601     suppress_error = 0;
 602     r = guestfs_umount (g, pathordevice);
 603     if (r == -1)
 604       return -1;
 605   }
 606   {
 607     char device[] = "/dev/VG/LV";
 608     int r;
 609     suppress_error = 0;
 610     r = guestfs_lvresize (g, device, 20);
 611     if (r == -1)
 612       return -1;
 613   }
 614   {
 615     char device[] = "/dev/VG/LV";
 616     int r;
 617     suppress_error = 0;
 618     r = guestfs_e2fsck_f (g, device);
 619     if (r == -1)
 620       return -1;
 621   }
 622   {
 623     char device[] = "/dev/VG/LV";
 624     int r;
 625     suppress_error = 0;
 626     r = guestfs_resize2fs (g, device);
 627     if (r == -1)
 628       return -1;
 629   }
 630   {
 631     char device[] = "/dev/VG/LV";
 632     char mountpoint[] = "/";
 633     int r;
 634     suppress_error = 0;
 635     r = guestfs_mount (g, device, mountpoint);
 636     if (r == -1)
 637       return -1;
 638   }
 639   {
 640     char path[] = "/new";
 641     char *r;
 642     suppress_error = 0;
 643     r = guestfs_cat (g, path);
 644     if (r == NULL)
 645       return -1;
 646     if (strcmp (r, expected) != 0) {
 647       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 648       return -1;
 649     }
 650     free (r);
 651   }
 652   return 0;
 653 }
 654
 655 static int test_zerofree_0_prereq (void)
 656 {
 657   const char *str = getenv ("SKIP_ZEROFREE");
 658   return str && strcmp (str, "1") == 0;
 659 }
 660
 661 static int test_zerofree_0 (void)
 662 {
 663   if (! test_zerofree_0_prereq ()) {
 664   /* InitNone|InitEmpty for test_zerofree_0 */
 665   {
 666     char device[] = "/dev/sda";
 667     device[5] = devchar;
 668     int r;
 669     suppress_error = 0;
 670     r = guestfs_blockdev_setrw (g, device);
 671     if (r == -1)
 672       return -1;
 673   }
 674   {
 675     int r;
 676     suppress_error = 0;
 677     r = guestfs_umount_all (g);
 678     if (r == -1)
 679       return -1;
 680   }
 681   {
 682     int r;
 683     suppress_error = 0;
 684     r = guestfs_lvm_remove_all (g);
 685     if (r == -1)
 686       return -1;
 687   }
 688   /* TestOutput for zerofree (0) */
 689   char expected[] = "test file";
 690   {
 691     char device[] = "/dev/sda";
 692     device[5] = devchar;
 693     char lines_0[] = ",";
 694     char *lines[] = {
 695       lines_0,
 696       NULL
 697     };
 698     int r;
 699     suppress_error = 0;
 700     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 701     if (r == -1)
 702       return -1;
 703   }
 704   {
 705     char fstype[] = "ext3";
 706     char device[] = "/dev/sda1";
 707     device[5] = devchar;
 708     int r;
 709     suppress_error = 0;
 710     r = guestfs_mkfs (g, fstype, device);
 711     if (r == -1)
 712       return -1;
 713   }
 714   {
 715     char device[] = "/dev/sda1";
 716     device[5] = devchar;
 717     char mountpoint[] = "/";
 718     int r;
 719     suppress_error = 0;
 720     r = guestfs_mount (g, device, mountpoint);
 721     if (r == -1)
 722       return -1;
 723   }
 724   {
 725     char path[] = "/new";
 726     char content[] = "test file";
 727     int r;
 728     suppress_error = 0;
 729     r = guestfs_write_file (g, path, content, 0);
 730     if (r == -1)
 731       return -1;
 732   }
 733   {
 734     char pathordevice[] = "/dev/sda1";
 735     pathordevice[5] = devchar;
 736     int r;
 737     suppress_error = 0;
 738     r = guestfs_umount (g, pathordevice);
 739     if (r == -1)
 740       return -1;
 741   }
 742   {
 743     char device[] = "/dev/sda1";
 744     device[5] = devchar;
 745     int r;
 746     suppress_error = 0;
 747     r = guestfs_zerofree (g, device);
 748     if (r == -1)
 749       return -1;
 750   }
 751   {
 752     char device[] = "/dev/sda1";
 753     device[5] = devchar;
 754     char mountpoint[] = "/";
 755     int r;
 756     suppress_error = 0;
 757     r = guestfs_mount (g, device, mountpoint);
 758     if (r == -1)
 759       return -1;
 760   }
 761   {
 762     char path[] = "/new";
 763     char *r;
 764     suppress_error = 0;
 765     r = guestfs_cat (g, path);
 766     if (r == NULL)
 767       return -1;
 768     if (strcmp (r, expected) != 0) {
 769       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
 770       return -1;
 771     }
 772     free (r);
 773   }
 774   } else
 775     printf ("%s skipped (reason: test prerequisite)\n", "test_zerofree_0");
 776   return 0;
 777 }
 778
 779 static int test_hexdump_0 (void)
 780 {
 781   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
 782   {
 783     char device[] = "/dev/sda";
 784     device[5] = devchar;
 785     int r;
 786     suppress_error = 0;
 787     r = guestfs_blockdev_setrw (g, device);
 788     if (r == -1)
 789       return -1;
 790   }
 791   {
 792     int r;
 793     suppress_error = 0;
 794     r = guestfs_umount_all (g);
 795     if (r == -1)
 796       return -1;
 797   }
 798   {
 799     int r;
 800     suppress_error = 0;
 801     r = guestfs_lvm_remove_all (g);
 802     if (r == -1)
 803       return -1;
 804   }
 805   {
 806     char device[] = "/dev/sda";
 807     device[5] = devchar;
 808     char lines_0[] = ",";
 809     char *lines[] = {
 810       lines_0,
 811       NULL
 812     };
 813     int r;
 814     suppress_error = 0;
 815     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 816     if (r == -1)
 817       return -1;
 818   }
 819   {
 820     char fstype[] = "ext2";
 821     char device[] = "/dev/sda1";
 822     device[5] = devchar;
 823     int r;
 824     suppress_error = 0;
 825     r = guestfs_mkfs (g, fstype, device);
 826     if (r == -1)
 827       return -1;
 828   }
 829   {
 830     char device[] = "/dev/sda1";
 831     device[5] = devchar;
 832     char mountpoint[] = "/";
 833     int r;
 834     suppress_error = 0;
 835     r = guestfs_mount (g, device, mountpoint);
 836     if (r == -1)
 837       return -1;
 838   }
 839   /* TestOutput for hexdump (0) */
 840   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
 841   {
 842     char path[] = "/new";
 843     char content[] = "hello\nworld\n";
 844     int r;
 845     suppress_error = 0;
 846     r = guestfs_write_file (g, path, content, 12);
 847     if (r == -1)
 848       return -1;
 849   }
 850   {
 851     char path[] = "/new";
 852     char *r;
 853     suppress_error = 0;
 854     r = guestfs_hexdump (g, path);
 855     if (r == NULL)
 856       return -1;
 857     if (strcmp (r, expected) != 0) {
 858       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
 859       return -1;
 860     }
 861     free (r);
 862   }
 863   return 0;
 864 }
 865
 866 static int test_strings_e_0 (void)
 867 {
 868   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
 869   {
 870     char device[] = "/dev/sda";
 871     device[5] = devchar;
 872     int r;
 873     suppress_error = 0;
 874     r = guestfs_blockdev_setrw (g, device);
 875     if (r == -1)
 876       return -1;
 877   }
 878   {
 879     int r;
 880     suppress_error = 0;
 881     r = guestfs_umount_all (g);
 882     if (r == -1)
 883       return -1;
 884   }
 885   {
 886     int r;
 887     suppress_error = 0;
 888     r = guestfs_lvm_remove_all (g);
 889     if (r == -1)
 890       return -1;
 891   }
 892   {
 893     char device[] = "/dev/sda";
 894     device[5] = devchar;
 895     char lines_0[] = ",";
 896     char *lines[] = {
 897       lines_0,
 898       NULL
 899     };
 900     int r;
 901     suppress_error = 0;
 902     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 903     if (r == -1)
 904       return -1;
 905   }
 906   {
 907     char fstype[] = "ext2";
 908     char device[] = "/dev/sda1";
 909     device[5] = devchar;
 910     int r;
 911     suppress_error = 0;
 912     r = guestfs_mkfs (g, fstype, device);
 913     if (r == -1)
 914       return -1;
 915   }
 916   {
 917     char device[] = "/dev/sda1";
 918     device[5] = devchar;
 919     char mountpoint[] = "/";
 920     int r;
 921     suppress_error = 0;
 922     r = guestfs_mount (g, device, mountpoint);
 923     if (r == -1)
 924       return -1;
 925   }
 926   /* TestOutputList for strings_e (0) */
 927   {
 928     char path[] = "/new";
 929     char content[] = "hello\nworld\n";
 930     int r;
 931     suppress_error = 0;
 932     r = guestfs_write_file (g, path, content, 0);
 933     if (r == -1)
 934       return -1;
 935   }
 936   {
 937     char encoding[] = "b";
 938     char path[] = "/new";
 939     char **r;
 940     int i;
 941     suppress_error = 0;
 942     r = guestfs_strings_e (g, encoding, path);
 943     if (r == NULL)
 944       return -1;
 945     if (r[0] != NULL) {
 946       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
 947       print_strings (r);
 948       return -1;
 949     }
 950     for (i = 0; r[i] != NULL; ++i)
 951       free (r[i]);
 952     free (r);
 953   }
 954   return 0;
 955 }
 956
 957 static int test_strings_e_1 (void)
 958 {
 959   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
 960   return 0;
 961 }
 962
 963 static int test_strings_0 (void)
 964 {
 965   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
 966   {
 967     char device[] = "/dev/sda";
 968     device[5] = devchar;
 969     int r;
 970     suppress_error = 0;
 971     r = guestfs_blockdev_setrw (g, device);
 972     if (r == -1)
 973       return -1;
 974   }
 975   {
 976     int r;
 977     suppress_error = 0;
 978     r = guestfs_umount_all (g);
 979     if (r == -1)
 980       return -1;
 981   }
 982   {
 983     int r;
 984     suppress_error = 0;
 985     r = guestfs_lvm_remove_all (g);
 986     if (r == -1)
 987       return -1;
 988   }
 989   {
 990     char device[] = "/dev/sda";
 991     device[5] = devchar;
 992     char lines_0[] = ",";
 993     char *lines[] = {
 994       lines_0,
 995       NULL
 996     };
 997     int r;
 998     suppress_error = 0;
 999     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1000     if (r == -1)
1001       return -1;
1002   }
1003   {
1004     char fstype[] = "ext2";
1005     char device[] = "/dev/sda1";
1006     device[5] = devchar;
1007     int r;
1008     suppress_error = 0;
1009     r = guestfs_mkfs (g, fstype, device);
1010     if (r == -1)
1011       return -1;
1012   }
1013   {
1014     char device[] = "/dev/sda1";
1015     device[5] = devchar;
1016     char mountpoint[] = "/";
1017     int r;
1018     suppress_error = 0;
1019     r = guestfs_mount (g, device, mountpoint);
1020     if (r == -1)
1021       return -1;
1022   }
1023   /* TestOutputList for strings (0) */
1024   {
1025     char path[] = "/new";
1026     char content[] = "hello\nworld\n";
1027     int r;
1028     suppress_error = 0;
1029     r = guestfs_write_file (g, path, content, 0);
1030     if (r == -1)
1031       return -1;
1032   }
1033   {
1034     char path[] = "/new";
1035     char **r;
1036     int i;
1037     suppress_error = 0;
1038     r = guestfs_strings (g, path);
1039     if (r == NULL)
1040       return -1;
1041     if (!r[0]) {
1042       fprintf (stderr, "test_strings_0: short list returned from command\n");
1043       print_strings (r);
1044       return -1;
1045     }
1046     {
1047       char expected[] = "hello";
1048       if (strcmp (r[0], expected) != 0) {
1049         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1050         return -1;
1051       }
1052     }
1053     if (!r[1]) {
1054       fprintf (stderr, "test_strings_0: short list returned from command\n");
1055       print_strings (r);
1056       return -1;
1057     }
1058     {
1059       char expected[] = "world";
1060       if (strcmp (r[1], expected) != 0) {
1061         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1062         return -1;
1063       }
1064     }
1065     if (r[2] != NULL) {
1066       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1067       print_strings (r);
1068       return -1;
1069     }
1070     for (i = 0; r[i] != NULL; ++i)
1071       free (r[i]);
1072     free (r);
1073   }
1074   return 0;
1075 }
1076
1077 static int test_strings_1 (void)
1078 {
1079   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1080   {
1081     char device[] = "/dev/sda";
1082     device[5] = devchar;
1083     int r;
1084     suppress_error = 0;
1085     r = guestfs_blockdev_setrw (g, device);
1086     if (r == -1)
1087       return -1;
1088   }
1089   {
1090     int r;
1091     suppress_error = 0;
1092     r = guestfs_umount_all (g);
1093     if (r == -1)
1094       return -1;
1095   }
1096   {
1097     int r;
1098     suppress_error = 0;
1099     r = guestfs_lvm_remove_all (g);
1100     if (r == -1)
1101       return -1;
1102   }
1103   {
1104     char device[] = "/dev/sda";
1105     device[5] = devchar;
1106     char lines_0[] = ",";
1107     char *lines[] = {
1108       lines_0,
1109       NULL
1110     };
1111     int r;
1112     suppress_error = 0;
1113     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1114     if (r == -1)
1115       return -1;
1116   }
1117   {
1118     char fstype[] = "ext2";
1119     char device[] = "/dev/sda1";
1120     device[5] = devchar;
1121     int r;
1122     suppress_error = 0;
1123     r = guestfs_mkfs (g, fstype, device);
1124     if (r == -1)
1125       return -1;
1126   }
1127   {
1128     char device[] = "/dev/sda1";
1129     device[5] = devchar;
1130     char mountpoint[] = "/";
1131     int r;
1132     suppress_error = 0;
1133     r = guestfs_mount (g, device, mountpoint);
1134     if (r == -1)
1135       return -1;
1136   }
1137   /* TestOutputList for strings (1) */
1138   {
1139     char path[] = "/new";
1140     int r;
1141     suppress_error = 0;
1142     r = guestfs_touch (g, path);
1143     if (r == -1)
1144       return -1;
1145   }
1146   {
1147     char path[] = "/new";
1148     char **r;
1149     int i;
1150     suppress_error = 0;
1151     r = guestfs_strings (g, path);
1152     if (r == NULL)
1153       return -1;
1154     if (r[0] != NULL) {
1155       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1156       print_strings (r);
1157       return -1;
1158     }
1159     for (i = 0; r[i] != NULL; ++i)
1160       free (r[i]);
1161     free (r);
1162   }
1163   return 0;
1164 }
1165
1166 static int test_equal_0 (void)
1167 {
1168   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1169   {
1170     char device[] = "/dev/sda";
1171     device[5] = devchar;
1172     int r;
1173     suppress_error = 0;
1174     r = guestfs_blockdev_setrw (g, device);
1175     if (r == -1)
1176       return -1;
1177   }
1178   {
1179     int r;
1180     suppress_error = 0;
1181     r = guestfs_umount_all (g);
1182     if (r == -1)
1183       return -1;
1184   }
1185   {
1186     int r;
1187     suppress_error = 0;
1188     r = guestfs_lvm_remove_all (g);
1189     if (r == -1)
1190       return -1;
1191   }
1192   {
1193     char device[] = "/dev/sda";
1194     device[5] = devchar;
1195     char lines_0[] = ",";
1196     char *lines[] = {
1197       lines_0,
1198       NULL
1199     };
1200     int r;
1201     suppress_error = 0;
1202     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1203     if (r == -1)
1204       return -1;
1205   }
1206   {
1207     char fstype[] = "ext2";
1208     char device[] = "/dev/sda1";
1209     device[5] = devchar;
1210     int r;
1211     suppress_error = 0;
1212     r = guestfs_mkfs (g, fstype, device);
1213     if (r == -1)
1214       return -1;
1215   }
1216   {
1217     char device[] = "/dev/sda1";
1218     device[5] = devchar;
1219     char mountpoint[] = "/";
1220     int r;
1221     suppress_error = 0;
1222     r = guestfs_mount (g, device, mountpoint);
1223     if (r == -1)
1224       return -1;
1225   }
1226   /* TestOutputTrue for equal (0) */
1227   {
1228     char path[] = "/file1";
1229     char content[] = "contents of a file";
1230     int r;
1231     suppress_error = 0;
1232     r = guestfs_write_file (g, path, content, 0);
1233     if (r == -1)
1234       return -1;
1235   }
1236   {
1237     char src[] = "/file1";
1238     char dest[] = "/file2";
1239     int r;
1240     suppress_error = 0;
1241     r = guestfs_cp (g, src, dest);
1242     if (r == -1)
1243       return -1;
1244   }
1245   {
1246     char file1[] = "/file1";
1247     char file2[] = "/file2";
1248     int r;
1249     suppress_error = 0;
1250     r = guestfs_equal (g, file1, file2);
1251     if (r == -1)
1252       return -1;
1253     if (!r) {
1254       fprintf (stderr, "test_equal_0: expected true, got false\n");
1255       return -1;
1256     }
1257   }
1258   return 0;
1259 }
1260
1261 static int test_equal_1 (void)
1262 {
1263   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1264   {
1265     char device[] = "/dev/sda";
1266     device[5] = devchar;
1267     int r;
1268     suppress_error = 0;
1269     r = guestfs_blockdev_setrw (g, device);
1270     if (r == -1)
1271       return -1;
1272   }
1273   {
1274     int r;
1275     suppress_error = 0;
1276     r = guestfs_umount_all (g);
1277     if (r == -1)
1278       return -1;
1279   }
1280   {
1281     int r;
1282     suppress_error = 0;
1283     r = guestfs_lvm_remove_all (g);
1284     if (r == -1)
1285       return -1;
1286   }
1287   {
1288     char device[] = "/dev/sda";
1289     device[5] = devchar;
1290     char lines_0[] = ",";
1291     char *lines[] = {
1292       lines_0,
1293       NULL
1294     };
1295     int r;
1296     suppress_error = 0;
1297     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1298     if (r == -1)
1299       return -1;
1300   }
1301   {
1302     char fstype[] = "ext2";
1303     char device[] = "/dev/sda1";
1304     device[5] = devchar;
1305     int r;
1306     suppress_error = 0;
1307     r = guestfs_mkfs (g, fstype, device);
1308     if (r == -1)
1309       return -1;
1310   }
1311   {
1312     char device[] = "/dev/sda1";
1313     device[5] = devchar;
1314     char mountpoint[] = "/";
1315     int r;
1316     suppress_error = 0;
1317     r = guestfs_mount (g, device, mountpoint);
1318     if (r == -1)
1319       return -1;
1320   }
1321   /* TestOutputFalse for equal (1) */
1322   {
1323     char path[] = "/file1";
1324     char content[] = "contents of a file";
1325     int r;
1326     suppress_error = 0;
1327     r = guestfs_write_file (g, path, content, 0);
1328     if (r == -1)
1329       return -1;
1330   }
1331   {
1332     char path[] = "/file2";
1333     char content[] = "contents of another file";
1334     int r;
1335     suppress_error = 0;
1336     r = guestfs_write_file (g, path, content, 0);
1337     if (r == -1)
1338       return -1;
1339   }
1340   {
1341     char file1[] = "/file1";
1342     char file2[] = "/file2";
1343     int r;
1344     suppress_error = 0;
1345     r = guestfs_equal (g, file1, file2);
1346     if (r == -1)
1347       return -1;
1348     if (r) {
1349       fprintf (stderr, "test_equal_1: expected false, got true\n");
1350       return -1;
1351     }
1352   }
1353   return 0;
1354 }
1355
1356 static int test_equal_2 (void)
1357 {
1358   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1359   {
1360     char device[] = "/dev/sda";
1361     device[5] = devchar;
1362     int r;
1363     suppress_error = 0;
1364     r = guestfs_blockdev_setrw (g, device);
1365     if (r == -1)
1366       return -1;
1367   }
1368   {
1369     int r;
1370     suppress_error = 0;
1371     r = guestfs_umount_all (g);
1372     if (r == -1)
1373       return -1;
1374   }
1375   {
1376     int r;
1377     suppress_error = 0;
1378     r = guestfs_lvm_remove_all (g);
1379     if (r == -1)
1380       return -1;
1381   }
1382   {
1383     char device[] = "/dev/sda";
1384     device[5] = devchar;
1385     char lines_0[] = ",";
1386     char *lines[] = {
1387       lines_0,
1388       NULL
1389     };
1390     int r;
1391     suppress_error = 0;
1392     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1393     if (r == -1)
1394       return -1;
1395   }
1396   {
1397     char fstype[] = "ext2";
1398     char device[] = "/dev/sda1";
1399     device[5] = devchar;
1400     int r;
1401     suppress_error = 0;
1402     r = guestfs_mkfs (g, fstype, device);
1403     if (r == -1)
1404       return -1;
1405   }
1406   {
1407     char device[] = "/dev/sda1";
1408     device[5] = devchar;
1409     char mountpoint[] = "/";
1410     int r;
1411     suppress_error = 0;
1412     r = guestfs_mount (g, device, mountpoint);
1413     if (r == -1)
1414       return -1;
1415   }
1416   /* TestLastFail for equal (2) */
1417   {
1418     char file1[] = "/file1";
1419     char file2[] = "/file2";
1420     int r;
1421     suppress_error = 1;
1422     r = guestfs_equal (g, file1, file2);
1423     if (r != -1)
1424       return -1;
1425   }
1426   return 0;
1427 }
1428
1429 static int test_ping_daemon_0 (void)
1430 {
1431   /* InitNone|InitEmpty for test_ping_daemon_0 */
1432   {
1433     char device[] = "/dev/sda";
1434     device[5] = devchar;
1435     int r;
1436     suppress_error = 0;
1437     r = guestfs_blockdev_setrw (g, device);
1438     if (r == -1)
1439       return -1;
1440   }
1441   {
1442     int r;
1443     suppress_error = 0;
1444     r = guestfs_umount_all (g);
1445     if (r == -1)
1446       return -1;
1447   }
1448   {
1449     int r;
1450     suppress_error = 0;
1451     r = guestfs_lvm_remove_all (g);
1452     if (r == -1)
1453       return -1;
1454   }
1455   /* TestRun for ping_daemon (0) */
1456   {
1457     int r;
1458     suppress_error = 0;
1459     r = guestfs_ping_daemon (g);
1460     if (r == -1)
1461       return -1;
1462   }
1463   return 0;
1464 }
1465
1466 static int test_dmesg_0 (void)
1467 {
1468   /* InitNone|InitEmpty for test_dmesg_0 */
1469   {
1470     char device[] = "/dev/sda";
1471     device[5] = devchar;
1472     int r;
1473     suppress_error = 0;
1474     r = guestfs_blockdev_setrw (g, device);
1475     if (r == -1)
1476       return -1;
1477   }
1478   {
1479     int r;
1480     suppress_error = 0;
1481     r = guestfs_umount_all (g);
1482     if (r == -1)
1483       return -1;
1484   }
1485   {
1486     int r;
1487     suppress_error = 0;
1488     r = guestfs_lvm_remove_all (g);
1489     if (r == -1)
1490       return -1;
1491   }
1492   /* TestRun for dmesg (0) */
1493   {
1494     char *r;
1495     suppress_error = 0;
1496     r = guestfs_dmesg (g);
1497     if (r == NULL)
1498       return -1;
1499     free (r);
1500   }
1501   return 0;
1502 }
1503
1504 static int test_drop_caches_0 (void)
1505 {
1506   /* InitNone|InitEmpty for test_drop_caches_0 */
1507   {
1508     char device[] = "/dev/sda";
1509     device[5] = devchar;
1510     int r;
1511     suppress_error = 0;
1512     r = guestfs_blockdev_setrw (g, device);
1513     if (r == -1)
1514       return -1;
1515   }
1516   {
1517     int r;
1518     suppress_error = 0;
1519     r = guestfs_umount_all (g);
1520     if (r == -1)
1521       return -1;
1522   }
1523   {
1524     int r;
1525     suppress_error = 0;
1526     r = guestfs_lvm_remove_all (g);
1527     if (r == -1)
1528       return -1;
1529   }
1530   /* TestRun for drop_caches (0) */
1531   {
1532     int r;
1533     suppress_error = 0;
1534     r = guestfs_drop_caches (g, 3);
1535     if (r == -1)
1536       return -1;
1537   }
1538   return 0;
1539 }
1540
1541 static int test_mv_0 (void)
1542 {
1543   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1544   {
1545     char device[] = "/dev/sda";
1546     device[5] = devchar;
1547     int r;
1548     suppress_error = 0;
1549     r = guestfs_blockdev_setrw (g, device);
1550     if (r == -1)
1551       return -1;
1552   }
1553   {
1554     int r;
1555     suppress_error = 0;
1556     r = guestfs_umount_all (g);
1557     if (r == -1)
1558       return -1;
1559   }
1560   {
1561     int r;
1562     suppress_error = 0;
1563     r = guestfs_lvm_remove_all (g);
1564     if (r == -1)
1565       return -1;
1566   }
1567   {
1568     char device[] = "/dev/sda";
1569     device[5] = devchar;
1570     char lines_0[] = ",";
1571     char *lines[] = {
1572       lines_0,
1573       NULL
1574     };
1575     int r;
1576     suppress_error = 0;
1577     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1578     if (r == -1)
1579       return -1;
1580   }
1581   {
1582     char fstype[] = "ext2";
1583     char device[] = "/dev/sda1";
1584     device[5] = devchar;
1585     int r;
1586     suppress_error = 0;
1587     r = guestfs_mkfs (g, fstype, device);
1588     if (r == -1)
1589       return -1;
1590   }
1591   {
1592     char device[] = "/dev/sda1";
1593     device[5] = devchar;
1594     char mountpoint[] = "/";
1595     int r;
1596     suppress_error = 0;
1597     r = guestfs_mount (g, device, mountpoint);
1598     if (r == -1)
1599       return -1;
1600   }
1601   /* TestOutput for mv (0) */
1602   char expected[] = "file content";
1603   {
1604     char path[] = "/old";
1605     char content[] = "file content";
1606     int r;
1607     suppress_error = 0;
1608     r = guestfs_write_file (g, path, content, 0);
1609     if (r == -1)
1610       return -1;
1611   }
1612   {
1613     char src[] = "/old";
1614     char dest[] = "/new";
1615     int r;
1616     suppress_error = 0;
1617     r = guestfs_mv (g, src, dest);
1618     if (r == -1)
1619       return -1;
1620   }
1621   {
1622     char path[] = "/new";
1623     char *r;
1624     suppress_error = 0;
1625     r = guestfs_cat (g, path);
1626     if (r == NULL)
1627       return -1;
1628     if (strcmp (r, expected) != 0) {
1629       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1630       return -1;
1631     }
1632     free (r);
1633   }
1634   return 0;
1635 }
1636
1637 static int test_mv_1 (void)
1638 {
1639   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1640   {
1641     char device[] = "/dev/sda";
1642     device[5] = devchar;
1643     int r;
1644     suppress_error = 0;
1645     r = guestfs_blockdev_setrw (g, device);
1646     if (r == -1)
1647       return -1;
1648   }
1649   {
1650     int r;
1651     suppress_error = 0;
1652     r = guestfs_umount_all (g);
1653     if (r == -1)
1654       return -1;
1655   }
1656   {
1657     int r;
1658     suppress_error = 0;
1659     r = guestfs_lvm_remove_all (g);
1660     if (r == -1)
1661       return -1;
1662   }
1663   {
1664     char device[] = "/dev/sda";
1665     device[5] = devchar;
1666     char lines_0[] = ",";
1667     char *lines[] = {
1668       lines_0,
1669       NULL
1670     };
1671     int r;
1672     suppress_error = 0;
1673     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1674     if (r == -1)
1675       return -1;
1676   }
1677   {
1678     char fstype[] = "ext2";
1679     char device[] = "/dev/sda1";
1680     device[5] = devchar;
1681     int r;
1682     suppress_error = 0;
1683     r = guestfs_mkfs (g, fstype, device);
1684     if (r == -1)
1685       return -1;
1686   }
1687   {
1688     char device[] = "/dev/sda1";
1689     device[5] = devchar;
1690     char mountpoint[] = "/";
1691     int r;
1692     suppress_error = 0;
1693     r = guestfs_mount (g, device, mountpoint);
1694     if (r == -1)
1695       return -1;
1696   }
1697   /* TestOutputFalse for mv (1) */
1698   {
1699     char path[] = "/old";
1700     char content[] = "file content";
1701     int r;
1702     suppress_error = 0;
1703     r = guestfs_write_file (g, path, content, 0);
1704     if (r == -1)
1705       return -1;
1706   }
1707   {
1708     char src[] = "/old";
1709     char dest[] = "/new";
1710     int r;
1711     suppress_error = 0;
1712     r = guestfs_mv (g, src, dest);
1713     if (r == -1)
1714       return -1;
1715   }
1716   {
1717     char path[] = "/old";
1718     int r;
1719     suppress_error = 0;
1720     r = guestfs_is_file (g, path);
1721     if (r == -1)
1722       return -1;
1723     if (r) {
1724       fprintf (stderr, "test_mv_1: expected false, got true\n");
1725       return -1;
1726     }
1727   }
1728   return 0;
1729 }
1730
1731 static int test_cp_a_0 (void)
1732 {
1733   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
1734   {
1735     char device[] = "/dev/sda";
1736     device[5] = devchar;
1737     int r;
1738     suppress_error = 0;
1739     r = guestfs_blockdev_setrw (g, device);
1740     if (r == -1)
1741       return -1;
1742   }
1743   {
1744     int r;
1745     suppress_error = 0;
1746     r = guestfs_umount_all (g);
1747     if (r == -1)
1748       return -1;
1749   }
1750   {
1751     int r;
1752     suppress_error = 0;
1753     r = guestfs_lvm_remove_all (g);
1754     if (r == -1)
1755       return -1;
1756   }
1757   {
1758     char device[] = "/dev/sda";
1759     device[5] = devchar;
1760     char lines_0[] = ",";
1761     char *lines[] = {
1762       lines_0,
1763       NULL
1764     };
1765     int r;
1766     suppress_error = 0;
1767     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1768     if (r == -1)
1769       return -1;
1770   }
1771   {
1772     char fstype[] = "ext2";
1773     char device[] = "/dev/sda1";
1774     device[5] = devchar;
1775     int r;
1776     suppress_error = 0;
1777     r = guestfs_mkfs (g, fstype, device);
1778     if (r == -1)
1779       return -1;
1780   }
1781   {
1782     char device[] = "/dev/sda1";
1783     device[5] = devchar;
1784     char mountpoint[] = "/";
1785     int r;
1786     suppress_error = 0;
1787     r = guestfs_mount (g, device, mountpoint);
1788     if (r == -1)
1789       return -1;
1790   }
1791   /* TestOutput for cp_a (0) */
1792   char expected[] = "file content";
1793   {
1794     char path[] = "/olddir";
1795     int r;
1796     suppress_error = 0;
1797     r = guestfs_mkdir (g, path);
1798     if (r == -1)
1799       return -1;
1800   }
1801   {
1802     char path[] = "/newdir";
1803     int r;
1804     suppress_error = 0;
1805     r = guestfs_mkdir (g, path);
1806     if (r == -1)
1807       return -1;
1808   }
1809   {
1810     char path[] = "/olddir/file";
1811     char content[] = "file content";
1812     int r;
1813     suppress_error = 0;
1814     r = guestfs_write_file (g, path, content, 0);
1815     if (r == -1)
1816       return -1;
1817   }
1818   {
1819     char src[] = "/olddir";
1820     char dest[] = "/newdir";
1821     int r;
1822     suppress_error = 0;
1823     r = guestfs_cp_a (g, src, dest);
1824     if (r == -1)
1825       return -1;
1826   }
1827   {
1828     char path[] = "/newdir/olddir/file";
1829     char *r;
1830     suppress_error = 0;
1831     r = guestfs_cat (g, path);
1832     if (r == NULL)
1833       return -1;
1834     if (strcmp (r, expected) != 0) {
1835       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1836       return -1;
1837     }
1838     free (r);
1839   }
1840   return 0;
1841 }
1842
1843 static int test_cp_0 (void)
1844 {
1845   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
1846   {
1847     char device[] = "/dev/sda";
1848     device[5] = devchar;
1849     int r;
1850     suppress_error = 0;
1851     r = guestfs_blockdev_setrw (g, device);
1852     if (r == -1)
1853       return -1;
1854   }
1855   {
1856     int r;
1857     suppress_error = 0;
1858     r = guestfs_umount_all (g);
1859     if (r == -1)
1860       return -1;
1861   }
1862   {
1863     int r;
1864     suppress_error = 0;
1865     r = guestfs_lvm_remove_all (g);
1866     if (r == -1)
1867       return -1;
1868   }
1869   {
1870     char device[] = "/dev/sda";
1871     device[5] = devchar;
1872     char lines_0[] = ",";
1873     char *lines[] = {
1874       lines_0,
1875       NULL
1876     };
1877     int r;
1878     suppress_error = 0;
1879     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1880     if (r == -1)
1881       return -1;
1882   }
1883   {
1884     char fstype[] = "ext2";
1885     char device[] = "/dev/sda1";
1886     device[5] = devchar;
1887     int r;
1888     suppress_error = 0;
1889     r = guestfs_mkfs (g, fstype, device);
1890     if (r == -1)
1891       return -1;
1892   }
1893   {
1894     char device[] = "/dev/sda1";
1895     device[5] = devchar;
1896     char mountpoint[] = "/";
1897     int r;
1898     suppress_error = 0;
1899     r = guestfs_mount (g, device, mountpoint);
1900     if (r == -1)
1901       return -1;
1902   }
1903   /* TestOutput for cp (0) */
1904   char expected[] = "file content";
1905   {
1906     char path[] = "/old";
1907     char content[] = "file content";
1908     int r;
1909     suppress_error = 0;
1910     r = guestfs_write_file (g, path, content, 0);
1911     if (r == -1)
1912       return -1;
1913   }
1914   {
1915     char src[] = "/old";
1916     char dest[] = "/new";
1917     int r;
1918     suppress_error = 0;
1919     r = guestfs_cp (g, src, dest);
1920     if (r == -1)
1921       return -1;
1922   }
1923   {
1924     char path[] = "/new";
1925     char *r;
1926     suppress_error = 0;
1927     r = guestfs_cat (g, path);
1928     if (r == NULL)
1929       return -1;
1930     if (strcmp (r, expected) != 0) {
1931       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1932       return -1;
1933     }
1934     free (r);
1935   }
1936   return 0;
1937 }
1938
1939 static int test_cp_1 (void)
1940 {
1941   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
1942   {
1943     char device[] = "/dev/sda";
1944     device[5] = devchar;
1945     int r;
1946     suppress_error = 0;
1947     r = guestfs_blockdev_setrw (g, device);
1948     if (r == -1)
1949       return -1;
1950   }
1951   {
1952     int r;
1953     suppress_error = 0;
1954     r = guestfs_umount_all (g);
1955     if (r == -1)
1956       return -1;
1957   }
1958   {
1959     int r;
1960     suppress_error = 0;
1961     r = guestfs_lvm_remove_all (g);
1962     if (r == -1)
1963       return -1;
1964   }
1965   {
1966     char device[] = "/dev/sda";
1967     device[5] = devchar;
1968     char lines_0[] = ",";
1969     char *lines[] = {
1970       lines_0,
1971       NULL
1972     };
1973     int r;
1974     suppress_error = 0;
1975     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1976     if (r == -1)
1977       return -1;
1978   }
1979   {
1980     char fstype[] = "ext2";
1981     char device[] = "/dev/sda1";
1982     device[5] = devchar;
1983     int r;
1984     suppress_error = 0;
1985     r = guestfs_mkfs (g, fstype, device);
1986     if (r == -1)
1987       return -1;
1988   }
1989   {
1990     char device[] = "/dev/sda1";
1991     device[5] = devchar;
1992     char mountpoint[] = "/";
1993     int r;
1994     suppress_error = 0;
1995     r = guestfs_mount (g, device, mountpoint);
1996     if (r == -1)
1997       return -1;
1998   }
1999   /* TestOutputTrue for cp (1) */
2000   {
2001     char path[] = "/old";
2002     char content[] = "file content";
2003     int r;
2004     suppress_error = 0;
2005     r = guestfs_write_file (g, path, content, 0);
2006     if (r == -1)
2007       return -1;
2008   }
2009   {
2010     char src[] = "/old";
2011     char dest[] = "/new";
2012     int r;
2013     suppress_error = 0;
2014     r = guestfs_cp (g, src, dest);
2015     if (r == -1)
2016       return -1;
2017   }
2018   {
2019     char path[] = "/old";
2020     int r;
2021     suppress_error = 0;
2022     r = guestfs_is_file (g, path);
2023     if (r == -1)
2024       return -1;
2025     if (!r) {
2026       fprintf (stderr, "test_cp_1: expected true, got false\n");
2027       return -1;
2028     }
2029   }
2030   return 0;
2031 }
2032
2033 static int test_cp_2 (void)
2034 {
2035   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2036   {
2037     char device[] = "/dev/sda";
2038     device[5] = devchar;
2039     int r;
2040     suppress_error = 0;
2041     r = guestfs_blockdev_setrw (g, device);
2042     if (r == -1)
2043       return -1;
2044   }
2045   {
2046     int r;
2047     suppress_error = 0;
2048     r = guestfs_umount_all (g);
2049     if (r == -1)
2050       return -1;
2051   }
2052   {
2053     int r;
2054     suppress_error = 0;
2055     r = guestfs_lvm_remove_all (g);
2056     if (r == -1)
2057       return -1;
2058   }
2059   {
2060     char device[] = "/dev/sda";
2061     device[5] = devchar;
2062     char lines_0[] = ",";
2063     char *lines[] = {
2064       lines_0,
2065       NULL
2066     };
2067     int r;
2068     suppress_error = 0;
2069     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2070     if (r == -1)
2071       return -1;
2072   }
2073   {
2074     char fstype[] = "ext2";
2075     char device[] = "/dev/sda1";
2076     device[5] = devchar;
2077     int r;
2078     suppress_error = 0;
2079     r = guestfs_mkfs (g, fstype, device);
2080     if (r == -1)
2081       return -1;
2082   }
2083   {
2084     char device[] = "/dev/sda1";
2085     device[5] = devchar;
2086     char mountpoint[] = "/";
2087     int r;
2088     suppress_error = 0;
2089     r = guestfs_mount (g, device, mountpoint);
2090     if (r == -1)
2091       return -1;
2092   }
2093   /* TestOutput for cp (2) */
2094   char expected[] = "file content";
2095   {
2096     char path[] = "/old";
2097     char content[] = "file content";
2098     int r;
2099     suppress_error = 0;
2100     r = guestfs_write_file (g, path, content, 0);
2101     if (r == -1)
2102       return -1;
2103   }
2104   {
2105     char path[] = "/dir";
2106     int r;
2107     suppress_error = 0;
2108     r = guestfs_mkdir (g, path);
2109     if (r == -1)
2110       return -1;
2111   }
2112   {
2113     char src[] = "/old";
2114     char dest[] = "/dir/new";
2115     int r;
2116     suppress_error = 0;
2117     r = guestfs_cp (g, src, dest);
2118     if (r == -1)
2119       return -1;
2120   }
2121   {
2122     char path[] = "/dir/new";
2123     char *r;
2124     suppress_error = 0;
2125     r = guestfs_cat (g, path);
2126     if (r == NULL)
2127       return -1;
2128     if (strcmp (r, expected) != 0) {
2129       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2130       return -1;
2131     }
2132     free (r);
2133   }
2134   return 0;
2135 }
2136
2137 static int test_grub_install_0 (void)
2138 {
2139   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2140   {
2141     char device[] = "/dev/sda";
2142     device[5] = devchar;
2143     int r;
2144     suppress_error = 0;
2145     r = guestfs_blockdev_setrw (g, device);
2146     if (r == -1)
2147       return -1;
2148   }
2149   {
2150     int r;
2151     suppress_error = 0;
2152     r = guestfs_umount_all (g);
2153     if (r == -1)
2154       return -1;
2155   }
2156   {
2157     int r;
2158     suppress_error = 0;
2159     r = guestfs_lvm_remove_all (g);
2160     if (r == -1)
2161       return -1;
2162   }
2163   {
2164     char device[] = "/dev/sda";
2165     device[5] = devchar;
2166     char lines_0[] = ",";
2167     char *lines[] = {
2168       lines_0,
2169       NULL
2170     };
2171     int r;
2172     suppress_error = 0;
2173     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2174     if (r == -1)
2175       return -1;
2176   }
2177   {
2178     char fstype[] = "ext2";
2179     char device[] = "/dev/sda1";
2180     device[5] = devchar;
2181     int r;
2182     suppress_error = 0;
2183     r = guestfs_mkfs (g, fstype, device);
2184     if (r == -1)
2185       return -1;
2186   }
2187   {
2188     char device[] = "/dev/sda1";
2189     device[5] = devchar;
2190     char mountpoint[] = "/";
2191     int r;
2192     suppress_error = 0;
2193     r = guestfs_mount (g, device, mountpoint);
2194     if (r == -1)
2195       return -1;
2196   }
2197   /* TestOutputTrue for grub_install (0) */
2198   {
2199     char root[] = "/";
2200     char device[] = "/dev/sda1";
2201     device[5] = devchar;
2202     int r;
2203     suppress_error = 0;
2204     r = guestfs_grub_install (g, root, device);
2205     if (r == -1)
2206       return -1;
2207   }
2208   {
2209     char path[] = "/boot";
2210     int r;
2211     suppress_error = 0;
2212     r = guestfs_is_dir (g, path);
2213     if (r == -1)
2214       return -1;
2215     if (!r) {
2216       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2217       return -1;
2218     }
2219   }
2220   return 0;
2221 }
2222
2223 static int test_zero_0 (void)
2224 {
2225   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2226   {
2227     char device[] = "/dev/sda";
2228     device[5] = devchar;
2229     int r;
2230     suppress_error = 0;
2231     r = guestfs_blockdev_setrw (g, device);
2232     if (r == -1)
2233       return -1;
2234   }
2235   {
2236     int r;
2237     suppress_error = 0;
2238     r = guestfs_umount_all (g);
2239     if (r == -1)
2240       return -1;
2241   }
2242   {
2243     int r;
2244     suppress_error = 0;
2245     r = guestfs_lvm_remove_all (g);
2246     if (r == -1)
2247       return -1;
2248   }
2249   {
2250     char device[] = "/dev/sda";
2251     device[5] = devchar;
2252     char lines_0[] = ",";
2253     char *lines[] = {
2254       lines_0,
2255       NULL
2256     };
2257     int r;
2258     suppress_error = 0;
2259     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2260     if (r == -1)
2261       return -1;
2262   }
2263   {
2264     char fstype[] = "ext2";
2265     char device[] = "/dev/sda1";
2266     device[5] = devchar;
2267     int r;
2268     suppress_error = 0;
2269     r = guestfs_mkfs (g, fstype, device);
2270     if (r == -1)
2271       return -1;
2272   }
2273   {
2274     char device[] = "/dev/sda1";
2275     device[5] = devchar;
2276     char mountpoint[] = "/";
2277     int r;
2278     suppress_error = 0;
2279     r = guestfs_mount (g, device, mountpoint);
2280     if (r == -1)
2281       return -1;
2282   }
2283   /* TestOutput for zero (0) */
2284   char expected[] = "data";
2285   {
2286     char pathordevice[] = "/dev/sda1";
2287     pathordevice[5] = devchar;
2288     int r;
2289     suppress_error = 0;
2290     r = guestfs_umount (g, pathordevice);
2291     if (r == -1)
2292       return -1;
2293   }
2294   {
2295     char device[] = "/dev/sda1";
2296     device[5] = devchar;
2297     int r;
2298     suppress_error = 0;
2299     r = guestfs_zero (g, device);
2300     if (r == -1)
2301       return -1;
2302   }
2303   {
2304     char path[] = "/dev/sda1";
2305     path[5] = devchar;
2306     char *r;
2307     suppress_error = 0;
2308     r = guestfs_file (g, path);
2309     if (r == NULL)
2310       return -1;
2311     if (strcmp (r, expected) != 0) {
2312       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2313       return -1;
2314     }
2315     free (r);
2316   }
2317   return 0;
2318 }
2319
2320 static int test_fsck_0 (void)
2321 {
2322   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2323   {
2324     char device[] = "/dev/sda";
2325     device[5] = devchar;
2326     int r;
2327     suppress_error = 0;
2328     r = guestfs_blockdev_setrw (g, device);
2329     if (r == -1)
2330       return -1;
2331   }
2332   {
2333     int r;
2334     suppress_error = 0;
2335     r = guestfs_umount_all (g);
2336     if (r == -1)
2337       return -1;
2338   }
2339   {
2340     int r;
2341     suppress_error = 0;
2342     r = guestfs_lvm_remove_all (g);
2343     if (r == -1)
2344       return -1;
2345   }
2346   {
2347     char device[] = "/dev/sda";
2348     device[5] = devchar;
2349     char lines_0[] = ",";
2350     char *lines[] = {
2351       lines_0,
2352       NULL
2353     };
2354     int r;
2355     suppress_error = 0;
2356     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2357     if (r == -1)
2358       return -1;
2359   }
2360   {
2361     char fstype[] = "ext2";
2362     char device[] = "/dev/sda1";
2363     device[5] = devchar;
2364     int r;
2365     suppress_error = 0;
2366     r = guestfs_mkfs (g, fstype, device);
2367     if (r == -1)
2368       return -1;
2369   }
2370   {
2371     char device[] = "/dev/sda1";
2372     device[5] = devchar;
2373     char mountpoint[] = "/";
2374     int r;
2375     suppress_error = 0;
2376     r = guestfs_mount (g, device, mountpoint);
2377     if (r == -1)
2378       return -1;
2379   }
2380   /* TestOutputInt for fsck (0) */
2381   {
2382     char pathordevice[] = "/dev/sda1";
2383     pathordevice[5] = devchar;
2384     int r;
2385     suppress_error = 0;
2386     r = guestfs_umount (g, pathordevice);
2387     if (r == -1)
2388       return -1;
2389   }
2390   {
2391     char fstype[] = "ext2";
2392     char device[] = "/dev/sda1";
2393     device[5] = devchar;
2394     int r;
2395     suppress_error = 0;
2396     r = guestfs_fsck (g, fstype, device);
2397     if (r == -1)
2398       return -1;
2399     if (r != 0) {
2400       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
2401       return -1;
2402     }
2403   }
2404   return 0;
2405 }
2406
2407 static int test_fsck_1 (void)
2408 {
2409   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2410   {
2411     char device[] = "/dev/sda";
2412     device[5] = devchar;
2413     int r;
2414     suppress_error = 0;
2415     r = guestfs_blockdev_setrw (g, device);
2416     if (r == -1)
2417       return -1;
2418   }
2419   {
2420     int r;
2421     suppress_error = 0;
2422     r = guestfs_umount_all (g);
2423     if (r == -1)
2424       return -1;
2425   }
2426   {
2427     int r;
2428     suppress_error = 0;
2429     r = guestfs_lvm_remove_all (g);
2430     if (r == -1)
2431       return -1;
2432   }
2433   {
2434     char device[] = "/dev/sda";
2435     device[5] = devchar;
2436     char lines_0[] = ",";
2437     char *lines[] = {
2438       lines_0,
2439       NULL
2440     };
2441     int r;
2442     suppress_error = 0;
2443     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2444     if (r == -1)
2445       return -1;
2446   }
2447   {
2448     char fstype[] = "ext2";
2449     char device[] = "/dev/sda1";
2450     device[5] = devchar;
2451     int r;
2452     suppress_error = 0;
2453     r = guestfs_mkfs (g, fstype, device);
2454     if (r == -1)
2455       return -1;
2456   }
2457   {
2458     char device[] = "/dev/sda1";
2459     device[5] = devchar;
2460     char mountpoint[] = "/";
2461     int r;
2462     suppress_error = 0;
2463     r = guestfs_mount (g, device, mountpoint);
2464     if (r == -1)
2465       return -1;
2466   }
2467   /* TestOutputInt for fsck (1) */
2468   {
2469     char pathordevice[] = "/dev/sda1";
2470     pathordevice[5] = devchar;
2471     int r;
2472     suppress_error = 0;
2473     r = guestfs_umount (g, pathordevice);
2474     if (r == -1)
2475       return -1;
2476   }
2477   {
2478     char device[] = "/dev/sda1";
2479     device[5] = devchar;
2480     int r;
2481     suppress_error = 0;
2482     r = guestfs_zero (g, device);
2483     if (r == -1)
2484       return -1;
2485   }
2486   {
2487     char fstype[] = "ext2";
2488     char device[] = "/dev/sda1";
2489     device[5] = devchar;
2490     int r;
2491     suppress_error = 0;
2492     r = guestfs_fsck (g, fstype, device);
2493     if (r == -1)
2494       return -1;
2495     if (r != 8) {
2496       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
2497       return -1;
2498     }
2499   }
2500   return 0;
2501 }
2502
2503 static int test_set_e2uuid_0 (void)
2504 {
2505   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2506   {
2507     char device[] = "/dev/sda";
2508     device[5] = devchar;
2509     int r;
2510     suppress_error = 0;
2511     r = guestfs_blockdev_setrw (g, device);
2512     if (r == -1)
2513       return -1;
2514   }
2515   {
2516     int r;
2517     suppress_error = 0;
2518     r = guestfs_umount_all (g);
2519     if (r == -1)
2520       return -1;
2521   }
2522   {
2523     int r;
2524     suppress_error = 0;
2525     r = guestfs_lvm_remove_all (g);
2526     if (r == -1)
2527       return -1;
2528   }
2529   {
2530     char device[] = "/dev/sda";
2531     device[5] = devchar;
2532     char lines_0[] = ",";
2533     char *lines[] = {
2534       lines_0,
2535       NULL
2536     };
2537     int r;
2538     suppress_error = 0;
2539     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2540     if (r == -1)
2541       return -1;
2542   }
2543   {
2544     char fstype[] = "ext2";
2545     char device[] = "/dev/sda1";
2546     device[5] = devchar;
2547     int r;
2548     suppress_error = 0;
2549     r = guestfs_mkfs (g, fstype, device);
2550     if (r == -1)
2551       return -1;
2552   }
2553   {
2554     char device[] = "/dev/sda1";
2555     device[5] = devchar;
2556     char mountpoint[] = "/";
2557     int r;
2558     suppress_error = 0;
2559     r = guestfs_mount (g, device, mountpoint);
2560     if (r == -1)
2561       return -1;
2562   }
2563   /* TestOutput for set_e2uuid (0) */
2564   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2565   {
2566     char device[] = "/dev/sda1";
2567     device[5] = devchar;
2568     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2569     int r;
2570     suppress_error = 0;
2571     r = guestfs_set_e2uuid (g, device, uuid);
2572     if (r == -1)
2573       return -1;
2574   }
2575   {
2576     char device[] = "/dev/sda1";
2577     device[5] = devchar;
2578     char *r;
2579     suppress_error = 0;
2580     r = guestfs_get_e2uuid (g, device);
2581     if (r == NULL)
2582       return -1;
2583     if (strcmp (r, expected) != 0) {
2584       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2585       return -1;
2586     }
2587     free (r);
2588   }
2589   return 0;
2590 }
2591
2592 static int test_set_e2uuid_1 (void)
2593 {
2594   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
2595   {
2596     char device[] = "/dev/sda";
2597     device[5] = devchar;
2598     int r;
2599     suppress_error = 0;
2600     r = guestfs_blockdev_setrw (g, device);
2601     if (r == -1)
2602       return -1;
2603   }
2604   {
2605     int r;
2606     suppress_error = 0;
2607     r = guestfs_umount_all (g);
2608     if (r == -1)
2609       return -1;
2610   }
2611   {
2612     int r;
2613     suppress_error = 0;
2614     r = guestfs_lvm_remove_all (g);
2615     if (r == -1)
2616       return -1;
2617   }
2618   {
2619     char device[] = "/dev/sda";
2620     device[5] = devchar;
2621     char lines_0[] = ",";
2622     char *lines[] = {
2623       lines_0,
2624       NULL
2625     };
2626     int r;
2627     suppress_error = 0;
2628     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2629     if (r == -1)
2630       return -1;
2631   }
2632   {
2633     char fstype[] = "ext2";
2634     char device[] = "/dev/sda1";
2635     device[5] = devchar;
2636     int r;
2637     suppress_error = 0;
2638     r = guestfs_mkfs (g, fstype, device);
2639     if (r == -1)
2640       return -1;
2641   }
2642   {
2643     char device[] = "/dev/sda1";
2644     device[5] = devchar;
2645     char mountpoint[] = "/";
2646     int r;
2647     suppress_error = 0;
2648     r = guestfs_mount (g, device, mountpoint);
2649     if (r == -1)
2650       return -1;
2651   }
2652   /* TestOutput for set_e2uuid (1) */
2653   char expected[] = "";
2654   {
2655     char device[] = "/dev/sda1";
2656     device[5] = devchar;
2657     char uuid[] = "clear";
2658     int r;
2659     suppress_error = 0;
2660     r = guestfs_set_e2uuid (g, device, uuid);
2661     if (r == -1)
2662       return -1;
2663   }
2664   {
2665     char device[] = "/dev/sda1";
2666     device[5] = devchar;
2667     char *r;
2668     suppress_error = 0;
2669     r = guestfs_get_e2uuid (g, device);
2670     if (r == NULL)
2671       return -1;
2672     if (strcmp (r, expected) != 0) {
2673       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2674       return -1;
2675     }
2676     free (r);
2677   }
2678   return 0;
2679 }
2680
2681 static int test_set_e2uuid_2 (void)
2682 {
2683   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
2684   {
2685     char device[] = "/dev/sda";
2686     device[5] = devchar;
2687     int r;
2688     suppress_error = 0;
2689     r = guestfs_blockdev_setrw (g, device);
2690     if (r == -1)
2691       return -1;
2692   }
2693   {
2694     int r;
2695     suppress_error = 0;
2696     r = guestfs_umount_all (g);
2697     if (r == -1)
2698       return -1;
2699   }
2700   {
2701     int r;
2702     suppress_error = 0;
2703     r = guestfs_lvm_remove_all (g);
2704     if (r == -1)
2705       return -1;
2706   }
2707   {
2708     char device[] = "/dev/sda";
2709     device[5] = devchar;
2710     char lines_0[] = ",";
2711     char *lines[] = {
2712       lines_0,
2713       NULL
2714     };
2715     int r;
2716     suppress_error = 0;
2717     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2718     if (r == -1)
2719       return -1;
2720   }
2721   {
2722     char fstype[] = "ext2";
2723     char device[] = "/dev/sda1";
2724     device[5] = devchar;
2725     int r;
2726     suppress_error = 0;
2727     r = guestfs_mkfs (g, fstype, device);
2728     if (r == -1)
2729       return -1;
2730   }
2731   {
2732     char device[] = "/dev/sda1";
2733     device[5] = devchar;
2734     char mountpoint[] = "/";
2735     int r;
2736     suppress_error = 0;
2737     r = guestfs_mount (g, device, mountpoint);
2738     if (r == -1)
2739       return -1;
2740   }
2741   /* TestRun for set_e2uuid (2) */
2742   {
2743     char device[] = "/dev/sda1";
2744     device[5] = devchar;
2745     char uuid[] = "random";
2746     int r;
2747     suppress_error = 0;
2748     r = guestfs_set_e2uuid (g, device, uuid);
2749     if (r == -1)
2750       return -1;
2751   }
2752   return 0;
2753 }
2754
2755 static int test_set_e2uuid_3 (void)
2756 {
2757   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
2758   {
2759     char device[] = "/dev/sda";
2760     device[5] = devchar;
2761     int r;
2762     suppress_error = 0;
2763     r = guestfs_blockdev_setrw (g, device);
2764     if (r == -1)
2765       return -1;
2766   }
2767   {
2768     int r;
2769     suppress_error = 0;
2770     r = guestfs_umount_all (g);
2771     if (r == -1)
2772       return -1;
2773   }
2774   {
2775     int r;
2776     suppress_error = 0;
2777     r = guestfs_lvm_remove_all (g);
2778     if (r == -1)
2779       return -1;
2780   }
2781   {
2782     char device[] = "/dev/sda";
2783     device[5] = devchar;
2784     char lines_0[] = ",";
2785     char *lines[] = {
2786       lines_0,
2787       NULL
2788     };
2789     int r;
2790     suppress_error = 0;
2791     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2792     if (r == -1)
2793       return -1;
2794   }
2795   {
2796     char fstype[] = "ext2";
2797     char device[] = "/dev/sda1";
2798     device[5] = devchar;
2799     int r;
2800     suppress_error = 0;
2801     r = guestfs_mkfs (g, fstype, device);
2802     if (r == -1)
2803       return -1;
2804   }
2805   {
2806     char device[] = "/dev/sda1";
2807     device[5] = devchar;
2808     char mountpoint[] = "/";
2809     int r;
2810     suppress_error = 0;
2811     r = guestfs_mount (g, device, mountpoint);
2812     if (r == -1)
2813       return -1;
2814   }
2815   /* TestRun for set_e2uuid (3) */
2816   {
2817     char device[] = "/dev/sda1";
2818     device[5] = devchar;
2819     char uuid[] = "time";
2820     int r;
2821     suppress_error = 0;
2822     r = guestfs_set_e2uuid (g, device, uuid);
2823     if (r == -1)
2824       return -1;
2825   }
2826   return 0;
2827 }
2828
2829 static int test_set_e2label_0 (void)
2830 {
2831   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
2832   {
2833     char device[] = "/dev/sda";
2834     device[5] = devchar;
2835     int r;
2836     suppress_error = 0;
2837     r = guestfs_blockdev_setrw (g, device);
2838     if (r == -1)
2839       return -1;
2840   }
2841   {
2842     int r;
2843     suppress_error = 0;
2844     r = guestfs_umount_all (g);
2845     if (r == -1)
2846       return -1;
2847   }
2848   {
2849     int r;
2850     suppress_error = 0;
2851     r = guestfs_lvm_remove_all (g);
2852     if (r == -1)
2853       return -1;
2854   }
2855   {
2856     char device[] = "/dev/sda";
2857     device[5] = devchar;
2858     char lines_0[] = ",";
2859     char *lines[] = {
2860       lines_0,
2861       NULL
2862     };
2863     int r;
2864     suppress_error = 0;
2865     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2866     if (r == -1)
2867       return -1;
2868   }
2869   {
2870     char fstype[] = "ext2";
2871     char device[] = "/dev/sda1";
2872     device[5] = devchar;
2873     int r;
2874     suppress_error = 0;
2875     r = guestfs_mkfs (g, fstype, device);
2876     if (r == -1)
2877       return -1;
2878   }
2879   {
2880     char device[] = "/dev/sda1";
2881     device[5] = devchar;
2882     char mountpoint[] = "/";
2883     int r;
2884     suppress_error = 0;
2885     r = guestfs_mount (g, device, mountpoint);
2886     if (r == -1)
2887       return -1;
2888   }
2889   /* TestOutput for set_e2label (0) */
2890   char expected[] = "testlabel";
2891   {
2892     char device[] = "/dev/sda1";
2893     device[5] = devchar;
2894     char label[] = "testlabel";
2895     int r;
2896     suppress_error = 0;
2897     r = guestfs_set_e2label (g, device, label);
2898     if (r == -1)
2899       return -1;
2900   }
2901   {
2902     char device[] = "/dev/sda1";
2903     device[5] = devchar;
2904     char *r;
2905     suppress_error = 0;
2906     r = guestfs_get_e2label (g, device);
2907     if (r == NULL)
2908       return -1;
2909     if (strcmp (r, expected) != 0) {
2910       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2911       return -1;
2912     }
2913     free (r);
2914   }
2915   return 0;
2916 }
2917
2918 static int test_pvremove_0 (void)
2919 {
2920   /* InitNone|InitEmpty for test_pvremove_0 */
2921   {
2922     char device[] = "/dev/sda";
2923     device[5] = devchar;
2924     int r;
2925     suppress_error = 0;
2926     r = guestfs_blockdev_setrw (g, device);
2927     if (r == -1)
2928       return -1;
2929   }
2930   {
2931     int r;
2932     suppress_error = 0;
2933     r = guestfs_umount_all (g);
2934     if (r == -1)
2935       return -1;
2936   }
2937   {
2938     int r;
2939     suppress_error = 0;
2940     r = guestfs_lvm_remove_all (g);
2941     if (r == -1)
2942       return -1;
2943   }
2944   /* TestOutputList for pvremove (0) */
2945   {
2946     char device[] = "/dev/sda";
2947     device[5] = devchar;
2948     char lines_0[] = ",";
2949     char *lines[] = {
2950       lines_0,
2951       NULL
2952     };
2953     int r;
2954     suppress_error = 0;
2955     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2956     if (r == -1)
2957       return -1;
2958   }
2959   {
2960     char device[] = "/dev/sda1";
2961     device[5] = devchar;
2962     int r;
2963     suppress_error = 0;
2964     r = guestfs_pvcreate (g, device);
2965     if (r == -1)
2966       return -1;
2967   }
2968   {
2969     char volgroup[] = "VG";
2970     char physvols_0[] = "/dev/sda1";
2971     physvols_0[5] = devchar;
2972     char *physvols[] = {
2973       physvols_0,
2974       NULL
2975     };
2976     int r;
2977     suppress_error = 0;
2978     r = guestfs_vgcreate (g, volgroup, physvols);
2979     if (r == -1)
2980       return -1;
2981   }
2982   {
2983     char logvol[] = "LV1";
2984     char volgroup[] = "VG";
2985     int r;
2986     suppress_error = 0;
2987     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2988     if (r == -1)
2989       return -1;
2990   }
2991   {
2992     char logvol[] = "LV2";
2993     char volgroup[] = "VG";
2994     int r;
2995     suppress_error = 0;
2996     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2997     if (r == -1)
2998       return -1;
2999   }
3000   {
3001     char vgname[] = "VG";
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_vgremove (g, vgname);
3005     if (r == -1)
3006       return -1;
3007   }
3008   {
3009     char device[] = "/dev/sda1";
3010     device[5] = devchar;
3011     int r;
3012     suppress_error = 0;
3013     r = guestfs_pvremove (g, device);
3014     if (r == -1)
3015       return -1;
3016   }
3017   {
3018     char **r;
3019     int i;
3020     suppress_error = 0;
3021     r = guestfs_lvs (g);
3022     if (r == NULL)
3023       return -1;
3024     if (r[0] != NULL) {
3025       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3026       print_strings (r);
3027       return -1;
3028     }
3029     for (i = 0; r[i] != NULL; ++i)
3030       free (r[i]);
3031     free (r);
3032   }
3033   return 0;
3034 }
3035
3036 static int test_pvremove_1 (void)
3037 {
3038   /* InitNone|InitEmpty for test_pvremove_1 */
3039   {
3040     char device[] = "/dev/sda";
3041     device[5] = devchar;
3042     int r;
3043     suppress_error = 0;
3044     r = guestfs_blockdev_setrw (g, device);
3045     if (r == -1)
3046       return -1;
3047   }
3048   {
3049     int r;
3050     suppress_error = 0;
3051     r = guestfs_umount_all (g);
3052     if (r == -1)
3053       return -1;
3054   }
3055   {
3056     int r;
3057     suppress_error = 0;
3058     r = guestfs_lvm_remove_all (g);
3059     if (r == -1)
3060       return -1;
3061   }
3062   /* TestOutputList for pvremove (1) */
3063   {
3064     char device[] = "/dev/sda";
3065     device[5] = devchar;
3066     char lines_0[] = ",";
3067     char *lines[] = {
3068       lines_0,
3069       NULL
3070     };
3071     int r;
3072     suppress_error = 0;
3073     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3074     if (r == -1)
3075       return -1;
3076   }
3077   {
3078     char device[] = "/dev/sda1";
3079     device[5] = devchar;
3080     int r;
3081     suppress_error = 0;
3082     r = guestfs_pvcreate (g, device);
3083     if (r == -1)
3084       return -1;
3085   }
3086   {
3087     char volgroup[] = "VG";
3088     char physvols_0[] = "/dev/sda1";
3089     physvols_0[5] = devchar;
3090     char *physvols[] = {
3091       physvols_0,
3092       NULL
3093     };
3094     int r;
3095     suppress_error = 0;
3096     r = guestfs_vgcreate (g, volgroup, physvols);
3097     if (r == -1)
3098       return -1;
3099   }
3100   {
3101     char logvol[] = "LV1";
3102     char volgroup[] = "VG";
3103     int r;
3104     suppress_error = 0;
3105     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3106     if (r == -1)
3107       return -1;
3108   }
3109   {
3110     char logvol[] = "LV2";
3111     char volgroup[] = "VG";
3112     int r;
3113     suppress_error = 0;
3114     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3115     if (r == -1)
3116       return -1;
3117   }
3118   {
3119     char vgname[] = "VG";
3120     int r;
3121     suppress_error = 0;
3122     r = guestfs_vgremove (g, vgname);
3123     if (r == -1)
3124       return -1;
3125   }
3126   {
3127     char device[] = "/dev/sda1";
3128     device[5] = devchar;
3129     int r;
3130     suppress_error = 0;
3131     r = guestfs_pvremove (g, device);
3132     if (r == -1)
3133       return -1;
3134   }
3135   {
3136     char **r;
3137     int i;
3138     suppress_error = 0;
3139     r = guestfs_vgs (g);
3140     if (r == NULL)
3141       return -1;
3142     if (r[0] != NULL) {
3143       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3144       print_strings (r);
3145       return -1;
3146     }
3147     for (i = 0; r[i] != NULL; ++i)
3148       free (r[i]);
3149     free (r);
3150   }
3151   return 0;
3152 }
3153
3154 static int test_pvremove_2 (void)
3155 {
3156   /* InitNone|InitEmpty for test_pvremove_2 */
3157   {
3158     char device[] = "/dev/sda";
3159     device[5] = devchar;
3160     int r;
3161     suppress_error = 0;
3162     r = guestfs_blockdev_setrw (g, device);
3163     if (r == -1)
3164       return -1;
3165   }
3166   {
3167     int r;
3168     suppress_error = 0;
3169     r = guestfs_umount_all (g);
3170     if (r == -1)
3171       return -1;
3172   }
3173   {
3174     int r;
3175     suppress_error = 0;
3176     r = guestfs_lvm_remove_all (g);
3177     if (r == -1)
3178       return -1;
3179   }
3180   /* TestOutputList for pvremove (2) */
3181   {
3182     char device[] = "/dev/sda";
3183     device[5] = devchar;
3184     char lines_0[] = ",";
3185     char *lines[] = {
3186       lines_0,
3187       NULL
3188     };
3189     int r;
3190     suppress_error = 0;
3191     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3192     if (r == -1)
3193       return -1;
3194   }
3195   {
3196     char device[] = "/dev/sda1";
3197     device[5] = devchar;
3198     int r;
3199     suppress_error = 0;
3200     r = guestfs_pvcreate (g, device);
3201     if (r == -1)
3202       return -1;
3203   }
3204   {
3205     char volgroup[] = "VG";
3206     char physvols_0[] = "/dev/sda1";
3207     physvols_0[5] = devchar;
3208     char *physvols[] = {
3209       physvols_0,
3210       NULL
3211     };
3212     int r;
3213     suppress_error = 0;
3214     r = guestfs_vgcreate (g, volgroup, physvols);
3215     if (r == -1)
3216       return -1;
3217   }
3218   {
3219     char logvol[] = "LV1";
3220     char volgroup[] = "VG";
3221     int r;
3222     suppress_error = 0;
3223     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3224     if (r == -1)
3225       return -1;
3226   }
3227   {
3228     char logvol[] = "LV2";
3229     char volgroup[] = "VG";
3230     int r;
3231     suppress_error = 0;
3232     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3233     if (r == -1)
3234       return -1;
3235   }
3236   {
3237     char vgname[] = "VG";
3238     int r;
3239     suppress_error = 0;
3240     r = guestfs_vgremove (g, vgname);
3241     if (r == -1)
3242       return -1;
3243   }
3244   {
3245     char device[] = "/dev/sda1";
3246     device[5] = devchar;
3247     int r;
3248     suppress_error = 0;
3249     r = guestfs_pvremove (g, device);
3250     if (r == -1)
3251       return -1;
3252   }
3253   {
3254     char **r;
3255     int i;
3256     suppress_error = 0;
3257     r = guestfs_pvs (g);
3258     if (r == NULL)
3259       return -1;
3260     if (r[0] != NULL) {
3261       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3262       print_strings (r);
3263       return -1;
3264     }
3265     for (i = 0; r[i] != NULL; ++i)
3266       free (r[i]);
3267     free (r);
3268   }
3269   return 0;
3270 }
3271
3272 static int test_vgremove_0 (void)
3273 {
3274   /* InitNone|InitEmpty for test_vgremove_0 */
3275   {
3276     char device[] = "/dev/sda";
3277     device[5] = devchar;
3278     int r;
3279     suppress_error = 0;
3280     r = guestfs_blockdev_setrw (g, device);
3281     if (r == -1)
3282       return -1;
3283   }
3284   {
3285     int r;
3286     suppress_error = 0;
3287     r = guestfs_umount_all (g);
3288     if (r == -1)
3289       return -1;
3290   }
3291   {
3292     int r;
3293     suppress_error = 0;
3294     r = guestfs_lvm_remove_all (g);
3295     if (r == -1)
3296       return -1;
3297   }
3298   /* TestOutputList for vgremove (0) */
3299   {
3300     char device[] = "/dev/sda";
3301     device[5] = devchar;
3302     char lines_0[] = ",";
3303     char *lines[] = {
3304       lines_0,
3305       NULL
3306     };
3307     int r;
3308     suppress_error = 0;
3309     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3310     if (r == -1)
3311       return -1;
3312   }
3313   {
3314     char device[] = "/dev/sda1";
3315     device[5] = devchar;
3316     int r;
3317     suppress_error = 0;
3318     r = guestfs_pvcreate (g, device);
3319     if (r == -1)
3320       return -1;
3321   }
3322   {
3323     char volgroup[] = "VG";
3324     char physvols_0[] = "/dev/sda1";
3325     physvols_0[5] = devchar;
3326     char *physvols[] = {
3327       physvols_0,
3328       NULL
3329     };
3330     int r;
3331     suppress_error = 0;
3332     r = guestfs_vgcreate (g, volgroup, physvols);
3333     if (r == -1)
3334       return -1;
3335   }
3336   {
3337     char logvol[] = "LV1";
3338     char volgroup[] = "VG";
3339     int r;
3340     suppress_error = 0;
3341     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3342     if (r == -1)
3343       return -1;
3344   }
3345   {
3346     char logvol[] = "LV2";
3347     char volgroup[] = "VG";
3348     int r;
3349     suppress_error = 0;
3350     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3351     if (r == -1)
3352       return -1;
3353   }
3354   {
3355     char vgname[] = "VG";
3356     int r;
3357     suppress_error = 0;
3358     r = guestfs_vgremove (g, vgname);
3359     if (r == -1)
3360       return -1;
3361   }
3362   {
3363     char **r;
3364     int i;
3365     suppress_error = 0;
3366     r = guestfs_lvs (g);
3367     if (r == NULL)
3368       return -1;
3369     if (r[0] != NULL) {
3370       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3371       print_strings (r);
3372       return -1;
3373     }
3374     for (i = 0; r[i] != NULL; ++i)
3375       free (r[i]);
3376     free (r);
3377   }
3378   return 0;
3379 }
3380
3381 static int test_vgremove_1 (void)
3382 {
3383   /* InitNone|InitEmpty for test_vgremove_1 */
3384   {
3385     char device[] = "/dev/sda";
3386     device[5] = devchar;
3387     int r;
3388     suppress_error = 0;
3389     r = guestfs_blockdev_setrw (g, device);
3390     if (r == -1)
3391       return -1;
3392   }
3393   {
3394     int r;
3395     suppress_error = 0;
3396     r = guestfs_umount_all (g);
3397     if (r == -1)
3398       return -1;
3399   }
3400   {
3401     int r;
3402     suppress_error = 0;
3403     r = guestfs_lvm_remove_all (g);
3404     if (r == -1)
3405       return -1;
3406   }
3407   /* TestOutputList for vgremove (1) */
3408   {
3409     char device[] = "/dev/sda";
3410     device[5] = devchar;
3411     char lines_0[] = ",";
3412     char *lines[] = {
3413       lines_0,
3414       NULL
3415     };
3416     int r;
3417     suppress_error = 0;
3418     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3419     if (r == -1)
3420       return -1;
3421   }
3422   {
3423     char device[] = "/dev/sda1";
3424     device[5] = devchar;
3425     int r;
3426     suppress_error = 0;
3427     r = guestfs_pvcreate (g, device);
3428     if (r == -1)
3429       return -1;
3430   }
3431   {
3432     char volgroup[] = "VG";
3433     char physvols_0[] = "/dev/sda1";
3434     physvols_0[5] = devchar;
3435     char *physvols[] = {
3436       physvols_0,
3437       NULL
3438     };
3439     int r;
3440     suppress_error = 0;
3441     r = guestfs_vgcreate (g, volgroup, physvols);
3442     if (r == -1)
3443       return -1;
3444   }
3445   {
3446     char logvol[] = "LV1";
3447     char volgroup[] = "VG";
3448     int r;
3449     suppress_error = 0;
3450     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3451     if (r == -1)
3452       return -1;
3453   }
3454   {
3455     char logvol[] = "LV2";
3456     char volgroup[] = "VG";
3457     int r;
3458     suppress_error = 0;
3459     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3460     if (r == -1)
3461       return -1;
3462   }
3463   {
3464     char vgname[] = "VG";
3465     int r;
3466     suppress_error = 0;
3467     r = guestfs_vgremove (g, vgname);
3468     if (r == -1)
3469       return -1;
3470   }
3471   {
3472     char **r;
3473     int i;
3474     suppress_error = 0;
3475     r = guestfs_vgs (g);
3476     if (r == NULL)
3477       return -1;
3478     if (r[0] != NULL) {
3479       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
3480       print_strings (r);
3481       return -1;
3482     }
3483     for (i = 0; r[i] != NULL; ++i)
3484       free (r[i]);
3485     free (r);
3486   }
3487   return 0;
3488 }
3489
3490 static int test_lvremove_0 (void)
3491 {
3492   /* InitNone|InitEmpty for test_lvremove_0 */
3493   {
3494     char device[] = "/dev/sda";
3495     device[5] = devchar;
3496     int r;
3497     suppress_error = 0;
3498     r = guestfs_blockdev_setrw (g, device);
3499     if (r == -1)
3500       return -1;
3501   }
3502   {
3503     int r;
3504     suppress_error = 0;
3505     r = guestfs_umount_all (g);
3506     if (r == -1)
3507       return -1;
3508   }
3509   {
3510     int r;
3511     suppress_error = 0;
3512     r = guestfs_lvm_remove_all (g);
3513     if (r == -1)
3514       return -1;
3515   }
3516   /* TestOutputList for lvremove (0) */
3517   {
3518     char device[] = "/dev/sda";
3519     device[5] = devchar;
3520     char lines_0[] = ",";
3521     char *lines[] = {
3522       lines_0,
3523       NULL
3524     };
3525     int r;
3526     suppress_error = 0;
3527     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3528     if (r == -1)
3529       return -1;
3530   }
3531   {
3532     char device[] = "/dev/sda1";
3533     device[5] = devchar;
3534     int r;
3535     suppress_error = 0;
3536     r = guestfs_pvcreate (g, device);
3537     if (r == -1)
3538       return -1;
3539   }
3540   {
3541     char volgroup[] = "VG";
3542     char physvols_0[] = "/dev/sda1";
3543     physvols_0[5] = devchar;
3544     char *physvols[] = {
3545       physvols_0,
3546       NULL
3547     };
3548     int r;
3549     suppress_error = 0;
3550     r = guestfs_vgcreate (g, volgroup, physvols);
3551     if (r == -1)
3552       return -1;
3553   }
3554   {
3555     char logvol[] = "LV1";
3556     char volgroup[] = "VG";
3557     int r;
3558     suppress_error = 0;
3559     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3560     if (r == -1)
3561       return -1;
3562   }
3563   {
3564     char logvol[] = "LV2";
3565     char volgroup[] = "VG";
3566     int r;
3567     suppress_error = 0;
3568     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3569     if (r == -1)
3570       return -1;
3571   }
3572   {
3573     char device[] = "/dev/VG/LV1";
3574     int r;
3575     suppress_error = 0;
3576     r = guestfs_lvremove (g, device);
3577     if (r == -1)
3578       return -1;
3579   }
3580   {
3581     char **r;
3582     int i;
3583     suppress_error = 0;
3584     r = guestfs_lvs (g);
3585     if (r == NULL)
3586       return -1;
3587     if (!r[0]) {
3588       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
3589       print_strings (r);
3590       return -1;
3591     }
3592     {
3593       char expected[] = "/dev/VG/LV2";
3594       if (strcmp (r[0], expected) != 0) {
3595         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3596         return -1;
3597       }
3598     }
3599     if (r[1] != NULL) {
3600       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
3601       print_strings (r);
3602       return -1;
3603     }
3604     for (i = 0; r[i] != NULL; ++i)
3605       free (r[i]);
3606     free (r);
3607   }
3608   return 0;
3609 }
3610
3611 static int test_lvremove_1 (void)
3612 {
3613   /* InitNone|InitEmpty for test_lvremove_1 */
3614   {
3615     char device[] = "/dev/sda";
3616     device[5] = devchar;
3617     int r;
3618     suppress_error = 0;
3619     r = guestfs_blockdev_setrw (g, device);
3620     if (r == -1)
3621       return -1;
3622   }
3623   {
3624     int r;
3625     suppress_error = 0;
3626     r = guestfs_umount_all (g);
3627     if (r == -1)
3628       return -1;
3629   }
3630   {
3631     int r;
3632     suppress_error = 0;
3633     r = guestfs_lvm_remove_all (g);
3634     if (r == -1)
3635       return -1;
3636   }
3637   /* TestOutputList for lvremove (1) */
3638   {
3639     char device[] = "/dev/sda";
3640     device[5] = devchar;
3641     char lines_0[] = ",";
3642     char *lines[] = {
3643       lines_0,
3644       NULL
3645     };
3646     int r;
3647     suppress_error = 0;
3648     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3649     if (r == -1)
3650       return -1;
3651   }
3652   {
3653     char device[] = "/dev/sda1";
3654     device[5] = devchar;
3655     int r;
3656     suppress_error = 0;
3657     r = guestfs_pvcreate (g, device);
3658     if (r == -1)
3659       return -1;
3660   }
3661   {
3662     char volgroup[] = "VG";
3663     char physvols_0[] = "/dev/sda1";
3664     physvols_0[5] = devchar;
3665     char *physvols[] = {
3666       physvols_0,
3667       NULL
3668     };
3669     int r;
3670     suppress_error = 0;
3671     r = guestfs_vgcreate (g, volgroup, physvols);
3672     if (r == -1)
3673       return -1;
3674   }
3675   {
3676     char logvol[] = "LV1";
3677     char volgroup[] = "VG";
3678     int r;
3679     suppress_error = 0;
3680     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3681     if (r == -1)
3682       return -1;
3683   }
3684   {
3685     char logvol[] = "LV2";
3686     char volgroup[] = "VG";
3687     int r;
3688     suppress_error = 0;
3689     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3690     if (r == -1)
3691       return -1;
3692   }
3693   {
3694     char device[] = "/dev/VG";
3695     int r;
3696     suppress_error = 0;
3697     r = guestfs_lvremove (g, device);
3698     if (r == -1)
3699       return -1;
3700   }
3701   {
3702     char **r;
3703     int i;
3704     suppress_error = 0;
3705     r = guestfs_lvs (g);
3706     if (r == NULL)
3707       return -1;
3708     if (r[0] != NULL) {
3709       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3710       print_strings (r);
3711       return -1;
3712     }
3713     for (i = 0; r[i] != NULL; ++i)
3714       free (r[i]);
3715     free (r);
3716   }
3717   return 0;
3718 }
3719
3720 static int test_lvremove_2 (void)
3721 {
3722   /* InitNone|InitEmpty for test_lvremove_2 */
3723   {
3724     char device[] = "/dev/sda";
3725     device[5] = devchar;
3726     int r;
3727     suppress_error = 0;
3728     r = guestfs_blockdev_setrw (g, device);
3729     if (r == -1)
3730       return -1;
3731   }
3732   {
3733     int r;
3734     suppress_error = 0;
3735     r = guestfs_umount_all (g);
3736     if (r == -1)
3737       return -1;
3738   }
3739   {
3740     int r;
3741     suppress_error = 0;
3742     r = guestfs_lvm_remove_all (g);
3743     if (r == -1)
3744       return -1;
3745   }
3746   /* TestOutputList for lvremove (2) */
3747   {
3748     char device[] = "/dev/sda";
3749     device[5] = devchar;
3750     char lines_0[] = ",";
3751     char *lines[] = {
3752       lines_0,
3753       NULL
3754     };
3755     int r;
3756     suppress_error = 0;
3757     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3758     if (r == -1)
3759       return -1;
3760   }
3761   {
3762     char device[] = "/dev/sda1";
3763     device[5] = devchar;
3764     int r;
3765     suppress_error = 0;
3766     r = guestfs_pvcreate (g, device);
3767     if (r == -1)
3768       return -1;
3769   }
3770   {
3771     char volgroup[] = "VG";
3772     char physvols_0[] = "/dev/sda1";
3773     physvols_0[5] = devchar;
3774     char *physvols[] = {
3775       physvols_0,
3776       NULL
3777     };
3778     int r;
3779     suppress_error = 0;
3780     r = guestfs_vgcreate (g, volgroup, physvols);
3781     if (r == -1)
3782       return -1;
3783   }
3784   {
3785     char logvol[] = "LV1";
3786     char volgroup[] = "VG";
3787     int r;
3788     suppress_error = 0;
3789     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3790     if (r == -1)
3791       return -1;
3792   }
3793   {
3794     char logvol[] = "LV2";
3795     char volgroup[] = "VG";
3796     int r;
3797     suppress_error = 0;
3798     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3799     if (r == -1)
3800       return -1;
3801   }
3802   {
3803     char device[] = "/dev/VG";
3804     int r;
3805     suppress_error = 0;
3806     r = guestfs_lvremove (g, device);
3807     if (r == -1)
3808       return -1;
3809   }
3810   {
3811     char **r;
3812     int i;
3813     suppress_error = 0;
3814     r = guestfs_vgs (g);
3815     if (r == NULL)
3816       return -1;
3817     if (!r[0]) {
3818       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3819       print_strings (r);
3820       return -1;
3821     }
3822     {
3823       char expected[] = "VG";
3824       if (strcmp (r[0], expected) != 0) {
3825         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3826         return -1;
3827       }
3828     }
3829     if (r[1] != NULL) {
3830       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3831       print_strings (r);
3832       return -1;
3833     }
3834     for (i = 0; r[i] != NULL; ++i)
3835       free (r[i]);
3836     free (r);
3837   }
3838   return 0;
3839 }
3840
3841 static int test_mount_ro_0 (void)
3842 {
3843   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
3844   {
3845     char device[] = "/dev/sda";
3846     device[5] = devchar;
3847     int r;
3848     suppress_error = 0;
3849     r = guestfs_blockdev_setrw (g, device);
3850     if (r == -1)
3851       return -1;
3852   }
3853   {
3854     int r;
3855     suppress_error = 0;
3856     r = guestfs_umount_all (g);
3857     if (r == -1)
3858       return -1;
3859   }
3860   {
3861     int r;
3862     suppress_error = 0;
3863     r = guestfs_lvm_remove_all (g);
3864     if (r == -1)
3865       return -1;
3866   }
3867   {
3868     char device[] = "/dev/sda";
3869     device[5] = devchar;
3870     char lines_0[] = ",";
3871     char *lines[] = {
3872       lines_0,
3873       NULL
3874     };
3875     int r;
3876     suppress_error = 0;
3877     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3878     if (r == -1)
3879       return -1;
3880   }
3881   {
3882     char fstype[] = "ext2";
3883     char device[] = "/dev/sda1";
3884     device[5] = devchar;
3885     int r;
3886     suppress_error = 0;
3887     r = guestfs_mkfs (g, fstype, device);
3888     if (r == -1)
3889       return -1;
3890   }
3891   {
3892     char device[] = "/dev/sda1";
3893     device[5] = devchar;
3894     char mountpoint[] = "/";
3895     int r;
3896     suppress_error = 0;
3897     r = guestfs_mount (g, device, mountpoint);
3898     if (r == -1)
3899       return -1;
3900   }
3901   /* TestLastFail for mount_ro (0) */
3902   {
3903     char pathordevice[] = "/";
3904     int r;
3905     suppress_error = 0;
3906     r = guestfs_umount (g, pathordevice);
3907     if (r == -1)
3908       return -1;
3909   }
3910   {
3911     char device[] = "/dev/sda1";
3912     device[5] = devchar;
3913     char mountpoint[] = "/";
3914     int r;
3915     suppress_error = 0;
3916     r = guestfs_mount_ro (g, device, mountpoint);
3917     if (r == -1)
3918       return -1;
3919   }
3920   {
3921     char path[] = "/new";
3922     int r;
3923     suppress_error = 1;
3924     r = guestfs_touch (g, path);
3925     if (r != -1)
3926       return -1;
3927   }
3928   return 0;
3929 }
3930
3931 static int test_mount_ro_1 (void)
3932 {
3933   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
3934   {
3935     char device[] = "/dev/sda";
3936     device[5] = devchar;
3937     int r;
3938     suppress_error = 0;
3939     r = guestfs_blockdev_setrw (g, device);
3940     if (r == -1)
3941       return -1;
3942   }
3943   {
3944     int r;
3945     suppress_error = 0;
3946     r = guestfs_umount_all (g);
3947     if (r == -1)
3948       return -1;
3949   }
3950   {
3951     int r;
3952     suppress_error = 0;
3953     r = guestfs_lvm_remove_all (g);
3954     if (r == -1)
3955       return -1;
3956   }
3957   {
3958     char device[] = "/dev/sda";
3959     device[5] = devchar;
3960     char lines_0[] = ",";
3961     char *lines[] = {
3962       lines_0,
3963       NULL
3964     };
3965     int r;
3966     suppress_error = 0;
3967     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3968     if (r == -1)
3969       return -1;
3970   }
3971   {
3972     char fstype[] = "ext2";
3973     char device[] = "/dev/sda1";
3974     device[5] = devchar;
3975     int r;
3976     suppress_error = 0;
3977     r = guestfs_mkfs (g, fstype, device);
3978     if (r == -1)
3979       return -1;
3980   }
3981   {
3982     char device[] = "/dev/sda1";
3983     device[5] = devchar;
3984     char mountpoint[] = "/";
3985     int r;
3986     suppress_error = 0;
3987     r = guestfs_mount (g, device, mountpoint);
3988     if (r == -1)
3989       return -1;
3990   }
3991   /* TestOutput for mount_ro (1) */
3992   char expected[] = "data";
3993   {
3994     char path[] = "/new";
3995     char content[] = "data";
3996     int r;
3997     suppress_error = 0;
3998     r = guestfs_write_file (g, path, content, 0);
3999     if (r == -1)
4000       return -1;
4001   }
4002   {
4003     char pathordevice[] = "/";
4004     int r;
4005     suppress_error = 0;
4006     r = guestfs_umount (g, pathordevice);
4007     if (r == -1)
4008       return -1;
4009   }
4010   {
4011     char device[] = "/dev/sda1";
4012     device[5] = devchar;
4013     char mountpoint[] = "/";
4014     int r;
4015     suppress_error = 0;
4016     r = guestfs_mount_ro (g, device, mountpoint);
4017     if (r == -1)
4018       return -1;
4019   }
4020   {
4021     char path[] = "/new";
4022     char *r;
4023     suppress_error = 0;
4024     r = guestfs_cat (g, path);
4025     if (r == NULL)
4026       return -1;
4027     if (strcmp (r, expected) != 0) {
4028       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4029       return -1;
4030     }
4031     free (r);
4032   }
4033   return 0;
4034 }
4035
4036 static int test_tgz_in_0 (void)
4037 {
4038   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4039   {
4040     char device[] = "/dev/sda";
4041     device[5] = devchar;
4042     int r;
4043     suppress_error = 0;
4044     r = guestfs_blockdev_setrw (g, device);
4045     if (r == -1)
4046       return -1;
4047   }
4048   {
4049     int r;
4050     suppress_error = 0;
4051     r = guestfs_umount_all (g);
4052     if (r == -1)
4053       return -1;
4054   }
4055   {
4056     int r;
4057     suppress_error = 0;
4058     r = guestfs_lvm_remove_all (g);
4059     if (r == -1)
4060       return -1;
4061   }
4062   {
4063     char device[] = "/dev/sda";
4064     device[5] = devchar;
4065     char lines_0[] = ",";
4066     char *lines[] = {
4067       lines_0,
4068       NULL
4069     };
4070     int r;
4071     suppress_error = 0;
4072     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4073     if (r == -1)
4074       return -1;
4075   }
4076   {
4077     char fstype[] = "ext2";
4078     char device[] = "/dev/sda1";
4079     device[5] = devchar;
4080     int r;
4081     suppress_error = 0;
4082     r = guestfs_mkfs (g, fstype, device);
4083     if (r == -1)
4084       return -1;
4085   }
4086   {
4087     char device[] = "/dev/sda1";
4088     device[5] = devchar;
4089     char mountpoint[] = "/";
4090     int r;
4091     suppress_error = 0;
4092     r = guestfs_mount (g, device, mountpoint);
4093     if (r == -1)
4094       return -1;
4095   }
4096   /* TestOutput for tgz_in (0) */
4097   char expected[] = "hello\n";
4098   {
4099     char directory[] = "/";
4100     int r;
4101     suppress_error = 0;
4102     r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
4103     if (r == -1)
4104       return -1;
4105   }
4106   {
4107     char path[] = "/hello";
4108     char *r;
4109     suppress_error = 0;
4110     r = guestfs_cat (g, path);
4111     if (r == NULL)
4112       return -1;
4113     if (strcmp (r, expected) != 0) {
4114       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4115       return -1;
4116     }
4117     free (r);
4118   }
4119   return 0;
4120 }
4121
4122 static int test_tar_in_0 (void)
4123 {
4124   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4125   {
4126     char device[] = "/dev/sda";
4127     device[5] = devchar;
4128     int r;
4129     suppress_error = 0;
4130     r = guestfs_blockdev_setrw (g, device);
4131     if (r == -1)
4132       return -1;
4133   }
4134   {
4135     int r;
4136     suppress_error = 0;
4137     r = guestfs_umount_all (g);
4138     if (r == -1)
4139       return -1;
4140   }
4141   {
4142     int r;
4143     suppress_error = 0;
4144     r = guestfs_lvm_remove_all (g);
4145     if (r == -1)
4146       return -1;
4147   }
4148   {
4149     char device[] = "/dev/sda";
4150     device[5] = devchar;
4151     char lines_0[] = ",";
4152     char *lines[] = {
4153       lines_0,
4154       NULL
4155     };
4156     int r;
4157     suppress_error = 0;
4158     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4159     if (r == -1)
4160       return -1;
4161   }
4162   {
4163     char fstype[] = "ext2";
4164     char device[] = "/dev/sda1";
4165     device[5] = devchar;
4166     int r;
4167     suppress_error = 0;
4168     r = guestfs_mkfs (g, fstype, device);
4169     if (r == -1)
4170       return -1;
4171   }
4172   {
4173     char device[] = "/dev/sda1";
4174     device[5] = devchar;
4175     char mountpoint[] = "/";
4176     int r;
4177     suppress_error = 0;
4178     r = guestfs_mount (g, device, mountpoint);
4179     if (r == -1)
4180       return -1;
4181   }
4182   /* TestOutput for tar_in (0) */
4183   char expected[] = "hello\n";
4184   {
4185     char directory[] = "/";
4186     int r;
4187     suppress_error = 0;
4188     r = guestfs_tar_in (g, "images/helloworld.tar", directory);
4189     if (r == -1)
4190       return -1;
4191   }
4192   {
4193     char path[] = "/hello";
4194     char *r;
4195     suppress_error = 0;
4196     r = guestfs_cat (g, path);
4197     if (r == NULL)
4198       return -1;
4199     if (strcmp (r, expected) != 0) {
4200       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4201       return -1;
4202     }
4203     free (r);
4204   }
4205   return 0;
4206 }
4207
4208 static int test_checksum_0 (void)
4209 {
4210   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4211   {
4212     char device[] = "/dev/sda";
4213     device[5] = devchar;
4214     int r;
4215     suppress_error = 0;
4216     r = guestfs_blockdev_setrw (g, device);
4217     if (r == -1)
4218       return -1;
4219   }
4220   {
4221     int r;
4222     suppress_error = 0;
4223     r = guestfs_umount_all (g);
4224     if (r == -1)
4225       return -1;
4226   }
4227   {
4228     int r;
4229     suppress_error = 0;
4230     r = guestfs_lvm_remove_all (g);
4231     if (r == -1)
4232       return -1;
4233   }
4234   {
4235     char device[] = "/dev/sda";
4236     device[5] = devchar;
4237     char lines_0[] = ",";
4238     char *lines[] = {
4239       lines_0,
4240       NULL
4241     };
4242     int r;
4243     suppress_error = 0;
4244     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4245     if (r == -1)
4246       return -1;
4247   }
4248   {
4249     char fstype[] = "ext2";
4250     char device[] = "/dev/sda1";
4251     device[5] = devchar;
4252     int r;
4253     suppress_error = 0;
4254     r = guestfs_mkfs (g, fstype, device);
4255     if (r == -1)
4256       return -1;
4257   }
4258   {
4259     char device[] = "/dev/sda1";
4260     device[5] = devchar;
4261     char mountpoint[] = "/";
4262     int r;
4263     suppress_error = 0;
4264     r = guestfs_mount (g, device, mountpoint);
4265     if (r == -1)
4266       return -1;
4267   }
4268   /* TestOutput for checksum (0) */
4269   char expected[] = "935282863";
4270   {
4271     char path[] = "/new";
4272     char content[] = "test\n";
4273     int r;
4274     suppress_error = 0;
4275     r = guestfs_write_file (g, path, content, 0);
4276     if (r == -1)
4277       return -1;
4278   }
4279   {
4280     char csumtype[] = "crc";
4281     char path[] = "/new";
4282     char *r;
4283     suppress_error = 0;
4284     r = guestfs_checksum (g, csumtype, path);
4285     if (r == NULL)
4286       return -1;
4287     if (strcmp (r, expected) != 0) {
4288       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
4289       return -1;
4290     }
4291     free (r);
4292   }
4293   return 0;
4294 }
4295
4296 static int test_checksum_1 (void)
4297 {
4298   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
4299   {
4300     char device[] = "/dev/sda";
4301     device[5] = devchar;
4302     int r;
4303     suppress_error = 0;
4304     r = guestfs_blockdev_setrw (g, device);
4305     if (r == -1)
4306       return -1;
4307   }
4308   {
4309     int r;
4310     suppress_error = 0;
4311     r = guestfs_umount_all (g);
4312     if (r == -1)
4313       return -1;
4314   }
4315   {
4316     int r;
4317     suppress_error = 0;
4318     r = guestfs_lvm_remove_all (g);
4319     if (r == -1)
4320       return -1;
4321   }
4322   {
4323     char device[] = "/dev/sda";
4324     device[5] = devchar;
4325     char lines_0[] = ",";
4326     char *lines[] = {
4327       lines_0,
4328       NULL
4329     };
4330     int r;
4331     suppress_error = 0;
4332     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4333     if (r == -1)
4334       return -1;
4335   }
4336   {
4337     char fstype[] = "ext2";
4338     char device[] = "/dev/sda1";
4339     device[5] = devchar;
4340     int r;
4341     suppress_error = 0;
4342     r = guestfs_mkfs (g, fstype, device);
4343     if (r == -1)
4344       return -1;
4345   }
4346   {
4347     char device[] = "/dev/sda1";
4348     device[5] = devchar;
4349     char mountpoint[] = "/";
4350     int r;
4351     suppress_error = 0;
4352     r = guestfs_mount (g, device, mountpoint);
4353     if (r == -1)
4354       return -1;
4355   }
4356   /* TestLastFail for checksum (1) */
4357   {
4358     char csumtype[] = "crc";
4359     char path[] = "/new";
4360     char *r;
4361     suppress_error = 1;
4362     r = guestfs_checksum (g, csumtype, path);
4363     if (r != NULL)
4364       return -1;
4365     free (r);
4366   }
4367   return 0;
4368 }
4369
4370 static int test_checksum_2 (void)
4371 {
4372   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
4373   {
4374     char device[] = "/dev/sda";
4375     device[5] = devchar;
4376     int r;
4377     suppress_error = 0;
4378     r = guestfs_blockdev_setrw (g, device);
4379     if (r == -1)
4380       return -1;
4381   }
4382   {
4383     int r;
4384     suppress_error = 0;
4385     r = guestfs_umount_all (g);
4386     if (r == -1)
4387       return -1;
4388   }
4389   {
4390     int r;
4391     suppress_error = 0;
4392     r = guestfs_lvm_remove_all (g);
4393     if (r == -1)
4394       return -1;
4395   }
4396   {
4397     char device[] = "/dev/sda";
4398     device[5] = devchar;
4399     char lines_0[] = ",";
4400     char *lines[] = {
4401       lines_0,
4402       NULL
4403     };
4404     int r;
4405     suppress_error = 0;
4406     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4407     if (r == -1)
4408       return -1;
4409   }
4410   {
4411     char fstype[] = "ext2";
4412     char device[] = "/dev/sda1";
4413     device[5] = devchar;
4414     int r;
4415     suppress_error = 0;
4416     r = guestfs_mkfs (g, fstype, device);
4417     if (r == -1)
4418       return -1;
4419   }
4420   {
4421     char device[] = "/dev/sda1";
4422     device[5] = devchar;
4423     char mountpoint[] = "/";
4424     int r;
4425     suppress_error = 0;
4426     r = guestfs_mount (g, device, mountpoint);
4427     if (r == -1)
4428       return -1;
4429   }
4430   /* TestOutput for checksum (2) */
4431   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
4432   {
4433     char path[] = "/new";
4434     char content[] = "test\n";
4435     int r;
4436     suppress_error = 0;
4437     r = guestfs_write_file (g, path, content, 0);
4438     if (r == -1)
4439       return -1;
4440   }
4441   {
4442     char csumtype[] = "md5";
4443     char path[] = "/new";
4444     char *r;
4445     suppress_error = 0;
4446     r = guestfs_checksum (g, csumtype, path);
4447     if (r == NULL)
4448       return -1;
4449     if (strcmp (r, expected) != 0) {
4450       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
4451       return -1;
4452     }
4453     free (r);
4454   }
4455   return 0;
4456 }
4457
4458 static int test_checksum_3 (void)
4459 {
4460   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
4461   {
4462     char device[] = "/dev/sda";
4463     device[5] = devchar;
4464     int r;
4465     suppress_error = 0;
4466     r = guestfs_blockdev_setrw (g, device);
4467     if (r == -1)
4468       return -1;
4469   }
4470   {
4471     int r;
4472     suppress_error = 0;
4473     r = guestfs_umount_all (g);
4474     if (r == -1)
4475       return -1;
4476   }
4477   {
4478     int r;
4479     suppress_error = 0;
4480     r = guestfs_lvm_remove_all (g);
4481     if (r == -1)
4482       return -1;
4483   }
4484   {
4485     char device[] = "/dev/sda";
4486     device[5] = devchar;
4487     char lines_0[] = ",";
4488     char *lines[] = {
4489       lines_0,
4490       NULL
4491     };
4492     int r;
4493     suppress_error = 0;
4494     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4495     if (r == -1)
4496       return -1;
4497   }
4498   {
4499     char fstype[] = "ext2";
4500     char device[] = "/dev/sda1";
4501     device[5] = devchar;
4502     int r;
4503     suppress_error = 0;
4504     r = guestfs_mkfs (g, fstype, device);
4505     if (r == -1)
4506       return -1;
4507   }
4508   {
4509     char device[] = "/dev/sda1";
4510     device[5] = devchar;
4511     char mountpoint[] = "/";
4512     int r;
4513     suppress_error = 0;
4514     r = guestfs_mount (g, device, mountpoint);
4515     if (r == -1)
4516       return -1;
4517   }
4518   /* TestOutput for checksum (3) */
4519   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
4520   {
4521     char path[] = "/new";
4522     char content[] = "test\n";
4523     int r;
4524     suppress_error = 0;
4525     r = guestfs_write_file (g, path, content, 0);
4526     if (r == -1)
4527       return -1;
4528   }
4529   {
4530     char csumtype[] = "sha1";
4531     char path[] = "/new";
4532     char *r;
4533     suppress_error = 0;
4534     r = guestfs_checksum (g, csumtype, path);
4535     if (r == NULL)
4536       return -1;
4537     if (strcmp (r, expected) != 0) {
4538       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
4539       return -1;
4540     }
4541     free (r);
4542   }
4543   return 0;
4544 }
4545
4546 static int test_checksum_4 (void)
4547 {
4548   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
4549   {
4550     char device[] = "/dev/sda";
4551     device[5] = devchar;
4552     int r;
4553     suppress_error = 0;
4554     r = guestfs_blockdev_setrw (g, device);
4555     if (r == -1)
4556       return -1;
4557   }
4558   {
4559     int r;
4560     suppress_error = 0;
4561     r = guestfs_umount_all (g);
4562     if (r == -1)
4563       return -1;
4564   }
4565   {
4566     int r;
4567     suppress_error = 0;
4568     r = guestfs_lvm_remove_all (g);
4569     if (r == -1)
4570       return -1;
4571   }
4572   {
4573     char device[] = "/dev/sda";
4574     device[5] = devchar;
4575     char lines_0[] = ",";
4576     char *lines[] = {
4577       lines_0,
4578       NULL
4579     };
4580     int r;
4581     suppress_error = 0;
4582     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4583     if (r == -1)
4584       return -1;
4585   }
4586   {
4587     char fstype[] = "ext2";
4588     char device[] = "/dev/sda1";
4589     device[5] = devchar;
4590     int r;
4591     suppress_error = 0;
4592     r = guestfs_mkfs (g, fstype, device);
4593     if (r == -1)
4594       return -1;
4595   }
4596   {
4597     char device[] = "/dev/sda1";
4598     device[5] = devchar;
4599     char mountpoint[] = "/";
4600     int r;
4601     suppress_error = 0;
4602     r = guestfs_mount (g, device, mountpoint);
4603     if (r == -1)
4604       return -1;
4605   }
4606   /* TestOutput for checksum (4) */
4607   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
4608   {
4609     char path[] = "/new";
4610     char content[] = "test\n";
4611     int r;
4612     suppress_error = 0;
4613     r = guestfs_write_file (g, path, content, 0);
4614     if (r == -1)
4615       return -1;
4616   }
4617   {
4618     char csumtype[] = "sha224";
4619     char path[] = "/new";
4620     char *r;
4621     suppress_error = 0;
4622     r = guestfs_checksum (g, csumtype, path);
4623     if (r == NULL)
4624       return -1;
4625     if (strcmp (r, expected) != 0) {
4626       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
4627       return -1;
4628     }
4629     free (r);
4630   }
4631   return 0;
4632 }
4633
4634 static int test_checksum_5 (void)
4635 {
4636   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
4637   {
4638     char device[] = "/dev/sda";
4639     device[5] = devchar;
4640     int r;
4641     suppress_error = 0;
4642     r = guestfs_blockdev_setrw (g, device);
4643     if (r == -1)
4644       return -1;
4645   }
4646   {
4647     int r;
4648     suppress_error = 0;
4649     r = guestfs_umount_all (g);
4650     if (r == -1)
4651       return -1;
4652   }
4653   {
4654     int r;
4655     suppress_error = 0;
4656     r = guestfs_lvm_remove_all (g);
4657     if (r == -1)
4658       return -1;
4659   }
4660   {
4661     char device[] = "/dev/sda";
4662     device[5] = devchar;
4663     char lines_0[] = ",";
4664     char *lines[] = {
4665       lines_0,
4666       NULL
4667     };
4668     int r;
4669     suppress_error = 0;
4670     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4671     if (r == -1)
4672       return -1;
4673   }
4674   {
4675     char fstype[] = "ext2";
4676     char device[] = "/dev/sda1";
4677     device[5] = devchar;
4678     int r;
4679     suppress_error = 0;
4680     r = guestfs_mkfs (g, fstype, device);
4681     if (r == -1)
4682       return -1;
4683   }
4684   {
4685     char device[] = "/dev/sda1";
4686     device[5] = devchar;
4687     char mountpoint[] = "/";
4688     int r;
4689     suppress_error = 0;
4690     r = guestfs_mount (g, device, mountpoint);
4691     if (r == -1)
4692       return -1;
4693   }
4694   /* TestOutput for checksum (5) */
4695   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4696   {
4697     char path[] = "/new";
4698     char content[] = "test\n";
4699     int r;
4700     suppress_error = 0;
4701     r = guestfs_write_file (g, path, content, 0);
4702     if (r == -1)
4703       return -1;
4704   }
4705   {
4706     char csumtype[] = "sha256";
4707     char path[] = "/new";
4708     char *r;
4709     suppress_error = 0;
4710     r = guestfs_checksum (g, csumtype, path);
4711     if (r == NULL)
4712       return -1;
4713     if (strcmp (r, expected) != 0) {
4714       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4715       return -1;
4716     }
4717     free (r);
4718   }
4719   return 0;
4720 }
4721
4722 static int test_checksum_6 (void)
4723 {
4724   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
4725   {
4726     char device[] = "/dev/sda";
4727     device[5] = devchar;
4728     int r;
4729     suppress_error = 0;
4730     r = guestfs_blockdev_setrw (g, device);
4731     if (r == -1)
4732       return -1;
4733   }
4734   {
4735     int r;
4736     suppress_error = 0;
4737     r = guestfs_umount_all (g);
4738     if (r == -1)
4739       return -1;
4740   }
4741   {
4742     int r;
4743     suppress_error = 0;
4744     r = guestfs_lvm_remove_all (g);
4745     if (r == -1)
4746       return -1;
4747   }
4748   {
4749     char device[] = "/dev/sda";
4750     device[5] = devchar;
4751     char lines_0[] = ",";
4752     char *lines[] = {
4753       lines_0,
4754       NULL
4755     };
4756     int r;
4757     suppress_error = 0;
4758     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4759     if (r == -1)
4760       return -1;
4761   }
4762   {
4763     char fstype[] = "ext2";
4764     char device[] = "/dev/sda1";
4765     device[5] = devchar;
4766     int r;
4767     suppress_error = 0;
4768     r = guestfs_mkfs (g, fstype, device);
4769     if (r == -1)
4770       return -1;
4771   }
4772   {
4773     char device[] = "/dev/sda1";
4774     device[5] = devchar;
4775     char mountpoint[] = "/";
4776     int r;
4777     suppress_error = 0;
4778     r = guestfs_mount (g, device, mountpoint);
4779     if (r == -1)
4780       return -1;
4781   }
4782   /* TestOutput for checksum (6) */
4783   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4784   {
4785     char path[] = "/new";
4786     char content[] = "test\n";
4787     int r;
4788     suppress_error = 0;
4789     r = guestfs_write_file (g, path, content, 0);
4790     if (r == -1)
4791       return -1;
4792   }
4793   {
4794     char csumtype[] = "sha384";
4795     char path[] = "/new";
4796     char *r;
4797     suppress_error = 0;
4798     r = guestfs_checksum (g, csumtype, path);
4799     if (r == NULL)
4800       return -1;
4801     if (strcmp (r, expected) != 0) {
4802       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4803       return -1;
4804     }
4805     free (r);
4806   }
4807   return 0;
4808 }
4809
4810 static int test_checksum_7 (void)
4811 {
4812   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
4813   {
4814     char device[] = "/dev/sda";
4815     device[5] = devchar;
4816     int r;
4817     suppress_error = 0;
4818     r = guestfs_blockdev_setrw (g, device);
4819     if (r == -1)
4820       return -1;
4821   }
4822   {
4823     int r;
4824     suppress_error = 0;
4825     r = guestfs_umount_all (g);
4826     if (r == -1)
4827       return -1;
4828   }
4829   {
4830     int r;
4831     suppress_error = 0;
4832     r = guestfs_lvm_remove_all (g);
4833     if (r == -1)
4834       return -1;
4835   }
4836   {
4837     char device[] = "/dev/sda";
4838     device[5] = devchar;
4839     char lines_0[] = ",";
4840     char *lines[] = {
4841       lines_0,
4842       NULL
4843     };
4844     int r;
4845     suppress_error = 0;
4846     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4847     if (r == -1)
4848       return -1;
4849   }
4850   {
4851     char fstype[] = "ext2";
4852     char device[] = "/dev/sda1";
4853     device[5] = devchar;
4854     int r;
4855     suppress_error = 0;
4856     r = guestfs_mkfs (g, fstype, device);
4857     if (r == -1)
4858       return -1;
4859   }
4860   {
4861     char device[] = "/dev/sda1";
4862     device[5] = devchar;
4863     char mountpoint[] = "/";
4864     int r;
4865     suppress_error = 0;
4866     r = guestfs_mount (g, device, mountpoint);
4867     if (r == -1)
4868       return -1;
4869   }
4870   /* TestOutput for checksum (7) */
4871   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4872   {
4873     char path[] = "/new";
4874     char content[] = "test\n";
4875     int r;
4876     suppress_error = 0;
4877     r = guestfs_write_file (g, path, content, 0);
4878     if (r == -1)
4879       return -1;
4880   }
4881   {
4882     char csumtype[] = "sha512";
4883     char path[] = "/new";
4884     char *r;
4885     suppress_error = 0;
4886     r = guestfs_checksum (g, csumtype, path);
4887     if (r == NULL)
4888       return -1;
4889     if (strcmp (r, expected) != 0) {
4890       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4891       return -1;
4892     }
4893     free (r);
4894   }
4895   return 0;
4896 }
4897
4898 static int test_download_0 (void)
4899 {
4900   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
4901   {
4902     char device[] = "/dev/sda";
4903     device[5] = devchar;
4904     int r;
4905     suppress_error = 0;
4906     r = guestfs_blockdev_setrw (g, device);
4907     if (r == -1)
4908       return -1;
4909   }
4910   {
4911     int r;
4912     suppress_error = 0;
4913     r = guestfs_umount_all (g);
4914     if (r == -1)
4915       return -1;
4916   }
4917   {
4918     int r;
4919     suppress_error = 0;
4920     r = guestfs_lvm_remove_all (g);
4921     if (r == -1)
4922       return -1;
4923   }
4924   {
4925     char device[] = "/dev/sda";
4926     device[5] = devchar;
4927     char lines_0[] = ",";
4928     char *lines[] = {
4929       lines_0,
4930       NULL
4931     };
4932     int r;
4933     suppress_error = 0;
4934     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4935     if (r == -1)
4936       return -1;
4937   }
4938   {
4939     char fstype[] = "ext2";
4940     char device[] = "/dev/sda1";
4941     device[5] = devchar;
4942     int r;
4943     suppress_error = 0;
4944     r = guestfs_mkfs (g, fstype, device);
4945     if (r == -1)
4946       return -1;
4947   }
4948   {
4949     char device[] = "/dev/sda1";
4950     device[5] = devchar;
4951     char mountpoint[] = "/";
4952     int r;
4953     suppress_error = 0;
4954     r = guestfs_mount (g, device, mountpoint);
4955     if (r == -1)
4956       return -1;
4957   }
4958   /* TestOutput for download (0) */
4959   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4960   {
4961     char remotefilename[] = "/COPYING.LIB";
4962     int r;
4963     suppress_error = 0;
4964     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4965     if (r == -1)
4966       return -1;
4967   }
4968   {
4969     char remotefilename[] = "/COPYING.LIB";
4970     int r;
4971     suppress_error = 0;
4972     r = guestfs_download (g, remotefilename, "testdownload.tmp");
4973     if (r == -1)
4974       return -1;
4975   }
4976   {
4977     char remotefilename[] = "/upload";
4978     int r;
4979     suppress_error = 0;
4980     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4981     if (r == -1)
4982       return -1;
4983   }
4984   {
4985     char csumtype[] = "md5";
4986     char path[] = "/upload";
4987     char *r;
4988     suppress_error = 0;
4989     r = guestfs_checksum (g, csumtype, path);
4990     if (r == NULL)
4991       return -1;
4992     if (strcmp (r, expected) != 0) {
4993       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4994       return -1;
4995     }
4996     free (r);
4997   }
4998   return 0;
4999 }
5000
5001 static int test_upload_0 (void)
5002 {
5003   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5004   {
5005     char device[] = "/dev/sda";
5006     device[5] = devchar;
5007     int r;
5008     suppress_error = 0;
5009     r = guestfs_blockdev_setrw (g, device);
5010     if (r == -1)
5011       return -1;
5012   }
5013   {
5014     int r;
5015     suppress_error = 0;
5016     r = guestfs_umount_all (g);
5017     if (r == -1)
5018       return -1;
5019   }
5020   {
5021     int r;
5022     suppress_error = 0;
5023     r = guestfs_lvm_remove_all (g);
5024     if (r == -1)
5025       return -1;
5026   }
5027   {
5028     char device[] = "/dev/sda";
5029     device[5] = devchar;
5030     char lines_0[] = ",";
5031     char *lines[] = {
5032       lines_0,
5033       NULL
5034     };
5035     int r;
5036     suppress_error = 0;
5037     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5038     if (r == -1)
5039       return -1;
5040   }
5041   {
5042     char fstype[] = "ext2";
5043     char device[] = "/dev/sda1";
5044     device[5] = devchar;
5045     int r;
5046     suppress_error = 0;
5047     r = guestfs_mkfs (g, fstype, device);
5048     if (r == -1)
5049       return -1;
5050   }
5051   {
5052     char device[] = "/dev/sda1";
5053     device[5] = devchar;
5054     char mountpoint[] = "/";
5055     int r;
5056     suppress_error = 0;
5057     r = guestfs_mount (g, device, mountpoint);
5058     if (r == -1)
5059       return -1;
5060   }
5061   /* TestOutput for upload (0) */
5062   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5063   {
5064     char remotefilename[] = "/COPYING.LIB";
5065     int r;
5066     suppress_error = 0;
5067     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
5068     if (r == -1)
5069       return -1;
5070   }
5071   {
5072     char csumtype[] = "md5";
5073     char path[] = "/COPYING.LIB";
5074     char *r;
5075     suppress_error = 0;
5076     r = guestfs_checksum (g, csumtype, path);
5077     if (r == NULL)
5078       return -1;
5079     if (strcmp (r, expected) != 0) {
5080       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
5081       return -1;
5082     }
5083     free (r);
5084   }
5085   return 0;
5086 }
5087
5088 static int test_blockdev_rereadpt_0 (void)
5089 {
5090   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
5091   {
5092     char device[] = "/dev/sda";
5093     device[5] = devchar;
5094     int r;
5095     suppress_error = 0;
5096     r = guestfs_blockdev_setrw (g, device);
5097     if (r == -1)
5098       return -1;
5099   }
5100   {
5101     int r;
5102     suppress_error = 0;
5103     r = guestfs_umount_all (g);
5104     if (r == -1)
5105       return -1;
5106   }
5107   {
5108     int r;
5109     suppress_error = 0;
5110     r = guestfs_lvm_remove_all (g);
5111     if (r == -1)
5112       return -1;
5113   }
5114   /* TestRun for blockdev_rereadpt (0) */
5115   {
5116     char device[] = "/dev/sda";
5117     device[5] = devchar;
5118     int r;
5119     suppress_error = 0;
5120     r = guestfs_blockdev_rereadpt (g, device);
5121     if (r == -1)
5122       return -1;
5123   }
5124   return 0;
5125 }
5126
5127 static int test_blockdev_flushbufs_0 (void)
5128 {
5129   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
5130   {
5131     char device[] = "/dev/sda";
5132     device[5] = devchar;
5133     int r;
5134     suppress_error = 0;
5135     r = guestfs_blockdev_setrw (g, device);
5136     if (r == -1)
5137       return -1;
5138   }
5139   {
5140     int r;
5141     suppress_error = 0;
5142     r = guestfs_umount_all (g);
5143     if (r == -1)
5144       return -1;
5145   }
5146   {
5147     int r;
5148     suppress_error = 0;
5149     r = guestfs_lvm_remove_all (g);
5150     if (r == -1)
5151       return -1;
5152   }
5153   /* TestRun for blockdev_flushbufs (0) */
5154   {
5155     char device[] = "/dev/sda";
5156     device[5] = devchar;
5157     int r;
5158     suppress_error = 0;
5159     r = guestfs_blockdev_flushbufs (g, device);
5160     if (r == -1)
5161       return -1;
5162   }
5163   return 0;
5164 }
5165
5166 static int test_blockdev_getsize64_0 (void)
5167 {
5168   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
5169   {
5170     char device[] = "/dev/sda";
5171     device[5] = devchar;
5172     int r;
5173     suppress_error = 0;
5174     r = guestfs_blockdev_setrw (g, device);
5175     if (r == -1)
5176       return -1;
5177   }
5178   {
5179     int r;
5180     suppress_error = 0;
5181     r = guestfs_umount_all (g);
5182     if (r == -1)
5183       return -1;
5184   }
5185   {
5186     int r;
5187     suppress_error = 0;
5188     r = guestfs_lvm_remove_all (g);
5189     if (r == -1)
5190       return -1;
5191   }
5192   /* TestOutputInt for blockdev_getsize64 (0) */
5193   {
5194     char device[] = "/dev/sda";
5195     device[5] = devchar;
5196     int64_t r;
5197     suppress_error = 0;
5198     r = guestfs_blockdev_getsize64 (g, device);
5199     if (r == -1)
5200       return -1;
5201     if (r != 524288000) {
5202       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
5203       return -1;
5204     }
5205   }
5206   return 0;
5207 }
5208
5209 static int test_blockdev_getsz_0 (void)
5210 {
5211   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
5212   {
5213     char device[] = "/dev/sda";
5214     device[5] = devchar;
5215     int r;
5216     suppress_error = 0;
5217     r = guestfs_blockdev_setrw (g, device);
5218     if (r == -1)
5219       return -1;
5220   }
5221   {
5222     int r;
5223     suppress_error = 0;
5224     r = guestfs_umount_all (g);
5225     if (r == -1)
5226       return -1;
5227   }
5228   {
5229     int r;
5230     suppress_error = 0;
5231     r = guestfs_lvm_remove_all (g);
5232     if (r == -1)
5233       return -1;
5234   }
5235   /* TestOutputInt for blockdev_getsz (0) */
5236   {
5237     char device[] = "/dev/sda";
5238     device[5] = devchar;
5239     int64_t r;
5240     suppress_error = 0;
5241     r = guestfs_blockdev_getsz (g, device);
5242     if (r == -1)
5243       return -1;
5244     if (r != 1024000) {
5245       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
5246       return -1;
5247     }
5248   }
5249   return 0;
5250 }
5251
5252 static int test_blockdev_getbsz_0 (void)
5253 {
5254   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
5255   {
5256     char device[] = "/dev/sda";
5257     device[5] = devchar;
5258     int r;
5259     suppress_error = 0;
5260     r = guestfs_blockdev_setrw (g, device);
5261     if (r == -1)
5262       return -1;
5263   }
5264   {
5265     int r;
5266     suppress_error = 0;
5267     r = guestfs_umount_all (g);
5268     if (r == -1)
5269       return -1;
5270   }
5271   {
5272     int r;
5273     suppress_error = 0;
5274     r = guestfs_lvm_remove_all (g);
5275     if (r == -1)
5276       return -1;
5277   }
5278   /* TestOutputInt for blockdev_getbsz (0) */
5279   {
5280     char device[] = "/dev/sda";
5281     device[5] = devchar;
5282     int r;
5283     suppress_error = 0;
5284     r = guestfs_blockdev_getbsz (g, device);
5285     if (r == -1)
5286       return -1;
5287     if (r != 4096) {
5288       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
5289       return -1;
5290     }
5291   }
5292   return 0;
5293 }
5294
5295 static int test_blockdev_getss_0 (void)
5296 {
5297   /* InitNone|InitEmpty for test_blockdev_getss_0 */
5298   {
5299     char device[] = "/dev/sda";
5300     device[5] = devchar;
5301     int r;
5302     suppress_error = 0;
5303     r = guestfs_blockdev_setrw (g, device);
5304     if (r == -1)
5305       return -1;
5306   }
5307   {
5308     int r;
5309     suppress_error = 0;
5310     r = guestfs_umount_all (g);
5311     if (r == -1)
5312       return -1;
5313   }
5314   {
5315     int r;
5316     suppress_error = 0;
5317     r = guestfs_lvm_remove_all (g);
5318     if (r == -1)
5319       return -1;
5320   }
5321   /* TestOutputInt for blockdev_getss (0) */
5322   {
5323     char device[] = "/dev/sda";
5324     device[5] = devchar;
5325     int r;
5326     suppress_error = 0;
5327     r = guestfs_blockdev_getss (g, device);
5328     if (r == -1)
5329       return -1;
5330     if (r != 512) {
5331       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
5332       return -1;
5333     }
5334   }
5335   return 0;
5336 }
5337
5338 static int test_blockdev_getro_0 (void)
5339 {
5340   /* InitNone|InitEmpty for test_blockdev_getro_0 */
5341   {
5342     char device[] = "/dev/sda";
5343     device[5] = devchar;
5344     int r;
5345     suppress_error = 0;
5346     r = guestfs_blockdev_setrw (g, device);
5347     if (r == -1)
5348       return -1;
5349   }
5350   {
5351     int r;
5352     suppress_error = 0;
5353     r = guestfs_umount_all (g);
5354     if (r == -1)
5355       return -1;
5356   }
5357   {
5358     int r;
5359     suppress_error = 0;
5360     r = guestfs_lvm_remove_all (g);
5361     if (r == -1)
5362       return -1;
5363   }
5364   /* TestOutputTrue for blockdev_getro (0) */
5365   {
5366     char device[] = "/dev/sda";
5367     device[5] = devchar;
5368     int r;
5369     suppress_error = 0;
5370     r = guestfs_blockdev_setro (g, device);
5371     if (r == -1)
5372       return -1;
5373   }
5374   {
5375     char device[] = "/dev/sda";
5376     device[5] = devchar;
5377     int r;
5378     suppress_error = 0;
5379     r = guestfs_blockdev_getro (g, device);
5380     if (r == -1)
5381       return -1;
5382     if (!r) {
5383       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
5384       return -1;
5385     }
5386   }
5387   return 0;
5388 }
5389
5390 static int test_blockdev_setrw_0 (void)
5391 {
5392   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
5393   {
5394     char device[] = "/dev/sda";
5395     device[5] = devchar;
5396     int r;
5397     suppress_error = 0;
5398     r = guestfs_blockdev_setrw (g, device);
5399     if (r == -1)
5400       return -1;
5401   }
5402   {
5403     int r;
5404     suppress_error = 0;
5405     r = guestfs_umount_all (g);
5406     if (r == -1)
5407       return -1;
5408   }
5409   {
5410     int r;
5411     suppress_error = 0;
5412     r = guestfs_lvm_remove_all (g);
5413     if (r == -1)
5414       return -1;
5415   }
5416   /* TestOutputFalse for blockdev_setrw (0) */
5417   {
5418     char device[] = "/dev/sda";
5419     device[5] = devchar;
5420     int r;
5421     suppress_error = 0;
5422     r = guestfs_blockdev_setrw (g, device);
5423     if (r == -1)
5424       return -1;
5425   }
5426   {
5427     char device[] = "/dev/sda";
5428     device[5] = devchar;
5429     int r;
5430     suppress_error = 0;
5431     r = guestfs_blockdev_getro (g, device);
5432     if (r == -1)
5433       return -1;
5434     if (r) {
5435       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
5436       return -1;
5437     }
5438   }
5439   return 0;
5440 }
5441
5442 static int test_blockdev_setro_0 (void)
5443 {
5444   /* InitNone|InitEmpty for test_blockdev_setro_0 */
5445   {
5446     char device[] = "/dev/sda";
5447     device[5] = devchar;
5448     int r;
5449     suppress_error = 0;
5450     r = guestfs_blockdev_setrw (g, device);
5451     if (r == -1)
5452       return -1;
5453   }
5454   {
5455     int r;
5456     suppress_error = 0;
5457     r = guestfs_umount_all (g);
5458     if (r == -1)
5459       return -1;
5460   }
5461   {
5462     int r;
5463     suppress_error = 0;
5464     r = guestfs_lvm_remove_all (g);
5465     if (r == -1)
5466       return -1;
5467   }
5468   /* TestOutputTrue for blockdev_setro (0) */
5469   {
5470     char device[] = "/dev/sda";
5471     device[5] = devchar;
5472     int r;
5473     suppress_error = 0;
5474     r = guestfs_blockdev_setro (g, device);
5475     if (r == -1)
5476       return -1;
5477   }
5478   {
5479     char device[] = "/dev/sda";
5480     device[5] = devchar;
5481     int r;
5482     suppress_error = 0;
5483     r = guestfs_blockdev_getro (g, device);
5484     if (r == -1)
5485       return -1;
5486     if (!r) {
5487       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
5488       return -1;
5489     }
5490   }
5491   return 0;
5492 }
5493
5494 static int test_statvfs_0 (void)
5495 {
5496   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
5497   {
5498     char device[] = "/dev/sda";
5499     device[5] = devchar;
5500     int r;
5501     suppress_error = 0;
5502     r = guestfs_blockdev_setrw (g, device);
5503     if (r == -1)
5504       return -1;
5505   }
5506   {
5507     int r;
5508     suppress_error = 0;
5509     r = guestfs_umount_all (g);
5510     if (r == -1)
5511       return -1;
5512   }
5513   {
5514     int r;
5515     suppress_error = 0;
5516     r = guestfs_lvm_remove_all (g);
5517     if (r == -1)
5518       return -1;
5519   }
5520   {
5521     char device[] = "/dev/sda";
5522     device[5] = devchar;
5523     char lines_0[] = ",";
5524     char *lines[] = {
5525       lines_0,
5526       NULL
5527     };
5528     int r;
5529     suppress_error = 0;
5530     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5531     if (r == -1)
5532       return -1;
5533   }
5534   {
5535     char fstype[] = "ext2";
5536     char device[] = "/dev/sda1";
5537     device[5] = devchar;
5538     int r;
5539     suppress_error = 0;
5540     r = guestfs_mkfs (g, fstype, device);
5541     if (r == -1)
5542       return -1;
5543   }
5544   {
5545     char device[] = "/dev/sda1";
5546     device[5] = devchar;
5547     char mountpoint[] = "/";
5548     int r;
5549     suppress_error = 0;
5550     r = guestfs_mount (g, device, mountpoint);
5551     if (r == -1)
5552       return -1;
5553   }
5554   /* TestOutputStruct for statvfs (0) */
5555   {
5556     char path[] = "/";
5557     struct guestfs_statvfs *r;
5558     suppress_error = 0;
5559     r = guestfs_statvfs (g, path);
5560     if (r == NULL)
5561       return -1;
5562     if (r->bfree != 487702) {
5563       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
5564                (int) r->bfree);
5565       return -1;
5566     }
5567     if (r->blocks != 490020) {
5568       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
5569                (int) r->blocks);
5570       return -1;
5571     }
5572     if (r->bsize != 1024) {
5573       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
5574                (int) r->bsize);
5575       return -1;
5576     }
5577     free (r);
5578   }
5579   return 0;
5580 }
5581
5582 static int test_lstat_0 (void)
5583 {
5584   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
5585   {
5586     char device[] = "/dev/sda";
5587     device[5] = devchar;
5588     int r;
5589     suppress_error = 0;
5590     r = guestfs_blockdev_setrw (g, device);
5591     if (r == -1)
5592       return -1;
5593   }
5594   {
5595     int r;
5596     suppress_error = 0;
5597     r = guestfs_umount_all (g);
5598     if (r == -1)
5599       return -1;
5600   }
5601   {
5602     int r;
5603     suppress_error = 0;
5604     r = guestfs_lvm_remove_all (g);
5605     if (r == -1)
5606       return -1;
5607   }
5608   {
5609     char device[] = "/dev/sda";
5610     device[5] = devchar;
5611     char lines_0[] = ",";
5612     char *lines[] = {
5613       lines_0,
5614       NULL
5615     };
5616     int r;
5617     suppress_error = 0;
5618     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5619     if (r == -1)
5620       return -1;
5621   }
5622   {
5623     char fstype[] = "ext2";
5624     char device[] = "/dev/sda1";
5625     device[5] = devchar;
5626     int r;
5627     suppress_error = 0;
5628     r = guestfs_mkfs (g, fstype, device);
5629     if (r == -1)
5630       return -1;
5631   }
5632   {
5633     char device[] = "/dev/sda1";
5634     device[5] = devchar;
5635     char mountpoint[] = "/";
5636     int r;
5637     suppress_error = 0;
5638     r = guestfs_mount (g, device, mountpoint);
5639     if (r == -1)
5640       return -1;
5641   }
5642   /* TestOutputStruct for lstat (0) */
5643   {
5644     char path[] = "/new";
5645     int r;
5646     suppress_error = 0;
5647     r = guestfs_touch (g, path);
5648     if (r == -1)
5649       return -1;
5650   }
5651   {
5652     char path[] = "/new";
5653     struct guestfs_stat *r;
5654     suppress_error = 0;
5655     r = guestfs_lstat (g, path);
5656     if (r == NULL)
5657       return -1;
5658     if (r->size != 0) {
5659       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
5660                (int) r->size);
5661       return -1;
5662     }
5663     free (r);
5664   }
5665   return 0;
5666 }
5667
5668 static int test_stat_0 (void)
5669 {
5670   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
5671   {
5672     char device[] = "/dev/sda";
5673     device[5] = devchar;
5674     int r;
5675     suppress_error = 0;
5676     r = guestfs_blockdev_setrw (g, device);
5677     if (r == -1)
5678       return -1;
5679   }
5680   {
5681     int r;
5682     suppress_error = 0;
5683     r = guestfs_umount_all (g);
5684     if (r == -1)
5685       return -1;
5686   }
5687   {
5688     int r;
5689     suppress_error = 0;
5690     r = guestfs_lvm_remove_all (g);
5691     if (r == -1)
5692       return -1;
5693   }
5694   {
5695     char device[] = "/dev/sda";
5696     device[5] = devchar;
5697     char lines_0[] = ",";
5698     char *lines[] = {
5699       lines_0,
5700       NULL
5701     };
5702     int r;
5703     suppress_error = 0;
5704     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5705     if (r == -1)
5706       return -1;
5707   }
5708   {
5709     char fstype[] = "ext2";
5710     char device[] = "/dev/sda1";
5711     device[5] = devchar;
5712     int r;
5713     suppress_error = 0;
5714     r = guestfs_mkfs (g, fstype, device);
5715     if (r == -1)
5716       return -1;
5717   }
5718   {
5719     char device[] = "/dev/sda1";
5720     device[5] = devchar;
5721     char mountpoint[] = "/";
5722     int r;
5723     suppress_error = 0;
5724     r = guestfs_mount (g, device, mountpoint);
5725     if (r == -1)
5726       return -1;
5727   }
5728   /* TestOutputStruct for stat (0) */
5729   {
5730     char path[] = "/new";
5731     int r;
5732     suppress_error = 0;
5733     r = guestfs_touch (g, path);
5734     if (r == -1)
5735       return -1;
5736   }
5737   {
5738     char path[] = "/new";
5739     struct guestfs_stat *r;
5740     suppress_error = 0;
5741     r = guestfs_stat (g, path);
5742     if (r == NULL)
5743       return -1;
5744     if (r->size != 0) {
5745       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5746                (int) r->size);
5747       return -1;
5748     }
5749     free (r);
5750   }
5751   return 0;
5752 }
5753
5754 static int test_command_lines_0_prereq (void)
5755 {
5756   const char *str = getenv ("SKIP_TEST_COMMAND");
5757   return str && strcmp (str, "1") == 0;
5758 }
5759
5760 static int test_command_lines_0 (void)
5761 {
5762   if (! test_command_lines_0_prereq ()) {
5763   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
5764   {
5765     char device[] = "/dev/sda";
5766     device[5] = devchar;
5767     int r;
5768     suppress_error = 0;
5769     r = guestfs_blockdev_setrw (g, device);
5770     if (r == -1)
5771       return -1;
5772   }
5773   {
5774     int r;
5775     suppress_error = 0;
5776     r = guestfs_umount_all (g);
5777     if (r == -1)
5778       return -1;
5779   }
5780   {
5781     int r;
5782     suppress_error = 0;
5783     r = guestfs_lvm_remove_all (g);
5784     if (r == -1)
5785       return -1;
5786   }
5787   {
5788     char device[] = "/dev/sda";
5789     device[5] = devchar;
5790     char lines_0[] = ",";
5791     char *lines[] = {
5792       lines_0,
5793       NULL
5794     };
5795     int r;
5796     suppress_error = 0;
5797     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5798     if (r == -1)
5799       return -1;
5800   }
5801   {
5802     char fstype[] = "ext2";
5803     char device[] = "/dev/sda1";
5804     device[5] = devchar;
5805     int r;
5806     suppress_error = 0;
5807     r = guestfs_mkfs (g, fstype, device);
5808     if (r == -1)
5809       return -1;
5810   }
5811   {
5812     char device[] = "/dev/sda1";
5813     device[5] = devchar;
5814     char mountpoint[] = "/";
5815     int r;
5816     suppress_error = 0;
5817     r = guestfs_mount (g, device, mountpoint);
5818     if (r == -1)
5819       return -1;
5820   }
5821   /* TestOutputList for command_lines (0) */
5822   {
5823     char remotefilename[] = "/test-command";
5824     int r;
5825     suppress_error = 0;
5826     r = guestfs_upload (g, "test-command", remotefilename);
5827     if (r == -1)
5828       return -1;
5829   }
5830   {
5831     char path[] = "/test-command";
5832     int r;
5833     suppress_error = 0;
5834     r = guestfs_chmod (g, 493, path);
5835     if (r == -1)
5836       return -1;
5837   }
5838   {
5839     char arguments_0[] = "/test-command";
5840     char arguments_1[] = "1";
5841     char *arguments[] = {
5842       arguments_0,
5843       arguments_1,
5844       NULL
5845     };
5846     char **r;
5847     int i;
5848     suppress_error = 0;
5849     r = guestfs_command_lines (g, arguments);
5850     if (r == NULL)
5851       return -1;
5852     if (!r[0]) {
5853       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5854       print_strings (r);
5855       return -1;
5856     }
5857     {
5858       char expected[] = "Result1";
5859       if (strcmp (r[0], expected) != 0) {
5860         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5861         return -1;
5862       }
5863     }
5864     if (r[1] != NULL) {
5865       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5866       print_strings (r);
5867       return -1;
5868     }
5869     for (i = 0; r[i] != NULL; ++i)
5870       free (r[i]);
5871     free (r);
5872   }
5873   } else
5874     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5875   return 0;
5876 }
5877
5878 static int test_command_lines_1_prereq (void)
5879 {
5880   const char *str = getenv ("SKIP_TEST_COMMAND");
5881   return str && strcmp (str, "1") == 0;
5882 }
5883
5884 static int test_command_lines_1 (void)
5885 {
5886   if (! test_command_lines_1_prereq ()) {
5887   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
5888   {
5889     char device[] = "/dev/sda";
5890     device[5] = devchar;
5891     int r;
5892     suppress_error = 0;
5893     r = guestfs_blockdev_setrw (g, device);
5894     if (r == -1)
5895       return -1;
5896   }
5897   {
5898     int r;
5899     suppress_error = 0;
5900     r = guestfs_umount_all (g);
5901     if (r == -1)
5902       return -1;
5903   }
5904   {
5905     int r;
5906     suppress_error = 0;
5907     r = guestfs_lvm_remove_all (g);
5908     if (r == -1)
5909       return -1;
5910   }
5911   {
5912     char device[] = "/dev/sda";
5913     device[5] = devchar;
5914     char lines_0[] = ",";
5915     char *lines[] = {
5916       lines_0,
5917       NULL
5918     };
5919     int r;
5920     suppress_error = 0;
5921     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5922     if (r == -1)
5923       return -1;
5924   }
5925   {
5926     char fstype[] = "ext2";
5927     char device[] = "/dev/sda1";
5928     device[5] = devchar;
5929     int r;
5930     suppress_error = 0;
5931     r = guestfs_mkfs (g, fstype, device);
5932     if (r == -1)
5933       return -1;
5934   }
5935   {
5936     char device[] = "/dev/sda1";
5937     device[5] = devchar;
5938     char mountpoint[] = "/";
5939     int r;
5940     suppress_error = 0;
5941     r = guestfs_mount (g, device, mountpoint);
5942     if (r == -1)
5943       return -1;
5944   }
5945   /* TestOutputList for command_lines (1) */
5946   {
5947     char remotefilename[] = "/test-command";
5948     int r;
5949     suppress_error = 0;
5950     r = guestfs_upload (g, "test-command", remotefilename);
5951     if (r == -1)
5952       return -1;
5953   }
5954   {
5955     char path[] = "/test-command";
5956     int r;
5957     suppress_error = 0;
5958     r = guestfs_chmod (g, 493, path);
5959     if (r == -1)
5960       return -1;
5961   }
5962   {
5963     char arguments_0[] = "/test-command";
5964     char arguments_1[] = "2";
5965     char *arguments[] = {
5966       arguments_0,
5967       arguments_1,
5968       NULL
5969     };
5970     char **r;
5971     int i;
5972     suppress_error = 0;
5973     r = guestfs_command_lines (g, arguments);
5974     if (r == NULL)
5975       return -1;
5976     if (!r[0]) {
5977       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5978       print_strings (r);
5979       return -1;
5980     }
5981     {
5982       char expected[] = "Result2";
5983       if (strcmp (r[0], expected) != 0) {
5984         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5985         return -1;
5986       }
5987     }
5988     if (r[1] != NULL) {
5989       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5990       print_strings (r);
5991       return -1;
5992     }
5993     for (i = 0; r[i] != NULL; ++i)
5994       free (r[i]);
5995     free (r);
5996   }
5997   } else
5998     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5999   return 0;
6000 }
6001
6002 static int test_command_lines_2_prereq (void)
6003 {
6004   const char *str = getenv ("SKIP_TEST_COMMAND");
6005   return str && strcmp (str, "1") == 0;
6006 }
6007
6008 static int test_command_lines_2 (void)
6009 {
6010   if (! test_command_lines_2_prereq ()) {
6011   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
6012   {
6013     char device[] = "/dev/sda";
6014     device[5] = devchar;
6015     int r;
6016     suppress_error = 0;
6017     r = guestfs_blockdev_setrw (g, device);
6018     if (r == -1)
6019       return -1;
6020   }
6021   {
6022     int r;
6023     suppress_error = 0;
6024     r = guestfs_umount_all (g);
6025     if (r == -1)
6026       return -1;
6027   }
6028   {
6029     int r;
6030     suppress_error = 0;
6031     r = guestfs_lvm_remove_all (g);
6032     if (r == -1)
6033       return -1;
6034   }
6035   {
6036     char device[] = "/dev/sda";
6037     device[5] = devchar;
6038     char lines_0[] = ",";
6039     char *lines[] = {
6040       lines_0,
6041       NULL
6042     };
6043     int r;
6044     suppress_error = 0;
6045     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6046     if (r == -1)
6047       return -1;
6048   }
6049   {
6050     char fstype[] = "ext2";
6051     char device[] = "/dev/sda1";
6052     device[5] = devchar;
6053     int r;
6054     suppress_error = 0;
6055     r = guestfs_mkfs (g, fstype, device);
6056     if (r == -1)
6057       return -1;
6058   }
6059   {
6060     char device[] = "/dev/sda1";
6061     device[5] = devchar;
6062     char mountpoint[] = "/";
6063     int r;
6064     suppress_error = 0;
6065     r = guestfs_mount (g, device, mountpoint);
6066     if (r == -1)
6067       return -1;
6068   }
6069   /* TestOutputList for command_lines (2) */
6070   {
6071     char remotefilename[] = "/test-command";
6072     int r;
6073     suppress_error = 0;
6074     r = guestfs_upload (g, "test-command", remotefilename);
6075     if (r == -1)
6076       return -1;
6077   }
6078   {
6079     char path[] = "/test-command";
6080     int r;
6081     suppress_error = 0;
6082     r = guestfs_chmod (g, 493, path);
6083     if (r == -1)
6084       return -1;
6085   }
6086   {
6087     char arguments_0[] = "/test-command";
6088     char arguments_1[] = "3";
6089     char *arguments[] = {
6090       arguments_0,
6091       arguments_1,
6092       NULL
6093     };
6094     char **r;
6095     int i;
6096     suppress_error = 0;
6097     r = guestfs_command_lines (g, arguments);
6098     if (r == NULL)
6099       return -1;
6100     if (!r[0]) {
6101       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
6102       print_strings (r);
6103       return -1;
6104     }
6105     {
6106       char expected[] = "";
6107       if (strcmp (r[0], expected) != 0) {
6108         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6109         return -1;
6110       }
6111     }
6112     if (!r[1]) {
6113       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
6114       print_strings (r);
6115       return -1;
6116     }
6117     {
6118       char expected[] = "Result3";
6119       if (strcmp (r[1], expected) != 0) {
6120         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6121         return -1;
6122       }
6123     }
6124     if (r[2] != NULL) {
6125       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
6126       print_strings (r);
6127       return -1;
6128     }
6129     for (i = 0; r[i] != NULL; ++i)
6130       free (r[i]);
6131     free (r);
6132   }
6133   } else
6134     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
6135   return 0;
6136 }
6137
6138 static int test_command_lines_3_prereq (void)
6139 {
6140   const char *str = getenv ("SKIP_TEST_COMMAND");
6141   return str && strcmp (str, "1") == 0;
6142 }
6143
6144 static int test_command_lines_3 (void)
6145 {
6146   if (! test_command_lines_3_prereq ()) {
6147   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
6148   {
6149     char device[] = "/dev/sda";
6150     device[5] = devchar;
6151     int r;
6152     suppress_error = 0;
6153     r = guestfs_blockdev_setrw (g, device);
6154     if (r == -1)
6155       return -1;
6156   }
6157   {
6158     int r;
6159     suppress_error = 0;
6160     r = guestfs_umount_all (g);
6161     if (r == -1)
6162       return -1;
6163   }
6164   {
6165     int r;
6166     suppress_error = 0;
6167     r = guestfs_lvm_remove_all (g);
6168     if (r == -1)
6169       return -1;
6170   }
6171   {
6172     char device[] = "/dev/sda";
6173     device[5] = devchar;
6174     char lines_0[] = ",";
6175     char *lines[] = {
6176       lines_0,
6177       NULL
6178     };
6179     int r;
6180     suppress_error = 0;
6181     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6182     if (r == -1)
6183       return -1;
6184   }
6185   {
6186     char fstype[] = "ext2";
6187     char device[] = "/dev/sda1";
6188     device[5] = devchar;
6189     int r;
6190     suppress_error = 0;
6191     r = guestfs_mkfs (g, fstype, device);
6192     if (r == -1)
6193       return -1;
6194   }
6195   {
6196     char device[] = "/dev/sda1";
6197     device[5] = devchar;
6198     char mountpoint[] = "/";
6199     int r;
6200     suppress_error = 0;
6201     r = guestfs_mount (g, device, mountpoint);
6202     if (r == -1)
6203       return -1;
6204   }
6205   /* TestOutputList for command_lines (3) */
6206   {
6207     char remotefilename[] = "/test-command";
6208     int r;
6209     suppress_error = 0;
6210     r = guestfs_upload (g, "test-command", remotefilename);
6211     if (r == -1)
6212       return -1;
6213   }
6214   {
6215     char path[] = "/test-command";
6216     int r;
6217     suppress_error = 0;
6218     r = guestfs_chmod (g, 493, path);
6219     if (r == -1)
6220       return -1;
6221   }
6222   {
6223     char arguments_0[] = "/test-command";
6224     char arguments_1[] = "4";
6225     char *arguments[] = {
6226       arguments_0,
6227       arguments_1,
6228       NULL
6229     };
6230     char **r;
6231     int i;
6232     suppress_error = 0;
6233     r = guestfs_command_lines (g, arguments);
6234     if (r == NULL)
6235       return -1;
6236     if (!r[0]) {
6237       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6238       print_strings (r);
6239       return -1;
6240     }
6241     {
6242       char expected[] = "";
6243       if (strcmp (r[0], expected) != 0) {
6244         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6245         return -1;
6246       }
6247     }
6248     if (!r[1]) {
6249       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6250       print_strings (r);
6251       return -1;
6252     }
6253     {
6254       char expected[] = "Result4";
6255       if (strcmp (r[1], expected) != 0) {
6256         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6257         return -1;
6258       }
6259     }
6260     if (r[2] != NULL) {
6261       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
6262       print_strings (r);
6263       return -1;
6264     }
6265     for (i = 0; r[i] != NULL; ++i)
6266       free (r[i]);
6267     free (r);
6268   }
6269   } else
6270     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
6271   return 0;
6272 }
6273
6274 static int test_command_lines_4_prereq (void)
6275 {
6276   const char *str = getenv ("SKIP_TEST_COMMAND");
6277   return str && strcmp (str, "1") == 0;
6278 }
6279
6280 static int test_command_lines_4 (void)
6281 {
6282   if (! test_command_lines_4_prereq ()) {
6283   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
6284   {
6285     char device[] = "/dev/sda";
6286     device[5] = devchar;
6287     int r;
6288     suppress_error = 0;
6289     r = guestfs_blockdev_setrw (g, device);
6290     if (r == -1)
6291       return -1;
6292   }
6293   {
6294     int r;
6295     suppress_error = 0;
6296     r = guestfs_umount_all (g);
6297     if (r == -1)
6298       return -1;
6299   }
6300   {
6301     int r;
6302     suppress_error = 0;
6303     r = guestfs_lvm_remove_all (g);
6304     if (r == -1)
6305       return -1;
6306   }
6307   {
6308     char device[] = "/dev/sda";
6309     device[5] = devchar;
6310     char lines_0[] = ",";
6311     char *lines[] = {
6312       lines_0,
6313       NULL
6314     };
6315     int r;
6316     suppress_error = 0;
6317     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6318     if (r == -1)
6319       return -1;
6320   }
6321   {
6322     char fstype[] = "ext2";
6323     char device[] = "/dev/sda1";
6324     device[5] = devchar;
6325     int r;
6326     suppress_error = 0;
6327     r = guestfs_mkfs (g, fstype, device);
6328     if (r == -1)
6329       return -1;
6330   }
6331   {
6332     char device[] = "/dev/sda1";
6333     device[5] = devchar;
6334     char mountpoint[] = "/";
6335     int r;
6336     suppress_error = 0;
6337     r = guestfs_mount (g, device, mountpoint);
6338     if (r == -1)
6339       return -1;
6340   }
6341   /* TestOutputList for command_lines (4) */
6342   {
6343     char remotefilename[] = "/test-command";
6344     int r;
6345     suppress_error = 0;
6346     r = guestfs_upload (g, "test-command", remotefilename);
6347     if (r == -1)
6348       return -1;
6349   }
6350   {
6351     char path[] = "/test-command";
6352     int r;
6353     suppress_error = 0;
6354     r = guestfs_chmod (g, 493, path);
6355     if (r == -1)
6356       return -1;
6357   }
6358   {
6359     char arguments_0[] = "/test-command";
6360     char arguments_1[] = "5";
6361     char *arguments[] = {
6362       arguments_0,
6363       arguments_1,
6364       NULL
6365     };
6366     char **r;
6367     int i;
6368     suppress_error = 0;
6369     r = guestfs_command_lines (g, arguments);
6370     if (r == NULL)
6371       return -1;
6372     if (!r[0]) {
6373       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6374       print_strings (r);
6375       return -1;
6376     }
6377     {
6378       char expected[] = "";
6379       if (strcmp (r[0], expected) != 0) {
6380         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6381         return -1;
6382       }
6383     }
6384     if (!r[1]) {
6385       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6386       print_strings (r);
6387       return -1;
6388     }
6389     {
6390       char expected[] = "Result5";
6391       if (strcmp (r[1], expected) != 0) {
6392         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6393         return -1;
6394       }
6395     }
6396     if (!r[2]) {
6397       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6398       print_strings (r);
6399       return -1;
6400     }
6401     {
6402       char expected[] = "";
6403       if (strcmp (r[2], expected) != 0) {
6404         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6405         return -1;
6406       }
6407     }
6408     if (r[3] != NULL) {
6409       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
6410       print_strings (r);
6411       return -1;
6412     }
6413     for (i = 0; r[i] != NULL; ++i)
6414       free (r[i]);
6415     free (r);
6416   }
6417   } else
6418     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
6419   return 0;
6420 }
6421
6422 static int test_command_lines_5_prereq (void)
6423 {
6424   const char *str = getenv ("SKIP_TEST_COMMAND");
6425   return str && strcmp (str, "1") == 0;
6426 }
6427
6428 static int test_command_lines_5 (void)
6429 {
6430   if (! test_command_lines_5_prereq ()) {
6431   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
6432   {
6433     char device[] = "/dev/sda";
6434     device[5] = devchar;
6435     int r;
6436     suppress_error = 0;
6437     r = guestfs_blockdev_setrw (g, device);
6438     if (r == -1)
6439       return -1;
6440   }
6441   {
6442     int r;
6443     suppress_error = 0;
6444     r = guestfs_umount_all (g);
6445     if (r == -1)
6446       return -1;
6447   }
6448   {
6449     int r;
6450     suppress_error = 0;
6451     r = guestfs_lvm_remove_all (g);
6452     if (r == -1)
6453       return -1;
6454   }
6455   {
6456     char device[] = "/dev/sda";
6457     device[5] = devchar;
6458     char lines_0[] = ",";
6459     char *lines[] = {
6460       lines_0,
6461       NULL
6462     };
6463     int r;
6464     suppress_error = 0;
6465     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6466     if (r == -1)
6467       return -1;
6468   }
6469   {
6470     char fstype[] = "ext2";
6471     char device[] = "/dev/sda1";
6472     device[5] = devchar;
6473     int r;
6474     suppress_error = 0;
6475     r = guestfs_mkfs (g, fstype, device);
6476     if (r == -1)
6477       return -1;
6478   }
6479   {
6480     char device[] = "/dev/sda1";
6481     device[5] = devchar;
6482     char mountpoint[] = "/";
6483     int r;
6484     suppress_error = 0;
6485     r = guestfs_mount (g, device, mountpoint);
6486     if (r == -1)
6487       return -1;
6488   }
6489   /* TestOutputList for command_lines (5) */
6490   {
6491     char remotefilename[] = "/test-command";
6492     int r;
6493     suppress_error = 0;
6494     r = guestfs_upload (g, "test-command", remotefilename);
6495     if (r == -1)
6496       return -1;
6497   }
6498   {
6499     char path[] = "/test-command";
6500     int r;
6501     suppress_error = 0;
6502     r = guestfs_chmod (g, 493, path);
6503     if (r == -1)
6504       return -1;
6505   }
6506   {
6507     char arguments_0[] = "/test-command";
6508     char arguments_1[] = "6";
6509     char *arguments[] = {
6510       arguments_0,
6511       arguments_1,
6512       NULL
6513     };
6514     char **r;
6515     int i;
6516     suppress_error = 0;
6517     r = guestfs_command_lines (g, arguments);
6518     if (r == NULL)
6519       return -1;
6520     if (!r[0]) {
6521       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6522       print_strings (r);
6523       return -1;
6524     }
6525     {
6526       char expected[] = "";
6527       if (strcmp (r[0], expected) != 0) {
6528         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6529         return -1;
6530       }
6531     }
6532     if (!r[1]) {
6533       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6534       print_strings (r);
6535       return -1;
6536     }
6537     {
6538       char expected[] = "";
6539       if (strcmp (r[1], expected) != 0) {
6540         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6541         return -1;
6542       }
6543     }
6544     if (!r[2]) {
6545       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6546       print_strings (r);
6547       return -1;
6548     }
6549     {
6550       char expected[] = "Result6";
6551       if (strcmp (r[2], expected) != 0) {
6552         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6553         return -1;
6554       }
6555     }
6556     if (!r[3]) {
6557       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6558       print_strings (r);
6559       return -1;
6560     }
6561     {
6562       char expected[] = "";
6563       if (strcmp (r[3], expected) != 0) {
6564         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
6565         return -1;
6566       }
6567     }
6568     if (r[4] != NULL) {
6569       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
6570       print_strings (r);
6571       return -1;
6572     }
6573     for (i = 0; r[i] != NULL; ++i)
6574       free (r[i]);
6575     free (r);
6576   }
6577   } else
6578     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
6579   return 0;
6580 }
6581
6582 static int test_command_lines_6_prereq (void)
6583 {
6584   const char *str = getenv ("SKIP_TEST_COMMAND");
6585   return str && strcmp (str, "1") == 0;
6586 }
6587
6588 static int test_command_lines_6 (void)
6589 {
6590   if (! test_command_lines_6_prereq ()) {
6591   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
6592   {
6593     char device[] = "/dev/sda";
6594     device[5] = devchar;
6595     int r;
6596     suppress_error = 0;
6597     r = guestfs_blockdev_setrw (g, device);
6598     if (r == -1)
6599       return -1;
6600   }
6601   {
6602     int r;
6603     suppress_error = 0;
6604     r = guestfs_umount_all (g);
6605     if (r == -1)
6606       return -1;
6607   }
6608   {
6609     int r;
6610     suppress_error = 0;
6611     r = guestfs_lvm_remove_all (g);
6612     if (r == -1)
6613       return -1;
6614   }
6615   {
6616     char device[] = "/dev/sda";
6617     device[5] = devchar;
6618     char lines_0[] = ",";
6619     char *lines[] = {
6620       lines_0,
6621       NULL
6622     };
6623     int r;
6624     suppress_error = 0;
6625     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6626     if (r == -1)
6627       return -1;
6628   }
6629   {
6630     char fstype[] = "ext2";
6631     char device[] = "/dev/sda1";
6632     device[5] = devchar;
6633     int r;
6634     suppress_error = 0;
6635     r = guestfs_mkfs (g, fstype, device);
6636     if (r == -1)
6637       return -1;
6638   }
6639   {
6640     char device[] = "/dev/sda1";
6641     device[5] = devchar;
6642     char mountpoint[] = "/";
6643     int r;
6644     suppress_error = 0;
6645     r = guestfs_mount (g, device, mountpoint);
6646     if (r == -1)
6647       return -1;
6648   }
6649   /* TestOutputList for command_lines (6) */
6650   {
6651     char remotefilename[] = "/test-command";
6652     int r;
6653     suppress_error = 0;
6654     r = guestfs_upload (g, "test-command", remotefilename);
6655     if (r == -1)
6656       return -1;
6657   }
6658   {
6659     char path[] = "/test-command";
6660     int r;
6661     suppress_error = 0;
6662     r = guestfs_chmod (g, 493, path);
6663     if (r == -1)
6664       return -1;
6665   }
6666   {
6667     char arguments_0[] = "/test-command";
6668     char arguments_1[] = "7";
6669     char *arguments[] = {
6670       arguments_0,
6671       arguments_1,
6672       NULL
6673     };
6674     char **r;
6675     int i;
6676     suppress_error = 0;
6677     r = guestfs_command_lines (g, arguments);
6678     if (r == NULL)
6679       return -1;
6680     if (r[0] != NULL) {
6681       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6682       print_strings (r);
6683       return -1;
6684     }
6685     for (i = 0; r[i] != NULL; ++i)
6686       free (r[i]);
6687     free (r);
6688   }
6689   } else
6690     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6691   return 0;
6692 }
6693
6694 static int test_command_lines_7_prereq (void)
6695 {
6696   const char *str = getenv ("SKIP_TEST_COMMAND");
6697   return str && strcmp (str, "1") == 0;
6698 }
6699
6700 static int test_command_lines_7 (void)
6701 {
6702   if (! test_command_lines_7_prereq ()) {
6703   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
6704   {
6705     char device[] = "/dev/sda";
6706     device[5] = devchar;
6707     int r;
6708     suppress_error = 0;
6709     r = guestfs_blockdev_setrw (g, device);
6710     if (r == -1)
6711       return -1;
6712   }
6713   {
6714     int r;
6715     suppress_error = 0;
6716     r = guestfs_umount_all (g);
6717     if (r == -1)
6718       return -1;
6719   }
6720   {
6721     int r;
6722     suppress_error = 0;
6723     r = guestfs_lvm_remove_all (g);
6724     if (r == -1)
6725       return -1;
6726   }
6727   {
6728     char device[] = "/dev/sda";
6729     device[5] = devchar;
6730     char lines_0[] = ",";
6731     char *lines[] = {
6732       lines_0,
6733       NULL
6734     };
6735     int r;
6736     suppress_error = 0;
6737     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6738     if (r == -1)
6739       return -1;
6740   }
6741   {
6742     char fstype[] = "ext2";
6743     char device[] = "/dev/sda1";
6744     device[5] = devchar;
6745     int r;
6746     suppress_error = 0;
6747     r = guestfs_mkfs (g, fstype, device);
6748     if (r == -1)
6749       return -1;
6750   }
6751   {
6752     char device[] = "/dev/sda1";
6753     device[5] = devchar;
6754     char mountpoint[] = "/";
6755     int r;
6756     suppress_error = 0;
6757     r = guestfs_mount (g, device, mountpoint);
6758     if (r == -1)
6759       return -1;
6760   }
6761   /* TestOutputList for command_lines (7) */
6762   {
6763     char remotefilename[] = "/test-command";
6764     int r;
6765     suppress_error = 0;
6766     r = guestfs_upload (g, "test-command", remotefilename);
6767     if (r == -1)
6768       return -1;
6769   }
6770   {
6771     char path[] = "/test-command";
6772     int r;
6773     suppress_error = 0;
6774     r = guestfs_chmod (g, 493, path);
6775     if (r == -1)
6776       return -1;
6777   }
6778   {
6779     char arguments_0[] = "/test-command";
6780     char arguments_1[] = "8";
6781     char *arguments[] = {
6782       arguments_0,
6783       arguments_1,
6784       NULL
6785     };
6786     char **r;
6787     int i;
6788     suppress_error = 0;
6789     r = guestfs_command_lines (g, arguments);
6790     if (r == NULL)
6791       return -1;
6792     if (!r[0]) {
6793       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6794       print_strings (r);
6795       return -1;
6796     }
6797     {
6798       char expected[] = "";
6799       if (strcmp (r[0], expected) != 0) {
6800         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6801         return -1;
6802       }
6803     }
6804     if (r[1] != NULL) {
6805       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6806       print_strings (r);
6807       return -1;
6808     }
6809     for (i = 0; r[i] != NULL; ++i)
6810       free (r[i]);
6811     free (r);
6812   }
6813   } else
6814     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6815   return 0;
6816 }
6817
6818 static int test_command_lines_8_prereq (void)
6819 {
6820   const char *str = getenv ("SKIP_TEST_COMMAND");
6821   return str && strcmp (str, "1") == 0;
6822 }
6823
6824 static int test_command_lines_8 (void)
6825 {
6826   if (! test_command_lines_8_prereq ()) {
6827   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
6828   {
6829     char device[] = "/dev/sda";
6830     device[5] = devchar;
6831     int r;
6832     suppress_error = 0;
6833     r = guestfs_blockdev_setrw (g, device);
6834     if (r == -1)
6835       return -1;
6836   }
6837   {
6838     int r;
6839     suppress_error = 0;
6840     r = guestfs_umount_all (g);
6841     if (r == -1)
6842       return -1;
6843   }
6844   {
6845     int r;
6846     suppress_error = 0;
6847     r = guestfs_lvm_remove_all (g);
6848     if (r == -1)
6849       return -1;
6850   }
6851   {
6852     char device[] = "/dev/sda";
6853     device[5] = devchar;
6854     char lines_0[] = ",";
6855     char *lines[] = {
6856       lines_0,
6857       NULL
6858     };
6859     int r;
6860     suppress_error = 0;
6861     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6862     if (r == -1)
6863       return -1;
6864   }
6865   {
6866     char fstype[] = "ext2";
6867     char device[] = "/dev/sda1";
6868     device[5] = devchar;
6869     int r;
6870     suppress_error = 0;
6871     r = guestfs_mkfs (g, fstype, device);
6872     if (r == -1)
6873       return -1;
6874   }
6875   {
6876     char device[] = "/dev/sda1";
6877     device[5] = devchar;
6878     char mountpoint[] = "/";
6879     int r;
6880     suppress_error = 0;
6881     r = guestfs_mount (g, device, mountpoint);
6882     if (r == -1)
6883       return -1;
6884   }
6885   /* TestOutputList for command_lines (8) */
6886   {
6887     char remotefilename[] = "/test-command";
6888     int r;
6889     suppress_error = 0;
6890     r = guestfs_upload (g, "test-command", remotefilename);
6891     if (r == -1)
6892       return -1;
6893   }
6894   {
6895     char path[] = "/test-command";
6896     int r;
6897     suppress_error = 0;
6898     r = guestfs_chmod (g, 493, path);
6899     if (r == -1)
6900       return -1;
6901   }
6902   {
6903     char arguments_0[] = "/test-command";
6904     char arguments_1[] = "9";
6905     char *arguments[] = {
6906       arguments_0,
6907       arguments_1,
6908       NULL
6909     };
6910     char **r;
6911     int i;
6912     suppress_error = 0;
6913     r = guestfs_command_lines (g, arguments);
6914     if (r == NULL)
6915       return -1;
6916     if (!r[0]) {
6917       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6918       print_strings (r);
6919       return -1;
6920     }
6921     {
6922       char expected[] = "";
6923       if (strcmp (r[0], expected) != 0) {
6924         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6925         return -1;
6926       }
6927     }
6928     if (!r[1]) {
6929       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6930       print_strings (r);
6931       return -1;
6932     }
6933     {
6934       char expected[] = "";
6935       if (strcmp (r[1], expected) != 0) {
6936         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6937         return -1;
6938       }
6939     }
6940     if (r[2] != NULL) {
6941       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6942       print_strings (r);
6943       return -1;
6944     }
6945     for (i = 0; r[i] != NULL; ++i)
6946       free (r[i]);
6947     free (r);
6948   }
6949   } else
6950     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6951   return 0;
6952 }
6953
6954 static int test_command_lines_9_prereq (void)
6955 {
6956   const char *str = getenv ("SKIP_TEST_COMMAND");
6957   return str && strcmp (str, "1") == 0;
6958 }
6959
6960 static int test_command_lines_9 (void)
6961 {
6962   if (! test_command_lines_9_prereq ()) {
6963   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
6964   {
6965     char device[] = "/dev/sda";
6966     device[5] = devchar;
6967     int r;
6968     suppress_error = 0;
6969     r = guestfs_blockdev_setrw (g, device);
6970     if (r == -1)
6971       return -1;
6972   }
6973   {
6974     int r;
6975     suppress_error = 0;
6976     r = guestfs_umount_all (g);
6977     if (r == -1)
6978       return -1;
6979   }
6980   {
6981     int r;
6982     suppress_error = 0;
6983     r = guestfs_lvm_remove_all (g);
6984     if (r == -1)
6985       return -1;
6986   }
6987   {
6988     char device[] = "/dev/sda";
6989     device[5] = devchar;
6990     char lines_0[] = ",";
6991     char *lines[] = {
6992       lines_0,
6993       NULL
6994     };
6995     int r;
6996     suppress_error = 0;
6997     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6998     if (r == -1)
6999       return -1;
7000   }
7001   {
7002     char fstype[] = "ext2";
7003     char device[] = "/dev/sda1";
7004     device[5] = devchar;
7005     int r;
7006     suppress_error = 0;
7007     r = guestfs_mkfs (g, fstype, device);
7008     if (r == -1)
7009       return -1;
7010   }
7011   {
7012     char device[] = "/dev/sda1";
7013     device[5] = devchar;
7014     char mountpoint[] = "/";
7015     int r;
7016     suppress_error = 0;
7017     r = guestfs_mount (g, device, mountpoint);
7018     if (r == -1)
7019       return -1;
7020   }
7021   /* TestOutputList for command_lines (9) */
7022   {
7023     char remotefilename[] = "/test-command";
7024     int r;
7025     suppress_error = 0;
7026     r = guestfs_upload (g, "test-command", remotefilename);
7027     if (r == -1)
7028       return -1;
7029   }
7030   {
7031     char path[] = "/test-command";
7032     int r;
7033     suppress_error = 0;
7034     r = guestfs_chmod (g, 493, path);
7035     if (r == -1)
7036       return -1;
7037   }
7038   {
7039     char arguments_0[] = "/test-command";
7040     char arguments_1[] = "10";
7041     char *arguments[] = {
7042       arguments_0,
7043       arguments_1,
7044       NULL
7045     };
7046     char **r;
7047     int i;
7048     suppress_error = 0;
7049     r = guestfs_command_lines (g, arguments);
7050     if (r == NULL)
7051       return -1;
7052     if (!r[0]) {
7053       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
7054       print_strings (r);
7055       return -1;
7056     }
7057     {
7058       char expected[] = "Result10-1";
7059       if (strcmp (r[0], expected) != 0) {
7060         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7061         return -1;
7062       }
7063     }
7064     if (!r[1]) {
7065       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
7066       print_strings (r);
7067       return -1;
7068     }
7069     {
7070       char expected[] = "Result10-2";
7071       if (strcmp (r[1], expected) != 0) {
7072         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7073         return -1;
7074       }
7075     }
7076     if (r[2] != NULL) {
7077       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
7078       print_strings (r);
7079       return -1;
7080     }
7081     for (i = 0; r[i] != NULL; ++i)
7082       free (r[i]);
7083     free (r);
7084   }
7085   } else
7086     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
7087   return 0;
7088 }
7089
7090 static int test_command_lines_10_prereq (void)
7091 {
7092   const char *str = getenv ("SKIP_TEST_COMMAND");
7093   return str && strcmp (str, "1") == 0;
7094 }
7095
7096 static int test_command_lines_10 (void)
7097 {
7098   if (! test_command_lines_10_prereq ()) {
7099   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
7100   {
7101     char device[] = "/dev/sda";
7102     device[5] = devchar;
7103     int r;
7104     suppress_error = 0;
7105     r = guestfs_blockdev_setrw (g, device);
7106     if (r == -1)
7107       return -1;
7108   }
7109   {
7110     int r;
7111     suppress_error = 0;
7112     r = guestfs_umount_all (g);
7113     if (r == -1)
7114       return -1;
7115   }
7116   {
7117     int r;
7118     suppress_error = 0;
7119     r = guestfs_lvm_remove_all (g);
7120     if (r == -1)
7121       return -1;
7122   }
7123   {
7124     char device[] = "/dev/sda";
7125     device[5] = devchar;
7126     char lines_0[] = ",";
7127     char *lines[] = {
7128       lines_0,
7129       NULL
7130     };
7131     int r;
7132     suppress_error = 0;
7133     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7134     if (r == -1)
7135       return -1;
7136   }
7137   {
7138     char fstype[] = "ext2";
7139     char device[] = "/dev/sda1";
7140     device[5] = devchar;
7141     int r;
7142     suppress_error = 0;
7143     r = guestfs_mkfs (g, fstype, device);
7144     if (r == -1)
7145       return -1;
7146   }
7147   {
7148     char device[] = "/dev/sda1";
7149     device[5] = devchar;
7150     char mountpoint[] = "/";
7151     int r;
7152     suppress_error = 0;
7153     r = guestfs_mount (g, device, mountpoint);
7154     if (r == -1)
7155       return -1;
7156   }
7157   /* TestOutputList for command_lines (10) */
7158   {
7159     char remotefilename[] = "/test-command";
7160     int r;
7161     suppress_error = 0;
7162     r = guestfs_upload (g, "test-command", remotefilename);
7163     if (r == -1)
7164       return -1;
7165   }
7166   {
7167     char path[] = "/test-command";
7168     int r;
7169     suppress_error = 0;
7170     r = guestfs_chmod (g, 493, path);
7171     if (r == -1)
7172       return -1;
7173   }
7174   {
7175     char arguments_0[] = "/test-command";
7176     char arguments_1[] = "11";
7177     char *arguments[] = {
7178       arguments_0,
7179       arguments_1,
7180       NULL
7181     };
7182     char **r;
7183     int i;
7184     suppress_error = 0;
7185     r = guestfs_command_lines (g, arguments);
7186     if (r == NULL)
7187       return -1;
7188     if (!r[0]) {
7189       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7190       print_strings (r);
7191       return -1;
7192     }
7193     {
7194       char expected[] = "Result11-1";
7195       if (strcmp (r[0], expected) != 0) {
7196         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7197         return -1;
7198       }
7199     }
7200     if (!r[1]) {
7201       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7202       print_strings (r);
7203       return -1;
7204     }
7205     {
7206       char expected[] = "Result11-2";
7207       if (strcmp (r[1], expected) != 0) {
7208         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7209         return -1;
7210       }
7211     }
7212     if (r[2] != NULL) {
7213       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
7214       print_strings (r);
7215       return -1;
7216     }
7217     for (i = 0; r[i] != NULL; ++i)
7218       free (r[i]);
7219     free (r);
7220   }
7221   } else
7222     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
7223   return 0;
7224 }
7225
7226 static int test_command_0_prereq (void)
7227 {
7228   const char *str = getenv ("SKIP_TEST_COMMAND");
7229   return str && strcmp (str, "1") == 0;
7230 }
7231
7232 static int test_command_0 (void)
7233 {
7234   if (! test_command_0_prereq ()) {
7235   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
7236   {
7237     char device[] = "/dev/sda";
7238     device[5] = devchar;
7239     int r;
7240     suppress_error = 0;
7241     r = guestfs_blockdev_setrw (g, device);
7242     if (r == -1)
7243       return -1;
7244   }
7245   {
7246     int r;
7247     suppress_error = 0;
7248     r = guestfs_umount_all (g);
7249     if (r == -1)
7250       return -1;
7251   }
7252   {
7253     int r;
7254     suppress_error = 0;
7255     r = guestfs_lvm_remove_all (g);
7256     if (r == -1)
7257       return -1;
7258   }
7259   {
7260     char device[] = "/dev/sda";
7261     device[5] = devchar;
7262     char lines_0[] = ",";
7263     char *lines[] = {
7264       lines_0,
7265       NULL
7266     };
7267     int r;
7268     suppress_error = 0;
7269     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7270     if (r == -1)
7271       return -1;
7272   }
7273   {
7274     char fstype[] = "ext2";
7275     char device[] = "/dev/sda1";
7276     device[5] = devchar;
7277     int r;
7278     suppress_error = 0;
7279     r = guestfs_mkfs (g, fstype, device);
7280     if (r == -1)
7281       return -1;
7282   }
7283   {
7284     char device[] = "/dev/sda1";
7285     device[5] = devchar;
7286     char mountpoint[] = "/";
7287     int r;
7288     suppress_error = 0;
7289     r = guestfs_mount (g, device, mountpoint);
7290     if (r == -1)
7291       return -1;
7292   }
7293   /* TestOutput for command (0) */
7294   char expected[] = "Result1";
7295   {
7296     char remotefilename[] = "/test-command";
7297     int r;
7298     suppress_error = 0;
7299     r = guestfs_upload (g, "test-command", remotefilename);
7300     if (r == -1)
7301       return -1;
7302   }
7303   {
7304     char path[] = "/test-command";
7305     int r;
7306     suppress_error = 0;
7307     r = guestfs_chmod (g, 493, path);
7308     if (r == -1)
7309       return -1;
7310   }
7311   {
7312     char arguments_0[] = "/test-command";
7313     char arguments_1[] = "1";
7314     char *arguments[] = {
7315       arguments_0,
7316       arguments_1,
7317       NULL
7318     };
7319     char *r;
7320     suppress_error = 0;
7321     r = guestfs_command (g, arguments);
7322     if (r == NULL)
7323       return -1;
7324     if (strcmp (r, expected) != 0) {
7325       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
7326       return -1;
7327     }
7328     free (r);
7329   }
7330   } else
7331     printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
7332   return 0;
7333 }
7334
7335 static int test_command_1_prereq (void)
7336 {
7337   const char *str = getenv ("SKIP_TEST_COMMAND");
7338   return str && strcmp (str, "1") == 0;
7339 }
7340
7341 static int test_command_1 (void)
7342 {
7343   if (! test_command_1_prereq ()) {
7344   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
7345   {
7346     char device[] = "/dev/sda";
7347     device[5] = devchar;
7348     int r;
7349     suppress_error = 0;
7350     r = guestfs_blockdev_setrw (g, device);
7351     if (r == -1)
7352       return -1;
7353   }
7354   {
7355     int r;
7356     suppress_error = 0;
7357     r = guestfs_umount_all (g);
7358     if (r == -1)
7359       return -1;
7360   }
7361   {
7362     int r;
7363     suppress_error = 0;
7364     r = guestfs_lvm_remove_all (g);
7365     if (r == -1)
7366       return -1;
7367   }
7368   {
7369     char device[] = "/dev/sda";
7370     device[5] = devchar;
7371     char lines_0[] = ",";
7372     char *lines[] = {
7373       lines_0,
7374       NULL
7375     };
7376     int r;
7377     suppress_error = 0;
7378     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7379     if (r == -1)
7380       return -1;
7381   }
7382   {
7383     char fstype[] = "ext2";
7384     char device[] = "/dev/sda1";
7385     device[5] = devchar;
7386     int r;
7387     suppress_error = 0;
7388     r = guestfs_mkfs (g, fstype, device);
7389     if (r == -1)
7390       return -1;
7391   }
7392   {
7393     char device[] = "/dev/sda1";
7394     device[5] = devchar;
7395     char mountpoint[] = "/";
7396     int r;
7397     suppress_error = 0;
7398     r = guestfs_mount (g, device, mountpoint);
7399     if (r == -1)
7400       return -1;
7401   }
7402   /* TestOutput for command (1) */
7403   char expected[] = "Result2\n";
7404   {
7405     char remotefilename[] = "/test-command";
7406     int r;
7407     suppress_error = 0;
7408     r = guestfs_upload (g, "test-command", remotefilename);
7409     if (r == -1)
7410       return -1;
7411   }
7412   {
7413     char path[] = "/test-command";
7414     int r;
7415     suppress_error = 0;
7416     r = guestfs_chmod (g, 493, path);
7417     if (r == -1)
7418       return -1;
7419   }
7420   {
7421     char arguments_0[] = "/test-command";
7422     char arguments_1[] = "2";
7423     char *arguments[] = {
7424       arguments_0,
7425       arguments_1,
7426       NULL
7427     };
7428     char *r;
7429     suppress_error = 0;
7430     r = guestfs_command (g, arguments);
7431     if (r == NULL)
7432       return -1;
7433     if (strcmp (r, expected) != 0) {
7434       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
7435       return -1;
7436     }
7437     free (r);
7438   }
7439   } else
7440     printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
7441   return 0;
7442 }
7443
7444 static int test_command_2_prereq (void)
7445 {
7446   const char *str = getenv ("SKIP_TEST_COMMAND");
7447   return str && strcmp (str, "1") == 0;
7448 }
7449
7450 static int test_command_2 (void)
7451 {
7452   if (! test_command_2_prereq ()) {
7453   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
7454   {
7455     char device[] = "/dev/sda";
7456     device[5] = devchar;
7457     int r;
7458     suppress_error = 0;
7459     r = guestfs_blockdev_setrw (g, device);
7460     if (r == -1)
7461       return -1;
7462   }
7463   {
7464     int r;
7465     suppress_error = 0;
7466     r = guestfs_umount_all (g);
7467     if (r == -1)
7468       return -1;
7469   }
7470   {
7471     int r;
7472     suppress_error = 0;
7473     r = guestfs_lvm_remove_all (g);
7474     if (r == -1)
7475       return -1;
7476   }
7477   {
7478     char device[] = "/dev/sda";
7479     device[5] = devchar;
7480     char lines_0[] = ",";
7481     char *lines[] = {
7482       lines_0,
7483       NULL
7484     };
7485     int r;
7486     suppress_error = 0;
7487     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7488     if (r == -1)
7489       return -1;
7490   }
7491   {
7492     char fstype[] = "ext2";
7493     char device[] = "/dev/sda1";
7494     device[5] = devchar;
7495     int r;
7496     suppress_error = 0;
7497     r = guestfs_mkfs (g, fstype, device);
7498     if (r == -1)
7499       return -1;
7500   }
7501   {
7502     char device[] = "/dev/sda1";
7503     device[5] = devchar;
7504     char mountpoint[] = "/";
7505     int r;
7506     suppress_error = 0;
7507     r = guestfs_mount (g, device, mountpoint);
7508     if (r == -1)
7509       return -1;
7510   }
7511   /* TestOutput for command (2) */
7512   char expected[] = "\nResult3";
7513   {
7514     char remotefilename[] = "/test-command";
7515     int r;
7516     suppress_error = 0;
7517     r = guestfs_upload (g, "test-command", remotefilename);
7518     if (r == -1)
7519       return -1;
7520   }
7521   {
7522     char path[] = "/test-command";
7523     int r;
7524     suppress_error = 0;
7525     r = guestfs_chmod (g, 493, path);
7526     if (r == -1)
7527       return -1;
7528   }
7529   {
7530     char arguments_0[] = "/test-command";
7531     char arguments_1[] = "3";
7532     char *arguments[] = {
7533       arguments_0,
7534       arguments_1,
7535       NULL
7536     };
7537     char *r;
7538     suppress_error = 0;
7539     r = guestfs_command (g, arguments);
7540     if (r == NULL)
7541       return -1;
7542     if (strcmp (r, expected) != 0) {
7543       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
7544       return -1;
7545     }
7546     free (r);
7547   }
7548   } else
7549     printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
7550   return 0;
7551 }
7552
7553 static int test_command_3_prereq (void)
7554 {
7555   const char *str = getenv ("SKIP_TEST_COMMAND");
7556   return str && strcmp (str, "1") == 0;
7557 }
7558
7559 static int test_command_3 (void)
7560 {
7561   if (! test_command_3_prereq ()) {
7562   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
7563   {
7564     char device[] = "/dev/sda";
7565     device[5] = devchar;
7566     int r;
7567     suppress_error = 0;
7568     r = guestfs_blockdev_setrw (g, device);
7569     if (r == -1)
7570       return -1;
7571   }
7572   {
7573     int r;
7574     suppress_error = 0;
7575     r = guestfs_umount_all (g);
7576     if (r == -1)
7577       return -1;
7578   }
7579   {
7580     int r;
7581     suppress_error = 0;
7582     r = guestfs_lvm_remove_all (g);
7583     if (r == -1)
7584       return -1;
7585   }
7586   {
7587     char device[] = "/dev/sda";
7588     device[5] = devchar;
7589     char lines_0[] = ",";
7590     char *lines[] = {
7591       lines_0,
7592       NULL
7593     };
7594     int r;
7595     suppress_error = 0;
7596     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7597     if (r == -1)
7598       return -1;
7599   }
7600   {
7601     char fstype[] = "ext2";
7602     char device[] = "/dev/sda1";
7603     device[5] = devchar;
7604     int r;
7605     suppress_error = 0;
7606     r = guestfs_mkfs (g, fstype, device);
7607     if (r == -1)
7608       return -1;
7609   }
7610   {
7611     char device[] = "/dev/sda1";
7612     device[5] = devchar;
7613     char mountpoint[] = "/";
7614     int r;
7615     suppress_error = 0;
7616     r = guestfs_mount (g, device, mountpoint);
7617     if (r == -1)
7618       return -1;
7619   }
7620   /* TestOutput for command (3) */
7621   char expected[] = "\nResult4\n";
7622   {
7623     char remotefilename[] = "/test-command";
7624     int r;
7625     suppress_error = 0;
7626     r = guestfs_upload (g, "test-command", remotefilename);
7627     if (r == -1)
7628       return -1;
7629   }
7630   {
7631     char path[] = "/test-command";
7632     int r;
7633     suppress_error = 0;
7634     r = guestfs_chmod (g, 493, path);
7635     if (r == -1)
7636       return -1;
7637   }
7638   {
7639     char arguments_0[] = "/test-command";
7640     char arguments_1[] = "4";
7641     char *arguments[] = {
7642       arguments_0,
7643       arguments_1,
7644       NULL
7645     };
7646     char *r;
7647     suppress_error = 0;
7648     r = guestfs_command (g, arguments);
7649     if (r == NULL)
7650       return -1;
7651     if (strcmp (r, expected) != 0) {
7652       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
7653       return -1;
7654     }
7655     free (r);
7656   }
7657   } else
7658     printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
7659   return 0;
7660 }
7661
7662 static int test_command_4_prereq (void)
7663 {
7664   const char *str = getenv ("SKIP_TEST_COMMAND");
7665   return str && strcmp (str, "1") == 0;
7666 }
7667
7668 static int test_command_4 (void)
7669 {
7670   if (! test_command_4_prereq ()) {
7671   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
7672   {
7673     char device[] = "/dev/sda";
7674     device[5] = devchar;
7675     int r;
7676     suppress_error = 0;
7677     r = guestfs_blockdev_setrw (g, device);
7678     if (r == -1)
7679       return -1;
7680   }
7681   {
7682     int r;
7683     suppress_error = 0;
7684     r = guestfs_umount_all (g);
7685     if (r == -1)
7686       return -1;
7687   }
7688   {
7689     int r;
7690     suppress_error = 0;
7691     r = guestfs_lvm_remove_all (g);
7692     if (r == -1)
7693       return -1;
7694   }
7695   {
7696     char device[] = "/dev/sda";
7697     device[5] = devchar;
7698     char lines_0[] = ",";
7699     char *lines[] = {
7700       lines_0,
7701       NULL
7702     };
7703     int r;
7704     suppress_error = 0;
7705     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7706     if (r == -1)
7707       return -1;
7708   }
7709   {
7710     char fstype[] = "ext2";
7711     char device[] = "/dev/sda1";
7712     device[5] = devchar;
7713     int r;
7714     suppress_error = 0;
7715     r = guestfs_mkfs (g, fstype, device);
7716     if (r == -1)
7717       return -1;
7718   }
7719   {
7720     char device[] = "/dev/sda1";
7721     device[5] = devchar;
7722     char mountpoint[] = "/";
7723     int r;
7724     suppress_error = 0;
7725     r = guestfs_mount (g, device, mountpoint);
7726     if (r == -1)
7727       return -1;
7728   }
7729   /* TestOutput for command (4) */
7730   char expected[] = "\nResult5\n\n";
7731   {
7732     char remotefilename[] = "/test-command";
7733     int r;
7734     suppress_error = 0;
7735     r = guestfs_upload (g, "test-command", remotefilename);
7736     if (r == -1)
7737       return -1;
7738   }
7739   {
7740     char path[] = "/test-command";
7741     int r;
7742     suppress_error = 0;
7743     r = guestfs_chmod (g, 493, path);
7744     if (r == -1)
7745       return -1;
7746   }
7747   {
7748     char arguments_0[] = "/test-command";
7749     char arguments_1[] = "5";
7750     char *arguments[] = {
7751       arguments_0,
7752       arguments_1,
7753       NULL
7754     };
7755     char *r;
7756     suppress_error = 0;
7757     r = guestfs_command (g, arguments);
7758     if (r == NULL)
7759       return -1;
7760     if (strcmp (r, expected) != 0) {
7761       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7762       return -1;
7763     }
7764     free (r);
7765   }
7766   } else
7767     printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7768   return 0;
7769 }
7770
7771 static int test_command_5_prereq (void)
7772 {
7773   const char *str = getenv ("SKIP_TEST_COMMAND");
7774   return str && strcmp (str, "1") == 0;
7775 }
7776
7777 static int test_command_5 (void)
7778 {
7779   if (! test_command_5_prereq ()) {
7780   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
7781   {
7782     char device[] = "/dev/sda";
7783     device[5] = devchar;
7784     int r;
7785     suppress_error = 0;
7786     r = guestfs_blockdev_setrw (g, device);
7787     if (r == -1)
7788       return -1;
7789   }
7790   {
7791     int r;
7792     suppress_error = 0;
7793     r = guestfs_umount_all (g);
7794     if (r == -1)
7795       return -1;
7796   }
7797   {
7798     int r;
7799     suppress_error = 0;
7800     r = guestfs_lvm_remove_all (g);
7801     if (r == -1)
7802       return -1;
7803   }
7804   {
7805     char device[] = "/dev/sda";
7806     device[5] = devchar;
7807     char lines_0[] = ",";
7808     char *lines[] = {
7809       lines_0,
7810       NULL
7811     };
7812     int r;
7813     suppress_error = 0;
7814     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7815     if (r == -1)
7816       return -1;
7817   }
7818   {
7819     char fstype[] = "ext2";
7820     char device[] = "/dev/sda1";
7821     device[5] = devchar;
7822     int r;
7823     suppress_error = 0;
7824     r = guestfs_mkfs (g, fstype, device);
7825     if (r == -1)
7826       return -1;
7827   }
7828   {
7829     char device[] = "/dev/sda1";
7830     device[5] = devchar;
7831     char mountpoint[] = "/";
7832     int r;
7833     suppress_error = 0;
7834     r = guestfs_mount (g, device, mountpoint);
7835     if (r == -1)
7836       return -1;
7837   }
7838   /* TestOutput for command (5) */
7839   char expected[] = "\n\nResult6\n\n";
7840   {
7841     char remotefilename[] = "/test-command";
7842     int r;
7843     suppress_error = 0;
7844     r = guestfs_upload (g, "test-command", remotefilename);
7845     if (r == -1)
7846       return -1;
7847   }
7848   {
7849     char path[] = "/test-command";
7850     int r;
7851     suppress_error = 0;
7852     r = guestfs_chmod (g, 493, path);
7853     if (r == -1)
7854       return -1;
7855   }
7856   {
7857     char arguments_0[] = "/test-command";
7858     char arguments_1[] = "6";
7859     char *arguments[] = {
7860       arguments_0,
7861       arguments_1,
7862       NULL
7863     };
7864     char *r;
7865     suppress_error = 0;
7866     r = guestfs_command (g, arguments);
7867     if (r == NULL)
7868       return -1;
7869     if (strcmp (r, expected) != 0) {
7870       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7871       return -1;
7872     }
7873     free (r);
7874   }
7875   } else
7876     printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7877   return 0;
7878 }
7879
7880 static int test_command_6_prereq (void)
7881 {
7882   const char *str = getenv ("SKIP_TEST_COMMAND");
7883   return str && strcmp (str, "1") == 0;
7884 }
7885
7886 static int test_command_6 (void)
7887 {
7888   if (! test_command_6_prereq ()) {
7889   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
7890   {
7891     char device[] = "/dev/sda";
7892     device[5] = devchar;
7893     int r;
7894     suppress_error = 0;
7895     r = guestfs_blockdev_setrw (g, device);
7896     if (r == -1)
7897       return -1;
7898   }
7899   {
7900     int r;
7901     suppress_error = 0;
7902     r = guestfs_umount_all (g);
7903     if (r == -1)
7904       return -1;
7905   }
7906   {
7907     int r;
7908     suppress_error = 0;
7909     r = guestfs_lvm_remove_all (g);
7910     if (r == -1)
7911       return -1;
7912   }
7913   {
7914     char device[] = "/dev/sda";
7915     device[5] = devchar;
7916     char lines_0[] = ",";
7917     char *lines[] = {
7918       lines_0,
7919       NULL
7920     };
7921     int r;
7922     suppress_error = 0;
7923     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7924     if (r == -1)
7925       return -1;
7926   }
7927   {
7928     char fstype[] = "ext2";
7929     char device[] = "/dev/sda1";
7930     device[5] = devchar;
7931     int r;
7932     suppress_error = 0;
7933     r = guestfs_mkfs (g, fstype, device);
7934     if (r == -1)
7935       return -1;
7936   }
7937   {
7938     char device[] = "/dev/sda1";
7939     device[5] = devchar;
7940     char mountpoint[] = "/";
7941     int r;
7942     suppress_error = 0;
7943     r = guestfs_mount (g, device, mountpoint);
7944     if (r == -1)
7945       return -1;
7946   }
7947   /* TestOutput for command (6) */
7948   char expected[] = "";
7949   {
7950     char remotefilename[] = "/test-command";
7951     int r;
7952     suppress_error = 0;
7953     r = guestfs_upload (g, "test-command", remotefilename);
7954     if (r == -1)
7955       return -1;
7956   }
7957   {
7958     char path[] = "/test-command";
7959     int r;
7960     suppress_error = 0;
7961     r = guestfs_chmod (g, 493, path);
7962     if (r == -1)
7963       return -1;
7964   }
7965   {
7966     char arguments_0[] = "/test-command";
7967     char arguments_1[] = "7";
7968     char *arguments[] = {
7969       arguments_0,
7970       arguments_1,
7971       NULL
7972     };
7973     char *r;
7974     suppress_error = 0;
7975     r = guestfs_command (g, arguments);
7976     if (r == NULL)
7977       return -1;
7978     if (strcmp (r, expected) != 0) {
7979       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7980       return -1;
7981     }
7982     free (r);
7983   }
7984   } else
7985     printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7986   return 0;
7987 }
7988
7989 static int test_command_7_prereq (void)
7990 {
7991   const char *str = getenv ("SKIP_TEST_COMMAND");
7992   return str && strcmp (str, "1") == 0;
7993 }
7994
7995 static int test_command_7 (void)
7996 {
7997   if (! test_command_7_prereq ()) {
7998   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
7999   {
8000     char device[] = "/dev/sda";
8001     device[5] = devchar;
8002     int r;
8003     suppress_error = 0;
8004     r = guestfs_blockdev_setrw (g, device);
8005     if (r == -1)
8006       return -1;
8007   }
8008   {
8009     int r;
8010     suppress_error = 0;
8011     r = guestfs_umount_all (g);
8012     if (r == -1)
8013       return -1;
8014   }
8015   {
8016     int r;
8017     suppress_error = 0;
8018     r = guestfs_lvm_remove_all (g);
8019     if (r == -1)
8020       return -1;
8021   }
8022   {
8023     char device[] = "/dev/sda";
8024     device[5] = devchar;
8025     char lines_0[] = ",";
8026     char *lines[] = {
8027       lines_0,
8028       NULL
8029     };
8030     int r;
8031     suppress_error = 0;
8032     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8033     if (r == -1)
8034       return -1;
8035   }
8036   {
8037     char fstype[] = "ext2";
8038     char device[] = "/dev/sda1";
8039     device[5] = devchar;
8040     int r;
8041     suppress_error = 0;
8042     r = guestfs_mkfs (g, fstype, device);
8043     if (r == -1)
8044       return -1;
8045   }
8046   {
8047     char device[] = "/dev/sda1";
8048     device[5] = devchar;
8049     char mountpoint[] = "/";
8050     int r;
8051     suppress_error = 0;
8052     r = guestfs_mount (g, device, mountpoint);
8053     if (r == -1)
8054       return -1;
8055   }
8056   /* TestOutput for command (7) */
8057   char expected[] = "\n";
8058   {
8059     char remotefilename[] = "/test-command";
8060     int r;
8061     suppress_error = 0;
8062     r = guestfs_upload (g, "test-command", remotefilename);
8063     if (r == -1)
8064       return -1;
8065   }
8066   {
8067     char path[] = "/test-command";
8068     int r;
8069     suppress_error = 0;
8070     r = guestfs_chmod (g, 493, path);
8071     if (r == -1)
8072       return -1;
8073   }
8074   {
8075     char arguments_0[] = "/test-command";
8076     char arguments_1[] = "8";
8077     char *arguments[] = {
8078       arguments_0,
8079       arguments_1,
8080       NULL
8081     };
8082     char *r;
8083     suppress_error = 0;
8084     r = guestfs_command (g, arguments);
8085     if (r == NULL)
8086       return -1;
8087     if (strcmp (r, expected) != 0) {
8088       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
8089       return -1;
8090     }
8091     free (r);
8092   }
8093   } else
8094     printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
8095   return 0;
8096 }
8097
8098 static int test_command_8_prereq (void)
8099 {
8100   const char *str = getenv ("SKIP_TEST_COMMAND");
8101   return str && strcmp (str, "1") == 0;
8102 }
8103
8104 static int test_command_8 (void)
8105 {
8106   if (! test_command_8_prereq ()) {
8107   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
8108   {
8109     char device[] = "/dev/sda";
8110     device[5] = devchar;
8111     int r;
8112     suppress_error = 0;
8113     r = guestfs_blockdev_setrw (g, device);
8114     if (r == -1)
8115       return -1;
8116   }
8117   {
8118     int r;
8119     suppress_error = 0;
8120     r = guestfs_umount_all (g);
8121     if (r == -1)
8122       return -1;
8123   }
8124   {
8125     int r;
8126     suppress_error = 0;
8127     r = guestfs_lvm_remove_all (g);
8128     if (r == -1)
8129       return -1;
8130   }
8131   {
8132     char device[] = "/dev/sda";
8133     device[5] = devchar;
8134     char lines_0[] = ",";
8135     char *lines[] = {
8136       lines_0,
8137       NULL
8138     };
8139     int r;
8140     suppress_error = 0;
8141     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8142     if (r == -1)
8143       return -1;
8144   }
8145   {
8146     char fstype[] = "ext2";
8147     char device[] = "/dev/sda1";
8148     device[5] = devchar;
8149     int r;
8150     suppress_error = 0;
8151     r = guestfs_mkfs (g, fstype, device);
8152     if (r == -1)
8153       return -1;
8154   }
8155   {
8156     char device[] = "/dev/sda1";
8157     device[5] = devchar;
8158     char mountpoint[] = "/";
8159     int r;
8160     suppress_error = 0;
8161     r = guestfs_mount (g, device, mountpoint);
8162     if (r == -1)
8163       return -1;
8164   }
8165   /* TestOutput for command (8) */
8166   char expected[] = "\n\n";
8167   {
8168     char remotefilename[] = "/test-command";
8169     int r;
8170     suppress_error = 0;
8171     r = guestfs_upload (g, "test-command", remotefilename);
8172     if (r == -1)
8173       return -1;
8174   }
8175   {
8176     char path[] = "/test-command";
8177     int r;
8178     suppress_error = 0;
8179     r = guestfs_chmod (g, 493, path);
8180     if (r == -1)
8181       return -1;
8182   }
8183   {
8184     char arguments_0[] = "/test-command";
8185     char arguments_1[] = "9";
8186     char *arguments[] = {
8187       arguments_0,
8188       arguments_1,
8189       NULL
8190     };
8191     char *r;
8192     suppress_error = 0;
8193     r = guestfs_command (g, arguments);
8194     if (r == NULL)
8195       return -1;
8196     if (strcmp (r, expected) != 0) {
8197       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
8198       return -1;
8199     }
8200     free (r);
8201   }
8202   } else
8203     printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
8204   return 0;
8205 }
8206
8207 static int test_command_9_prereq (void)
8208 {
8209   const char *str = getenv ("SKIP_TEST_COMMAND");
8210   return str && strcmp (str, "1") == 0;
8211 }
8212
8213 static int test_command_9 (void)
8214 {
8215   if (! test_command_9_prereq ()) {
8216   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
8217   {
8218     char device[] = "/dev/sda";
8219     device[5] = devchar;
8220     int r;
8221     suppress_error = 0;
8222     r = guestfs_blockdev_setrw (g, device);
8223     if (r == -1)
8224       return -1;
8225   }
8226   {
8227     int r;
8228     suppress_error = 0;
8229     r = guestfs_umount_all (g);
8230     if (r == -1)
8231       return -1;
8232   }
8233   {
8234     int r;
8235     suppress_error = 0;
8236     r = guestfs_lvm_remove_all (g);
8237     if (r == -1)
8238       return -1;
8239   }
8240   {
8241     char device[] = "/dev/sda";
8242     device[5] = devchar;
8243     char lines_0[] = ",";
8244     char *lines[] = {
8245       lines_0,
8246       NULL
8247     };
8248     int r;
8249     suppress_error = 0;
8250     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8251     if (r == -1)
8252       return -1;
8253   }
8254   {
8255     char fstype[] = "ext2";
8256     char device[] = "/dev/sda1";
8257     device[5] = devchar;
8258     int r;
8259     suppress_error = 0;
8260     r = guestfs_mkfs (g, fstype, device);
8261     if (r == -1)
8262       return -1;
8263   }
8264   {
8265     char device[] = "/dev/sda1";
8266     device[5] = devchar;
8267     char mountpoint[] = "/";
8268     int r;
8269     suppress_error = 0;
8270     r = guestfs_mount (g, device, mountpoint);
8271     if (r == -1)
8272       return -1;
8273   }
8274   /* TestOutput for command (9) */
8275   char expected[] = "Result10-1\nResult10-2\n";
8276   {
8277     char remotefilename[] = "/test-command";
8278     int r;
8279     suppress_error = 0;
8280     r = guestfs_upload (g, "test-command", remotefilename);
8281     if (r == -1)
8282       return -1;
8283   }
8284   {
8285     char path[] = "/test-command";
8286     int r;
8287     suppress_error = 0;
8288     r = guestfs_chmod (g, 493, path);
8289     if (r == -1)
8290       return -1;
8291   }
8292   {
8293     char arguments_0[] = "/test-command";
8294     char arguments_1[] = "10";
8295     char *arguments[] = {
8296       arguments_0,
8297       arguments_1,
8298       NULL
8299     };
8300     char *r;
8301     suppress_error = 0;
8302     r = guestfs_command (g, arguments);
8303     if (r == NULL)
8304       return -1;
8305     if (strcmp (r, expected) != 0) {
8306       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
8307       return -1;
8308     }
8309     free (r);
8310   }
8311   } else
8312     printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
8313   return 0;
8314 }
8315
8316 static int test_command_10_prereq (void)
8317 {
8318   const char *str = getenv ("SKIP_TEST_COMMAND");
8319   return str && strcmp (str, "1") == 0;
8320 }
8321
8322 static int test_command_10 (void)
8323 {
8324   if (! test_command_10_prereq ()) {
8325   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
8326   {
8327     char device[] = "/dev/sda";
8328     device[5] = devchar;
8329     int r;
8330     suppress_error = 0;
8331     r = guestfs_blockdev_setrw (g, device);
8332     if (r == -1)
8333       return -1;
8334   }
8335   {
8336     int r;
8337     suppress_error = 0;
8338     r = guestfs_umount_all (g);
8339     if (r == -1)
8340       return -1;
8341   }
8342   {
8343     int r;
8344     suppress_error = 0;
8345     r = guestfs_lvm_remove_all (g);
8346     if (r == -1)
8347       return -1;
8348   }
8349   {
8350     char device[] = "/dev/sda";
8351     device[5] = devchar;
8352     char lines_0[] = ",";
8353     char *lines[] = {
8354       lines_0,
8355       NULL
8356     };
8357     int r;
8358     suppress_error = 0;
8359     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8360     if (r == -1)
8361       return -1;
8362   }
8363   {
8364     char fstype[] = "ext2";
8365     char device[] = "/dev/sda1";
8366     device[5] = devchar;
8367     int r;
8368     suppress_error = 0;
8369     r = guestfs_mkfs (g, fstype, device);
8370     if (r == -1)
8371       return -1;
8372   }
8373   {
8374     char device[] = "/dev/sda1";
8375     device[5] = devchar;
8376     char mountpoint[] = "/";
8377     int r;
8378     suppress_error = 0;
8379     r = guestfs_mount (g, device, mountpoint);
8380     if (r == -1)
8381       return -1;
8382   }
8383   /* TestOutput for command (10) */
8384   char expected[] = "Result11-1\nResult11-2";
8385   {
8386     char remotefilename[] = "/test-command";
8387     int r;
8388     suppress_error = 0;
8389     r = guestfs_upload (g, "test-command", remotefilename);
8390     if (r == -1)
8391       return -1;
8392   }
8393   {
8394     char path[] = "/test-command";
8395     int r;
8396     suppress_error = 0;
8397     r = guestfs_chmod (g, 493, path);
8398     if (r == -1)
8399       return -1;
8400   }
8401   {
8402     char arguments_0[] = "/test-command";
8403     char arguments_1[] = "11";
8404     char *arguments[] = {
8405       arguments_0,
8406       arguments_1,
8407       NULL
8408     };
8409     char *r;
8410     suppress_error = 0;
8411     r = guestfs_command (g, arguments);
8412     if (r == NULL)
8413       return -1;
8414     if (strcmp (r, expected) != 0) {
8415       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
8416       return -1;
8417     }
8418     free (r);
8419   }
8420   } else
8421     printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
8422   return 0;
8423 }
8424
8425 static int test_command_11_prereq (void)
8426 {
8427   const char *str = getenv ("SKIP_TEST_COMMAND");
8428   return str && strcmp (str, "1") == 0;
8429 }
8430
8431 static int test_command_11 (void)
8432 {
8433   if (! test_command_11_prereq ()) {
8434   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
8435   {
8436     char device[] = "/dev/sda";
8437     device[5] = devchar;
8438     int r;
8439     suppress_error = 0;
8440     r = guestfs_blockdev_setrw (g, device);
8441     if (r == -1)
8442       return -1;
8443   }
8444   {
8445     int r;
8446     suppress_error = 0;
8447     r = guestfs_umount_all (g);
8448     if (r == -1)
8449       return -1;
8450   }
8451   {
8452     int r;
8453     suppress_error = 0;
8454     r = guestfs_lvm_remove_all (g);
8455     if (r == -1)
8456       return -1;
8457   }
8458   {
8459     char device[] = "/dev/sda";
8460     device[5] = devchar;
8461     char lines_0[] = ",";
8462     char *lines[] = {
8463       lines_0,
8464       NULL
8465     };
8466     int r;
8467     suppress_error = 0;
8468     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8469     if (r == -1)
8470       return -1;
8471   }
8472   {
8473     char fstype[] = "ext2";
8474     char device[] = "/dev/sda1";
8475     device[5] = devchar;
8476     int r;
8477     suppress_error = 0;
8478     r = guestfs_mkfs (g, fstype, device);
8479     if (r == -1)
8480       return -1;
8481   }
8482   {
8483     char device[] = "/dev/sda1";
8484     device[5] = devchar;
8485     char mountpoint[] = "/";
8486     int r;
8487     suppress_error = 0;
8488     r = guestfs_mount (g, device, mountpoint);
8489     if (r == -1)
8490       return -1;
8491   }
8492   /* TestLastFail for command (11) */
8493   {
8494     char remotefilename[] = "/test-command";
8495     int r;
8496     suppress_error = 0;
8497     r = guestfs_upload (g, "test-command", remotefilename);
8498     if (r == -1)
8499       return -1;
8500   }
8501   {
8502     char path[] = "/test-command";
8503     int r;
8504     suppress_error = 0;
8505     r = guestfs_chmod (g, 493, path);
8506     if (r == -1)
8507       return -1;
8508   }
8509   {
8510     char arguments_0[] = "/test-command";
8511     char *arguments[] = {
8512       arguments_0,
8513       NULL
8514     };
8515     char *r;
8516     suppress_error = 1;
8517     r = guestfs_command (g, arguments);
8518     if (r != NULL)
8519       return -1;
8520     free (r);
8521   }
8522   } else
8523     printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
8524   return 0;
8525 }
8526
8527 static int test_file_0 (void)
8528 {
8529   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
8530   {
8531     char device[] = "/dev/sda";
8532     device[5] = devchar;
8533     int r;
8534     suppress_error = 0;
8535     r = guestfs_blockdev_setrw (g, device);
8536     if (r == -1)
8537       return -1;
8538   }
8539   {
8540     int r;
8541     suppress_error = 0;
8542     r = guestfs_umount_all (g);
8543     if (r == -1)
8544       return -1;
8545   }
8546   {
8547     int r;
8548     suppress_error = 0;
8549     r = guestfs_lvm_remove_all (g);
8550     if (r == -1)
8551       return -1;
8552   }
8553   {
8554     char device[] = "/dev/sda";
8555     device[5] = devchar;
8556     char lines_0[] = ",";
8557     char *lines[] = {
8558       lines_0,
8559       NULL
8560     };
8561     int r;
8562     suppress_error = 0;
8563     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8564     if (r == -1)
8565       return -1;
8566   }
8567   {
8568     char fstype[] = "ext2";
8569     char device[] = "/dev/sda1";
8570     device[5] = devchar;
8571     int r;
8572     suppress_error = 0;
8573     r = guestfs_mkfs (g, fstype, device);
8574     if (r == -1)
8575       return -1;
8576   }
8577   {
8578     char device[] = "/dev/sda1";
8579     device[5] = devchar;
8580     char mountpoint[] = "/";
8581     int r;
8582     suppress_error = 0;
8583     r = guestfs_mount (g, device, mountpoint);
8584     if (r == -1)
8585       return -1;
8586   }
8587   /* TestOutput for file (0) */
8588   char expected[] = "empty";
8589   {
8590     char path[] = "/new";
8591     int r;
8592     suppress_error = 0;
8593     r = guestfs_touch (g, path);
8594     if (r == -1)
8595       return -1;
8596   }
8597   {
8598     char path[] = "/new";
8599     char *r;
8600     suppress_error = 0;
8601     r = guestfs_file (g, path);
8602     if (r == NULL)
8603       return -1;
8604     if (strcmp (r, expected) != 0) {
8605       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8606       return -1;
8607     }
8608     free (r);
8609   }
8610   return 0;
8611 }
8612
8613 static int test_file_1 (void)
8614 {
8615   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
8616   {
8617     char device[] = "/dev/sda";
8618     device[5] = devchar;
8619     int r;
8620     suppress_error = 0;
8621     r = guestfs_blockdev_setrw (g, device);
8622     if (r == -1)
8623       return -1;
8624   }
8625   {
8626     int r;
8627     suppress_error = 0;
8628     r = guestfs_umount_all (g);
8629     if (r == -1)
8630       return -1;
8631   }
8632   {
8633     int r;
8634     suppress_error = 0;
8635     r = guestfs_lvm_remove_all (g);
8636     if (r == -1)
8637       return -1;
8638   }
8639   {
8640     char device[] = "/dev/sda";
8641     device[5] = devchar;
8642     char lines_0[] = ",";
8643     char *lines[] = {
8644       lines_0,
8645       NULL
8646     };
8647     int r;
8648     suppress_error = 0;
8649     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8650     if (r == -1)
8651       return -1;
8652   }
8653   {
8654     char fstype[] = "ext2";
8655     char device[] = "/dev/sda1";
8656     device[5] = devchar;
8657     int r;
8658     suppress_error = 0;
8659     r = guestfs_mkfs (g, fstype, device);
8660     if (r == -1)
8661       return -1;
8662   }
8663   {
8664     char device[] = "/dev/sda1";
8665     device[5] = devchar;
8666     char mountpoint[] = "/";
8667     int r;
8668     suppress_error = 0;
8669     r = guestfs_mount (g, device, mountpoint);
8670     if (r == -1)
8671       return -1;
8672   }
8673   /* TestOutput for file (1) */
8674   char expected[] = "ASCII text";
8675   {
8676     char path[] = "/new";
8677     char content[] = "some content\n";
8678     int r;
8679     suppress_error = 0;
8680     r = guestfs_write_file (g, path, content, 0);
8681     if (r == -1)
8682       return -1;
8683   }
8684   {
8685     char path[] = "/new";
8686     char *r;
8687     suppress_error = 0;
8688     r = guestfs_file (g, path);
8689     if (r == NULL)
8690       return -1;
8691     if (strcmp (r, expected) != 0) {
8692       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8693       return -1;
8694     }
8695     free (r);
8696   }
8697   return 0;
8698 }
8699
8700 static int test_file_2 (void)
8701 {
8702   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
8703   {
8704     char device[] = "/dev/sda";
8705     device[5] = devchar;
8706     int r;
8707     suppress_error = 0;
8708     r = guestfs_blockdev_setrw (g, device);
8709     if (r == -1)
8710       return -1;
8711   }
8712   {
8713     int r;
8714     suppress_error = 0;
8715     r = guestfs_umount_all (g);
8716     if (r == -1)
8717       return -1;
8718   }
8719   {
8720     int r;
8721     suppress_error = 0;
8722     r = guestfs_lvm_remove_all (g);
8723     if (r == -1)
8724       return -1;
8725   }
8726   {
8727     char device[] = "/dev/sda";
8728     device[5] = devchar;
8729     char lines_0[] = ",";
8730     char *lines[] = {
8731       lines_0,
8732       NULL
8733     };
8734     int r;
8735     suppress_error = 0;
8736     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8737     if (r == -1)
8738       return -1;
8739   }
8740   {
8741     char fstype[] = "ext2";
8742     char device[] = "/dev/sda1";
8743     device[5] = devchar;
8744     int r;
8745     suppress_error = 0;
8746     r = guestfs_mkfs (g, fstype, device);
8747     if (r == -1)
8748       return -1;
8749   }
8750   {
8751     char device[] = "/dev/sda1";
8752     device[5] = devchar;
8753     char mountpoint[] = "/";
8754     int r;
8755     suppress_error = 0;
8756     r = guestfs_mount (g, device, mountpoint);
8757     if (r == -1)
8758       return -1;
8759   }
8760   /* TestLastFail for file (2) */
8761   {
8762     char path[] = "/nofile";
8763     char *r;
8764     suppress_error = 1;
8765     r = guestfs_file (g, path);
8766     if (r != NULL)
8767       return -1;
8768     free (r);
8769   }
8770   return 0;
8771 }
8772
8773 static int test_umount_all_0 (void)
8774 {
8775   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
8776   {
8777     char device[] = "/dev/sda";
8778     device[5] = devchar;
8779     int r;
8780     suppress_error = 0;
8781     r = guestfs_blockdev_setrw (g, device);
8782     if (r == -1)
8783       return -1;
8784   }
8785   {
8786     int r;
8787     suppress_error = 0;
8788     r = guestfs_umount_all (g);
8789     if (r == -1)
8790       return -1;
8791   }
8792   {
8793     int r;
8794     suppress_error = 0;
8795     r = guestfs_lvm_remove_all (g);
8796     if (r == -1)
8797       return -1;
8798   }
8799   {
8800     char device[] = "/dev/sda";
8801     device[5] = devchar;
8802     char lines_0[] = ",";
8803     char *lines[] = {
8804       lines_0,
8805       NULL
8806     };
8807     int r;
8808     suppress_error = 0;
8809     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8810     if (r == -1)
8811       return -1;
8812   }
8813   {
8814     char fstype[] = "ext2";
8815     char device[] = "/dev/sda1";
8816     device[5] = devchar;
8817     int r;
8818     suppress_error = 0;
8819     r = guestfs_mkfs (g, fstype, device);
8820     if (r == -1)
8821       return -1;
8822   }
8823   {
8824     char device[] = "/dev/sda1";
8825     device[5] = devchar;
8826     char mountpoint[] = "/";
8827     int r;
8828     suppress_error = 0;
8829     r = guestfs_mount (g, device, mountpoint);
8830     if (r == -1)
8831       return -1;
8832   }
8833   /* TestOutputList for umount_all (0) */
8834   {
8835     int r;
8836     suppress_error = 0;
8837     r = guestfs_umount_all (g);
8838     if (r == -1)
8839       return -1;
8840   }
8841   {
8842     char **r;
8843     int i;
8844     suppress_error = 0;
8845     r = guestfs_mounts (g);
8846     if (r == NULL)
8847       return -1;
8848     if (r[0] != NULL) {
8849       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8850       print_strings (r);
8851       return -1;
8852     }
8853     for (i = 0; r[i] != NULL; ++i)
8854       free (r[i]);
8855     free (r);
8856   }
8857   return 0;
8858 }
8859
8860 static int test_umount_all_1 (void)
8861 {
8862   /* InitNone|InitEmpty for test_umount_all_1 */
8863   {
8864     char device[] = "/dev/sda";
8865     device[5] = devchar;
8866     int r;
8867     suppress_error = 0;
8868     r = guestfs_blockdev_setrw (g, device);
8869     if (r == -1)
8870       return -1;
8871   }
8872   {
8873     int r;
8874     suppress_error = 0;
8875     r = guestfs_umount_all (g);
8876     if (r == -1)
8877       return -1;
8878   }
8879   {
8880     int r;
8881     suppress_error = 0;
8882     r = guestfs_lvm_remove_all (g);
8883     if (r == -1)
8884       return -1;
8885   }
8886   /* TestOutputList for umount_all (1) */
8887   {
8888     char device[] = "/dev/sda";
8889     device[5] = devchar;
8890     char lines_0[] = ",10";
8891     char lines_1[] = ",20";
8892     char lines_2[] = ",";
8893     char *lines[] = {
8894       lines_0,
8895       lines_1,
8896       lines_2,
8897       NULL
8898     };
8899     int r;
8900     suppress_error = 0;
8901     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8902     if (r == -1)
8903       return -1;
8904   }
8905   {
8906     char fstype[] = "ext2";
8907     char device[] = "/dev/sda1";
8908     device[5] = devchar;
8909     int r;
8910     suppress_error = 0;
8911     r = guestfs_mkfs (g, fstype, device);
8912     if (r == -1)
8913       return -1;
8914   }
8915   {
8916     char fstype[] = "ext2";
8917     char device[] = "/dev/sda2";
8918     device[5] = devchar;
8919     int r;
8920     suppress_error = 0;
8921     r = guestfs_mkfs (g, fstype, device);
8922     if (r == -1)
8923       return -1;
8924   }
8925   {
8926     char fstype[] = "ext2";
8927     char device[] = "/dev/sda3";
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   {
8946     char path[] = "/mp1";
8947     int r;
8948     suppress_error = 0;
8949     r = guestfs_mkdir (g, path);
8950     if (r == -1)
8951       return -1;
8952   }
8953   {
8954     char device[] = "/dev/sda2";
8955     device[5] = devchar;
8956     char mountpoint[] = "/mp1";
8957     int r;
8958     suppress_error = 0;
8959     r = guestfs_mount (g, device, mountpoint);
8960     if (r == -1)
8961       return -1;
8962   }
8963   {
8964     char path[] = "/mp1/mp2";
8965     int r;
8966     suppress_error = 0;
8967     r = guestfs_mkdir (g, path);
8968     if (r == -1)
8969       return -1;
8970   }
8971   {
8972     char device[] = "/dev/sda3";
8973     device[5] = devchar;
8974     char mountpoint[] = "/mp1/mp2";
8975     int r;
8976     suppress_error = 0;
8977     r = guestfs_mount (g, device, mountpoint);
8978     if (r == -1)
8979       return -1;
8980   }
8981   {
8982     char path[] = "/mp1/mp2/mp3";
8983     int r;
8984     suppress_error = 0;
8985     r = guestfs_mkdir (g, path);
8986     if (r == -1)
8987       return -1;
8988   }
8989   {
8990     int r;
8991     suppress_error = 0;
8992     r = guestfs_umount_all (g);
8993     if (r == -1)
8994       return -1;
8995   }
8996   {
8997     char **r;
8998     int i;
8999     suppress_error = 0;
9000     r = guestfs_mounts (g);
9001     if (r == NULL)
9002       return -1;
9003     if (r[0] != NULL) {
9004       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
9005       print_strings (r);
9006       return -1;
9007     }
9008     for (i = 0; r[i] != NULL; ++i)
9009       free (r[i]);
9010     free (r);
9011   }
9012   return 0;
9013 }
9014
9015 static int test_mounts_0 (void)
9016 {
9017   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
9018   {
9019     char device[] = "/dev/sda";
9020     device[5] = devchar;
9021     int r;
9022     suppress_error = 0;
9023     r = guestfs_blockdev_setrw (g, device);
9024     if (r == -1)
9025       return -1;
9026   }
9027   {
9028     int r;
9029     suppress_error = 0;
9030     r = guestfs_umount_all (g);
9031     if (r == -1)
9032       return -1;
9033   }
9034   {
9035     int r;
9036     suppress_error = 0;
9037     r = guestfs_lvm_remove_all (g);
9038     if (r == -1)
9039       return -1;
9040   }
9041   {
9042     char device[] = "/dev/sda";
9043     device[5] = devchar;
9044     char lines_0[] = ",";
9045     char *lines[] = {
9046       lines_0,
9047       NULL
9048     };
9049     int r;
9050     suppress_error = 0;
9051     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9052     if (r == -1)
9053       return -1;
9054   }
9055   {
9056     char fstype[] = "ext2";
9057     char device[] = "/dev/sda1";
9058     device[5] = devchar;
9059     int r;
9060     suppress_error = 0;
9061     r = guestfs_mkfs (g, fstype, device);
9062     if (r == -1)
9063       return -1;
9064   }
9065   {
9066     char device[] = "/dev/sda1";
9067     device[5] = devchar;
9068     char mountpoint[] = "/";
9069     int r;
9070     suppress_error = 0;
9071     r = guestfs_mount (g, device, mountpoint);
9072     if (r == -1)
9073       return -1;
9074   }
9075   /* TestOutputList for mounts (0) */
9076   {
9077     char **r;
9078     int i;
9079     suppress_error = 0;
9080     r = guestfs_mounts (g);
9081     if (r == NULL)
9082       return -1;
9083     if (!r[0]) {
9084       fprintf (stderr, "test_mounts_0: short list returned from command\n");
9085       print_strings (r);
9086       return -1;
9087     }
9088     {
9089       char expected[] = "/dev/sda1";
9090       expected[5] = devchar;
9091       if (strcmp (r[0], expected) != 0) {
9092         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9093         return -1;
9094       }
9095     }
9096     if (r[1] != NULL) {
9097       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
9098       print_strings (r);
9099       return -1;
9100     }
9101     for (i = 0; r[i] != NULL; ++i)
9102       free (r[i]);
9103     free (r);
9104   }
9105   return 0;
9106 }
9107
9108 static int test_umount_0 (void)
9109 {
9110   /* InitNone|InitEmpty for test_umount_0 */
9111   {
9112     char device[] = "/dev/sda";
9113     device[5] = devchar;
9114     int r;
9115     suppress_error = 0;
9116     r = guestfs_blockdev_setrw (g, device);
9117     if (r == -1)
9118       return -1;
9119   }
9120   {
9121     int r;
9122     suppress_error = 0;
9123     r = guestfs_umount_all (g);
9124     if (r == -1)
9125       return -1;
9126   }
9127   {
9128     int r;
9129     suppress_error = 0;
9130     r = guestfs_lvm_remove_all (g);
9131     if (r == -1)
9132       return -1;
9133   }
9134   /* TestOutputList for umount (0) */
9135   {
9136     char device[] = "/dev/sda";
9137     device[5] = devchar;
9138     char lines_0[] = ",";
9139     char *lines[] = {
9140       lines_0,
9141       NULL
9142     };
9143     int r;
9144     suppress_error = 0;
9145     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9146     if (r == -1)
9147       return -1;
9148   }
9149   {
9150     char fstype[] = "ext2";
9151     char device[] = "/dev/sda1";
9152     device[5] = devchar;
9153     int r;
9154     suppress_error = 0;
9155     r = guestfs_mkfs (g, fstype, device);
9156     if (r == -1)
9157       return -1;
9158   }
9159   {
9160     char device[] = "/dev/sda1";
9161     device[5] = devchar;
9162     char mountpoint[] = "/";
9163     int r;
9164     suppress_error = 0;
9165     r = guestfs_mount (g, device, mountpoint);
9166     if (r == -1)
9167       return -1;
9168   }
9169   {
9170     char **r;
9171     int i;
9172     suppress_error = 0;
9173     r = guestfs_mounts (g);
9174     if (r == NULL)
9175       return -1;
9176     if (!r[0]) {
9177       fprintf (stderr, "test_umount_0: short list returned from command\n");
9178       print_strings (r);
9179       return -1;
9180     }
9181     {
9182       char expected[] = "/dev/sda1";
9183       expected[5] = devchar;
9184       if (strcmp (r[0], expected) != 0) {
9185         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9186         return -1;
9187       }
9188     }
9189     if (r[1] != NULL) {
9190       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
9191       print_strings (r);
9192       return -1;
9193     }
9194     for (i = 0; r[i] != NULL; ++i)
9195       free (r[i]);
9196     free (r);
9197   }
9198   return 0;
9199 }
9200
9201 static int test_umount_1 (void)
9202 {
9203   /* InitNone|InitEmpty for test_umount_1 */
9204   {
9205     char device[] = "/dev/sda";
9206     device[5] = devchar;
9207     int r;
9208     suppress_error = 0;
9209     r = guestfs_blockdev_setrw (g, device);
9210     if (r == -1)
9211       return -1;
9212   }
9213   {
9214     int r;
9215     suppress_error = 0;
9216     r = guestfs_umount_all (g);
9217     if (r == -1)
9218       return -1;
9219   }
9220   {
9221     int r;
9222     suppress_error = 0;
9223     r = guestfs_lvm_remove_all (g);
9224     if (r == -1)
9225       return -1;
9226   }
9227   /* TestOutputList for umount (1) */
9228   {
9229     char device[] = "/dev/sda";
9230     device[5] = devchar;
9231     char lines_0[] = ",";
9232     char *lines[] = {
9233       lines_0,
9234       NULL
9235     };
9236     int r;
9237     suppress_error = 0;
9238     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9239     if (r == -1)
9240       return -1;
9241   }
9242   {
9243     char fstype[] = "ext2";
9244     char device[] = "/dev/sda1";
9245     device[5] = devchar;
9246     int r;
9247     suppress_error = 0;
9248     r = guestfs_mkfs (g, fstype, device);
9249     if (r == -1)
9250       return -1;
9251   }
9252   {
9253     char device[] = "/dev/sda1";
9254     device[5] = devchar;
9255     char mountpoint[] = "/";
9256     int r;
9257     suppress_error = 0;
9258     r = guestfs_mount (g, device, mountpoint);
9259     if (r == -1)
9260       return -1;
9261   }
9262   {
9263     char pathordevice[] = "/";
9264     int r;
9265     suppress_error = 0;
9266     r = guestfs_umount (g, pathordevice);
9267     if (r == -1)
9268       return -1;
9269   }
9270   {
9271     char **r;
9272     int i;
9273     suppress_error = 0;
9274     r = guestfs_mounts (g);
9275     if (r == NULL)
9276       return -1;
9277     if (r[0] != NULL) {
9278       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
9279       print_strings (r);
9280       return -1;
9281     }
9282     for (i = 0; r[i] != NULL; ++i)
9283       free (r[i]);
9284     free (r);
9285   }
9286   return 0;
9287 }
9288
9289 static int test_write_file_0 (void)
9290 {
9291   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
9292   {
9293     char device[] = "/dev/sda";
9294     device[5] = devchar;
9295     int r;
9296     suppress_error = 0;
9297     r = guestfs_blockdev_setrw (g, device);
9298     if (r == -1)
9299       return -1;
9300   }
9301   {
9302     int r;
9303     suppress_error = 0;
9304     r = guestfs_umount_all (g);
9305     if (r == -1)
9306       return -1;
9307   }
9308   {
9309     int r;
9310     suppress_error = 0;
9311     r = guestfs_lvm_remove_all (g);
9312     if (r == -1)
9313       return -1;
9314   }
9315   {
9316     char device[] = "/dev/sda";
9317     device[5] = devchar;
9318     char lines_0[] = ",";
9319     char *lines[] = {
9320       lines_0,
9321       NULL
9322     };
9323     int r;
9324     suppress_error = 0;
9325     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9326     if (r == -1)
9327       return -1;
9328   }
9329   {
9330     char fstype[] = "ext2";
9331     char device[] = "/dev/sda1";
9332     device[5] = devchar;
9333     int r;
9334     suppress_error = 0;
9335     r = guestfs_mkfs (g, fstype, device);
9336     if (r == -1)
9337       return -1;
9338   }
9339   {
9340     char device[] = "/dev/sda1";
9341     device[5] = devchar;
9342     char mountpoint[] = "/";
9343     int r;
9344     suppress_error = 0;
9345     r = guestfs_mount (g, device, mountpoint);
9346     if (r == -1)
9347       return -1;
9348   }
9349   /* TestOutput for write_file (0) */
9350   char expected[] = "new file contents";
9351   {
9352     char path[] = "/new";
9353     char content[] = "new file contents";
9354     int r;
9355     suppress_error = 0;
9356     r = guestfs_write_file (g, path, content, 0);
9357     if (r == -1)
9358       return -1;
9359   }
9360   {
9361     char path[] = "/new";
9362     char *r;
9363     suppress_error = 0;
9364     r = guestfs_cat (g, path);
9365     if (r == NULL)
9366       return -1;
9367     if (strcmp (r, expected) != 0) {
9368       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9369       return -1;
9370     }
9371     free (r);
9372   }
9373   return 0;
9374 }
9375
9376 static int test_write_file_1 (void)
9377 {
9378   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
9379   {
9380     char device[] = "/dev/sda";
9381     device[5] = devchar;
9382     int r;
9383     suppress_error = 0;
9384     r = guestfs_blockdev_setrw (g, device);
9385     if (r == -1)
9386       return -1;
9387   }
9388   {
9389     int r;
9390     suppress_error = 0;
9391     r = guestfs_umount_all (g);
9392     if (r == -1)
9393       return -1;
9394   }
9395   {
9396     int r;
9397     suppress_error = 0;
9398     r = guestfs_lvm_remove_all (g);
9399     if (r == -1)
9400       return -1;
9401   }
9402   {
9403     char device[] = "/dev/sda";
9404     device[5] = devchar;
9405     char lines_0[] = ",";
9406     char *lines[] = {
9407       lines_0,
9408       NULL
9409     };
9410     int r;
9411     suppress_error = 0;
9412     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9413     if (r == -1)
9414       return -1;
9415   }
9416   {
9417     char fstype[] = "ext2";
9418     char device[] = "/dev/sda1";
9419     device[5] = devchar;
9420     int r;
9421     suppress_error = 0;
9422     r = guestfs_mkfs (g, fstype, device);
9423     if (r == -1)
9424       return -1;
9425   }
9426   {
9427     char device[] = "/dev/sda1";
9428     device[5] = devchar;
9429     char mountpoint[] = "/";
9430     int r;
9431     suppress_error = 0;
9432     r = guestfs_mount (g, device, mountpoint);
9433     if (r == -1)
9434       return -1;
9435   }
9436   /* TestOutput for write_file (1) */
9437   char expected[] = "\nnew file contents\n";
9438   {
9439     char path[] = "/new";
9440     char content[] = "\nnew file contents\n";
9441     int r;
9442     suppress_error = 0;
9443     r = guestfs_write_file (g, path, content, 0);
9444     if (r == -1)
9445       return -1;
9446   }
9447   {
9448     char path[] = "/new";
9449     char *r;
9450     suppress_error = 0;
9451     r = guestfs_cat (g, path);
9452     if (r == NULL)
9453       return -1;
9454     if (strcmp (r, expected) != 0) {
9455       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9456       return -1;
9457     }
9458     free (r);
9459   }
9460   return 0;
9461 }
9462
9463 static int test_write_file_2 (void)
9464 {
9465   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
9466   {
9467     char device[] = "/dev/sda";
9468     device[5] = devchar;
9469     int r;
9470     suppress_error = 0;
9471     r = guestfs_blockdev_setrw (g, device);
9472     if (r == -1)
9473       return -1;
9474   }
9475   {
9476     int r;
9477     suppress_error = 0;
9478     r = guestfs_umount_all (g);
9479     if (r == -1)
9480       return -1;
9481   }
9482   {
9483     int r;
9484     suppress_error = 0;
9485     r = guestfs_lvm_remove_all (g);
9486     if (r == -1)
9487       return -1;
9488   }
9489   {
9490     char device[] = "/dev/sda";
9491     device[5] = devchar;
9492     char lines_0[] = ",";
9493     char *lines[] = {
9494       lines_0,
9495       NULL
9496     };
9497     int r;
9498     suppress_error = 0;
9499     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9500     if (r == -1)
9501       return -1;
9502   }
9503   {
9504     char fstype[] = "ext2";
9505     char device[] = "/dev/sda1";
9506     device[5] = devchar;
9507     int r;
9508     suppress_error = 0;
9509     r = guestfs_mkfs (g, fstype, device);
9510     if (r == -1)
9511       return -1;
9512   }
9513   {
9514     char device[] = "/dev/sda1";
9515     device[5] = devchar;
9516     char mountpoint[] = "/";
9517     int r;
9518     suppress_error = 0;
9519     r = guestfs_mount (g, device, mountpoint);
9520     if (r == -1)
9521       return -1;
9522   }
9523   /* TestOutput for write_file (2) */
9524   char expected[] = "\n\n";
9525   {
9526     char path[] = "/new";
9527     char content[] = "\n\n";
9528     int r;
9529     suppress_error = 0;
9530     r = guestfs_write_file (g, path, content, 0);
9531     if (r == -1)
9532       return -1;
9533   }
9534   {
9535     char path[] = "/new";
9536     char *r;
9537     suppress_error = 0;
9538     r = guestfs_cat (g, path);
9539     if (r == NULL)
9540       return -1;
9541     if (strcmp (r, expected) != 0) {
9542       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
9543       return -1;
9544     }
9545     free (r);
9546   }
9547   return 0;
9548 }
9549
9550 static int test_write_file_3 (void)
9551 {
9552   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
9553   {
9554     char device[] = "/dev/sda";
9555     device[5] = devchar;
9556     int r;
9557     suppress_error = 0;
9558     r = guestfs_blockdev_setrw (g, device);
9559     if (r == -1)
9560       return -1;
9561   }
9562   {
9563     int r;
9564     suppress_error = 0;
9565     r = guestfs_umount_all (g);
9566     if (r == -1)
9567       return -1;
9568   }
9569   {
9570     int r;
9571     suppress_error = 0;
9572     r = guestfs_lvm_remove_all (g);
9573     if (r == -1)
9574       return -1;
9575   }
9576   {
9577     char device[] = "/dev/sda";
9578     device[5] = devchar;
9579     char lines_0[] = ",";
9580     char *lines[] = {
9581       lines_0,
9582       NULL
9583     };
9584     int r;
9585     suppress_error = 0;
9586     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9587     if (r == -1)
9588       return -1;
9589   }
9590   {
9591     char fstype[] = "ext2";
9592     char device[] = "/dev/sda1";
9593     device[5] = devchar;
9594     int r;
9595     suppress_error = 0;
9596     r = guestfs_mkfs (g, fstype, device);
9597     if (r == -1)
9598       return -1;
9599   }
9600   {
9601     char device[] = "/dev/sda1";
9602     device[5] = devchar;
9603     char mountpoint[] = "/";
9604     int r;
9605     suppress_error = 0;
9606     r = guestfs_mount (g, device, mountpoint);
9607     if (r == -1)
9608       return -1;
9609   }
9610   /* TestOutput for write_file (3) */
9611   char expected[] = "";
9612   {
9613     char path[] = "/new";
9614     char content[] = "";
9615     int r;
9616     suppress_error = 0;
9617     r = guestfs_write_file (g, path, content, 0);
9618     if (r == -1)
9619       return -1;
9620   }
9621   {
9622     char path[] = "/new";
9623     char *r;
9624     suppress_error = 0;
9625     r = guestfs_cat (g, path);
9626     if (r == NULL)
9627       return -1;
9628     if (strcmp (r, expected) != 0) {
9629       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
9630       return -1;
9631     }
9632     free (r);
9633   }
9634   return 0;
9635 }
9636
9637 static int test_write_file_4 (void)
9638 {
9639   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
9640   {
9641     char device[] = "/dev/sda";
9642     device[5] = devchar;
9643     int r;
9644     suppress_error = 0;
9645     r = guestfs_blockdev_setrw (g, device);
9646     if (r == -1)
9647       return -1;
9648   }
9649   {
9650     int r;
9651     suppress_error = 0;
9652     r = guestfs_umount_all (g);
9653     if (r == -1)
9654       return -1;
9655   }
9656   {
9657     int r;
9658     suppress_error = 0;
9659     r = guestfs_lvm_remove_all (g);
9660     if (r == -1)
9661       return -1;
9662   }
9663   {
9664     char device[] = "/dev/sda";
9665     device[5] = devchar;
9666     char lines_0[] = ",";
9667     char *lines[] = {
9668       lines_0,
9669       NULL
9670     };
9671     int r;
9672     suppress_error = 0;
9673     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9674     if (r == -1)
9675       return -1;
9676   }
9677   {
9678     char fstype[] = "ext2";
9679     char device[] = "/dev/sda1";
9680     device[5] = devchar;
9681     int r;
9682     suppress_error = 0;
9683     r = guestfs_mkfs (g, fstype, device);
9684     if (r == -1)
9685       return -1;
9686   }
9687   {
9688     char device[] = "/dev/sda1";
9689     device[5] = devchar;
9690     char mountpoint[] = "/";
9691     int r;
9692     suppress_error = 0;
9693     r = guestfs_mount (g, device, mountpoint);
9694     if (r == -1)
9695       return -1;
9696   }
9697   /* TestOutput for write_file (4) */
9698   char expected[] = "\n\n\n";
9699   {
9700     char path[] = "/new";
9701     char content[] = "\n\n\n";
9702     int r;
9703     suppress_error = 0;
9704     r = guestfs_write_file (g, path, content, 0);
9705     if (r == -1)
9706       return -1;
9707   }
9708   {
9709     char path[] = "/new";
9710     char *r;
9711     suppress_error = 0;
9712     r = guestfs_cat (g, path);
9713     if (r == NULL)
9714       return -1;
9715     if (strcmp (r, expected) != 0) {
9716       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9717       return -1;
9718     }
9719     free (r);
9720   }
9721   return 0;
9722 }
9723
9724 static int test_write_file_5 (void)
9725 {
9726   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
9727   {
9728     char device[] = "/dev/sda";
9729     device[5] = devchar;
9730     int r;
9731     suppress_error = 0;
9732     r = guestfs_blockdev_setrw (g, device);
9733     if (r == -1)
9734       return -1;
9735   }
9736   {
9737     int r;
9738     suppress_error = 0;
9739     r = guestfs_umount_all (g);
9740     if (r == -1)
9741       return -1;
9742   }
9743   {
9744     int r;
9745     suppress_error = 0;
9746     r = guestfs_lvm_remove_all (g);
9747     if (r == -1)
9748       return -1;
9749   }
9750   {
9751     char device[] = "/dev/sda";
9752     device[5] = devchar;
9753     char lines_0[] = ",";
9754     char *lines[] = {
9755       lines_0,
9756       NULL
9757     };
9758     int r;
9759     suppress_error = 0;
9760     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9761     if (r == -1)
9762       return -1;
9763   }
9764   {
9765     char fstype[] = "ext2";
9766     char device[] = "/dev/sda1";
9767     device[5] = devchar;
9768     int r;
9769     suppress_error = 0;
9770     r = guestfs_mkfs (g, fstype, device);
9771     if (r == -1)
9772       return -1;
9773   }
9774   {
9775     char device[] = "/dev/sda1";
9776     device[5] = devchar;
9777     char mountpoint[] = "/";
9778     int r;
9779     suppress_error = 0;
9780     r = guestfs_mount (g, device, mountpoint);
9781     if (r == -1)
9782       return -1;
9783   }
9784   /* TestOutput for write_file (5) */
9785   char expected[] = "\n";
9786   {
9787     char path[] = "/new";
9788     char content[] = "\n";
9789     int r;
9790     suppress_error = 0;
9791     r = guestfs_write_file (g, path, content, 0);
9792     if (r == -1)
9793       return -1;
9794   }
9795   {
9796     char path[] = "/new";
9797     char *r;
9798     suppress_error = 0;
9799     r = guestfs_cat (g, path);
9800     if (r == NULL)
9801       return -1;
9802     if (strcmp (r, expected) != 0) {
9803       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9804       return -1;
9805     }
9806     free (r);
9807   }
9808   return 0;
9809 }
9810
9811 static int test_mkfs_0 (void)
9812 {
9813   /* InitNone|InitEmpty for test_mkfs_0 */
9814   {
9815     char device[] = "/dev/sda";
9816     device[5] = devchar;
9817     int r;
9818     suppress_error = 0;
9819     r = guestfs_blockdev_setrw (g, device);
9820     if (r == -1)
9821       return -1;
9822   }
9823   {
9824     int r;
9825     suppress_error = 0;
9826     r = guestfs_umount_all (g);
9827     if (r == -1)
9828       return -1;
9829   }
9830   {
9831     int r;
9832     suppress_error = 0;
9833     r = guestfs_lvm_remove_all (g);
9834     if (r == -1)
9835       return -1;
9836   }
9837   /* TestOutput for mkfs (0) */
9838   char expected[] = "new file contents";
9839   {
9840     char device[] = "/dev/sda";
9841     device[5] = devchar;
9842     char lines_0[] = ",";
9843     char *lines[] = {
9844       lines_0,
9845       NULL
9846     };
9847     int r;
9848     suppress_error = 0;
9849     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9850     if (r == -1)
9851       return -1;
9852   }
9853   {
9854     char fstype[] = "ext2";
9855     char device[] = "/dev/sda1";
9856     device[5] = devchar;
9857     int r;
9858     suppress_error = 0;
9859     r = guestfs_mkfs (g, fstype, device);
9860     if (r == -1)
9861       return -1;
9862   }
9863   {
9864     char device[] = "/dev/sda1";
9865     device[5] = devchar;
9866     char mountpoint[] = "/";
9867     int r;
9868     suppress_error = 0;
9869     r = guestfs_mount (g, device, mountpoint);
9870     if (r == -1)
9871       return -1;
9872   }
9873   {
9874     char path[] = "/new";
9875     char content[] = "new file contents";
9876     int r;
9877     suppress_error = 0;
9878     r = guestfs_write_file (g, path, content, 0);
9879     if (r == -1)
9880       return -1;
9881   }
9882   {
9883     char path[] = "/new";
9884     char *r;
9885     suppress_error = 0;
9886     r = guestfs_cat (g, path);
9887     if (r == NULL)
9888       return -1;
9889     if (strcmp (r, expected) != 0) {
9890       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9891       return -1;
9892     }
9893     free (r);
9894   }
9895   return 0;
9896 }
9897
9898 static int test_lvcreate_0 (void)
9899 {
9900   /* InitNone|InitEmpty for test_lvcreate_0 */
9901   {
9902     char device[] = "/dev/sda";
9903     device[5] = devchar;
9904     int r;
9905     suppress_error = 0;
9906     r = guestfs_blockdev_setrw (g, device);
9907     if (r == -1)
9908       return -1;
9909   }
9910   {
9911     int r;
9912     suppress_error = 0;
9913     r = guestfs_umount_all (g);
9914     if (r == -1)
9915       return -1;
9916   }
9917   {
9918     int r;
9919     suppress_error = 0;
9920     r = guestfs_lvm_remove_all (g);
9921     if (r == -1)
9922       return -1;
9923   }
9924   /* TestOutputList for lvcreate (0) */
9925   {
9926     char device[] = "/dev/sda";
9927     device[5] = devchar;
9928     char lines_0[] = ",10";
9929     char lines_1[] = ",20";
9930     char lines_2[] = ",";
9931     char *lines[] = {
9932       lines_0,
9933       lines_1,
9934       lines_2,
9935       NULL
9936     };
9937     int r;
9938     suppress_error = 0;
9939     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9940     if (r == -1)
9941       return -1;
9942   }
9943   {
9944     char device[] = "/dev/sda1";
9945     device[5] = devchar;
9946     int r;
9947     suppress_error = 0;
9948     r = guestfs_pvcreate (g, device);
9949     if (r == -1)
9950       return -1;
9951   }
9952   {
9953     char device[] = "/dev/sda2";
9954     device[5] = devchar;
9955     int r;
9956     suppress_error = 0;
9957     r = guestfs_pvcreate (g, device);
9958     if (r == -1)
9959       return -1;
9960   }
9961   {
9962     char device[] = "/dev/sda3";
9963     device[5] = devchar;
9964     int r;
9965     suppress_error = 0;
9966     r = guestfs_pvcreate (g, device);
9967     if (r == -1)
9968       return -1;
9969   }
9970   {
9971     char volgroup[] = "VG1";
9972     char physvols_0[] = "/dev/sda1";
9973     physvols_0[5] = devchar;
9974     char physvols_1[] = "/dev/sda2";
9975     physvols_1[5] = devchar;
9976     char *physvols[] = {
9977       physvols_0,
9978       physvols_1,
9979       NULL
9980     };
9981     int r;
9982     suppress_error = 0;
9983     r = guestfs_vgcreate (g, volgroup, physvols);
9984     if (r == -1)
9985       return -1;
9986   }
9987   {
9988     char volgroup[] = "VG2";
9989     char physvols_0[] = "/dev/sda3";
9990     physvols_0[5] = devchar;
9991     char *physvols[] = {
9992       physvols_0,
9993       NULL
9994     };
9995     int r;
9996     suppress_error = 0;
9997     r = guestfs_vgcreate (g, volgroup, physvols);
9998     if (r == -1)
9999       return -1;
10000   }
10001   {
10002     char logvol[] = "LV1";
10003     char volgroup[] = "VG1";
10004     int r;
10005     suppress_error = 0;
10006     r = guestfs_lvcreate (g, logvol, volgroup, 50);
10007     if (r == -1)
10008       return -1;
10009   }
10010   {
10011     char logvol[] = "LV2";
10012     char volgroup[] = "VG1";
10013     int r;
10014     suppress_error = 0;
10015     r = guestfs_lvcreate (g, logvol, volgroup, 50);
10016     if (r == -1)
10017       return -1;
10018   }
10019   {
10020     char logvol[] = "LV3";
10021     char volgroup[] = "VG2";
10022     int r;
10023     suppress_error = 0;
10024     r = guestfs_lvcreate (g, logvol, volgroup, 50);
10025     if (r == -1)
10026       return -1;
10027   }
10028   {
10029     char logvol[] = "LV4";
10030     char volgroup[] = "VG2";
10031     int r;
10032     suppress_error = 0;
10033     r = guestfs_lvcreate (g, logvol, volgroup, 50);
10034     if (r == -1)
10035       return -1;
10036   }
10037   {
10038     char logvol[] = "LV5";
10039     char volgroup[] = "VG2";
10040     int r;
10041     suppress_error = 0;
10042     r = guestfs_lvcreate (g, logvol, volgroup, 50);
10043     if (r == -1)
10044       return -1;
10045   }
10046   {
10047     char **r;
10048     int i;
10049     suppress_error = 0;
10050     r = guestfs_lvs (g);
10051     if (r == NULL)
10052       return -1;
10053     if (!r[0]) {
10054       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10055       print_strings (r);
10056       return -1;
10057     }
10058     {
10059       char expected[] = "/dev/VG1/LV1";
10060       if (strcmp (r[0], expected) != 0) {
10061         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10062         return -1;
10063       }
10064     }
10065     if (!r[1]) {
10066       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10067       print_strings (r);
10068       return -1;
10069     }
10070     {
10071       char expected[] = "/dev/VG1/LV2";
10072       if (strcmp (r[1], expected) != 0) {
10073         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10074         return -1;
10075       }
10076     }
10077     if (!r[2]) {
10078       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10079       print_strings (r);
10080       return -1;
10081     }
10082     {
10083       char expected[] = "/dev/VG2/LV3";
10084       if (strcmp (r[2], expected) != 0) {
10085         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10086         return -1;
10087       }
10088     }
10089     if (!r[3]) {
10090       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10091       print_strings (r);
10092       return -1;
10093     }
10094     {
10095       char expected[] = "/dev/VG2/LV4";
10096       if (strcmp (r[3], expected) != 0) {
10097         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10098         return -1;
10099       }
10100     }
10101     if (!r[4]) {
10102       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10103       print_strings (r);
10104       return -1;
10105     }
10106     {
10107       char expected[] = "/dev/VG2/LV5";
10108       if (strcmp (r[4], expected) != 0) {
10109         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
10110         return -1;
10111       }
10112     }
10113     if (r[5] != NULL) {
10114       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
10115       print_strings (r);
10116       return -1;
10117     }
10118     for (i = 0; r[i] != NULL; ++i)
10119       free (r[i]);
10120     free (r);
10121   }
10122   return 0;
10123 }
10124
10125 static int test_vgcreate_0 (void)
10126 {
10127   /* InitNone|InitEmpty for test_vgcreate_0 */
10128   {
10129     char device[] = "/dev/sda";
10130     device[5] = devchar;
10131     int r;
10132     suppress_error = 0;
10133     r = guestfs_blockdev_setrw (g, device);
10134     if (r == -1)
10135       return -1;
10136   }
10137   {
10138     int r;
10139     suppress_error = 0;
10140     r = guestfs_umount_all (g);
10141     if (r == -1)
10142       return -1;
10143   }
10144   {
10145     int r;
10146     suppress_error = 0;
10147     r = guestfs_lvm_remove_all (g);
10148     if (r == -1)
10149       return -1;
10150   }
10151   /* TestOutputList for vgcreate (0) */
10152   {
10153     char device[] = "/dev/sda";
10154     device[5] = devchar;
10155     char lines_0[] = ",10";
10156     char lines_1[] = ",20";
10157     char lines_2[] = ",";
10158     char *lines[] = {
10159       lines_0,
10160       lines_1,
10161       lines_2,
10162       NULL
10163     };
10164     int r;
10165     suppress_error = 0;
10166     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10167     if (r == -1)
10168       return -1;
10169   }
10170   {
10171     char device[] = "/dev/sda1";
10172     device[5] = devchar;
10173     int r;
10174     suppress_error = 0;
10175     r = guestfs_pvcreate (g, device);
10176     if (r == -1)
10177       return -1;
10178   }
10179   {
10180     char device[] = "/dev/sda2";
10181     device[5] = devchar;
10182     int r;
10183     suppress_error = 0;
10184     r = guestfs_pvcreate (g, device);
10185     if (r == -1)
10186       return -1;
10187   }
10188   {
10189     char device[] = "/dev/sda3";
10190     device[5] = devchar;
10191     int r;
10192     suppress_error = 0;
10193     r = guestfs_pvcreate (g, device);
10194     if (r == -1)
10195       return -1;
10196   }
10197   {
10198     char volgroup[] = "VG1";
10199     char physvols_0[] = "/dev/sda1";
10200     physvols_0[5] = devchar;
10201     char physvols_1[] = "/dev/sda2";
10202     physvols_1[5] = devchar;
10203     char *physvols[] = {
10204       physvols_0,
10205       physvols_1,
10206       NULL
10207     };
10208     int r;
10209     suppress_error = 0;
10210     r = guestfs_vgcreate (g, volgroup, physvols);
10211     if (r == -1)
10212       return -1;
10213   }
10214   {
10215     char volgroup[] = "VG2";
10216     char physvols_0[] = "/dev/sda3";
10217     physvols_0[5] = devchar;
10218     char *physvols[] = {
10219       physvols_0,
10220       NULL
10221     };
10222     int r;
10223     suppress_error = 0;
10224     r = guestfs_vgcreate (g, volgroup, physvols);
10225     if (r == -1)
10226       return -1;
10227   }
10228   {
10229     char **r;
10230     int i;
10231     suppress_error = 0;
10232     r = guestfs_vgs (g);
10233     if (r == NULL)
10234       return -1;
10235     if (!r[0]) {
10236       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10237       print_strings (r);
10238       return -1;
10239     }
10240     {
10241       char expected[] = "VG1";
10242       if (strcmp (r[0], expected) != 0) {
10243         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10244         return -1;
10245       }
10246     }
10247     if (!r[1]) {
10248       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10249       print_strings (r);
10250       return -1;
10251     }
10252     {
10253       char expected[] = "VG2";
10254       if (strcmp (r[1], expected) != 0) {
10255         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10256         return -1;
10257       }
10258     }
10259     if (r[2] != NULL) {
10260       fprintf (stderr, "test_vgcreate_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_pvcreate_0 (void)
10272 {
10273   /* InitNone|InitEmpty for test_pvcreate_0 */
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   /* TestOutputList for pvcreate (0) */
10298   {
10299     char device[] = "/dev/sda";
10300     device[5] = devchar;
10301     char lines_0[] = ",10";
10302     char lines_1[] = ",20";
10303     char lines_2[] = ",";
10304     char *lines[] = {
10305       lines_0,
10306       lines_1,
10307       lines_2,
10308       NULL
10309     };
10310     int r;
10311     suppress_error = 0;
10312     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10313     if (r == -1)
10314       return -1;
10315   }
10316   {
10317     char device[] = "/dev/sda1";
10318     device[5] = devchar;
10319     int r;
10320     suppress_error = 0;
10321     r = guestfs_pvcreate (g, device);
10322     if (r == -1)
10323       return -1;
10324   }
10325   {
10326     char device[] = "/dev/sda2";
10327     device[5] = devchar;
10328     int r;
10329     suppress_error = 0;
10330     r = guestfs_pvcreate (g, device);
10331     if (r == -1)
10332       return -1;
10333   }
10334   {
10335     char device[] = "/dev/sda3";
10336     device[5] = devchar;
10337     int r;
10338     suppress_error = 0;
10339     r = guestfs_pvcreate (g, device);
10340     if (r == -1)
10341       return -1;
10342   }
10343   {
10344     char **r;
10345     int i;
10346     suppress_error = 0;
10347     r = guestfs_pvs (g);
10348     if (r == NULL)
10349       return -1;
10350     if (!r[0]) {
10351       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10352       print_strings (r);
10353       return -1;
10354     }
10355     {
10356       char expected[] = "/dev/sda1";
10357       expected[5] = devchar;
10358       if (strcmp (r[0], expected) != 0) {
10359         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10360         return -1;
10361       }
10362     }
10363     if (!r[1]) {
10364       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10365       print_strings (r);
10366       return -1;
10367     }
10368     {
10369       char expected[] = "/dev/sda2";
10370       expected[5] = devchar;
10371       if (strcmp (r[1], expected) != 0) {
10372         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10373         return -1;
10374       }
10375     }
10376     if (!r[2]) {
10377       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10378       print_strings (r);
10379       return -1;
10380     }
10381     {
10382       char expected[] = "/dev/sda3";
10383       expected[5] = devchar;
10384       if (strcmp (r[2], expected) != 0) {
10385         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10386         return -1;
10387       }
10388     }
10389     if (r[3] != NULL) {
10390       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
10391       print_strings (r);
10392       return -1;
10393     }
10394     for (i = 0; r[i] != NULL; ++i)
10395       free (r[i]);
10396     free (r);
10397   }
10398   return 0;
10399 }
10400
10401 static int test_is_dir_0 (void)
10402 {
10403   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
10404   {
10405     char device[] = "/dev/sda";
10406     device[5] = devchar;
10407     int r;
10408     suppress_error = 0;
10409     r = guestfs_blockdev_setrw (g, device);
10410     if (r == -1)
10411       return -1;
10412   }
10413   {
10414     int r;
10415     suppress_error = 0;
10416     r = guestfs_umount_all (g);
10417     if (r == -1)
10418       return -1;
10419   }
10420   {
10421     int r;
10422     suppress_error = 0;
10423     r = guestfs_lvm_remove_all (g);
10424     if (r == -1)
10425       return -1;
10426   }
10427   {
10428     char device[] = "/dev/sda";
10429     device[5] = devchar;
10430     char lines_0[] = ",";
10431     char *lines[] = {
10432       lines_0,
10433       NULL
10434     };
10435     int r;
10436     suppress_error = 0;
10437     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10438     if (r == -1)
10439       return -1;
10440   }
10441   {
10442     char fstype[] = "ext2";
10443     char device[] = "/dev/sda1";
10444     device[5] = devchar;
10445     int r;
10446     suppress_error = 0;
10447     r = guestfs_mkfs (g, fstype, device);
10448     if (r == -1)
10449       return -1;
10450   }
10451   {
10452     char device[] = "/dev/sda1";
10453     device[5] = devchar;
10454     char mountpoint[] = "/";
10455     int r;
10456     suppress_error = 0;
10457     r = guestfs_mount (g, device, mountpoint);
10458     if (r == -1)
10459       return -1;
10460   }
10461   /* TestOutputFalse for is_dir (0) */
10462   {
10463     char path[] = "/new";
10464     int r;
10465     suppress_error = 0;
10466     r = guestfs_touch (g, path);
10467     if (r == -1)
10468       return -1;
10469   }
10470   {
10471     char path[] = "/new";
10472     int r;
10473     suppress_error = 0;
10474     r = guestfs_is_dir (g, path);
10475     if (r == -1)
10476       return -1;
10477     if (r) {
10478       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
10479       return -1;
10480     }
10481   }
10482   return 0;
10483 }
10484
10485 static int test_is_dir_1 (void)
10486 {
10487   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
10488   {
10489     char device[] = "/dev/sda";
10490     device[5] = devchar;
10491     int r;
10492     suppress_error = 0;
10493     r = guestfs_blockdev_setrw (g, device);
10494     if (r == -1)
10495       return -1;
10496   }
10497   {
10498     int r;
10499     suppress_error = 0;
10500     r = guestfs_umount_all (g);
10501     if (r == -1)
10502       return -1;
10503   }
10504   {
10505     int r;
10506     suppress_error = 0;
10507     r = guestfs_lvm_remove_all (g);
10508     if (r == -1)
10509       return -1;
10510   }
10511   {
10512     char device[] = "/dev/sda";
10513     device[5] = devchar;
10514     char lines_0[] = ",";
10515     char *lines[] = {
10516       lines_0,
10517       NULL
10518     };
10519     int r;
10520     suppress_error = 0;
10521     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10522     if (r == -1)
10523       return -1;
10524   }
10525   {
10526     char fstype[] = "ext2";
10527     char device[] = "/dev/sda1";
10528     device[5] = devchar;
10529     int r;
10530     suppress_error = 0;
10531     r = guestfs_mkfs (g, fstype, device);
10532     if (r == -1)
10533       return -1;
10534   }
10535   {
10536     char device[] = "/dev/sda1";
10537     device[5] = devchar;
10538     char mountpoint[] = "/";
10539     int r;
10540     suppress_error = 0;
10541     r = guestfs_mount (g, device, mountpoint);
10542     if (r == -1)
10543       return -1;
10544   }
10545   /* TestOutputTrue for is_dir (1) */
10546   {
10547     char path[] = "/new";
10548     int r;
10549     suppress_error = 0;
10550     r = guestfs_mkdir (g, path);
10551     if (r == -1)
10552       return -1;
10553   }
10554   {
10555     char path[] = "/new";
10556     int r;
10557     suppress_error = 0;
10558     r = guestfs_is_dir (g, path);
10559     if (r == -1)
10560       return -1;
10561     if (!r) {
10562       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
10563       return -1;
10564     }
10565   }
10566   return 0;
10567 }
10568
10569 static int test_is_file_0 (void)
10570 {
10571   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
10572   {
10573     char device[] = "/dev/sda";
10574     device[5] = devchar;
10575     int r;
10576     suppress_error = 0;
10577     r = guestfs_blockdev_setrw (g, device);
10578     if (r == -1)
10579       return -1;
10580   }
10581   {
10582     int r;
10583     suppress_error = 0;
10584     r = guestfs_umount_all (g);
10585     if (r == -1)
10586       return -1;
10587   }
10588   {
10589     int r;
10590     suppress_error = 0;
10591     r = guestfs_lvm_remove_all (g);
10592     if (r == -1)
10593       return -1;
10594   }
10595   {
10596     char device[] = "/dev/sda";
10597     device[5] = devchar;
10598     char lines_0[] = ",";
10599     char *lines[] = {
10600       lines_0,
10601       NULL
10602     };
10603     int r;
10604     suppress_error = 0;
10605     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10606     if (r == -1)
10607       return -1;
10608   }
10609   {
10610     char fstype[] = "ext2";
10611     char device[] = "/dev/sda1";
10612     device[5] = devchar;
10613     int r;
10614     suppress_error = 0;
10615     r = guestfs_mkfs (g, fstype, device);
10616     if (r == -1)
10617       return -1;
10618   }
10619   {
10620     char device[] = "/dev/sda1";
10621     device[5] = devchar;
10622     char mountpoint[] = "/";
10623     int r;
10624     suppress_error = 0;
10625     r = guestfs_mount (g, device, mountpoint);
10626     if (r == -1)
10627       return -1;
10628   }
10629   /* TestOutputTrue for is_file (0) */
10630   {
10631     char path[] = "/new";
10632     int r;
10633     suppress_error = 0;
10634     r = guestfs_touch (g, path);
10635     if (r == -1)
10636       return -1;
10637   }
10638   {
10639     char path[] = "/new";
10640     int r;
10641     suppress_error = 0;
10642     r = guestfs_is_file (g, path);
10643     if (r == -1)
10644       return -1;
10645     if (!r) {
10646       fprintf (stderr, "test_is_file_0: expected true, got false\n");
10647       return -1;
10648     }
10649   }
10650   return 0;
10651 }
10652
10653 static int test_is_file_1 (void)
10654 {
10655   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
10656   {
10657     char device[] = "/dev/sda";
10658     device[5] = devchar;
10659     int r;
10660     suppress_error = 0;
10661     r = guestfs_blockdev_setrw (g, device);
10662     if (r == -1)
10663       return -1;
10664   }
10665   {
10666     int r;
10667     suppress_error = 0;
10668     r = guestfs_umount_all (g);
10669     if (r == -1)
10670       return -1;
10671   }
10672   {
10673     int r;
10674     suppress_error = 0;
10675     r = guestfs_lvm_remove_all (g);
10676     if (r == -1)
10677       return -1;
10678   }
10679   {
10680     char device[] = "/dev/sda";
10681     device[5] = devchar;
10682     char lines_0[] = ",";
10683     char *lines[] = {
10684       lines_0,
10685       NULL
10686     };
10687     int r;
10688     suppress_error = 0;
10689     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10690     if (r == -1)
10691       return -1;
10692   }
10693   {
10694     char fstype[] = "ext2";
10695     char device[] = "/dev/sda1";
10696     device[5] = devchar;
10697     int r;
10698     suppress_error = 0;
10699     r = guestfs_mkfs (g, fstype, device);
10700     if (r == -1)
10701       return -1;
10702   }
10703   {
10704     char device[] = "/dev/sda1";
10705     device[5] = devchar;
10706     char mountpoint[] = "/";
10707     int r;
10708     suppress_error = 0;
10709     r = guestfs_mount (g, device, mountpoint);
10710     if (r == -1)
10711       return -1;
10712   }
10713   /* TestOutputFalse for is_file (1) */
10714   {
10715     char path[] = "/new";
10716     int r;
10717     suppress_error = 0;
10718     r = guestfs_mkdir (g, path);
10719     if (r == -1)
10720       return -1;
10721   }
10722   {
10723     char path[] = "/new";
10724     int r;
10725     suppress_error = 0;
10726     r = guestfs_is_file (g, path);
10727     if (r == -1)
10728       return -1;
10729     if (r) {
10730       fprintf (stderr, "test_is_file_1: expected false, got true\n");
10731       return -1;
10732     }
10733   }
10734   return 0;
10735 }
10736
10737 static int test_exists_0 (void)
10738 {
10739   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
10740   {
10741     char device[] = "/dev/sda";
10742     device[5] = devchar;
10743     int r;
10744     suppress_error = 0;
10745     r = guestfs_blockdev_setrw (g, device);
10746     if (r == -1)
10747       return -1;
10748   }
10749   {
10750     int r;
10751     suppress_error = 0;
10752     r = guestfs_umount_all (g);
10753     if (r == -1)
10754       return -1;
10755   }
10756   {
10757     int r;
10758     suppress_error = 0;
10759     r = guestfs_lvm_remove_all (g);
10760     if (r == -1)
10761       return -1;
10762   }
10763   {
10764     char device[] = "/dev/sda";
10765     device[5] = devchar;
10766     char lines_0[] = ",";
10767     char *lines[] = {
10768       lines_0,
10769       NULL
10770     };
10771     int r;
10772     suppress_error = 0;
10773     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10774     if (r == -1)
10775       return -1;
10776   }
10777   {
10778     char fstype[] = "ext2";
10779     char device[] = "/dev/sda1";
10780     device[5] = devchar;
10781     int r;
10782     suppress_error = 0;
10783     r = guestfs_mkfs (g, fstype, device);
10784     if (r == -1)
10785       return -1;
10786   }
10787   {
10788     char device[] = "/dev/sda1";
10789     device[5] = devchar;
10790     char mountpoint[] = "/";
10791     int r;
10792     suppress_error = 0;
10793     r = guestfs_mount (g, device, mountpoint);
10794     if (r == -1)
10795       return -1;
10796   }
10797   /* TestOutputTrue for exists (0) */
10798   {
10799     char path[] = "/new";
10800     int r;
10801     suppress_error = 0;
10802     r = guestfs_touch (g, path);
10803     if (r == -1)
10804       return -1;
10805   }
10806   {
10807     char path[] = "/new";
10808     int r;
10809     suppress_error = 0;
10810     r = guestfs_exists (g, path);
10811     if (r == -1)
10812       return -1;
10813     if (!r) {
10814       fprintf (stderr, "test_exists_0: expected true, got false\n");
10815       return -1;
10816     }
10817   }
10818   return 0;
10819 }
10820
10821 static int test_exists_1 (void)
10822 {
10823   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
10824   {
10825     char device[] = "/dev/sda";
10826     device[5] = devchar;
10827     int r;
10828     suppress_error = 0;
10829     r = guestfs_blockdev_setrw (g, device);
10830     if (r == -1)
10831       return -1;
10832   }
10833   {
10834     int r;
10835     suppress_error = 0;
10836     r = guestfs_umount_all (g);
10837     if (r == -1)
10838       return -1;
10839   }
10840   {
10841     int r;
10842     suppress_error = 0;
10843     r = guestfs_lvm_remove_all (g);
10844     if (r == -1)
10845       return -1;
10846   }
10847   {
10848     char device[] = "/dev/sda";
10849     device[5] = devchar;
10850     char lines_0[] = ",";
10851     char *lines[] = {
10852       lines_0,
10853       NULL
10854     };
10855     int r;
10856     suppress_error = 0;
10857     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10858     if (r == -1)
10859       return -1;
10860   }
10861   {
10862     char fstype[] = "ext2";
10863     char device[] = "/dev/sda1";
10864     device[5] = devchar;
10865     int r;
10866     suppress_error = 0;
10867     r = guestfs_mkfs (g, fstype, device);
10868     if (r == -1)
10869       return -1;
10870   }
10871   {
10872     char device[] = "/dev/sda1";
10873     device[5] = devchar;
10874     char mountpoint[] = "/";
10875     int r;
10876     suppress_error = 0;
10877     r = guestfs_mount (g, device, mountpoint);
10878     if (r == -1)
10879       return -1;
10880   }
10881   /* TestOutputTrue for exists (1) */
10882   {
10883     char path[] = "/new";
10884     int r;
10885     suppress_error = 0;
10886     r = guestfs_mkdir (g, path);
10887     if (r == -1)
10888       return -1;
10889   }
10890   {
10891     char path[] = "/new";
10892     int r;
10893     suppress_error = 0;
10894     r = guestfs_exists (g, path);
10895     if (r == -1)
10896       return -1;
10897     if (!r) {
10898       fprintf (stderr, "test_exists_1: expected true, got false\n");
10899       return -1;
10900     }
10901   }
10902   return 0;
10903 }
10904
10905 static int test_mkdir_p_0 (void)
10906 {
10907   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
10908   {
10909     char device[] = "/dev/sda";
10910     device[5] = devchar;
10911     int r;
10912     suppress_error = 0;
10913     r = guestfs_blockdev_setrw (g, device);
10914     if (r == -1)
10915       return -1;
10916   }
10917   {
10918     int r;
10919     suppress_error = 0;
10920     r = guestfs_umount_all (g);
10921     if (r == -1)
10922       return -1;
10923   }
10924   {
10925     int r;
10926     suppress_error = 0;
10927     r = guestfs_lvm_remove_all (g);
10928     if (r == -1)
10929       return -1;
10930   }
10931   {
10932     char device[] = "/dev/sda";
10933     device[5] = devchar;
10934     char lines_0[] = ",";
10935     char *lines[] = {
10936       lines_0,
10937       NULL
10938     };
10939     int r;
10940     suppress_error = 0;
10941     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10942     if (r == -1)
10943       return -1;
10944   }
10945   {
10946     char fstype[] = "ext2";
10947     char device[] = "/dev/sda1";
10948     device[5] = devchar;
10949     int r;
10950     suppress_error = 0;
10951     r = guestfs_mkfs (g, fstype, device);
10952     if (r == -1)
10953       return -1;
10954   }
10955   {
10956     char device[] = "/dev/sda1";
10957     device[5] = devchar;
10958     char mountpoint[] = "/";
10959     int r;
10960     suppress_error = 0;
10961     r = guestfs_mount (g, device, mountpoint);
10962     if (r == -1)
10963       return -1;
10964   }
10965   /* TestOutputTrue for mkdir_p (0) */
10966   {
10967     char path[] = "/new/foo/bar";
10968     int r;
10969     suppress_error = 0;
10970     r = guestfs_mkdir_p (g, path);
10971     if (r == -1)
10972       return -1;
10973   }
10974   {
10975     char path[] = "/new/foo/bar";
10976     int r;
10977     suppress_error = 0;
10978     r = guestfs_is_dir (g, path);
10979     if (r == -1)
10980       return -1;
10981     if (!r) {
10982       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10983       return -1;
10984     }
10985   }
10986   return 0;
10987 }
10988
10989 static int test_mkdir_p_1 (void)
10990 {
10991   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
10992   {
10993     char device[] = "/dev/sda";
10994     device[5] = devchar;
10995     int r;
10996     suppress_error = 0;
10997     r = guestfs_blockdev_setrw (g, device);
10998     if (r == -1)
10999       return -1;
11000   }
11001   {
11002     int r;
11003     suppress_error = 0;
11004     r = guestfs_umount_all (g);
11005     if (r == -1)
11006       return -1;
11007   }
11008   {
11009     int r;
11010     suppress_error = 0;
11011     r = guestfs_lvm_remove_all (g);
11012     if (r == -1)
11013       return -1;
11014   }
11015   {
11016     char device[] = "/dev/sda";
11017     device[5] = devchar;
11018     char lines_0[] = ",";
11019     char *lines[] = {
11020       lines_0,
11021       NULL
11022     };
11023     int r;
11024     suppress_error = 0;
11025     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11026     if (r == -1)
11027       return -1;
11028   }
11029   {
11030     char fstype[] = "ext2";
11031     char device[] = "/dev/sda1";
11032     device[5] = devchar;
11033     int r;
11034     suppress_error = 0;
11035     r = guestfs_mkfs (g, fstype, device);
11036     if (r == -1)
11037       return -1;
11038   }
11039   {
11040     char device[] = "/dev/sda1";
11041     device[5] = devchar;
11042     char mountpoint[] = "/";
11043     int r;
11044     suppress_error = 0;
11045     r = guestfs_mount (g, device, mountpoint);
11046     if (r == -1)
11047       return -1;
11048   }
11049   /* TestOutputTrue for mkdir_p (1) */
11050   {
11051     char path[] = "/new/foo/bar";
11052     int r;
11053     suppress_error = 0;
11054     r = guestfs_mkdir_p (g, path);
11055     if (r == -1)
11056       return -1;
11057   }
11058   {
11059     char path[] = "/new/foo";
11060     int r;
11061     suppress_error = 0;
11062     r = guestfs_is_dir (g, path);
11063     if (r == -1)
11064       return -1;
11065     if (!r) {
11066       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
11067       return -1;
11068     }
11069   }
11070   return 0;
11071 }
11072
11073 static int test_mkdir_p_2 (void)
11074 {
11075   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
11076   {
11077     char device[] = "/dev/sda";
11078     device[5] = devchar;
11079     int r;
11080     suppress_error = 0;
11081     r = guestfs_blockdev_setrw (g, device);
11082     if (r == -1)
11083       return -1;
11084   }
11085   {
11086     int r;
11087     suppress_error = 0;
11088     r = guestfs_umount_all (g);
11089     if (r == -1)
11090       return -1;
11091   }
11092   {
11093     int r;
11094     suppress_error = 0;
11095     r = guestfs_lvm_remove_all (g);
11096     if (r == -1)
11097       return -1;
11098   }
11099   {
11100     char device[] = "/dev/sda";
11101     device[5] = devchar;
11102     char lines_0[] = ",";
11103     char *lines[] = {
11104       lines_0,
11105       NULL
11106     };
11107     int r;
11108     suppress_error = 0;
11109     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11110     if (r == -1)
11111       return -1;
11112   }
11113   {
11114     char fstype[] = "ext2";
11115     char device[] = "/dev/sda1";
11116     device[5] = devchar;
11117     int r;
11118     suppress_error = 0;
11119     r = guestfs_mkfs (g, fstype, device);
11120     if (r == -1)
11121       return -1;
11122   }
11123   {
11124     char device[] = "/dev/sda1";
11125     device[5] = devchar;
11126     char mountpoint[] = "/";
11127     int r;
11128     suppress_error = 0;
11129     r = guestfs_mount (g, device, mountpoint);
11130     if (r == -1)
11131       return -1;
11132   }
11133   /* TestOutputTrue for mkdir_p (2) */
11134   {
11135     char path[] = "/new/foo/bar";
11136     int r;
11137     suppress_error = 0;
11138     r = guestfs_mkdir_p (g, path);
11139     if (r == -1)
11140       return -1;
11141   }
11142   {
11143     char path[] = "/new";
11144     int r;
11145     suppress_error = 0;
11146     r = guestfs_is_dir (g, path);
11147     if (r == -1)
11148       return -1;
11149     if (!r) {
11150       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
11151       return -1;
11152     }
11153   }
11154   return 0;
11155 }
11156
11157 static int test_mkdir_0 (void)
11158 {
11159   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
11160   {
11161     char device[] = "/dev/sda";
11162     device[5] = devchar;
11163     int r;
11164     suppress_error = 0;
11165     r = guestfs_blockdev_setrw (g, device);
11166     if (r == -1)
11167       return -1;
11168   }
11169   {
11170     int r;
11171     suppress_error = 0;
11172     r = guestfs_umount_all (g);
11173     if (r == -1)
11174       return -1;
11175   }
11176   {
11177     int r;
11178     suppress_error = 0;
11179     r = guestfs_lvm_remove_all (g);
11180     if (r == -1)
11181       return -1;
11182   }
11183   {
11184     char device[] = "/dev/sda";
11185     device[5] = devchar;
11186     char lines_0[] = ",";
11187     char *lines[] = {
11188       lines_0,
11189       NULL
11190     };
11191     int r;
11192     suppress_error = 0;
11193     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11194     if (r == -1)
11195       return -1;
11196   }
11197   {
11198     char fstype[] = "ext2";
11199     char device[] = "/dev/sda1";
11200     device[5] = devchar;
11201     int r;
11202     suppress_error = 0;
11203     r = guestfs_mkfs (g, fstype, device);
11204     if (r == -1)
11205       return -1;
11206   }
11207   {
11208     char device[] = "/dev/sda1";
11209     device[5] = devchar;
11210     char mountpoint[] = "/";
11211     int r;
11212     suppress_error = 0;
11213     r = guestfs_mount (g, device, mountpoint);
11214     if (r == -1)
11215       return -1;
11216   }
11217   /* TestOutputTrue for mkdir (0) */
11218   {
11219     char path[] = "/new";
11220     int r;
11221     suppress_error = 0;
11222     r = guestfs_mkdir (g, path);
11223     if (r == -1)
11224       return -1;
11225   }
11226   {
11227     char path[] = "/new";
11228     int r;
11229     suppress_error = 0;
11230     r = guestfs_is_dir (g, path);
11231     if (r == -1)
11232       return -1;
11233     if (!r) {
11234       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
11235       return -1;
11236     }
11237   }
11238   return 0;
11239 }
11240
11241 static int test_mkdir_1 (void)
11242 {
11243   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
11244   {
11245     char device[] = "/dev/sda";
11246     device[5] = devchar;
11247     int r;
11248     suppress_error = 0;
11249     r = guestfs_blockdev_setrw (g, device);
11250     if (r == -1)
11251       return -1;
11252   }
11253   {
11254     int r;
11255     suppress_error = 0;
11256     r = guestfs_umount_all (g);
11257     if (r == -1)
11258       return -1;
11259   }
11260   {
11261     int r;
11262     suppress_error = 0;
11263     r = guestfs_lvm_remove_all (g);
11264     if (r == -1)
11265       return -1;
11266   }
11267   {
11268     char device[] = "/dev/sda";
11269     device[5] = devchar;
11270     char lines_0[] = ",";
11271     char *lines[] = {
11272       lines_0,
11273       NULL
11274     };
11275     int r;
11276     suppress_error = 0;
11277     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11278     if (r == -1)
11279       return -1;
11280   }
11281   {
11282     char fstype[] = "ext2";
11283     char device[] = "/dev/sda1";
11284     device[5] = devchar;
11285     int r;
11286     suppress_error = 0;
11287     r = guestfs_mkfs (g, fstype, device);
11288     if (r == -1)
11289       return -1;
11290   }
11291   {
11292     char device[] = "/dev/sda1";
11293     device[5] = devchar;
11294     char mountpoint[] = "/";
11295     int r;
11296     suppress_error = 0;
11297     r = guestfs_mount (g, device, mountpoint);
11298     if (r == -1)
11299       return -1;
11300   }
11301   /* TestLastFail for mkdir (1) */
11302   {
11303     char path[] = "/new/foo/bar";
11304     int r;
11305     suppress_error = 1;
11306     r = guestfs_mkdir (g, path);
11307     if (r != -1)
11308       return -1;
11309   }
11310   return 0;
11311 }
11312
11313 static int test_rm_rf_0 (void)
11314 {
11315   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
11316   {
11317     char device[] = "/dev/sda";
11318     device[5] = devchar;
11319     int r;
11320     suppress_error = 0;
11321     r = guestfs_blockdev_setrw (g, device);
11322     if (r == -1)
11323       return -1;
11324   }
11325   {
11326     int r;
11327     suppress_error = 0;
11328     r = guestfs_umount_all (g);
11329     if (r == -1)
11330       return -1;
11331   }
11332   {
11333     int r;
11334     suppress_error = 0;
11335     r = guestfs_lvm_remove_all (g);
11336     if (r == -1)
11337       return -1;
11338   }
11339   {
11340     char device[] = "/dev/sda";
11341     device[5] = devchar;
11342     char lines_0[] = ",";
11343     char *lines[] = {
11344       lines_0,
11345       NULL
11346     };
11347     int r;
11348     suppress_error = 0;
11349     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11350     if (r == -1)
11351       return -1;
11352   }
11353   {
11354     char fstype[] = "ext2";
11355     char device[] = "/dev/sda1";
11356     device[5] = devchar;
11357     int r;
11358     suppress_error = 0;
11359     r = guestfs_mkfs (g, fstype, device);
11360     if (r == -1)
11361       return -1;
11362   }
11363   {
11364     char device[] = "/dev/sda1";
11365     device[5] = devchar;
11366     char mountpoint[] = "/";
11367     int r;
11368     suppress_error = 0;
11369     r = guestfs_mount (g, device, mountpoint);
11370     if (r == -1)
11371       return -1;
11372   }
11373   /* TestOutputFalse for rm_rf (0) */
11374   {
11375     char path[] = "/new";
11376     int r;
11377     suppress_error = 0;
11378     r = guestfs_mkdir (g, path);
11379     if (r == -1)
11380       return -1;
11381   }
11382   {
11383     char path[] = "/new/foo";
11384     int r;
11385     suppress_error = 0;
11386     r = guestfs_mkdir (g, path);
11387     if (r == -1)
11388       return -1;
11389   }
11390   {
11391     char path[] = "/new/foo/bar";
11392     int r;
11393     suppress_error = 0;
11394     r = guestfs_touch (g, path);
11395     if (r == -1)
11396       return -1;
11397   }
11398   {
11399     char path[] = "/new";
11400     int r;
11401     suppress_error = 0;
11402     r = guestfs_rm_rf (g, path);
11403     if (r == -1)
11404       return -1;
11405   }
11406   {
11407     char path[] = "/new";
11408     int r;
11409     suppress_error = 0;
11410     r = guestfs_exists (g, path);
11411     if (r == -1)
11412       return -1;
11413     if (r) {
11414       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
11415       return -1;
11416     }
11417   }
11418   return 0;
11419 }
11420
11421 static int test_rmdir_0 (void)
11422 {
11423   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
11424   {
11425     char device[] = "/dev/sda";
11426     device[5] = devchar;
11427     int r;
11428     suppress_error = 0;
11429     r = guestfs_blockdev_setrw (g, device);
11430     if (r == -1)
11431       return -1;
11432   }
11433   {
11434     int r;
11435     suppress_error = 0;
11436     r = guestfs_umount_all (g);
11437     if (r == -1)
11438       return -1;
11439   }
11440   {
11441     int r;
11442     suppress_error = 0;
11443     r = guestfs_lvm_remove_all (g);
11444     if (r == -1)
11445       return -1;
11446   }
11447   {
11448     char device[] = "/dev/sda";
11449     device[5] = devchar;
11450     char lines_0[] = ",";
11451     char *lines[] = {
11452       lines_0,
11453       NULL
11454     };
11455     int r;
11456     suppress_error = 0;
11457     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11458     if (r == -1)
11459       return -1;
11460   }
11461   {
11462     char fstype[] = "ext2";
11463     char device[] = "/dev/sda1";
11464     device[5] = devchar;
11465     int r;
11466     suppress_error = 0;
11467     r = guestfs_mkfs (g, fstype, device);
11468     if (r == -1)
11469       return -1;
11470   }
11471   {
11472     char device[] = "/dev/sda1";
11473     device[5] = devchar;
11474     char mountpoint[] = "/";
11475     int r;
11476     suppress_error = 0;
11477     r = guestfs_mount (g, device, mountpoint);
11478     if (r == -1)
11479       return -1;
11480   }
11481   /* TestRun for rmdir (0) */
11482   {
11483     char path[] = "/new";
11484     int r;
11485     suppress_error = 0;
11486     r = guestfs_mkdir (g, path);
11487     if (r == -1)
11488       return -1;
11489   }
11490   {
11491     char path[] = "/new";
11492     int r;
11493     suppress_error = 0;
11494     r = guestfs_rmdir (g, path);
11495     if (r == -1)
11496       return -1;
11497   }
11498   return 0;
11499 }
11500
11501 static int test_rmdir_1 (void)
11502 {
11503   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
11504   {
11505     char device[] = "/dev/sda";
11506     device[5] = devchar;
11507     int r;
11508     suppress_error = 0;
11509     r = guestfs_blockdev_setrw (g, device);
11510     if (r == -1)
11511       return -1;
11512   }
11513   {
11514     int r;
11515     suppress_error = 0;
11516     r = guestfs_umount_all (g);
11517     if (r == -1)
11518       return -1;
11519   }
11520   {
11521     int r;
11522     suppress_error = 0;
11523     r = guestfs_lvm_remove_all (g);
11524     if (r == -1)
11525       return -1;
11526   }
11527   {
11528     char device[] = "/dev/sda";
11529     device[5] = devchar;
11530     char lines_0[] = ",";
11531     char *lines[] = {
11532       lines_0,
11533       NULL
11534     };
11535     int r;
11536     suppress_error = 0;
11537     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11538     if (r == -1)
11539       return -1;
11540   }
11541   {
11542     char fstype[] = "ext2";
11543     char device[] = "/dev/sda1";
11544     device[5] = devchar;
11545     int r;
11546     suppress_error = 0;
11547     r = guestfs_mkfs (g, fstype, device);
11548     if (r == -1)
11549       return -1;
11550   }
11551   {
11552     char device[] = "/dev/sda1";
11553     device[5] = devchar;
11554     char mountpoint[] = "/";
11555     int r;
11556     suppress_error = 0;
11557     r = guestfs_mount (g, device, mountpoint);
11558     if (r == -1)
11559       return -1;
11560   }
11561   /* TestLastFail for rmdir (1) */
11562   {
11563     char path[] = "/new";
11564     int r;
11565     suppress_error = 1;
11566     r = guestfs_rmdir (g, path);
11567     if (r != -1)
11568       return -1;
11569   }
11570   return 0;
11571 }
11572
11573 static int test_rmdir_2 (void)
11574 {
11575   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
11576   {
11577     char device[] = "/dev/sda";
11578     device[5] = devchar;
11579     int r;
11580     suppress_error = 0;
11581     r = guestfs_blockdev_setrw (g, device);
11582     if (r == -1)
11583       return -1;
11584   }
11585   {
11586     int r;
11587     suppress_error = 0;
11588     r = guestfs_umount_all (g);
11589     if (r == -1)
11590       return -1;
11591   }
11592   {
11593     int r;
11594     suppress_error = 0;
11595     r = guestfs_lvm_remove_all (g);
11596     if (r == -1)
11597       return -1;
11598   }
11599   {
11600     char device[] = "/dev/sda";
11601     device[5] = devchar;
11602     char lines_0[] = ",";
11603     char *lines[] = {
11604       lines_0,
11605       NULL
11606     };
11607     int r;
11608     suppress_error = 0;
11609     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11610     if (r == -1)
11611       return -1;
11612   }
11613   {
11614     char fstype[] = "ext2";
11615     char device[] = "/dev/sda1";
11616     device[5] = devchar;
11617     int r;
11618     suppress_error = 0;
11619     r = guestfs_mkfs (g, fstype, device);
11620     if (r == -1)
11621       return -1;
11622   }
11623   {
11624     char device[] = "/dev/sda1";
11625     device[5] = devchar;
11626     char mountpoint[] = "/";
11627     int r;
11628     suppress_error = 0;
11629     r = guestfs_mount (g, device, mountpoint);
11630     if (r == -1)
11631       return -1;
11632   }
11633   /* TestLastFail for rmdir (2) */
11634   {
11635     char path[] = "/new";
11636     int r;
11637     suppress_error = 0;
11638     r = guestfs_touch (g, path);
11639     if (r == -1)
11640       return -1;
11641   }
11642   {
11643     char path[] = "/new";
11644     int r;
11645     suppress_error = 1;
11646     r = guestfs_rmdir (g, path);
11647     if (r != -1)
11648       return -1;
11649   }
11650   return 0;
11651 }
11652
11653 static int test_rm_0 (void)
11654 {
11655   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
11656   {
11657     char device[] = "/dev/sda";
11658     device[5] = devchar;
11659     int r;
11660     suppress_error = 0;
11661     r = guestfs_blockdev_setrw (g, device);
11662     if (r == -1)
11663       return -1;
11664   }
11665   {
11666     int r;
11667     suppress_error = 0;
11668     r = guestfs_umount_all (g);
11669     if (r == -1)
11670       return -1;
11671   }
11672   {
11673     int r;
11674     suppress_error = 0;
11675     r = guestfs_lvm_remove_all (g);
11676     if (r == -1)
11677       return -1;
11678   }
11679   {
11680     char device[] = "/dev/sda";
11681     device[5] = devchar;
11682     char lines_0[] = ",";
11683     char *lines[] = {
11684       lines_0,
11685       NULL
11686     };
11687     int r;
11688     suppress_error = 0;
11689     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11690     if (r == -1)
11691       return -1;
11692   }
11693   {
11694     char fstype[] = "ext2";
11695     char device[] = "/dev/sda1";
11696     device[5] = devchar;
11697     int r;
11698     suppress_error = 0;
11699     r = guestfs_mkfs (g, fstype, device);
11700     if (r == -1)
11701       return -1;
11702   }
11703   {
11704     char device[] = "/dev/sda1";
11705     device[5] = devchar;
11706     char mountpoint[] = "/";
11707     int r;
11708     suppress_error = 0;
11709     r = guestfs_mount (g, device, mountpoint);
11710     if (r == -1)
11711       return -1;
11712   }
11713   /* TestRun for rm (0) */
11714   {
11715     char path[] = "/new";
11716     int r;
11717     suppress_error = 0;
11718     r = guestfs_touch (g, path);
11719     if (r == -1)
11720       return -1;
11721   }
11722   {
11723     char path[] = "/new";
11724     int r;
11725     suppress_error = 0;
11726     r = guestfs_rm (g, path);
11727     if (r == -1)
11728       return -1;
11729   }
11730   return 0;
11731 }
11732
11733 static int test_rm_1 (void)
11734 {
11735   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
11736   {
11737     char device[] = "/dev/sda";
11738     device[5] = devchar;
11739     int r;
11740     suppress_error = 0;
11741     r = guestfs_blockdev_setrw (g, device);
11742     if (r == -1)
11743       return -1;
11744   }
11745   {
11746     int r;
11747     suppress_error = 0;
11748     r = guestfs_umount_all (g);
11749     if (r == -1)
11750       return -1;
11751   }
11752   {
11753     int r;
11754     suppress_error = 0;
11755     r = guestfs_lvm_remove_all (g);
11756     if (r == -1)
11757       return -1;
11758   }
11759   {
11760     char device[] = "/dev/sda";
11761     device[5] = devchar;
11762     char lines_0[] = ",";
11763     char *lines[] = {
11764       lines_0,
11765       NULL
11766     };
11767     int r;
11768     suppress_error = 0;
11769     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11770     if (r == -1)
11771       return -1;
11772   }
11773   {
11774     char fstype[] = "ext2";
11775     char device[] = "/dev/sda1";
11776     device[5] = devchar;
11777     int r;
11778     suppress_error = 0;
11779     r = guestfs_mkfs (g, fstype, device);
11780     if (r == -1)
11781       return -1;
11782   }
11783   {
11784     char device[] = "/dev/sda1";
11785     device[5] = devchar;
11786     char mountpoint[] = "/";
11787     int r;
11788     suppress_error = 0;
11789     r = guestfs_mount (g, device, mountpoint);
11790     if (r == -1)
11791       return -1;
11792   }
11793   /* TestLastFail for rm (1) */
11794   {
11795     char path[] = "/new";
11796     int r;
11797     suppress_error = 1;
11798     r = guestfs_rm (g, path);
11799     if (r != -1)
11800       return -1;
11801   }
11802   return 0;
11803 }
11804
11805 static int test_rm_2 (void)
11806 {
11807   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
11808   {
11809     char device[] = "/dev/sda";
11810     device[5] = devchar;
11811     int r;
11812     suppress_error = 0;
11813     r = guestfs_blockdev_setrw (g, device);
11814     if (r == -1)
11815       return -1;
11816   }
11817   {
11818     int r;
11819     suppress_error = 0;
11820     r = guestfs_umount_all (g);
11821     if (r == -1)
11822       return -1;
11823   }
11824   {
11825     int r;
11826     suppress_error = 0;
11827     r = guestfs_lvm_remove_all (g);
11828     if (r == -1)
11829       return -1;
11830   }
11831   {
11832     char device[] = "/dev/sda";
11833     device[5] = devchar;
11834     char lines_0[] = ",";
11835     char *lines[] = {
11836       lines_0,
11837       NULL
11838     };
11839     int r;
11840     suppress_error = 0;
11841     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11842     if (r == -1)
11843       return -1;
11844   }
11845   {
11846     char fstype[] = "ext2";
11847     char device[] = "/dev/sda1";
11848     device[5] = devchar;
11849     int r;
11850     suppress_error = 0;
11851     r = guestfs_mkfs (g, fstype, device);
11852     if (r == -1)
11853       return -1;
11854   }
11855   {
11856     char device[] = "/dev/sda1";
11857     device[5] = devchar;
11858     char mountpoint[] = "/";
11859     int r;
11860     suppress_error = 0;
11861     r = guestfs_mount (g, device, mountpoint);
11862     if (r == -1)
11863       return -1;
11864   }
11865   /* TestLastFail for rm (2) */
11866   {
11867     char path[] = "/new";
11868     int r;
11869     suppress_error = 0;
11870     r = guestfs_mkdir (g, path);
11871     if (r == -1)
11872       return -1;
11873   }
11874   {
11875     char path[] = "/new";
11876     int r;
11877     suppress_error = 1;
11878     r = guestfs_rm (g, path);
11879     if (r != -1)
11880       return -1;
11881   }
11882   return 0;
11883 }
11884
11885 static int test_read_lines_0 (void)
11886 {
11887   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
11888   {
11889     char device[] = "/dev/sda";
11890     device[5] = devchar;
11891     int r;
11892     suppress_error = 0;
11893     r = guestfs_blockdev_setrw (g, device);
11894     if (r == -1)
11895       return -1;
11896   }
11897   {
11898     int r;
11899     suppress_error = 0;
11900     r = guestfs_umount_all (g);
11901     if (r == -1)
11902       return -1;
11903   }
11904   {
11905     int r;
11906     suppress_error = 0;
11907     r = guestfs_lvm_remove_all (g);
11908     if (r == -1)
11909       return -1;
11910   }
11911   {
11912     char device[] = "/dev/sda";
11913     device[5] = devchar;
11914     char lines_0[] = ",";
11915     char *lines[] = {
11916       lines_0,
11917       NULL
11918     };
11919     int r;
11920     suppress_error = 0;
11921     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11922     if (r == -1)
11923       return -1;
11924   }
11925   {
11926     char fstype[] = "ext2";
11927     char device[] = "/dev/sda1";
11928     device[5] = devchar;
11929     int r;
11930     suppress_error = 0;
11931     r = guestfs_mkfs (g, fstype, device);
11932     if (r == -1)
11933       return -1;
11934   }
11935   {
11936     char device[] = "/dev/sda1";
11937     device[5] = devchar;
11938     char mountpoint[] = "/";
11939     int r;
11940     suppress_error = 0;
11941     r = guestfs_mount (g, device, mountpoint);
11942     if (r == -1)
11943       return -1;
11944   }
11945   /* TestOutputList for read_lines (0) */
11946   {
11947     char path[] = "/new";
11948     char content[] = "line1\r\nline2\nline3";
11949     int r;
11950     suppress_error = 0;
11951     r = guestfs_write_file (g, path, content, 0);
11952     if (r == -1)
11953       return -1;
11954   }
11955   {
11956     char path[] = "/new";
11957     char **r;
11958     int i;
11959     suppress_error = 0;
11960     r = guestfs_read_lines (g, path);
11961     if (r == NULL)
11962       return -1;
11963     if (!r[0]) {
11964       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11965       print_strings (r);
11966       return -1;
11967     }
11968     {
11969       char expected[] = "line1";
11970       if (strcmp (r[0], expected) != 0) {
11971         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11972         return -1;
11973       }
11974     }
11975     if (!r[1]) {
11976       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11977       print_strings (r);
11978       return -1;
11979     }
11980     {
11981       char expected[] = "line2";
11982       if (strcmp (r[1], expected) != 0) {
11983         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11984         return -1;
11985       }
11986     }
11987     if (!r[2]) {
11988       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11989       print_strings (r);
11990       return -1;
11991     }
11992     {
11993       char expected[] = "line3";
11994       if (strcmp (r[2], expected) != 0) {
11995         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11996         return -1;
11997       }
11998     }
11999     if (r[3] != NULL) {
12000       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
12001       print_strings (r);
12002       return -1;
12003     }
12004     for (i = 0; r[i] != NULL; ++i)
12005       free (r[i]);
12006     free (r);
12007   }
12008   return 0;
12009 }
12010
12011 static int test_read_lines_1 (void)
12012 {
12013   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
12014   {
12015     char device[] = "/dev/sda";
12016     device[5] = devchar;
12017     int r;
12018     suppress_error = 0;
12019     r = guestfs_blockdev_setrw (g, device);
12020     if (r == -1)
12021       return -1;
12022   }
12023   {
12024     int r;
12025     suppress_error = 0;
12026     r = guestfs_umount_all (g);
12027     if (r == -1)
12028       return -1;
12029   }
12030   {
12031     int r;
12032     suppress_error = 0;
12033     r = guestfs_lvm_remove_all (g);
12034     if (r == -1)
12035       return -1;
12036   }
12037   {
12038     char device[] = "/dev/sda";
12039     device[5] = devchar;
12040     char lines_0[] = ",";
12041     char *lines[] = {
12042       lines_0,
12043       NULL
12044     };
12045     int r;
12046     suppress_error = 0;
12047     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12048     if (r == -1)
12049       return -1;
12050   }
12051   {
12052     char fstype[] = "ext2";
12053     char device[] = "/dev/sda1";
12054     device[5] = devchar;
12055     int r;
12056     suppress_error = 0;
12057     r = guestfs_mkfs (g, fstype, device);
12058     if (r == -1)
12059       return -1;
12060   }
12061   {
12062     char device[] = "/dev/sda1";
12063     device[5] = devchar;
12064     char mountpoint[] = "/";
12065     int r;
12066     suppress_error = 0;
12067     r = guestfs_mount (g, device, mountpoint);
12068     if (r == -1)
12069       return -1;
12070   }
12071   /* TestOutputList for read_lines (1) */
12072   {
12073     char path[] = "/new";
12074     char content[] = "";
12075     int r;
12076     suppress_error = 0;
12077     r = guestfs_write_file (g, path, content, 0);
12078     if (r == -1)
12079       return -1;
12080   }
12081   {
12082     char path[] = "/new";
12083     char **r;
12084     int i;
12085     suppress_error = 0;
12086     r = guestfs_read_lines (g, path);
12087     if (r == NULL)
12088       return -1;
12089     if (r[0] != NULL) {
12090       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
12091       print_strings (r);
12092       return -1;
12093     }
12094     for (i = 0; r[i] != NULL; ++i)
12095       free (r[i]);
12096     free (r);
12097   }
12098   return 0;
12099 }
12100
12101 static int test_lvs_0 (void)
12102 {
12103   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
12104   {
12105     char device[] = "/dev/sda";
12106     device[5] = devchar;
12107     int r;
12108     suppress_error = 0;
12109     r = guestfs_blockdev_setrw (g, device);
12110     if (r == -1)
12111       return -1;
12112   }
12113   {
12114     int r;
12115     suppress_error = 0;
12116     r = guestfs_umount_all (g);
12117     if (r == -1)
12118       return -1;
12119   }
12120   {
12121     int r;
12122     suppress_error = 0;
12123     r = guestfs_lvm_remove_all (g);
12124     if (r == -1)
12125       return -1;
12126   }
12127   {
12128     char device[] = "/dev/sda";
12129     device[5] = devchar;
12130     char lines_0[] = ",";
12131     char *lines[] = {
12132       lines_0,
12133       NULL
12134     };
12135     int r;
12136     suppress_error = 0;
12137     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12138     if (r == -1)
12139       return -1;
12140   }
12141   {
12142     char device[] = "/dev/sda1";
12143     device[5] = devchar;
12144     int r;
12145     suppress_error = 0;
12146     r = guestfs_pvcreate (g, device);
12147     if (r == -1)
12148       return -1;
12149   }
12150   {
12151     char volgroup[] = "VG";
12152     char physvols_0[] = "/dev/sda1";
12153     physvols_0[5] = devchar;
12154     char *physvols[] = {
12155       physvols_0,
12156       NULL
12157     };
12158     int r;
12159     suppress_error = 0;
12160     r = guestfs_vgcreate (g, volgroup, physvols);
12161     if (r == -1)
12162       return -1;
12163   }
12164   {
12165     char logvol[] = "LV";
12166     char volgroup[] = "VG";
12167     int r;
12168     suppress_error = 0;
12169     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12170     if (r == -1)
12171       return -1;
12172   }
12173   {
12174     char fstype[] = "ext2";
12175     char device[] = "/dev/VG/LV";
12176     int r;
12177     suppress_error = 0;
12178     r = guestfs_mkfs (g, fstype, device);
12179     if (r == -1)
12180       return -1;
12181   }
12182   {
12183     char device[] = "/dev/VG/LV";
12184     char mountpoint[] = "/";
12185     int r;
12186     suppress_error = 0;
12187     r = guestfs_mount (g, device, mountpoint);
12188     if (r == -1)
12189       return -1;
12190   }
12191   /* TestOutputList for lvs (0) */
12192   {
12193     char **r;
12194     int i;
12195     suppress_error = 0;
12196     r = guestfs_lvs (g);
12197     if (r == NULL)
12198       return -1;
12199     if (!r[0]) {
12200       fprintf (stderr, "test_lvs_0: short list returned from command\n");
12201       print_strings (r);
12202       return -1;
12203     }
12204     {
12205       char expected[] = "/dev/VG/LV";
12206       if (strcmp (r[0], expected) != 0) {
12207         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12208         return -1;
12209       }
12210     }
12211     if (r[1] != NULL) {
12212       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
12213       print_strings (r);
12214       return -1;
12215     }
12216     for (i = 0; r[i] != NULL; ++i)
12217       free (r[i]);
12218     free (r);
12219   }
12220   return 0;
12221 }
12222
12223 static int test_lvs_1 (void)
12224 {
12225   /* InitNone|InitEmpty for test_lvs_1 */
12226   {
12227     char device[] = "/dev/sda";
12228     device[5] = devchar;
12229     int r;
12230     suppress_error = 0;
12231     r = guestfs_blockdev_setrw (g, device);
12232     if (r == -1)
12233       return -1;
12234   }
12235   {
12236     int r;
12237     suppress_error = 0;
12238     r = guestfs_umount_all (g);
12239     if (r == -1)
12240       return -1;
12241   }
12242   {
12243     int r;
12244     suppress_error = 0;
12245     r = guestfs_lvm_remove_all (g);
12246     if (r == -1)
12247       return -1;
12248   }
12249   /* TestOutputList for lvs (1) */
12250   {
12251     char device[] = "/dev/sda";
12252     device[5] = devchar;
12253     char lines_0[] = ",10";
12254     char lines_1[] = ",20";
12255     char lines_2[] = ",";
12256     char *lines[] = {
12257       lines_0,
12258       lines_1,
12259       lines_2,
12260       NULL
12261     };
12262     int r;
12263     suppress_error = 0;
12264     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12265     if (r == -1)
12266       return -1;
12267   }
12268   {
12269     char device[] = "/dev/sda1";
12270     device[5] = devchar;
12271     int r;
12272     suppress_error = 0;
12273     r = guestfs_pvcreate (g, device);
12274     if (r == -1)
12275       return -1;
12276   }
12277   {
12278     char device[] = "/dev/sda2";
12279     device[5] = devchar;
12280     int r;
12281     suppress_error = 0;
12282     r = guestfs_pvcreate (g, device);
12283     if (r == -1)
12284       return -1;
12285   }
12286   {
12287     char device[] = "/dev/sda3";
12288     device[5] = devchar;
12289     int r;
12290     suppress_error = 0;
12291     r = guestfs_pvcreate (g, device);
12292     if (r == -1)
12293       return -1;
12294   }
12295   {
12296     char volgroup[] = "VG1";
12297     char physvols_0[] = "/dev/sda1";
12298     physvols_0[5] = devchar;
12299     char physvols_1[] = "/dev/sda2";
12300     physvols_1[5] = devchar;
12301     char *physvols[] = {
12302       physvols_0,
12303       physvols_1,
12304       NULL
12305     };
12306     int r;
12307     suppress_error = 0;
12308     r = guestfs_vgcreate (g, volgroup, physvols);
12309     if (r == -1)
12310       return -1;
12311   }
12312   {
12313     char volgroup[] = "VG2";
12314     char physvols_0[] = "/dev/sda3";
12315     physvols_0[5] = devchar;
12316     char *physvols[] = {
12317       physvols_0,
12318       NULL
12319     };
12320     int r;
12321     suppress_error = 0;
12322     r = guestfs_vgcreate (g, volgroup, physvols);
12323     if (r == -1)
12324       return -1;
12325   }
12326   {
12327     char logvol[] = "LV1";
12328     char volgroup[] = "VG1";
12329     int r;
12330     suppress_error = 0;
12331     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12332     if (r == -1)
12333       return -1;
12334   }
12335   {
12336     char logvol[] = "LV2";
12337     char volgroup[] = "VG1";
12338     int r;
12339     suppress_error = 0;
12340     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12341     if (r == -1)
12342       return -1;
12343   }
12344   {
12345     char logvol[] = "LV3";
12346     char volgroup[] = "VG2";
12347     int r;
12348     suppress_error = 0;
12349     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12350     if (r == -1)
12351       return -1;
12352   }
12353   {
12354     char **r;
12355     int i;
12356     suppress_error = 0;
12357     r = guestfs_lvs (g);
12358     if (r == NULL)
12359       return -1;
12360     if (!r[0]) {
12361       fprintf (stderr, "test_lvs_1: short list returned from command\n");
12362       print_strings (r);
12363       return -1;
12364     }
12365     {
12366       char expected[] = "/dev/VG1/LV1";
12367       if (strcmp (r[0], expected) != 0) {
12368         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12369         return -1;
12370       }
12371     }
12372     if (!r[1]) {
12373       fprintf (stderr, "test_lvs_1: short list returned from command\n");
12374       print_strings (r);
12375       return -1;
12376     }
12377     {
12378       char expected[] = "/dev/VG1/LV2";
12379       if (strcmp (r[1], expected) != 0) {
12380         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12381         return -1;
12382       }
12383     }
12384     if (!r[2]) {
12385       fprintf (stderr, "test_lvs_1: short list returned from command\n");
12386       print_strings (r);
12387       return -1;
12388     }
12389     {
12390       char expected[] = "/dev/VG2/LV3";
12391       if (strcmp (r[2], expected) != 0) {
12392         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12393         return -1;
12394       }
12395     }
12396     if (r[3] != NULL) {
12397       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
12398       print_strings (r);
12399       return -1;
12400     }
12401     for (i = 0; r[i] != NULL; ++i)
12402       free (r[i]);
12403     free (r);
12404   }
12405   return 0;
12406 }
12407
12408 static int test_vgs_0 (void)
12409 {
12410   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
12411   {
12412     char device[] = "/dev/sda";
12413     device[5] = devchar;
12414     int r;
12415     suppress_error = 0;
12416     r = guestfs_blockdev_setrw (g, device);
12417     if (r == -1)
12418       return -1;
12419   }
12420   {
12421     int r;
12422     suppress_error = 0;
12423     r = guestfs_umount_all (g);
12424     if (r == -1)
12425       return -1;
12426   }
12427   {
12428     int r;
12429     suppress_error = 0;
12430     r = guestfs_lvm_remove_all (g);
12431     if (r == -1)
12432       return -1;
12433   }
12434   {
12435     char device[] = "/dev/sda";
12436     device[5] = devchar;
12437     char lines_0[] = ",";
12438     char *lines[] = {
12439       lines_0,
12440       NULL
12441     };
12442     int r;
12443     suppress_error = 0;
12444     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12445     if (r == -1)
12446       return -1;
12447   }
12448   {
12449     char device[] = "/dev/sda1";
12450     device[5] = devchar;
12451     int r;
12452     suppress_error = 0;
12453     r = guestfs_pvcreate (g, device);
12454     if (r == -1)
12455       return -1;
12456   }
12457   {
12458     char volgroup[] = "VG";
12459     char physvols_0[] = "/dev/sda1";
12460     physvols_0[5] = devchar;
12461     char *physvols[] = {
12462       physvols_0,
12463       NULL
12464     };
12465     int r;
12466     suppress_error = 0;
12467     r = guestfs_vgcreate (g, volgroup, physvols);
12468     if (r == -1)
12469       return -1;
12470   }
12471   {
12472     char logvol[] = "LV";
12473     char volgroup[] = "VG";
12474     int r;
12475     suppress_error = 0;
12476     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12477     if (r == -1)
12478       return -1;
12479   }
12480   {
12481     char fstype[] = "ext2";
12482     char device[] = "/dev/VG/LV";
12483     int r;
12484     suppress_error = 0;
12485     r = guestfs_mkfs (g, fstype, device);
12486     if (r == -1)
12487       return -1;
12488   }
12489   {
12490     char device[] = "/dev/VG/LV";
12491     char mountpoint[] = "/";
12492     int r;
12493     suppress_error = 0;
12494     r = guestfs_mount (g, device, mountpoint);
12495     if (r == -1)
12496       return -1;
12497   }
12498   /* TestOutputList for vgs (0) */
12499   {
12500     char **r;
12501     int i;
12502     suppress_error = 0;
12503     r = guestfs_vgs (g);
12504     if (r == NULL)
12505       return -1;
12506     if (!r[0]) {
12507       fprintf (stderr, "test_vgs_0: short list returned from command\n");
12508       print_strings (r);
12509       return -1;
12510     }
12511     {
12512       char expected[] = "VG";
12513       if (strcmp (r[0], expected) != 0) {
12514         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12515         return -1;
12516       }
12517     }
12518     if (r[1] != NULL) {
12519       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
12520       print_strings (r);
12521       return -1;
12522     }
12523     for (i = 0; r[i] != NULL; ++i)
12524       free (r[i]);
12525     free (r);
12526   }
12527   return 0;
12528 }
12529
12530 static int test_vgs_1 (void)
12531 {
12532   /* InitNone|InitEmpty for test_vgs_1 */
12533   {
12534     char device[] = "/dev/sda";
12535     device[5] = devchar;
12536     int r;
12537     suppress_error = 0;
12538     r = guestfs_blockdev_setrw (g, device);
12539     if (r == -1)
12540       return -1;
12541   }
12542   {
12543     int r;
12544     suppress_error = 0;
12545     r = guestfs_umount_all (g);
12546     if (r == -1)
12547       return -1;
12548   }
12549   {
12550     int r;
12551     suppress_error = 0;
12552     r = guestfs_lvm_remove_all (g);
12553     if (r == -1)
12554       return -1;
12555   }
12556   /* TestOutputList for vgs (1) */
12557   {
12558     char device[] = "/dev/sda";
12559     device[5] = devchar;
12560     char lines_0[] = ",10";
12561     char lines_1[] = ",20";
12562     char lines_2[] = ",";
12563     char *lines[] = {
12564       lines_0,
12565       lines_1,
12566       lines_2,
12567       NULL
12568     };
12569     int r;
12570     suppress_error = 0;
12571     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12572     if (r == -1)
12573       return -1;
12574   }
12575   {
12576     char device[] = "/dev/sda1";
12577     device[5] = devchar;
12578     int r;
12579     suppress_error = 0;
12580     r = guestfs_pvcreate (g, device);
12581     if (r == -1)
12582       return -1;
12583   }
12584   {
12585     char device[] = "/dev/sda2";
12586     device[5] = devchar;
12587     int r;
12588     suppress_error = 0;
12589     r = guestfs_pvcreate (g, device);
12590     if (r == -1)
12591       return -1;
12592   }
12593   {
12594     char device[] = "/dev/sda3";
12595     device[5] = devchar;
12596     int r;
12597     suppress_error = 0;
12598     r = guestfs_pvcreate (g, device);
12599     if (r == -1)
12600       return -1;
12601   }
12602   {
12603     char volgroup[] = "VG1";
12604     char physvols_0[] = "/dev/sda1";
12605     physvols_0[5] = devchar;
12606     char physvols_1[] = "/dev/sda2";
12607     physvols_1[5] = devchar;
12608     char *physvols[] = {
12609       physvols_0,
12610       physvols_1,
12611       NULL
12612     };
12613     int r;
12614     suppress_error = 0;
12615     r = guestfs_vgcreate (g, volgroup, physvols);
12616     if (r == -1)
12617       return -1;
12618   }
12619   {
12620     char volgroup[] = "VG2";
12621     char physvols_0[] = "/dev/sda3";
12622     physvols_0[5] = devchar;
12623     char *physvols[] = {
12624       physvols_0,
12625       NULL
12626     };
12627     int r;
12628     suppress_error = 0;
12629     r = guestfs_vgcreate (g, volgroup, physvols);
12630     if (r == -1)
12631       return -1;
12632   }
12633   {
12634     char **r;
12635     int i;
12636     suppress_error = 0;
12637     r = guestfs_vgs (g);
12638     if (r == NULL)
12639       return -1;
12640     if (!r[0]) {
12641       fprintf (stderr, "test_vgs_1: short list returned from command\n");
12642       print_strings (r);
12643       return -1;
12644     }
12645     {
12646       char expected[] = "VG1";
12647       if (strcmp (r[0], expected) != 0) {
12648         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12649         return -1;
12650       }
12651     }
12652     if (!r[1]) {
12653       fprintf (stderr, "test_vgs_1: short list returned from command\n");
12654       print_strings (r);
12655       return -1;
12656     }
12657     {
12658       char expected[] = "VG2";
12659       if (strcmp (r[1], expected) != 0) {
12660         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12661         return -1;
12662       }
12663     }
12664     if (r[2] != NULL) {
12665       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
12666       print_strings (r);
12667       return -1;
12668     }
12669     for (i = 0; r[i] != NULL; ++i)
12670       free (r[i]);
12671     free (r);
12672   }
12673   return 0;
12674 }
12675
12676 static int test_pvs_0 (void)
12677 {
12678   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
12679   {
12680     char device[] = "/dev/sda";
12681     device[5] = devchar;
12682     int r;
12683     suppress_error = 0;
12684     r = guestfs_blockdev_setrw (g, device);
12685     if (r == -1)
12686       return -1;
12687   }
12688   {
12689     int r;
12690     suppress_error = 0;
12691     r = guestfs_umount_all (g);
12692     if (r == -1)
12693       return -1;
12694   }
12695   {
12696     int r;
12697     suppress_error = 0;
12698     r = guestfs_lvm_remove_all (g);
12699     if (r == -1)
12700       return -1;
12701   }
12702   {
12703     char device[] = "/dev/sda";
12704     device[5] = devchar;
12705     char lines_0[] = ",";
12706     char *lines[] = {
12707       lines_0,
12708       NULL
12709     };
12710     int r;
12711     suppress_error = 0;
12712     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12713     if (r == -1)
12714       return -1;
12715   }
12716   {
12717     char device[] = "/dev/sda1";
12718     device[5] = devchar;
12719     int r;
12720     suppress_error = 0;
12721     r = guestfs_pvcreate (g, device);
12722     if (r == -1)
12723       return -1;
12724   }
12725   {
12726     char volgroup[] = "VG";
12727     char physvols_0[] = "/dev/sda1";
12728     physvols_0[5] = devchar;
12729     char *physvols[] = {
12730       physvols_0,
12731       NULL
12732     };
12733     int r;
12734     suppress_error = 0;
12735     r = guestfs_vgcreate (g, volgroup, physvols);
12736     if (r == -1)
12737       return -1;
12738   }
12739   {
12740     char logvol[] = "LV";
12741     char volgroup[] = "VG";
12742     int r;
12743     suppress_error = 0;
12744     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12745     if (r == -1)
12746       return -1;
12747   }
12748   {
12749     char fstype[] = "ext2";
12750     char device[] = "/dev/VG/LV";
12751     int r;
12752     suppress_error = 0;
12753     r = guestfs_mkfs (g, fstype, device);
12754     if (r == -1)
12755       return -1;
12756   }
12757   {
12758     char device[] = "/dev/VG/LV";
12759     char mountpoint[] = "/";
12760     int r;
12761     suppress_error = 0;
12762     r = guestfs_mount (g, device, mountpoint);
12763     if (r == -1)
12764       return -1;
12765   }
12766   /* TestOutputList for pvs (0) */
12767   {
12768     char **r;
12769     int i;
12770     suppress_error = 0;
12771     r = guestfs_pvs (g);
12772     if (r == NULL)
12773       return -1;
12774     if (!r[0]) {
12775       fprintf (stderr, "test_pvs_0: short list returned from command\n");
12776       print_strings (r);
12777       return -1;
12778     }
12779     {
12780       char expected[] = "/dev/sda1";
12781       expected[5] = devchar;
12782       if (strcmp (r[0], expected) != 0) {
12783         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12784         return -1;
12785       }
12786     }
12787     if (r[1] != NULL) {
12788       fprintf (stderr, "test_pvs_0: 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_pvs_1 (void)
12800 {
12801   /* InitNone|InitEmpty for test_pvs_1 */
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   /* TestOutputList for pvs (1) */
12826   {
12827     char device[] = "/dev/sda";
12828     device[5] = devchar;
12829     char lines_0[] = ",10";
12830     char lines_1[] = ",20";
12831     char lines_2[] = ",";
12832     char *lines[] = {
12833       lines_0,
12834       lines_1,
12835       lines_2,
12836       NULL
12837     };
12838     int r;
12839     suppress_error = 0;
12840     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12841     if (r == -1)
12842       return -1;
12843   }
12844   {
12845     char device[] = "/dev/sda1";
12846     device[5] = devchar;
12847     int r;
12848     suppress_error = 0;
12849     r = guestfs_pvcreate (g, device);
12850     if (r == -1)
12851       return -1;
12852   }
12853   {
12854     char device[] = "/dev/sda2";
12855     device[5] = devchar;
12856     int r;
12857     suppress_error = 0;
12858     r = guestfs_pvcreate (g, device);
12859     if (r == -1)
12860       return -1;
12861   }
12862   {
12863     char device[] = "/dev/sda3";
12864     device[5] = devchar;
12865     int r;
12866     suppress_error = 0;
12867     r = guestfs_pvcreate (g, device);
12868     if (r == -1)
12869       return -1;
12870   }
12871   {
12872     char **r;
12873     int i;
12874     suppress_error = 0;
12875     r = guestfs_pvs (g);
12876     if (r == NULL)
12877       return -1;
12878     if (!r[0]) {
12879       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12880       print_strings (r);
12881       return -1;
12882     }
12883     {
12884       char expected[] = "/dev/sda1";
12885       expected[5] = devchar;
12886       if (strcmp (r[0], expected) != 0) {
12887         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12888         return -1;
12889       }
12890     }
12891     if (!r[1]) {
12892       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12893       print_strings (r);
12894       return -1;
12895     }
12896     {
12897       char expected[] = "/dev/sda2";
12898       expected[5] = devchar;
12899       if (strcmp (r[1], expected) != 0) {
12900         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12901         return -1;
12902       }
12903     }
12904     if (!r[2]) {
12905       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12906       print_strings (r);
12907       return -1;
12908     }
12909     {
12910       char expected[] = "/dev/sda3";
12911       expected[5] = devchar;
12912       if (strcmp (r[2], expected) != 0) {
12913         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12914         return -1;
12915       }
12916     }
12917     if (r[3] != NULL) {
12918       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12919       print_strings (r);
12920       return -1;
12921     }
12922     for (i = 0; r[i] != NULL; ++i)
12923       free (r[i]);
12924     free (r);
12925   }
12926   return 0;
12927 }
12928
12929 static int test_list_partitions_0 (void)
12930 {
12931   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
12932   {
12933     char device[] = "/dev/sda";
12934     device[5] = devchar;
12935     int r;
12936     suppress_error = 0;
12937     r = guestfs_blockdev_setrw (g, device);
12938     if (r == -1)
12939       return -1;
12940   }
12941   {
12942     int r;
12943     suppress_error = 0;
12944     r = guestfs_umount_all (g);
12945     if (r == -1)
12946       return -1;
12947   }
12948   {
12949     int r;
12950     suppress_error = 0;
12951     r = guestfs_lvm_remove_all (g);
12952     if (r == -1)
12953       return -1;
12954   }
12955   {
12956     char device[] = "/dev/sda";
12957     device[5] = devchar;
12958     char lines_0[] = ",";
12959     char *lines[] = {
12960       lines_0,
12961       NULL
12962     };
12963     int r;
12964     suppress_error = 0;
12965     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12966     if (r == -1)
12967       return -1;
12968   }
12969   {
12970     char fstype[] = "ext2";
12971     char device[] = "/dev/sda1";
12972     device[5] = devchar;
12973     int r;
12974     suppress_error = 0;
12975     r = guestfs_mkfs (g, fstype, device);
12976     if (r == -1)
12977       return -1;
12978   }
12979   {
12980     char device[] = "/dev/sda1";
12981     device[5] = devchar;
12982     char mountpoint[] = "/";
12983     int r;
12984     suppress_error = 0;
12985     r = guestfs_mount (g, device, mountpoint);
12986     if (r == -1)
12987       return -1;
12988   }
12989   /* TestOutputList for list_partitions (0) */
12990   {
12991     char **r;
12992     int i;
12993     suppress_error = 0;
12994     r = guestfs_list_partitions (g);
12995     if (r == NULL)
12996       return -1;
12997     if (!r[0]) {
12998       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12999       print_strings (r);
13000       return -1;
13001     }
13002     {
13003       char expected[] = "/dev/sda1";
13004       expected[5] = devchar;
13005       if (strcmp (r[0], expected) != 0) {
13006         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13007         return -1;
13008       }
13009     }
13010     if (r[1] != NULL) {
13011       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
13012       print_strings (r);
13013       return -1;
13014     }
13015     for (i = 0; r[i] != NULL; ++i)
13016       free (r[i]);
13017     free (r);
13018   }
13019   return 0;
13020 }
13021
13022 static int test_list_partitions_1 (void)
13023 {
13024   /* InitNone|InitEmpty for test_list_partitions_1 */
13025   {
13026     char device[] = "/dev/sda";
13027     device[5] = devchar;
13028     int r;
13029     suppress_error = 0;
13030     r = guestfs_blockdev_setrw (g, device);
13031     if (r == -1)
13032       return -1;
13033   }
13034   {
13035     int r;
13036     suppress_error = 0;
13037     r = guestfs_umount_all (g);
13038     if (r == -1)
13039       return -1;
13040   }
13041   {
13042     int r;
13043     suppress_error = 0;
13044     r = guestfs_lvm_remove_all (g);
13045     if (r == -1)
13046       return -1;
13047   }
13048   /* TestOutputList for list_partitions (1) */
13049   {
13050     char device[] = "/dev/sda";
13051     device[5] = devchar;
13052     char lines_0[] = ",10";
13053     char lines_1[] = ",20";
13054     char lines_2[] = ",";
13055     char *lines[] = {
13056       lines_0,
13057       lines_1,
13058       lines_2,
13059       NULL
13060     };
13061     int r;
13062     suppress_error = 0;
13063     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13064     if (r == -1)
13065       return -1;
13066   }
13067   {
13068     char **r;
13069     int i;
13070     suppress_error = 0;
13071     r = guestfs_list_partitions (g);
13072     if (r == NULL)
13073       return -1;
13074     if (!r[0]) {
13075       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13076       print_strings (r);
13077       return -1;
13078     }
13079     {
13080       char expected[] = "/dev/sda1";
13081       expected[5] = devchar;
13082       if (strcmp (r[0], expected) != 0) {
13083         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13084         return -1;
13085       }
13086     }
13087     if (!r[1]) {
13088       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13089       print_strings (r);
13090       return -1;
13091     }
13092     {
13093       char expected[] = "/dev/sda2";
13094       expected[5] = devchar;
13095       if (strcmp (r[1], expected) != 0) {
13096         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13097         return -1;
13098       }
13099     }
13100     if (!r[2]) {
13101       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13102       print_strings (r);
13103       return -1;
13104     }
13105     {
13106       char expected[] = "/dev/sda3";
13107       expected[5] = devchar;
13108       if (strcmp (r[2], expected) != 0) {
13109         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13110         return -1;
13111       }
13112     }
13113     if (r[3] != NULL) {
13114       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
13115       print_strings (r);
13116       return -1;
13117     }
13118     for (i = 0; r[i] != NULL; ++i)
13119       free (r[i]);
13120     free (r);
13121   }
13122   return 0;
13123 }
13124
13125 static int test_list_devices_0 (void)
13126 {
13127   /* InitNone|InitEmpty for test_list_devices_0 */
13128   {
13129     char device[] = "/dev/sda";
13130     device[5] = devchar;
13131     int r;
13132     suppress_error = 0;
13133     r = guestfs_blockdev_setrw (g, device);
13134     if (r == -1)
13135       return -1;
13136   }
13137   {
13138     int r;
13139     suppress_error = 0;
13140     r = guestfs_umount_all (g);
13141     if (r == -1)
13142       return -1;
13143   }
13144   {
13145     int r;
13146     suppress_error = 0;
13147     r = guestfs_lvm_remove_all (g);
13148     if (r == -1)
13149       return -1;
13150   }
13151   /* TestOutputList for list_devices (0) */
13152   {
13153     char **r;
13154     int i;
13155     suppress_error = 0;
13156     r = guestfs_list_devices (g);
13157     if (r == NULL)
13158       return -1;
13159     if (!r[0]) {
13160       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13161       print_strings (r);
13162       return -1;
13163     }
13164     {
13165       char expected[] = "/dev/sda";
13166       expected[5] = devchar;
13167       if (strcmp (r[0], expected) != 0) {
13168         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13169         return -1;
13170       }
13171     }
13172     if (!r[1]) {
13173       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13174       print_strings (r);
13175       return -1;
13176     }
13177     {
13178       char expected[] = "/dev/sdb";
13179       expected[5] = devchar;
13180       if (strcmp (r[1], expected) != 0) {
13181         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13182         return -1;
13183       }
13184     }
13185     if (!r[2]) {
13186       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13187       print_strings (r);
13188       return -1;
13189     }
13190     {
13191       char expected[] = "/dev/sdc";
13192       expected[5] = devchar;
13193       if (strcmp (r[2], expected) != 0) {
13194         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13195         return -1;
13196       }
13197     }
13198     if (r[3] != NULL) {
13199       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
13200       print_strings (r);
13201       return -1;
13202     }
13203     for (i = 0; r[i] != NULL; ++i)
13204       free (r[i]);
13205     free (r);
13206   }
13207   return 0;
13208 }
13209
13210 static int test_ls_0 (void)
13211 {
13212   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
13213   {
13214     char device[] = "/dev/sda";
13215     device[5] = devchar;
13216     int r;
13217     suppress_error = 0;
13218     r = guestfs_blockdev_setrw (g, device);
13219     if (r == -1)
13220       return -1;
13221   }
13222   {
13223     int r;
13224     suppress_error = 0;
13225     r = guestfs_umount_all (g);
13226     if (r == -1)
13227       return -1;
13228   }
13229   {
13230     int r;
13231     suppress_error = 0;
13232     r = guestfs_lvm_remove_all (g);
13233     if (r == -1)
13234       return -1;
13235   }
13236   {
13237     char device[] = "/dev/sda";
13238     device[5] = devchar;
13239     char lines_0[] = ",";
13240     char *lines[] = {
13241       lines_0,
13242       NULL
13243     };
13244     int r;
13245     suppress_error = 0;
13246     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13247     if (r == -1)
13248       return -1;
13249   }
13250   {
13251     char fstype[] = "ext2";
13252     char device[] = "/dev/sda1";
13253     device[5] = devchar;
13254     int r;
13255     suppress_error = 0;
13256     r = guestfs_mkfs (g, fstype, device);
13257     if (r == -1)
13258       return -1;
13259   }
13260   {
13261     char device[] = "/dev/sda1";
13262     device[5] = devchar;
13263     char mountpoint[] = "/";
13264     int r;
13265     suppress_error = 0;
13266     r = guestfs_mount (g, device, mountpoint);
13267     if (r == -1)
13268       return -1;
13269   }
13270   /* TestOutputList for ls (0) */
13271   {
13272     char path[] = "/new";
13273     int r;
13274     suppress_error = 0;
13275     r = guestfs_touch (g, path);
13276     if (r == -1)
13277       return -1;
13278   }
13279   {
13280     char path[] = "/newer";
13281     int r;
13282     suppress_error = 0;
13283     r = guestfs_touch (g, path);
13284     if (r == -1)
13285       return -1;
13286   }
13287   {
13288     char path[] = "/newest";
13289     int r;
13290     suppress_error = 0;
13291     r = guestfs_touch (g, path);
13292     if (r == -1)
13293       return -1;
13294   }
13295   {
13296     char directory[] = "/";
13297     char **r;
13298     int i;
13299     suppress_error = 0;
13300     r = guestfs_ls (g, directory);
13301     if (r == NULL)
13302       return -1;
13303     if (!r[0]) {
13304       fprintf (stderr, "test_ls_0: short list returned from command\n");
13305       print_strings (r);
13306       return -1;
13307     }
13308     {
13309       char expected[] = "lost+found";
13310       if (strcmp (r[0], expected) != 0) {
13311         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13312         return -1;
13313       }
13314     }
13315     if (!r[1]) {
13316       fprintf (stderr, "test_ls_0: short list returned from command\n");
13317       print_strings (r);
13318       return -1;
13319     }
13320     {
13321       char expected[] = "new";
13322       if (strcmp (r[1], expected) != 0) {
13323         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13324         return -1;
13325       }
13326     }
13327     if (!r[2]) {
13328       fprintf (stderr, "test_ls_0: short list returned from command\n");
13329       print_strings (r);
13330       return -1;
13331     }
13332     {
13333       char expected[] = "newer";
13334       if (strcmp (r[2], expected) != 0) {
13335         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13336         return -1;
13337       }
13338     }
13339     if (!r[3]) {
13340       fprintf (stderr, "test_ls_0: short list returned from command\n");
13341       print_strings (r);
13342       return -1;
13343     }
13344     {
13345       char expected[] = "newest";
13346       if (strcmp (r[3], expected) != 0) {
13347         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
13348         return -1;
13349       }
13350     }
13351     if (r[4] != NULL) {
13352       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
13353       print_strings (r);
13354       return -1;
13355     }
13356     for (i = 0; r[i] != NULL; ++i)
13357       free (r[i]);
13358     free (r);
13359   }
13360   return 0;
13361 }
13362
13363 static int test_cat_0 (void)
13364 {
13365   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
13366   {
13367     char device[] = "/dev/sda";
13368     device[5] = devchar;
13369     int r;
13370     suppress_error = 0;
13371     r = guestfs_blockdev_setrw (g, device);
13372     if (r == -1)
13373       return -1;
13374   }
13375   {
13376     int r;
13377     suppress_error = 0;
13378     r = guestfs_umount_all (g);
13379     if (r == -1)
13380       return -1;
13381   }
13382   {
13383     int r;
13384     suppress_error = 0;
13385     r = guestfs_lvm_remove_all (g);
13386     if (r == -1)
13387       return -1;
13388   }
13389   {
13390     char device[] = "/dev/sda";
13391     device[5] = devchar;
13392     char lines_0[] = ",";
13393     char *lines[] = {
13394       lines_0,
13395       NULL
13396     };
13397     int r;
13398     suppress_error = 0;
13399     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13400     if (r == -1)
13401       return -1;
13402   }
13403   {
13404     char fstype[] = "ext2";
13405     char device[] = "/dev/sda1";
13406     device[5] = devchar;
13407     int r;
13408     suppress_error = 0;
13409     r = guestfs_mkfs (g, fstype, device);
13410     if (r == -1)
13411       return -1;
13412   }
13413   {
13414     char device[] = "/dev/sda1";
13415     device[5] = devchar;
13416     char mountpoint[] = "/";
13417     int r;
13418     suppress_error = 0;
13419     r = guestfs_mount (g, device, mountpoint);
13420     if (r == -1)
13421       return -1;
13422   }
13423   /* TestOutput for cat (0) */
13424   char expected[] = "new file contents";
13425   {
13426     char path[] = "/new";
13427     char content[] = "new file contents";
13428     int r;
13429     suppress_error = 0;
13430     r = guestfs_write_file (g, path, content, 0);
13431     if (r == -1)
13432       return -1;
13433   }
13434   {
13435     char path[] = "/new";
13436     char *r;
13437     suppress_error = 0;
13438     r = guestfs_cat (g, path);
13439     if (r == NULL)
13440       return -1;
13441     if (strcmp (r, expected) != 0) {
13442       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
13443       return -1;
13444     }
13445     free (r);
13446   }
13447   return 0;
13448 }
13449
13450 static int test_touch_0 (void)
13451 {
13452   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
13453   {
13454     char device[] = "/dev/sda";
13455     device[5] = devchar;
13456     int r;
13457     suppress_error = 0;
13458     r = guestfs_blockdev_setrw (g, device);
13459     if (r == -1)
13460       return -1;
13461   }
13462   {
13463     int r;
13464     suppress_error = 0;
13465     r = guestfs_umount_all (g);
13466     if (r == -1)
13467       return -1;
13468   }
13469   {
13470     int r;
13471     suppress_error = 0;
13472     r = guestfs_lvm_remove_all (g);
13473     if (r == -1)
13474       return -1;
13475   }
13476   {
13477     char device[] = "/dev/sda";
13478     device[5] = devchar;
13479     char lines_0[] = ",";
13480     char *lines[] = {
13481       lines_0,
13482       NULL
13483     };
13484     int r;
13485     suppress_error = 0;
13486     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13487     if (r == -1)
13488       return -1;
13489   }
13490   {
13491     char fstype[] = "ext2";
13492     char device[] = "/dev/sda1";
13493     device[5] = devchar;
13494     int r;
13495     suppress_error = 0;
13496     r = guestfs_mkfs (g, fstype, device);
13497     if (r == -1)
13498       return -1;
13499   }
13500   {
13501     char device[] = "/dev/sda1";
13502     device[5] = devchar;
13503     char mountpoint[] = "/";
13504     int r;
13505     suppress_error = 0;
13506     r = guestfs_mount (g, device, mountpoint);
13507     if (r == -1)
13508       return -1;
13509   }
13510   /* TestOutputTrue for touch (0) */
13511   {
13512     char path[] = "/new";
13513     int r;
13514     suppress_error = 0;
13515     r = guestfs_touch (g, path);
13516     if (r == -1)
13517       return -1;
13518   }
13519   {
13520     char path[] = "/new";
13521     int r;
13522     suppress_error = 0;
13523     r = guestfs_exists (g, path);
13524     if (r == -1)
13525       return -1;
13526     if (!r) {
13527       fprintf (stderr, "test_touch_0: expected true, got false\n");
13528       return -1;
13529     }
13530   }
13531   return 0;
13532 }
13533
13534 static int test_sync_0 (void)
13535 {
13536   /* InitNone|InitEmpty for test_sync_0 */
13537   {
13538     char device[] = "/dev/sda";
13539     device[5] = devchar;
13540     int r;
13541     suppress_error = 0;
13542     r = guestfs_blockdev_setrw (g, device);
13543     if (r == -1)
13544       return -1;
13545   }
13546   {
13547     int r;
13548     suppress_error = 0;
13549     r = guestfs_umount_all (g);
13550     if (r == -1)
13551       return -1;
13552   }
13553   {
13554     int r;
13555     suppress_error = 0;
13556     r = guestfs_lvm_remove_all (g);
13557     if (r == -1)
13558       return -1;
13559   }
13560   /* TestRun for sync (0) */
13561   {
13562     int r;
13563     suppress_error = 0;
13564     r = guestfs_sync (g);
13565     if (r == -1)
13566       return -1;
13567   }
13568   return 0;
13569 }
13570
13571 static int test_mount_0 (void)
13572 {
13573   /* InitNone|InitEmpty for test_mount_0 */
13574   {
13575     char device[] = "/dev/sda";
13576     device[5] = devchar;
13577     int r;
13578     suppress_error = 0;
13579     r = guestfs_blockdev_setrw (g, device);
13580     if (r == -1)
13581       return -1;
13582   }
13583   {
13584     int r;
13585     suppress_error = 0;
13586     r = guestfs_umount_all (g);
13587     if (r == -1)
13588       return -1;
13589   }
13590   {
13591     int r;
13592     suppress_error = 0;
13593     r = guestfs_lvm_remove_all (g);
13594     if (r == -1)
13595       return -1;
13596   }
13597   /* TestOutput for mount (0) */
13598   char expected[] = "new file contents";
13599   {
13600     char device[] = "/dev/sda";
13601     device[5] = devchar;
13602     char lines_0[] = ",";
13603     char *lines[] = {
13604       lines_0,
13605       NULL
13606     };
13607     int r;
13608     suppress_error = 0;
13609     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13610     if (r == -1)
13611       return -1;
13612   }
13613   {
13614     char fstype[] = "ext2";
13615     char device[] = "/dev/sda1";
13616     device[5] = devchar;
13617     int r;
13618     suppress_error = 0;
13619     r = guestfs_mkfs (g, fstype, device);
13620     if (r == -1)
13621       return -1;
13622   }
13623   {
13624     char device[] = "/dev/sda1";
13625     device[5] = devchar;
13626     char mountpoint[] = "/";
13627     int r;
13628     suppress_error = 0;
13629     r = guestfs_mount (g, device, mountpoint);
13630     if (r == -1)
13631       return -1;
13632   }
13633   {
13634     char path[] = "/new";
13635     char content[] = "new file contents";
13636     int r;
13637     suppress_error = 0;
13638     r = guestfs_write_file (g, path, content, 0);
13639     if (r == -1)
13640       return -1;
13641   }
13642   {
13643     char path[] = "/new";
13644     char *r;
13645     suppress_error = 0;
13646     r = guestfs_cat (g, path);
13647     if (r == NULL)
13648       return -1;
13649     if (strcmp (r, expected) != 0) {
13650       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
13651       return -1;
13652     }
13653     free (r);
13654   }
13655   return 0;
13656 }
13657
13658 int main (int argc, char *argv[])
13659 {
13660   char c = 0;
13661   int failed = 0;
13662   const char *srcdir;
13663   const char *filename;
13664   int fd, i;
13665   int nr_tests, test_num = 0;
13666   char **devs;
13667
13668   no_test_warnings ();
13669
13670   g = guestfs_create ();
13671   if (g == NULL) {
13672     printf ("guestfs_create FAILED\n");
13673     exit (1);
13674   }
13675
13676   guestfs_set_error_handler (g, print_error, NULL);
13677
13678   srcdir = getenv ("srcdir");
13679   if (!srcdir) srcdir = ".";
13680   chdir (srcdir);
13681   guestfs_set_path (g, ".");
13682
13683   filename = "test1.img";
13684   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13685   if (fd == -1) {
13686     perror (filename);
13687     exit (1);
13688   }
13689   if (lseek (fd, 524288000, SEEK_SET) == -1) {
13690     perror ("lseek");
13691     close (fd);
13692     unlink (filename);
13693     exit (1);
13694   }
13695   if (write (fd, &c, 1) == -1) {
13696     perror ("write");
13697     close (fd);
13698     unlink (filename);
13699     exit (1);
13700   }
13701   if (close (fd) == -1) {
13702     perror (filename);
13703     unlink (filename);
13704     exit (1);
13705   }
13706   if (guestfs_add_drive (g, filename) == -1) {
13707     printf ("guestfs_add_drive %s FAILED\n", filename);
13708     exit (1);
13709   }
13710
13711   filename = "test2.img";
13712   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13713   if (fd == -1) {
13714     perror (filename);
13715     exit (1);
13716   }
13717   if (lseek (fd, 52428800, SEEK_SET) == -1) {
13718     perror ("lseek");
13719     close (fd);
13720     unlink (filename);
13721     exit (1);
13722   }
13723   if (write (fd, &c, 1) == -1) {
13724     perror ("write");
13725     close (fd);
13726     unlink (filename);
13727     exit (1);
13728   }
13729   if (close (fd) == -1) {
13730     perror (filename);
13731     unlink (filename);
13732     exit (1);
13733   }
13734   if (guestfs_add_drive (g, filename) == -1) {
13735     printf ("guestfs_add_drive %s FAILED\n", filename);
13736     exit (1);
13737   }
13738
13739   filename = "test3.img";
13740   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13741   if (fd == -1) {
13742     perror (filename);
13743     exit (1);
13744   }
13745   if (lseek (fd, 10485760, SEEK_SET) == -1) {
13746     perror ("lseek");
13747     close (fd);
13748     unlink (filename);
13749     exit (1);
13750   }
13751   if (write (fd, &c, 1) == -1) {
13752     perror ("write");
13753     close (fd);
13754     unlink (filename);
13755     exit (1);
13756   }
13757   if (close (fd) == -1) {
13758     perror (filename);
13759     unlink (filename);
13760     exit (1);
13761   }
13762   if (guestfs_add_drive (g, filename) == -1) {
13763     printf ("guestfs_add_drive %s FAILED\n", filename);
13764     exit (1);
13765   }
13766
13767   if (guestfs_launch (g) == -1) {
13768     printf ("guestfs_launch FAILED\n");
13769     exit (1);
13770   }
13771   if (guestfs_wait_ready (g) == -1) {
13772     printf ("guestfs_wait_ready FAILED\n");
13773     exit (1);
13774   }
13775
13776   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13777    * names.  This changed between RHEL 5 and RHEL 6 so we have to
13778    * support both.
13779    */
13780   devs = guestfs_list_devices (g);
13781   if (devs == NULL || devs[0] == NULL) {
13782     printf ("guestfs_list_devices FAILED\n");
13783     exit (1);
13784   }
13785   if (strncmp (devs[0], "/dev/sd", 7) == 0)
13786     devchar = 's';
13787   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13788     devchar = 'h';
13789   else {
13790     printf ("guestfs_list_devices returned unexpected string '%s'\n",
13791             devs[0]);
13792     exit (1);
13793   }
13794   for (i = 0; devs[i] != NULL; ++i)
13795     free (devs[i]);
13796   free (devs);
13797
13798   nr_tests = 140;
13799
13800   test_num++;
13801   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
13802   if (test_find_0 () == -1) {
13803     printf ("test_find_0 FAILED\n");
13804     failed++;
13805   }
13806   test_num++;
13807   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
13808   if (test_find_1 () == -1) {
13809     printf ("test_find_1 FAILED\n");
13810     failed++;
13811   }
13812   test_num++;
13813   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
13814   if (test_find_2 () == -1) {
13815     printf ("test_find_2 FAILED\n");
13816     failed++;
13817   }
13818   test_num++;
13819   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
13820   if (test_lvresize_0 () == -1) {
13821     printf ("test_lvresize_0 FAILED\n");
13822     failed++;
13823   }
13824   test_num++;
13825   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13826   if (test_zerofree_0 () == -1) {
13827     printf ("test_zerofree_0 FAILED\n");
13828     failed++;
13829   }
13830   test_num++;
13831   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13832   if (test_hexdump_0 () == -1) {
13833     printf ("test_hexdump_0 FAILED\n");
13834     failed++;
13835   }
13836   test_num++;
13837   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13838   if (test_strings_e_0 () == -1) {
13839     printf ("test_strings_e_0 FAILED\n");
13840     failed++;
13841   }
13842   test_num++;
13843   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13844   if (test_strings_e_1 () == -1) {
13845     printf ("test_strings_e_1 FAILED\n");
13846     failed++;
13847   }
13848   test_num++;
13849   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13850   if (test_strings_0 () == -1) {
13851     printf ("test_strings_0 FAILED\n");
13852     failed++;
13853   }
13854   test_num++;
13855   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13856   if (test_strings_1 () == -1) {
13857     printf ("test_strings_1 FAILED\n");
13858     failed++;
13859   }
13860   test_num++;
13861   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13862   if (test_equal_0 () == -1) {
13863     printf ("test_equal_0 FAILED\n");
13864     failed++;
13865   }
13866   test_num++;
13867   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13868   if (test_equal_1 () == -1) {
13869     printf ("test_equal_1 FAILED\n");
13870     failed++;
13871   }
13872   test_num++;
13873   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13874   if (test_equal_2 () == -1) {
13875     printf ("test_equal_2 FAILED\n");
13876     failed++;
13877   }
13878   test_num++;
13879   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13880   if (test_ping_daemon_0 () == -1) {
13881     printf ("test_ping_daemon_0 FAILED\n");
13882     failed++;
13883   }
13884   test_num++;
13885   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13886   if (test_dmesg_0 () == -1) {
13887     printf ("test_dmesg_0 FAILED\n");
13888     failed++;
13889   }
13890   test_num++;
13891   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13892   if (test_drop_caches_0 () == -1) {
13893     printf ("test_drop_caches_0 FAILED\n");
13894     failed++;
13895   }
13896   test_num++;
13897   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13898   if (test_mv_0 () == -1) {
13899     printf ("test_mv_0 FAILED\n");
13900     failed++;
13901   }
13902   test_num++;
13903   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13904   if (test_mv_1 () == -1) {
13905     printf ("test_mv_1 FAILED\n");
13906     failed++;
13907   }
13908   test_num++;
13909   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13910   if (test_cp_a_0 () == -1) {
13911     printf ("test_cp_a_0 FAILED\n");
13912     failed++;
13913   }
13914   test_num++;
13915   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13916   if (test_cp_0 () == -1) {
13917     printf ("test_cp_0 FAILED\n");
13918     failed++;
13919   }
13920   test_num++;
13921   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13922   if (test_cp_1 () == -1) {
13923     printf ("test_cp_1 FAILED\n");
13924     failed++;
13925   }
13926   test_num++;
13927   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13928   if (test_cp_2 () == -1) {
13929     printf ("test_cp_2 FAILED\n");
13930     failed++;
13931   }
13932   test_num++;
13933   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13934   if (test_grub_install_0 () == -1) {
13935     printf ("test_grub_install_0 FAILED\n");
13936     failed++;
13937   }
13938   test_num++;
13939   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13940   if (test_zero_0 () == -1) {
13941     printf ("test_zero_0 FAILED\n");
13942     failed++;
13943   }
13944   test_num++;
13945   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13946   if (test_fsck_0 () == -1) {
13947     printf ("test_fsck_0 FAILED\n");
13948     failed++;
13949   }
13950   test_num++;
13951   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13952   if (test_fsck_1 () == -1) {
13953     printf ("test_fsck_1 FAILED\n");
13954     failed++;
13955   }
13956   test_num++;
13957   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13958   if (test_set_e2uuid_0 () == -1) {
13959     printf ("test_set_e2uuid_0 FAILED\n");
13960     failed++;
13961   }
13962   test_num++;
13963   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13964   if (test_set_e2uuid_1 () == -1) {
13965     printf ("test_set_e2uuid_1 FAILED\n");
13966     failed++;
13967   }
13968   test_num++;
13969   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13970   if (test_set_e2uuid_2 () == -1) {
13971     printf ("test_set_e2uuid_2 FAILED\n");
13972     failed++;
13973   }
13974   test_num++;
13975   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13976   if (test_set_e2uuid_3 () == -1) {
13977     printf ("test_set_e2uuid_3 FAILED\n");
13978     failed++;
13979   }
13980   test_num++;
13981   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13982   if (test_set_e2label_0 () == -1) {
13983     printf ("test_set_e2label_0 FAILED\n");
13984     failed++;
13985   }
13986   test_num++;
13987   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13988   if (test_pvremove_0 () == -1) {
13989     printf ("test_pvremove_0 FAILED\n");
13990     failed++;
13991   }
13992   test_num++;
13993   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13994   if (test_pvremove_1 () == -1) {
13995     printf ("test_pvremove_1 FAILED\n");
13996     failed++;
13997   }
13998   test_num++;
13999   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
14000   if (test_pvremove_2 () == -1) {
14001     printf ("test_pvremove_2 FAILED\n");
14002     failed++;
14003   }
14004   test_num++;
14005   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
14006   if (test_vgremove_0 () == -1) {
14007     printf ("test_vgremove_0 FAILED\n");
14008     failed++;
14009   }
14010   test_num++;
14011   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
14012   if (test_vgremove_1 () == -1) {
14013     printf ("test_vgremove_1 FAILED\n");
14014     failed++;
14015   }
14016   test_num++;
14017   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
14018   if (test_lvremove_0 () == -1) {
14019     printf ("test_lvremove_0 FAILED\n");
14020     failed++;
14021   }
14022   test_num++;
14023   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
14024   if (test_lvremove_1 () == -1) {
14025     printf ("test_lvremove_1 FAILED\n");
14026     failed++;
14027   }
14028   test_num++;
14029   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
14030   if (test_lvremove_2 () == -1) {
14031     printf ("test_lvremove_2 FAILED\n");
14032     failed++;
14033   }
14034   test_num++;
14035   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
14036   if (test_mount_ro_0 () == -1) {
14037     printf ("test_mount_ro_0 FAILED\n");
14038     failed++;
14039   }
14040   test_num++;
14041   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
14042   if (test_mount_ro_1 () == -1) {
14043     printf ("test_mount_ro_1 FAILED\n");
14044     failed++;
14045   }
14046   test_num++;
14047   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
14048   if (test_tgz_in_0 () == -1) {
14049     printf ("test_tgz_in_0 FAILED\n");
14050     failed++;
14051   }
14052   test_num++;
14053   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
14054   if (test_tar_in_0 () == -1) {
14055     printf ("test_tar_in_0 FAILED\n");
14056     failed++;
14057   }
14058   test_num++;
14059   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
14060   if (test_checksum_0 () == -1) {
14061     printf ("test_checksum_0 FAILED\n");
14062     failed++;
14063   }
14064   test_num++;
14065   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
14066   if (test_checksum_1 () == -1) {
14067     printf ("test_checksum_1 FAILED\n");
14068     failed++;
14069   }
14070   test_num++;
14071   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
14072   if (test_checksum_2 () == -1) {
14073     printf ("test_checksum_2 FAILED\n");
14074     failed++;
14075   }
14076   test_num++;
14077   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
14078   if (test_checksum_3 () == -1) {
14079     printf ("test_checksum_3 FAILED\n");
14080     failed++;
14081   }
14082   test_num++;
14083   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
14084   if (test_checksum_4 () == -1) {
14085     printf ("test_checksum_4 FAILED\n");
14086     failed++;
14087   }
14088   test_num++;
14089   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
14090   if (test_checksum_5 () == -1) {
14091     printf ("test_checksum_5 FAILED\n");
14092     failed++;
14093   }
14094   test_num++;
14095   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
14096   if (test_checksum_6 () == -1) {
14097     printf ("test_checksum_6 FAILED\n");
14098     failed++;
14099   }
14100   test_num++;
14101   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
14102   if (test_checksum_7 () == -1) {
14103     printf ("test_checksum_7 FAILED\n");
14104     failed++;
14105   }
14106   test_num++;
14107   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
14108   if (test_download_0 () == -1) {
14109     printf ("test_download_0 FAILED\n");
14110     failed++;
14111   }
14112   test_num++;
14113   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
14114   if (test_upload_0 () == -1) {
14115     printf ("test_upload_0 FAILED\n");
14116     failed++;
14117   }
14118   test_num++;
14119   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
14120   if (test_blockdev_rereadpt_0 () == -1) {
14121     printf ("test_blockdev_rereadpt_0 FAILED\n");
14122     failed++;
14123   }
14124   test_num++;
14125   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
14126   if (test_blockdev_flushbufs_0 () == -1) {
14127     printf ("test_blockdev_flushbufs_0 FAILED\n");
14128     failed++;
14129   }
14130   test_num++;
14131   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
14132   if (test_blockdev_getsize64_0 () == -1) {
14133     printf ("test_blockdev_getsize64_0 FAILED\n");
14134     failed++;
14135   }
14136   test_num++;
14137   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
14138   if (test_blockdev_getsz_0 () == -1) {
14139     printf ("test_blockdev_getsz_0 FAILED\n");
14140     failed++;
14141   }
14142   test_num++;
14143   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
14144   if (test_blockdev_getbsz_0 () == -1) {
14145     printf ("test_blockdev_getbsz_0 FAILED\n");
14146     failed++;
14147   }
14148   test_num++;
14149   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
14150   if (test_blockdev_getss_0 () == -1) {
14151     printf ("test_blockdev_getss_0 FAILED\n");
14152     failed++;
14153   }
14154   test_num++;
14155   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
14156   if (test_blockdev_getro_0 () == -1) {
14157     printf ("test_blockdev_getro_0 FAILED\n");
14158     failed++;
14159   }
14160   test_num++;
14161   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
14162   if (test_blockdev_setrw_0 () == -1) {
14163     printf ("test_blockdev_setrw_0 FAILED\n");
14164     failed++;
14165   }
14166   test_num++;
14167   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
14168   if (test_blockdev_setro_0 () == -1) {
14169     printf ("test_blockdev_setro_0 FAILED\n");
14170     failed++;
14171   }
14172   test_num++;
14173   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
14174   if (test_statvfs_0 () == -1) {
14175     printf ("test_statvfs_0 FAILED\n");
14176     failed++;
14177   }
14178   test_num++;
14179   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
14180   if (test_lstat_0 () == -1) {
14181     printf ("test_lstat_0 FAILED\n");
14182     failed++;
14183   }
14184   test_num++;
14185   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
14186   if (test_stat_0 () == -1) {
14187     printf ("test_stat_0 FAILED\n");
14188     failed++;
14189   }
14190   test_num++;
14191   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
14192   if (test_command_lines_0 () == -1) {
14193     printf ("test_command_lines_0 FAILED\n");
14194     failed++;
14195   }
14196   test_num++;
14197   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
14198   if (test_command_lines_1 () == -1) {
14199     printf ("test_command_lines_1 FAILED\n");
14200     failed++;
14201   }
14202   test_num++;
14203   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
14204   if (test_command_lines_2 () == -1) {
14205     printf ("test_command_lines_2 FAILED\n");
14206     failed++;
14207   }
14208   test_num++;
14209   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
14210   if (test_command_lines_3 () == -1) {
14211     printf ("test_command_lines_3 FAILED\n");
14212     failed++;
14213   }
14214   test_num++;
14215   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
14216   if (test_command_lines_4 () == -1) {
14217     printf ("test_command_lines_4 FAILED\n");
14218     failed++;
14219   }
14220   test_num++;
14221   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
14222   if (test_command_lines_5 () == -1) {
14223     printf ("test_command_lines_5 FAILED\n");
14224     failed++;
14225   }
14226   test_num++;
14227   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
14228   if (test_command_lines_6 () == -1) {
14229     printf ("test_command_lines_6 FAILED\n");
14230     failed++;
14231   }
14232   test_num++;
14233   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
14234   if (test_command_lines_7 () == -1) {
14235     printf ("test_command_lines_7 FAILED\n");
14236     failed++;
14237   }
14238   test_num++;
14239   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
14240   if (test_command_lines_8 () == -1) {
14241     printf ("test_command_lines_8 FAILED\n");
14242     failed++;
14243   }
14244   test_num++;
14245   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
14246   if (test_command_lines_9 () == -1) {
14247     printf ("test_command_lines_9 FAILED\n");
14248     failed++;
14249   }
14250   test_num++;
14251   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
14252   if (test_command_lines_10 () == -1) {
14253     printf ("test_command_lines_10 FAILED\n");
14254     failed++;
14255   }
14256   test_num++;
14257   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
14258   if (test_command_0 () == -1) {
14259     printf ("test_command_0 FAILED\n");
14260     failed++;
14261   }
14262   test_num++;
14263   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
14264   if (test_command_1 () == -1) {
14265     printf ("test_command_1 FAILED\n");
14266     failed++;
14267   }
14268   test_num++;
14269   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
14270   if (test_command_2 () == -1) {
14271     printf ("test_command_2 FAILED\n");
14272     failed++;
14273   }
14274   test_num++;
14275   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
14276   if (test_command_3 () == -1) {
14277     printf ("test_command_3 FAILED\n");
14278     failed++;
14279   }
14280   test_num++;
14281   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
14282   if (test_command_4 () == -1) {
14283     printf ("test_command_4 FAILED\n");
14284     failed++;
14285   }
14286   test_num++;
14287   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
14288   if (test_command_5 () == -1) {
14289     printf ("test_command_5 FAILED\n");
14290     failed++;
14291   }
14292   test_num++;
14293   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
14294   if (test_command_6 () == -1) {
14295     printf ("test_command_6 FAILED\n");
14296     failed++;
14297   }
14298   test_num++;
14299   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
14300   if (test_command_7 () == -1) {
14301     printf ("test_command_7 FAILED\n");
14302     failed++;
14303   }
14304   test_num++;
14305   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
14306   if (test_command_8 () == -1) {
14307     printf ("test_command_8 FAILED\n");
14308     failed++;
14309   }
14310   test_num++;
14311   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
14312   if (test_command_9 () == -1) {
14313     printf ("test_command_9 FAILED\n");
14314     failed++;
14315   }
14316   test_num++;
14317   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
14318   if (test_command_10 () == -1) {
14319     printf ("test_command_10 FAILED\n");
14320     failed++;
14321   }
14322   test_num++;
14323   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
14324   if (test_command_11 () == -1) {
14325     printf ("test_command_11 FAILED\n");
14326     failed++;
14327   }
14328   test_num++;
14329   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
14330   if (test_file_0 () == -1) {
14331     printf ("test_file_0 FAILED\n");
14332     failed++;
14333   }
14334   test_num++;
14335   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
14336   if (test_file_1 () == -1) {
14337     printf ("test_file_1 FAILED\n");
14338     failed++;
14339   }
14340   test_num++;
14341   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
14342   if (test_file_2 () == -1) {
14343     printf ("test_file_2 FAILED\n");
14344     failed++;
14345   }
14346   test_num++;
14347   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
14348   if (test_umount_all_0 () == -1) {
14349     printf ("test_umount_all_0 FAILED\n");
14350     failed++;
14351   }
14352   test_num++;
14353   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
14354   if (test_umount_all_1 () == -1) {
14355     printf ("test_umount_all_1 FAILED\n");
14356     failed++;
14357   }
14358   test_num++;
14359   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
14360   if (test_mounts_0 () == -1) {
14361     printf ("test_mounts_0 FAILED\n");
14362     failed++;
14363   }
14364   test_num++;
14365   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
14366   if (test_umount_0 () == -1) {
14367     printf ("test_umount_0 FAILED\n");
14368     failed++;
14369   }
14370   test_num++;
14371   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
14372   if (test_umount_1 () == -1) {
14373     printf ("test_umount_1 FAILED\n");
14374     failed++;
14375   }
14376   test_num++;
14377   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
14378   if (test_write_file_0 () == -1) {
14379     printf ("test_write_file_0 FAILED\n");
14380     failed++;
14381   }
14382   test_num++;
14383   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
14384   if (test_write_file_1 () == -1) {
14385     printf ("test_write_file_1 FAILED\n");
14386     failed++;
14387   }
14388   test_num++;
14389   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
14390   if (test_write_file_2 () == -1) {
14391     printf ("test_write_file_2 FAILED\n");
14392     failed++;
14393   }
14394   test_num++;
14395   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
14396   if (test_write_file_3 () == -1) {
14397     printf ("test_write_file_3 FAILED\n");
14398     failed++;
14399   }
14400   test_num++;
14401   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
14402   if (test_write_file_4 () == -1) {
14403     printf ("test_write_file_4 FAILED\n");
14404     failed++;
14405   }
14406   test_num++;
14407   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
14408   if (test_write_file_5 () == -1) {
14409     printf ("test_write_file_5 FAILED\n");
14410     failed++;
14411   }
14412   test_num++;
14413   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
14414   if (test_mkfs_0 () == -1) {
14415     printf ("test_mkfs_0 FAILED\n");
14416     failed++;
14417   }
14418   test_num++;
14419   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
14420   if (test_lvcreate_0 () == -1) {
14421     printf ("test_lvcreate_0 FAILED\n");
14422     failed++;
14423   }
14424   test_num++;
14425   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
14426   if (test_vgcreate_0 () == -1) {
14427     printf ("test_vgcreate_0 FAILED\n");
14428     failed++;
14429   }
14430   test_num++;
14431   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
14432   if (test_pvcreate_0 () == -1) {
14433     printf ("test_pvcreate_0 FAILED\n");
14434     failed++;
14435   }
14436   test_num++;
14437   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
14438   if (test_is_dir_0 () == -1) {
14439     printf ("test_is_dir_0 FAILED\n");
14440     failed++;
14441   }
14442   test_num++;
14443   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
14444   if (test_is_dir_1 () == -1) {
14445     printf ("test_is_dir_1 FAILED\n");
14446     failed++;
14447   }
14448   test_num++;
14449   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
14450   if (test_is_file_0 () == -1) {
14451     printf ("test_is_file_0 FAILED\n");
14452     failed++;
14453   }
14454   test_num++;
14455   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
14456   if (test_is_file_1 () == -1) {
14457     printf ("test_is_file_1 FAILED\n");
14458     failed++;
14459   }
14460   test_num++;
14461   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
14462   if (test_exists_0 () == -1) {
14463     printf ("test_exists_0 FAILED\n");
14464     failed++;
14465   }
14466   test_num++;
14467   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
14468   if (test_exists_1 () == -1) {
14469     printf ("test_exists_1 FAILED\n");
14470     failed++;
14471   }
14472   test_num++;
14473   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
14474   if (test_mkdir_p_0 () == -1) {
14475     printf ("test_mkdir_p_0 FAILED\n");
14476     failed++;
14477   }
14478   test_num++;
14479   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
14480   if (test_mkdir_p_1 () == -1) {
14481     printf ("test_mkdir_p_1 FAILED\n");
14482     failed++;
14483   }
14484   test_num++;
14485   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
14486   if (test_mkdir_p_2 () == -1) {
14487     printf ("test_mkdir_p_2 FAILED\n");
14488     failed++;
14489   }
14490   test_num++;
14491   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
14492   if (test_mkdir_0 () == -1) {
14493     printf ("test_mkdir_0 FAILED\n");
14494     failed++;
14495   }
14496   test_num++;
14497   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
14498   if (test_mkdir_1 () == -1) {
14499     printf ("test_mkdir_1 FAILED\n");
14500     failed++;
14501   }
14502   test_num++;
14503   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
14504   if (test_rm_rf_0 () == -1) {
14505     printf ("test_rm_rf_0 FAILED\n");
14506     failed++;
14507   }
14508   test_num++;
14509   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
14510   if (test_rmdir_0 () == -1) {
14511     printf ("test_rmdir_0 FAILED\n");
14512     failed++;
14513   }
14514   test_num++;
14515   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
14516   if (test_rmdir_1 () == -1) {
14517     printf ("test_rmdir_1 FAILED\n");
14518     failed++;
14519   }
14520   test_num++;
14521   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
14522   if (test_rmdir_2 () == -1) {
14523     printf ("test_rmdir_2 FAILED\n");
14524     failed++;
14525   }
14526   test_num++;
14527   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
14528   if (test_rm_0 () == -1) {
14529     printf ("test_rm_0 FAILED\n");
14530     failed++;
14531   }
14532   test_num++;
14533   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
14534   if (test_rm_1 () == -1) {
14535     printf ("test_rm_1 FAILED\n");
14536     failed++;
14537   }
14538   test_num++;
14539   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
14540   if (test_rm_2 () == -1) {
14541     printf ("test_rm_2 FAILED\n");
14542     failed++;
14543   }
14544   test_num++;
14545   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
14546   if (test_read_lines_0 () == -1) {
14547     printf ("test_read_lines_0 FAILED\n");
14548     failed++;
14549   }
14550   test_num++;
14551   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
14552   if (test_read_lines_1 () == -1) {
14553     printf ("test_read_lines_1 FAILED\n");
14554     failed++;
14555   }
14556   test_num++;
14557   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
14558   if (test_lvs_0 () == -1) {
14559     printf ("test_lvs_0 FAILED\n");
14560     failed++;
14561   }
14562   test_num++;
14563   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
14564   if (test_lvs_1 () == -1) {
14565     printf ("test_lvs_1 FAILED\n");
14566     failed++;
14567   }
14568   test_num++;
14569   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
14570   if (test_vgs_0 () == -1) {
14571     printf ("test_vgs_0 FAILED\n");
14572     failed++;
14573   }
14574   test_num++;
14575   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
14576   if (test_vgs_1 () == -1) {
14577     printf ("test_vgs_1 FAILED\n");
14578     failed++;
14579   }
14580   test_num++;
14581   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
14582   if (test_pvs_0 () == -1) {
14583     printf ("test_pvs_0 FAILED\n");
14584     failed++;
14585   }
14586   test_num++;
14587   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
14588   if (test_pvs_1 () == -1) {
14589     printf ("test_pvs_1 FAILED\n");
14590     failed++;
14591   }
14592   test_num++;
14593   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
14594   if (test_list_partitions_0 () == -1) {
14595     printf ("test_list_partitions_0 FAILED\n");
14596     failed++;
14597   }
14598   test_num++;
14599   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
14600   if (test_list_partitions_1 () == -1) {
14601     printf ("test_list_partitions_1 FAILED\n");
14602     failed++;
14603   }
14604   test_num++;
14605   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
14606   if (test_list_devices_0 () == -1) {
14607     printf ("test_list_devices_0 FAILED\n");
14608     failed++;
14609   }
14610   test_num++;
14611   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
14612   if (test_ls_0 () == -1) {
14613     printf ("test_ls_0 FAILED\n");
14614     failed++;
14615   }
14616   test_num++;
14617   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
14618   if (test_cat_0 () == -1) {
14619     printf ("test_cat_0 FAILED\n");
14620     failed++;
14621   }
14622   test_num++;
14623   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
14624   if (test_touch_0 () == -1) {
14625     printf ("test_touch_0 FAILED\n");
14626     failed++;
14627   }
14628   test_num++;
14629   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
14630   if (test_sync_0 () == -1) {
14631     printf ("test_sync_0 FAILED\n");
14632     failed++;
14633   }
14634   test_num++;
14635   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
14636   if (test_mount_0 () == -1) {
14637     printf ("test_mount_0 FAILED\n");
14638     failed++;
14639   }
14640
14641   guestfs_close (g);
14642   unlink ("test1.img");
14643   unlink ("test2.img");
14644   unlink ("test3.img");
14645
14646   if (failed > 0) {
14647     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
14648     exit (1);
14649   }
14650
14651   exit (0);
14652 }