tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 /* This will be 's' or 'h' depending on whether the guest kernel
  35  * names IDE devices /dev/sd* or /dev/hd*.
  36  */
  37 static char devchar = 's';
  38
  39 static void print_error (guestfs_h *g, void *data, const char *msg)
  40 {
  41   if (!suppress_error)
  42     fprintf (stderr, "%s\n", msg);
  43 }
  44
  45 static void print_strings (char * const * const argv)
  46 {
  47   int argc;
  48
  49   for (argc = 0; argv[argc] != NULL; ++argc)
  50     printf ("\t%s\n", argv[argc]);
  51 }
  52
  53 /*
  54 static void print_table (char * const * const argv)
  55 {
  56   int i;
  57
  58   for (i = 0; argv[i] != NULL; i += 2)
  59     printf ("%s: %s\n", argv[i], argv[i+1]);
  60 }
  61 */
  62
  63 static void no_test_warnings (void)
  64 {
  65   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 127 }
 128
 129 static int test_find_0 (void)
 130 {
 131   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 132   {
 133     char device[] = "/dev/sda";
 134     device[5] = devchar;
 135     int r;
 136     suppress_error = 0;
 137     r = guestfs_blockdev_setrw (g, device);
 138     if (r == -1)
 139       return -1;
 140   }
 141   {
 142     int r;
 143     suppress_error = 0;
 144     r = guestfs_umount_all (g);
 145     if (r == -1)
 146       return -1;
 147   }
 148   {
 149     int r;
 150     suppress_error = 0;
 151     r = guestfs_lvm_remove_all (g);
 152     if (r == -1)
 153       return -1;
 154   }
 155   {
 156     char device[] = "/dev/sda";
 157     device[5] = devchar;
 158     char lines_0[] = ",";
 159     char *lines[] = {
 160       lines_0,
 161       NULL
 162     };
 163     int r;
 164     suppress_error = 0;
 165     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 166     if (r == -1)
 167       return -1;
 168   }
 169   {
 170     char fstype[] = "ext2";
 171     char device[] = "/dev/sda1";
 172     device[5] = devchar;
 173     int r;
 174     suppress_error = 0;
 175     r = guestfs_mkfs (g, fstype, device);
 176     if (r == -1)
 177       return -1;
 178   }
 179   {
 180     char device[] = "/dev/sda1";
 181     device[5] = devchar;
 182     char mountpoint[] = "/";
 183     int r;
 184     suppress_error = 0;
 185     r = guestfs_mount (g, device, mountpoint);
 186     if (r == -1)
 187       return -1;
 188   }
 189   /* TestOutputList for find (0) */
 190   {
 191     char directory[] = "/";
 192     char **r;
 193     int i;
 194     suppress_error = 0;
 195     r = guestfs_find (g, directory);
 196     if (r == NULL)
 197       return -1;
 198     if (!r[0]) {
 199       fprintf (stderr, "test_find_0: short list returned from command\n");
 200       print_strings (r);
 201       return -1;
 202     }
 203     {
 204       char expected[] = "lost+found";
 205       if (strcmp (r[0], expected) != 0) {
 206         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 207         return -1;
 208       }
 209     }
 210     if (r[1] != NULL) {
 211       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 212       print_strings (r);
 213       return -1;
 214     }
 215     for (i = 0; r[i] != NULL; ++i)
 216       free (r[i]);
 217     free (r);
 218   }
 219   return 0;
 220 }
 221
 222 static int test_find_1 (void)
 223 {
 224   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
 225   {
 226     char device[] = "/dev/sda";
 227     device[5] = devchar;
 228     int r;
 229     suppress_error = 0;
 230     r = guestfs_blockdev_setrw (g, device);
 231     if (r == -1)
 232       return -1;
 233   }
 234   {
 235     int r;
 236     suppress_error = 0;
 237     r = guestfs_umount_all (g);
 238     if (r == -1)
 239       return -1;
 240   }
 241   {
 242     int r;
 243     suppress_error = 0;
 244     r = guestfs_lvm_remove_all (g);
 245     if (r == -1)
 246       return -1;
 247   }
 248   {
 249     char device[] = "/dev/sda";
 250     device[5] = devchar;
 251     char lines_0[] = ",";
 252     char *lines[] = {
 253       lines_0,
 254       NULL
 255     };
 256     int r;
 257     suppress_error = 0;
 258     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 259     if (r == -1)
 260       return -1;
 261   }
 262   {
 263     char fstype[] = "ext2";
 264     char device[] = "/dev/sda1";
 265     device[5] = devchar;
 266     int r;
 267     suppress_error = 0;
 268     r = guestfs_mkfs (g, fstype, device);
 269     if (r == -1)
 270       return -1;
 271   }
 272   {
 273     char device[] = "/dev/sda1";
 274     device[5] = devchar;
 275     char mountpoint[] = "/";
 276     int r;
 277     suppress_error = 0;
 278     r = guestfs_mount (g, device, mountpoint);
 279     if (r == -1)
 280       return -1;
 281   }
 282   /* TestOutputList for find (1) */
 283   {
 284     char path[] = "/a";
 285     int r;
 286     suppress_error = 0;
 287     r = guestfs_touch (g, path);
 288     if (r == -1)
 289       return -1;
 290   }
 291   {
 292     char path[] = "/b";
 293     int r;
 294     suppress_error = 0;
 295     r = guestfs_mkdir (g, path);
 296     if (r == -1)
 297       return -1;
 298   }
 299   {
 300     char path[] = "/b/c";
 301     int r;
 302     suppress_error = 0;
 303     r = guestfs_touch (g, path);
 304     if (r == -1)
 305       return -1;
 306   }
 307   {
 308     char directory[] = "/";
 309     char **r;
 310     int i;
 311     suppress_error = 0;
 312     r = guestfs_find (g, directory);
 313     if (r == NULL)
 314       return -1;
 315     if (!r[0]) {
 316       fprintf (stderr, "test_find_1: short list returned from command\n");
 317       print_strings (r);
 318       return -1;
 319     }
 320     {
 321       char expected[] = "a";
 322       if (strcmp (r[0], expected) != 0) {
 323         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 324         return -1;
 325       }
 326     }
 327     if (!r[1]) {
 328       fprintf (stderr, "test_find_1: short list returned from command\n");
 329       print_strings (r);
 330       return -1;
 331     }
 332     {
 333       char expected[] = "b";
 334       if (strcmp (r[1], expected) != 0) {
 335         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 336         return -1;
 337       }
 338     }
 339     if (!r[2]) {
 340       fprintf (stderr, "test_find_1: short list returned from command\n");
 341       print_strings (r);
 342       return -1;
 343     }
 344     {
 345       char expected[] = "b/c";
 346       if (strcmp (r[2], expected) != 0) {
 347         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 348         return -1;
 349       }
 350     }
 351     if (!r[3]) {
 352       fprintf (stderr, "test_find_1: short list returned from command\n");
 353       print_strings (r);
 354       return -1;
 355     }
 356     {
 357       char expected[] = "lost+found";
 358       if (strcmp (r[3], expected) != 0) {
 359         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 360         return -1;
 361       }
 362     }
 363     if (r[4] != NULL) {
 364       fprintf (stderr, "test_find_1: extra elements returned from command\n");
 365       print_strings (r);
 366       return -1;
 367     }
 368     for (i = 0; r[i] != NULL; ++i)
 369       free (r[i]);
 370     free (r);
 371   }
 372   return 0;
 373 }
 374
 375 static int test_find_2 (void)
 376 {
 377   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
 378   {
 379     char device[] = "/dev/sda";
 380     device[5] = devchar;
 381     int r;
 382     suppress_error = 0;
 383     r = guestfs_blockdev_setrw (g, device);
 384     if (r == -1)
 385       return -1;
 386   }
 387   {
 388     int r;
 389     suppress_error = 0;
 390     r = guestfs_umount_all (g);
 391     if (r == -1)
 392       return -1;
 393   }
 394   {
 395     int r;
 396     suppress_error = 0;
 397     r = guestfs_lvm_remove_all (g);
 398     if (r == -1)
 399       return -1;
 400   }
 401   {
 402     char device[] = "/dev/sda";
 403     device[5] = devchar;
 404     char lines_0[] = ",";
 405     char *lines[] = {
 406       lines_0,
 407       NULL
 408     };
 409     int r;
 410     suppress_error = 0;
 411     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 412     if (r == -1)
 413       return -1;
 414   }
 415   {
 416     char fstype[] = "ext2";
 417     char device[] = "/dev/sda1";
 418     device[5] = devchar;
 419     int r;
 420     suppress_error = 0;
 421     r = guestfs_mkfs (g, fstype, device);
 422     if (r == -1)
 423       return -1;
 424   }
 425   {
 426     char device[] = "/dev/sda1";
 427     device[5] = devchar;
 428     char mountpoint[] = "/";
 429     int r;
 430     suppress_error = 0;
 431     r = guestfs_mount (g, device, mountpoint);
 432     if (r == -1)
 433       return -1;
 434   }
 435   /* TestOutputList for find (2) */
 436   {
 437     char path[] = "/a/b/c";
 438     int r;
 439     suppress_error = 0;
 440     r = guestfs_mkdir_p (g, path);
 441     if (r == -1)
 442       return -1;
 443   }
 444   {
 445     char path[] = "/a/b/c/d";
 446     int r;
 447     suppress_error = 0;
 448     r = guestfs_touch (g, path);
 449     if (r == -1)
 450       return -1;
 451   }
 452   {
 453     char directory[] = "/a/b/";
 454     char **r;
 455     int i;
 456     suppress_error = 0;
 457     r = guestfs_find (g, directory);
 458     if (r == NULL)
 459       return -1;
 460     if (!r[0]) {
 461       fprintf (stderr, "test_find_2: short list returned from command\n");
 462       print_strings (r);
 463       return -1;
 464     }
 465     {
 466       char expected[] = "c";
 467       if (strcmp (r[0], expected) != 0) {
 468         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 469         return -1;
 470       }
 471     }
 472     if (!r[1]) {
 473       fprintf (stderr, "test_find_2: short list returned from command\n");
 474       print_strings (r);
 475       return -1;
 476     }
 477     {
 478       char expected[] = "c/d";
 479       if (strcmp (r[1], expected) != 0) {
 480         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 481         return -1;
 482       }
 483     }
 484     if (r[2] != NULL) {
 485       fprintf (stderr, "test_find_2: extra elements returned from command\n");
 486       print_strings (r);
 487       return -1;
 488     }
 489     for (i = 0; r[i] != NULL; ++i)
 490       free (r[i]);
 491     free (r);
 492   }
 493   return 0;
 494 }
 495
 496 static int test_lvresize_0 (void)
 497 {
 498   /* InitNone|InitEmpty for test_lvresize_0 */
 499   {
 500     char device[] = "/dev/sda";
 501     device[5] = devchar;
 502     int r;
 503     suppress_error = 0;
 504     r = guestfs_blockdev_setrw (g, device);
 505     if (r == -1)
 506       return -1;
 507   }
 508   {
 509     int r;
 510     suppress_error = 0;
 511     r = guestfs_umount_all (g);
 512     if (r == -1)
 513       return -1;
 514   }
 515   {
 516     int r;
 517     suppress_error = 0;
 518     r = guestfs_lvm_remove_all (g);
 519     if (r == -1)
 520       return -1;
 521   }
 522   /* TestOutput for lvresize (0) */
 523   char expected[] = "test content";
 524   {
 525     char device[] = "/dev/sda";
 526     device[5] = devchar;
 527     char lines_0[] = ",";
 528     char *lines[] = {
 529       lines_0,
 530       NULL
 531     };
 532     int r;
 533     suppress_error = 0;
 534     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 535     if (r == -1)
 536       return -1;
 537   }
 538   {
 539     char device[] = "/dev/sda1";
 540     device[5] = devchar;
 541     int r;
 542     suppress_error = 0;
 543     r = guestfs_pvcreate (g, device);
 544     if (r == -1)
 545       return -1;
 546   }
 547   {
 548     char volgroup[] = "VG";
 549     char physvols_0[] = "/dev/sda1";
 550     physvols_0[5] = devchar;
 551     char *physvols[] = {
 552       physvols_0,
 553       NULL
 554     };
 555     int r;
 556     suppress_error = 0;
 557     r = guestfs_vgcreate (g, volgroup, physvols);
 558     if (r == -1)
 559       return -1;
 560   }
 561   {
 562     char logvol[] = "LV";
 563     char volgroup[] = "VG";
 564     int r;
 565     suppress_error = 0;
 566     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 567     if (r == -1)
 568       return -1;
 569   }
 570   {
 571     char fstype[] = "ext2";
 572     char device[] = "/dev/VG/LV";
 573     int r;
 574     suppress_error = 0;
 575     r = guestfs_mkfs (g, fstype, device);
 576     if (r == -1)
 577       return -1;
 578   }
 579   {
 580     char device[] = "/dev/VG/LV";
 581     char mountpoint[] = "/";
 582     int r;
 583     suppress_error = 0;
 584     r = guestfs_mount (g, device, mountpoint);
 585     if (r == -1)
 586       return -1;
 587   }
 588   {
 589     char path[] = "/new";
 590     char content[] = "test content";
 591     int r;
 592     suppress_error = 0;
 593     r = guestfs_write_file (g, path, content, 0);
 594     if (r == -1)
 595       return -1;
 596   }
 597   {
 598     char pathordevice[] = "/";
 599     int r;
 600     suppress_error = 0;
 601     r = guestfs_umount (g, pathordevice);
 602     if (r == -1)
 603       return -1;
 604   }
 605   {
 606     char device[] = "/dev/VG/LV";
 607     int r;
 608     suppress_error = 0;
 609     r = guestfs_lvresize (g, device, 20);
 610     if (r == -1)
 611       return -1;
 612   }
 613   {
 614     char device[] = "/dev/VG/LV";
 615     int r;
 616     suppress_error = 0;
 617     r = guestfs_resize2fs (g, device);
 618     if (r == -1)
 619       return -1;
 620   }
 621   {
 622     char device[] = "/dev/VG/LV";
 623     char mountpoint[] = "/";
 624     int r;
 625     suppress_error = 0;
 626     r = guestfs_mount (g, device, mountpoint);
 627     if (r == -1)
 628       return -1;
 629   }
 630   {
 631     char path[] = "/new";
 632     char *r;
 633     suppress_error = 0;
 634     r = guestfs_cat (g, path);
 635     if (r == NULL)
 636       return -1;
 637     if (strcmp (r, expected) != 0) {
 638       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 639       return -1;
 640     }
 641     free (r);
 642   }
 643   return 0;
 644 }
 645
 646 static int test_zerofree_0_prereq (void)
 647 {
 648   const char *str = getenv ("SKIP_ZEROFREE");
 649   return str && strcmp (str, "1") == 0;
 650 }
 651
 652 static int test_zerofree_0 (void)
 653 {
 654   if (! test_zerofree_0_prereq ()) {
 655   /* InitNone|InitEmpty for test_zerofree_0 */
 656   {
 657     char device[] = "/dev/sda";
 658     device[5] = devchar;
 659     int r;
 660     suppress_error = 0;
 661     r = guestfs_blockdev_setrw (g, device);
 662     if (r == -1)
 663       return -1;
 664   }
 665   {
 666     int r;
 667     suppress_error = 0;
 668     r = guestfs_umount_all (g);
 669     if (r == -1)
 670       return -1;
 671   }
 672   {
 673     int r;
 674     suppress_error = 0;
 675     r = guestfs_lvm_remove_all (g);
 676     if (r == -1)
 677       return -1;
 678   }
 679   /* TestOutput for zerofree (0) */
 680   char expected[] = "test file";
 681   {
 682     char device[] = "/dev/sda";
 683     device[5] = devchar;
 684     char lines_0[] = ",";
 685     char *lines[] = {
 686       lines_0,
 687       NULL
 688     };
 689     int r;
 690     suppress_error = 0;
 691     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 692     if (r == -1)
 693       return -1;
 694   }
 695   {
 696     char fstype[] = "ext3";
 697     char device[] = "/dev/sda1";
 698     device[5] = devchar;
 699     int r;
 700     suppress_error = 0;
 701     r = guestfs_mkfs (g, fstype, device);
 702     if (r == -1)
 703       return -1;
 704   }
 705   {
 706     char device[] = "/dev/sda1";
 707     device[5] = devchar;
 708     char mountpoint[] = "/";
 709     int r;
 710     suppress_error = 0;
 711     r = guestfs_mount (g, device, mountpoint);
 712     if (r == -1)
 713       return -1;
 714   }
 715   {
 716     char path[] = "/new";
 717     char content[] = "test file";
 718     int r;
 719     suppress_error = 0;
 720     r = guestfs_write_file (g, path, content, 0);
 721     if (r == -1)
 722       return -1;
 723   }
 724   {
 725     char pathordevice[] = "/dev/sda1";
 726     pathordevice[5] = devchar;
 727     int r;
 728     suppress_error = 0;
 729     r = guestfs_umount (g, pathordevice);
 730     if (r == -1)
 731       return -1;
 732   }
 733   {
 734     char device[] = "/dev/sda1";
 735     device[5] = devchar;
 736     int r;
 737     suppress_error = 0;
 738     r = guestfs_zerofree (g, device);
 739     if (r == -1)
 740       return -1;
 741   }
 742   {
 743     char device[] = "/dev/sda1";
 744     device[5] = devchar;
 745     char mountpoint[] = "/";
 746     int r;
 747     suppress_error = 0;
 748     r = guestfs_mount (g, device, mountpoint);
 749     if (r == -1)
 750       return -1;
 751   }
 752   {
 753     char path[] = "/new";
 754     char *r;
 755     suppress_error = 0;
 756     r = guestfs_cat (g, path);
 757     if (r == NULL)
 758       return -1;
 759     if (strcmp (r, expected) != 0) {
 760       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
 761       return -1;
 762     }
 763     free (r);
 764   }
 765   } else
 766     printf ("%s skipped (reason: test prerequisite)\n", "test_zerofree_0");
 767   return 0;
 768 }
 769
 770 static int test_hexdump_0 (void)
 771 {
 772   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
 773   {
 774     char device[] = "/dev/sda";
 775     device[5] = devchar;
 776     int r;
 777     suppress_error = 0;
 778     r = guestfs_blockdev_setrw (g, device);
 779     if (r == -1)
 780       return -1;
 781   }
 782   {
 783     int r;
 784     suppress_error = 0;
 785     r = guestfs_umount_all (g);
 786     if (r == -1)
 787       return -1;
 788   }
 789   {
 790     int r;
 791     suppress_error = 0;
 792     r = guestfs_lvm_remove_all (g);
 793     if (r == -1)
 794       return -1;
 795   }
 796   {
 797     char device[] = "/dev/sda";
 798     device[5] = devchar;
 799     char lines_0[] = ",";
 800     char *lines[] = {
 801       lines_0,
 802       NULL
 803     };
 804     int r;
 805     suppress_error = 0;
 806     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 807     if (r == -1)
 808       return -1;
 809   }
 810   {
 811     char fstype[] = "ext2";
 812     char device[] = "/dev/sda1";
 813     device[5] = devchar;
 814     int r;
 815     suppress_error = 0;
 816     r = guestfs_mkfs (g, fstype, device);
 817     if (r == -1)
 818       return -1;
 819   }
 820   {
 821     char device[] = "/dev/sda1";
 822     device[5] = devchar;
 823     char mountpoint[] = "/";
 824     int r;
 825     suppress_error = 0;
 826     r = guestfs_mount (g, device, mountpoint);
 827     if (r == -1)
 828       return -1;
 829   }
 830   /* TestOutput for hexdump (0) */
 831   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
 832   {
 833     char path[] = "/new";
 834     char content[] = "hello\nworld\n";
 835     int r;
 836     suppress_error = 0;
 837     r = guestfs_write_file (g, path, content, 12);
 838     if (r == -1)
 839       return -1;
 840   }
 841   {
 842     char path[] = "/new";
 843     char *r;
 844     suppress_error = 0;
 845     r = guestfs_hexdump (g, path);
 846     if (r == NULL)
 847       return -1;
 848     if (strcmp (r, expected) != 0) {
 849       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
 850       return -1;
 851     }
 852     free (r);
 853   }
 854   return 0;
 855 }
 856
 857 static int test_strings_e_0 (void)
 858 {
 859   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
 860   {
 861     char device[] = "/dev/sda";
 862     device[5] = devchar;
 863     int r;
 864     suppress_error = 0;
 865     r = guestfs_blockdev_setrw (g, device);
 866     if (r == -1)
 867       return -1;
 868   }
 869   {
 870     int r;
 871     suppress_error = 0;
 872     r = guestfs_umount_all (g);
 873     if (r == -1)
 874       return -1;
 875   }
 876   {
 877     int r;
 878     suppress_error = 0;
 879     r = guestfs_lvm_remove_all (g);
 880     if (r == -1)
 881       return -1;
 882   }
 883   {
 884     char device[] = "/dev/sda";
 885     device[5] = devchar;
 886     char lines_0[] = ",";
 887     char *lines[] = {
 888       lines_0,
 889       NULL
 890     };
 891     int r;
 892     suppress_error = 0;
 893     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 894     if (r == -1)
 895       return -1;
 896   }
 897   {
 898     char fstype[] = "ext2";
 899     char device[] = "/dev/sda1";
 900     device[5] = devchar;
 901     int r;
 902     suppress_error = 0;
 903     r = guestfs_mkfs (g, fstype, device);
 904     if (r == -1)
 905       return -1;
 906   }
 907   {
 908     char device[] = "/dev/sda1";
 909     device[5] = devchar;
 910     char mountpoint[] = "/";
 911     int r;
 912     suppress_error = 0;
 913     r = guestfs_mount (g, device, mountpoint);
 914     if (r == -1)
 915       return -1;
 916   }
 917   /* TestOutputList for strings_e (0) */
 918   {
 919     char path[] = "/new";
 920     char content[] = "hello\nworld\n";
 921     int r;
 922     suppress_error = 0;
 923     r = guestfs_write_file (g, path, content, 0);
 924     if (r == -1)
 925       return -1;
 926   }
 927   {
 928     char encoding[] = "b";
 929     char path[] = "/new";
 930     char **r;
 931     int i;
 932     suppress_error = 0;
 933     r = guestfs_strings_e (g, encoding, path);
 934     if (r == NULL)
 935       return -1;
 936     if (r[0] != NULL) {
 937       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
 938       print_strings (r);
 939       return -1;
 940     }
 941     for (i = 0; r[i] != NULL; ++i)
 942       free (r[i]);
 943     free (r);
 944   }
 945   return 0;
 946 }
 947
 948 static int test_strings_e_1 (void)
 949 {
 950   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
 951   return 0;
 952 }
 953
 954 static int test_strings_0 (void)
 955 {
 956   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
 957   {
 958     char device[] = "/dev/sda";
 959     device[5] = devchar;
 960     int r;
 961     suppress_error = 0;
 962     r = guestfs_blockdev_setrw (g, device);
 963     if (r == -1)
 964       return -1;
 965   }
 966   {
 967     int r;
 968     suppress_error = 0;
 969     r = guestfs_umount_all (g);
 970     if (r == -1)
 971       return -1;
 972   }
 973   {
 974     int r;
 975     suppress_error = 0;
 976     r = guestfs_lvm_remove_all (g);
 977     if (r == -1)
 978       return -1;
 979   }
 980   {
 981     char device[] = "/dev/sda";
 982     device[5] = devchar;
 983     char lines_0[] = ",";
 984     char *lines[] = {
 985       lines_0,
 986       NULL
 987     };
 988     int r;
 989     suppress_error = 0;
 990     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 991     if (r == -1)
 992       return -1;
 993   }
 994   {
 995     char fstype[] = "ext2";
 996     char device[] = "/dev/sda1";
 997     device[5] = devchar;
 998     int r;
 999     suppress_error = 0;
1000     r = guestfs_mkfs (g, fstype, device);
1001     if (r == -1)
1002       return -1;
1003   }
1004   {
1005     char device[] = "/dev/sda1";
1006     device[5] = devchar;
1007     char mountpoint[] = "/";
1008     int r;
1009     suppress_error = 0;
1010     r = guestfs_mount (g, device, mountpoint);
1011     if (r == -1)
1012       return -1;
1013   }
1014   /* TestOutputList for strings (0) */
1015   {
1016     char path[] = "/new";
1017     char content[] = "hello\nworld\n";
1018     int r;
1019     suppress_error = 0;
1020     r = guestfs_write_file (g, path, content, 0);
1021     if (r == -1)
1022       return -1;
1023   }
1024   {
1025     char path[] = "/new";
1026     char **r;
1027     int i;
1028     suppress_error = 0;
1029     r = guestfs_strings (g, path);
1030     if (r == NULL)
1031       return -1;
1032     if (!r[0]) {
1033       fprintf (stderr, "test_strings_0: short list returned from command\n");
1034       print_strings (r);
1035       return -1;
1036     }
1037     {
1038       char expected[] = "hello";
1039       if (strcmp (r[0], expected) != 0) {
1040         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1041         return -1;
1042       }
1043     }
1044     if (!r[1]) {
1045       fprintf (stderr, "test_strings_0: short list returned from command\n");
1046       print_strings (r);
1047       return -1;
1048     }
1049     {
1050       char expected[] = "world";
1051       if (strcmp (r[1], expected) != 0) {
1052         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1053         return -1;
1054       }
1055     }
1056     if (r[2] != NULL) {
1057       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1058       print_strings (r);
1059       return -1;
1060     }
1061     for (i = 0; r[i] != NULL; ++i)
1062       free (r[i]);
1063     free (r);
1064   }
1065   return 0;
1066 }
1067
1068 static int test_strings_1 (void)
1069 {
1070   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1071   {
1072     char device[] = "/dev/sda";
1073     device[5] = devchar;
1074     int r;
1075     suppress_error = 0;
1076     r = guestfs_blockdev_setrw (g, device);
1077     if (r == -1)
1078       return -1;
1079   }
1080   {
1081     int r;
1082     suppress_error = 0;
1083     r = guestfs_umount_all (g);
1084     if (r == -1)
1085       return -1;
1086   }
1087   {
1088     int r;
1089     suppress_error = 0;
1090     r = guestfs_lvm_remove_all (g);
1091     if (r == -1)
1092       return -1;
1093   }
1094   {
1095     char device[] = "/dev/sda";
1096     device[5] = devchar;
1097     char lines_0[] = ",";
1098     char *lines[] = {
1099       lines_0,
1100       NULL
1101     };
1102     int r;
1103     suppress_error = 0;
1104     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1105     if (r == -1)
1106       return -1;
1107   }
1108   {
1109     char fstype[] = "ext2";
1110     char device[] = "/dev/sda1";
1111     device[5] = devchar;
1112     int r;
1113     suppress_error = 0;
1114     r = guestfs_mkfs (g, fstype, device);
1115     if (r == -1)
1116       return -1;
1117   }
1118   {
1119     char device[] = "/dev/sda1";
1120     device[5] = devchar;
1121     char mountpoint[] = "/";
1122     int r;
1123     suppress_error = 0;
1124     r = guestfs_mount (g, device, mountpoint);
1125     if (r == -1)
1126       return -1;
1127   }
1128   /* TestOutputList for strings (1) */
1129   {
1130     char path[] = "/new";
1131     int r;
1132     suppress_error = 0;
1133     r = guestfs_touch (g, path);
1134     if (r == -1)
1135       return -1;
1136   }
1137   {
1138     char path[] = "/new";
1139     char **r;
1140     int i;
1141     suppress_error = 0;
1142     r = guestfs_strings (g, path);
1143     if (r == NULL)
1144       return -1;
1145     if (r[0] != NULL) {
1146       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1147       print_strings (r);
1148       return -1;
1149     }
1150     for (i = 0; r[i] != NULL; ++i)
1151       free (r[i]);
1152     free (r);
1153   }
1154   return 0;
1155 }
1156
1157 static int test_equal_0 (void)
1158 {
1159   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1160   {
1161     char device[] = "/dev/sda";
1162     device[5] = devchar;
1163     int r;
1164     suppress_error = 0;
1165     r = guestfs_blockdev_setrw (g, device);
1166     if (r == -1)
1167       return -1;
1168   }
1169   {
1170     int r;
1171     suppress_error = 0;
1172     r = guestfs_umount_all (g);
1173     if (r == -1)
1174       return -1;
1175   }
1176   {
1177     int r;
1178     suppress_error = 0;
1179     r = guestfs_lvm_remove_all (g);
1180     if (r == -1)
1181       return -1;
1182   }
1183   {
1184     char device[] = "/dev/sda";
1185     device[5] = devchar;
1186     char lines_0[] = ",";
1187     char *lines[] = {
1188       lines_0,
1189       NULL
1190     };
1191     int r;
1192     suppress_error = 0;
1193     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1194     if (r == -1)
1195       return -1;
1196   }
1197   {
1198     char fstype[] = "ext2";
1199     char device[] = "/dev/sda1";
1200     device[5] = devchar;
1201     int r;
1202     suppress_error = 0;
1203     r = guestfs_mkfs (g, fstype, device);
1204     if (r == -1)
1205       return -1;
1206   }
1207   {
1208     char device[] = "/dev/sda1";
1209     device[5] = devchar;
1210     char mountpoint[] = "/";
1211     int r;
1212     suppress_error = 0;
1213     r = guestfs_mount (g, device, mountpoint);
1214     if (r == -1)
1215       return -1;
1216   }
1217   /* TestOutputTrue for equal (0) */
1218   {
1219     char path[] = "/file1";
1220     char content[] = "contents of a file";
1221     int r;
1222     suppress_error = 0;
1223     r = guestfs_write_file (g, path, content, 0);
1224     if (r == -1)
1225       return -1;
1226   }
1227   {
1228     char src[] = "/file1";
1229     char dest[] = "/file2";
1230     int r;
1231     suppress_error = 0;
1232     r = guestfs_cp (g, src, dest);
1233     if (r == -1)
1234       return -1;
1235   }
1236   {
1237     char file1[] = "/file1";
1238     char file2[] = "/file2";
1239     int r;
1240     suppress_error = 0;
1241     r = guestfs_equal (g, file1, file2);
1242     if (r == -1)
1243       return -1;
1244     if (!r) {
1245       fprintf (stderr, "test_equal_0: expected true, got false\n");
1246       return -1;
1247     }
1248   }
1249   return 0;
1250 }
1251
1252 static int test_equal_1 (void)
1253 {
1254   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1255   {
1256     char device[] = "/dev/sda";
1257     device[5] = devchar;
1258     int r;
1259     suppress_error = 0;
1260     r = guestfs_blockdev_setrw (g, device);
1261     if (r == -1)
1262       return -1;
1263   }
1264   {
1265     int r;
1266     suppress_error = 0;
1267     r = guestfs_umount_all (g);
1268     if (r == -1)
1269       return -1;
1270   }
1271   {
1272     int r;
1273     suppress_error = 0;
1274     r = guestfs_lvm_remove_all (g);
1275     if (r == -1)
1276       return -1;
1277   }
1278   {
1279     char device[] = "/dev/sda";
1280     device[5] = devchar;
1281     char lines_0[] = ",";
1282     char *lines[] = {
1283       lines_0,
1284       NULL
1285     };
1286     int r;
1287     suppress_error = 0;
1288     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1289     if (r == -1)
1290       return -1;
1291   }
1292   {
1293     char fstype[] = "ext2";
1294     char device[] = "/dev/sda1";
1295     device[5] = devchar;
1296     int r;
1297     suppress_error = 0;
1298     r = guestfs_mkfs (g, fstype, device);
1299     if (r == -1)
1300       return -1;
1301   }
1302   {
1303     char device[] = "/dev/sda1";
1304     device[5] = devchar;
1305     char mountpoint[] = "/";
1306     int r;
1307     suppress_error = 0;
1308     r = guestfs_mount (g, device, mountpoint);
1309     if (r == -1)
1310       return -1;
1311   }
1312   /* TestOutputFalse for equal (1) */
1313   {
1314     char path[] = "/file1";
1315     char content[] = "contents of a file";
1316     int r;
1317     suppress_error = 0;
1318     r = guestfs_write_file (g, path, content, 0);
1319     if (r == -1)
1320       return -1;
1321   }
1322   {
1323     char path[] = "/file2";
1324     char content[] = "contents of another file";
1325     int r;
1326     suppress_error = 0;
1327     r = guestfs_write_file (g, path, content, 0);
1328     if (r == -1)
1329       return -1;
1330   }
1331   {
1332     char file1[] = "/file1";
1333     char file2[] = "/file2";
1334     int r;
1335     suppress_error = 0;
1336     r = guestfs_equal (g, file1, file2);
1337     if (r == -1)
1338       return -1;
1339     if (r) {
1340       fprintf (stderr, "test_equal_1: expected false, got true\n");
1341       return -1;
1342     }
1343   }
1344   return 0;
1345 }
1346
1347 static int test_equal_2 (void)
1348 {
1349   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1350   {
1351     char device[] = "/dev/sda";
1352     device[5] = devchar;
1353     int r;
1354     suppress_error = 0;
1355     r = guestfs_blockdev_setrw (g, device);
1356     if (r == -1)
1357       return -1;
1358   }
1359   {
1360     int r;
1361     suppress_error = 0;
1362     r = guestfs_umount_all (g);
1363     if (r == -1)
1364       return -1;
1365   }
1366   {
1367     int r;
1368     suppress_error = 0;
1369     r = guestfs_lvm_remove_all (g);
1370     if (r == -1)
1371       return -1;
1372   }
1373   {
1374     char device[] = "/dev/sda";
1375     device[5] = devchar;
1376     char lines_0[] = ",";
1377     char *lines[] = {
1378       lines_0,
1379       NULL
1380     };
1381     int r;
1382     suppress_error = 0;
1383     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1384     if (r == -1)
1385       return -1;
1386   }
1387   {
1388     char fstype[] = "ext2";
1389     char device[] = "/dev/sda1";
1390     device[5] = devchar;
1391     int r;
1392     suppress_error = 0;
1393     r = guestfs_mkfs (g, fstype, device);
1394     if (r == -1)
1395       return -1;
1396   }
1397   {
1398     char device[] = "/dev/sda1";
1399     device[5] = devchar;
1400     char mountpoint[] = "/";
1401     int r;
1402     suppress_error = 0;
1403     r = guestfs_mount (g, device, mountpoint);
1404     if (r == -1)
1405       return -1;
1406   }
1407   /* TestLastFail for equal (2) */
1408   {
1409     char file1[] = "/file1";
1410     char file2[] = "/file2";
1411     int r;
1412     suppress_error = 1;
1413     r = guestfs_equal (g, file1, file2);
1414     if (r != -1)
1415       return -1;
1416   }
1417   return 0;
1418 }
1419
1420 static int test_ping_daemon_0 (void)
1421 {
1422   /* InitNone|InitEmpty for test_ping_daemon_0 */
1423   {
1424     char device[] = "/dev/sda";
1425     device[5] = devchar;
1426     int r;
1427     suppress_error = 0;
1428     r = guestfs_blockdev_setrw (g, device);
1429     if (r == -1)
1430       return -1;
1431   }
1432   {
1433     int r;
1434     suppress_error = 0;
1435     r = guestfs_umount_all (g);
1436     if (r == -1)
1437       return -1;
1438   }
1439   {
1440     int r;
1441     suppress_error = 0;
1442     r = guestfs_lvm_remove_all (g);
1443     if (r == -1)
1444       return -1;
1445   }
1446   /* TestRun for ping_daemon (0) */
1447   {
1448     int r;
1449     suppress_error = 0;
1450     r = guestfs_ping_daemon (g);
1451     if (r == -1)
1452       return -1;
1453   }
1454   return 0;
1455 }
1456
1457 static int test_dmesg_0 (void)
1458 {
1459   /* InitNone|InitEmpty for test_dmesg_0 */
1460   {
1461     char device[] = "/dev/sda";
1462     device[5] = devchar;
1463     int r;
1464     suppress_error = 0;
1465     r = guestfs_blockdev_setrw (g, device);
1466     if (r == -1)
1467       return -1;
1468   }
1469   {
1470     int r;
1471     suppress_error = 0;
1472     r = guestfs_umount_all (g);
1473     if (r == -1)
1474       return -1;
1475   }
1476   {
1477     int r;
1478     suppress_error = 0;
1479     r = guestfs_lvm_remove_all (g);
1480     if (r == -1)
1481       return -1;
1482   }
1483   /* TestRun for dmesg (0) */
1484   {
1485     char *r;
1486     suppress_error = 0;
1487     r = guestfs_dmesg (g);
1488     if (r == NULL)
1489       return -1;
1490     free (r);
1491   }
1492   return 0;
1493 }
1494
1495 static int test_drop_caches_0 (void)
1496 {
1497   /* InitNone|InitEmpty for test_drop_caches_0 */
1498   {
1499     char device[] = "/dev/sda";
1500     device[5] = devchar;
1501     int r;
1502     suppress_error = 0;
1503     r = guestfs_blockdev_setrw (g, device);
1504     if (r == -1)
1505       return -1;
1506   }
1507   {
1508     int r;
1509     suppress_error = 0;
1510     r = guestfs_umount_all (g);
1511     if (r == -1)
1512       return -1;
1513   }
1514   {
1515     int r;
1516     suppress_error = 0;
1517     r = guestfs_lvm_remove_all (g);
1518     if (r == -1)
1519       return -1;
1520   }
1521   /* TestRun for drop_caches (0) */
1522   {
1523     int r;
1524     suppress_error = 0;
1525     r = guestfs_drop_caches (g, 3);
1526     if (r == -1)
1527       return -1;
1528   }
1529   return 0;
1530 }
1531
1532 static int test_mv_0 (void)
1533 {
1534   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1535   {
1536     char device[] = "/dev/sda";
1537     device[5] = devchar;
1538     int r;
1539     suppress_error = 0;
1540     r = guestfs_blockdev_setrw (g, device);
1541     if (r == -1)
1542       return -1;
1543   }
1544   {
1545     int r;
1546     suppress_error = 0;
1547     r = guestfs_umount_all (g);
1548     if (r == -1)
1549       return -1;
1550   }
1551   {
1552     int r;
1553     suppress_error = 0;
1554     r = guestfs_lvm_remove_all (g);
1555     if (r == -1)
1556       return -1;
1557   }
1558   {
1559     char device[] = "/dev/sda";
1560     device[5] = devchar;
1561     char lines_0[] = ",";
1562     char *lines[] = {
1563       lines_0,
1564       NULL
1565     };
1566     int r;
1567     suppress_error = 0;
1568     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1569     if (r == -1)
1570       return -1;
1571   }
1572   {
1573     char fstype[] = "ext2";
1574     char device[] = "/dev/sda1";
1575     device[5] = devchar;
1576     int r;
1577     suppress_error = 0;
1578     r = guestfs_mkfs (g, fstype, device);
1579     if (r == -1)
1580       return -1;
1581   }
1582   {
1583     char device[] = "/dev/sda1";
1584     device[5] = devchar;
1585     char mountpoint[] = "/";
1586     int r;
1587     suppress_error = 0;
1588     r = guestfs_mount (g, device, mountpoint);
1589     if (r == -1)
1590       return -1;
1591   }
1592   /* TestOutput for mv (0) */
1593   char expected[] = "file content";
1594   {
1595     char path[] = "/old";
1596     char content[] = "file content";
1597     int r;
1598     suppress_error = 0;
1599     r = guestfs_write_file (g, path, content, 0);
1600     if (r == -1)
1601       return -1;
1602   }
1603   {
1604     char src[] = "/old";
1605     char dest[] = "/new";
1606     int r;
1607     suppress_error = 0;
1608     r = guestfs_mv (g, src, dest);
1609     if (r == -1)
1610       return -1;
1611   }
1612   {
1613     char path[] = "/new";
1614     char *r;
1615     suppress_error = 0;
1616     r = guestfs_cat (g, path);
1617     if (r == NULL)
1618       return -1;
1619     if (strcmp (r, expected) != 0) {
1620       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1621       return -1;
1622     }
1623     free (r);
1624   }
1625   return 0;
1626 }
1627
1628 static int test_mv_1 (void)
1629 {
1630   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1631   {
1632     char device[] = "/dev/sda";
1633     device[5] = devchar;
1634     int r;
1635     suppress_error = 0;
1636     r = guestfs_blockdev_setrw (g, device);
1637     if (r == -1)
1638       return -1;
1639   }
1640   {
1641     int r;
1642     suppress_error = 0;
1643     r = guestfs_umount_all (g);
1644     if (r == -1)
1645       return -1;
1646   }
1647   {
1648     int r;
1649     suppress_error = 0;
1650     r = guestfs_lvm_remove_all (g);
1651     if (r == -1)
1652       return -1;
1653   }
1654   {
1655     char device[] = "/dev/sda";
1656     device[5] = devchar;
1657     char lines_0[] = ",";
1658     char *lines[] = {
1659       lines_0,
1660       NULL
1661     };
1662     int r;
1663     suppress_error = 0;
1664     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1665     if (r == -1)
1666       return -1;
1667   }
1668   {
1669     char fstype[] = "ext2";
1670     char device[] = "/dev/sda1";
1671     device[5] = devchar;
1672     int r;
1673     suppress_error = 0;
1674     r = guestfs_mkfs (g, fstype, device);
1675     if (r == -1)
1676       return -1;
1677   }
1678   {
1679     char device[] = "/dev/sda1";
1680     device[5] = devchar;
1681     char mountpoint[] = "/";
1682     int r;
1683     suppress_error = 0;
1684     r = guestfs_mount (g, device, mountpoint);
1685     if (r == -1)
1686       return -1;
1687   }
1688   /* TestOutputFalse for mv (1) */
1689   {
1690     char path[] = "/old";
1691     char content[] = "file content";
1692     int r;
1693     suppress_error = 0;
1694     r = guestfs_write_file (g, path, content, 0);
1695     if (r == -1)
1696       return -1;
1697   }
1698   {
1699     char src[] = "/old";
1700     char dest[] = "/new";
1701     int r;
1702     suppress_error = 0;
1703     r = guestfs_mv (g, src, dest);
1704     if (r == -1)
1705       return -1;
1706   }
1707   {
1708     char path[] = "/old";
1709     int r;
1710     suppress_error = 0;
1711     r = guestfs_is_file (g, path);
1712     if (r == -1)
1713       return -1;
1714     if (r) {
1715       fprintf (stderr, "test_mv_1: expected false, got true\n");
1716       return -1;
1717     }
1718   }
1719   return 0;
1720 }
1721
1722 static int test_cp_a_0 (void)
1723 {
1724   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
1725   {
1726     char device[] = "/dev/sda";
1727     device[5] = devchar;
1728     int r;
1729     suppress_error = 0;
1730     r = guestfs_blockdev_setrw (g, device);
1731     if (r == -1)
1732       return -1;
1733   }
1734   {
1735     int r;
1736     suppress_error = 0;
1737     r = guestfs_umount_all (g);
1738     if (r == -1)
1739       return -1;
1740   }
1741   {
1742     int r;
1743     suppress_error = 0;
1744     r = guestfs_lvm_remove_all (g);
1745     if (r == -1)
1746       return -1;
1747   }
1748   {
1749     char device[] = "/dev/sda";
1750     device[5] = devchar;
1751     char lines_0[] = ",";
1752     char *lines[] = {
1753       lines_0,
1754       NULL
1755     };
1756     int r;
1757     suppress_error = 0;
1758     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1759     if (r == -1)
1760       return -1;
1761   }
1762   {
1763     char fstype[] = "ext2";
1764     char device[] = "/dev/sda1";
1765     device[5] = devchar;
1766     int r;
1767     suppress_error = 0;
1768     r = guestfs_mkfs (g, fstype, device);
1769     if (r == -1)
1770       return -1;
1771   }
1772   {
1773     char device[] = "/dev/sda1";
1774     device[5] = devchar;
1775     char mountpoint[] = "/";
1776     int r;
1777     suppress_error = 0;
1778     r = guestfs_mount (g, device, mountpoint);
1779     if (r == -1)
1780       return -1;
1781   }
1782   /* TestOutput for cp_a (0) */
1783   char expected[] = "file content";
1784   {
1785     char path[] = "/olddir";
1786     int r;
1787     suppress_error = 0;
1788     r = guestfs_mkdir (g, path);
1789     if (r == -1)
1790       return -1;
1791   }
1792   {
1793     char path[] = "/newdir";
1794     int r;
1795     suppress_error = 0;
1796     r = guestfs_mkdir (g, path);
1797     if (r == -1)
1798       return -1;
1799   }
1800   {
1801     char path[] = "/olddir/file";
1802     char content[] = "file content";
1803     int r;
1804     suppress_error = 0;
1805     r = guestfs_write_file (g, path, content, 0);
1806     if (r == -1)
1807       return -1;
1808   }
1809   {
1810     char src[] = "/olddir";
1811     char dest[] = "/newdir";
1812     int r;
1813     suppress_error = 0;
1814     r = guestfs_cp_a (g, src, dest);
1815     if (r == -1)
1816       return -1;
1817   }
1818   {
1819     char path[] = "/newdir/olddir/file";
1820     char *r;
1821     suppress_error = 0;
1822     r = guestfs_cat (g, path);
1823     if (r == NULL)
1824       return -1;
1825     if (strcmp (r, expected) != 0) {
1826       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1827       return -1;
1828     }
1829     free (r);
1830   }
1831   return 0;
1832 }
1833
1834 static int test_cp_0 (void)
1835 {
1836   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
1837   {
1838     char device[] = "/dev/sda";
1839     device[5] = devchar;
1840     int r;
1841     suppress_error = 0;
1842     r = guestfs_blockdev_setrw (g, device);
1843     if (r == -1)
1844       return -1;
1845   }
1846   {
1847     int r;
1848     suppress_error = 0;
1849     r = guestfs_umount_all (g);
1850     if (r == -1)
1851       return -1;
1852   }
1853   {
1854     int r;
1855     suppress_error = 0;
1856     r = guestfs_lvm_remove_all (g);
1857     if (r == -1)
1858       return -1;
1859   }
1860   {
1861     char device[] = "/dev/sda";
1862     device[5] = devchar;
1863     char lines_0[] = ",";
1864     char *lines[] = {
1865       lines_0,
1866       NULL
1867     };
1868     int r;
1869     suppress_error = 0;
1870     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1871     if (r == -1)
1872       return -1;
1873   }
1874   {
1875     char fstype[] = "ext2";
1876     char device[] = "/dev/sda1";
1877     device[5] = devchar;
1878     int r;
1879     suppress_error = 0;
1880     r = guestfs_mkfs (g, fstype, device);
1881     if (r == -1)
1882       return -1;
1883   }
1884   {
1885     char device[] = "/dev/sda1";
1886     device[5] = devchar;
1887     char mountpoint[] = "/";
1888     int r;
1889     suppress_error = 0;
1890     r = guestfs_mount (g, device, mountpoint);
1891     if (r == -1)
1892       return -1;
1893   }
1894   /* TestOutput for cp (0) */
1895   char expected[] = "file content";
1896   {
1897     char path[] = "/old";
1898     char content[] = "file content";
1899     int r;
1900     suppress_error = 0;
1901     r = guestfs_write_file (g, path, content, 0);
1902     if (r == -1)
1903       return -1;
1904   }
1905   {
1906     char src[] = "/old";
1907     char dest[] = "/new";
1908     int r;
1909     suppress_error = 0;
1910     r = guestfs_cp (g, src, dest);
1911     if (r == -1)
1912       return -1;
1913   }
1914   {
1915     char path[] = "/new";
1916     char *r;
1917     suppress_error = 0;
1918     r = guestfs_cat (g, path);
1919     if (r == NULL)
1920       return -1;
1921     if (strcmp (r, expected) != 0) {
1922       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1923       return -1;
1924     }
1925     free (r);
1926   }
1927   return 0;
1928 }
1929
1930 static int test_cp_1 (void)
1931 {
1932   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
1933   {
1934     char device[] = "/dev/sda";
1935     device[5] = devchar;
1936     int r;
1937     suppress_error = 0;
1938     r = guestfs_blockdev_setrw (g, device);
1939     if (r == -1)
1940       return -1;
1941   }
1942   {
1943     int r;
1944     suppress_error = 0;
1945     r = guestfs_umount_all (g);
1946     if (r == -1)
1947       return -1;
1948   }
1949   {
1950     int r;
1951     suppress_error = 0;
1952     r = guestfs_lvm_remove_all (g);
1953     if (r == -1)
1954       return -1;
1955   }
1956   {
1957     char device[] = "/dev/sda";
1958     device[5] = devchar;
1959     char lines_0[] = ",";
1960     char *lines[] = {
1961       lines_0,
1962       NULL
1963     };
1964     int r;
1965     suppress_error = 0;
1966     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1967     if (r == -1)
1968       return -1;
1969   }
1970   {
1971     char fstype[] = "ext2";
1972     char device[] = "/dev/sda1";
1973     device[5] = devchar;
1974     int r;
1975     suppress_error = 0;
1976     r = guestfs_mkfs (g, fstype, device);
1977     if (r == -1)
1978       return -1;
1979   }
1980   {
1981     char device[] = "/dev/sda1";
1982     device[5] = devchar;
1983     char mountpoint[] = "/";
1984     int r;
1985     suppress_error = 0;
1986     r = guestfs_mount (g, device, mountpoint);
1987     if (r == -1)
1988       return -1;
1989   }
1990   /* TestOutputTrue for cp (1) */
1991   {
1992     char path[] = "/old";
1993     char content[] = "file content";
1994     int r;
1995     suppress_error = 0;
1996     r = guestfs_write_file (g, path, content, 0);
1997     if (r == -1)
1998       return -1;
1999   }
2000   {
2001     char src[] = "/old";
2002     char dest[] = "/new";
2003     int r;
2004     suppress_error = 0;
2005     r = guestfs_cp (g, src, dest);
2006     if (r == -1)
2007       return -1;
2008   }
2009   {
2010     char path[] = "/old";
2011     int r;
2012     suppress_error = 0;
2013     r = guestfs_is_file (g, path);
2014     if (r == -1)
2015       return -1;
2016     if (!r) {
2017       fprintf (stderr, "test_cp_1: expected true, got false\n");
2018       return -1;
2019     }
2020   }
2021   return 0;
2022 }
2023
2024 static int test_cp_2 (void)
2025 {
2026   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2027   {
2028     char device[] = "/dev/sda";
2029     device[5] = devchar;
2030     int r;
2031     suppress_error = 0;
2032     r = guestfs_blockdev_setrw (g, device);
2033     if (r == -1)
2034       return -1;
2035   }
2036   {
2037     int r;
2038     suppress_error = 0;
2039     r = guestfs_umount_all (g);
2040     if (r == -1)
2041       return -1;
2042   }
2043   {
2044     int r;
2045     suppress_error = 0;
2046     r = guestfs_lvm_remove_all (g);
2047     if (r == -1)
2048       return -1;
2049   }
2050   {
2051     char device[] = "/dev/sda";
2052     device[5] = devchar;
2053     char lines_0[] = ",";
2054     char *lines[] = {
2055       lines_0,
2056       NULL
2057     };
2058     int r;
2059     suppress_error = 0;
2060     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2061     if (r == -1)
2062       return -1;
2063   }
2064   {
2065     char fstype[] = "ext2";
2066     char device[] = "/dev/sda1";
2067     device[5] = devchar;
2068     int r;
2069     suppress_error = 0;
2070     r = guestfs_mkfs (g, fstype, device);
2071     if (r == -1)
2072       return -1;
2073   }
2074   {
2075     char device[] = "/dev/sda1";
2076     device[5] = devchar;
2077     char mountpoint[] = "/";
2078     int r;
2079     suppress_error = 0;
2080     r = guestfs_mount (g, device, mountpoint);
2081     if (r == -1)
2082       return -1;
2083   }
2084   /* TestOutput for cp (2) */
2085   char expected[] = "file content";
2086   {
2087     char path[] = "/old";
2088     char content[] = "file content";
2089     int r;
2090     suppress_error = 0;
2091     r = guestfs_write_file (g, path, content, 0);
2092     if (r == -1)
2093       return -1;
2094   }
2095   {
2096     char path[] = "/dir";
2097     int r;
2098     suppress_error = 0;
2099     r = guestfs_mkdir (g, path);
2100     if (r == -1)
2101       return -1;
2102   }
2103   {
2104     char src[] = "/old";
2105     char dest[] = "/dir/new";
2106     int r;
2107     suppress_error = 0;
2108     r = guestfs_cp (g, src, dest);
2109     if (r == -1)
2110       return -1;
2111   }
2112   {
2113     char path[] = "/dir/new";
2114     char *r;
2115     suppress_error = 0;
2116     r = guestfs_cat (g, path);
2117     if (r == NULL)
2118       return -1;
2119     if (strcmp (r, expected) != 0) {
2120       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2121       return -1;
2122     }
2123     free (r);
2124   }
2125   return 0;
2126 }
2127
2128 static int test_grub_install_0 (void)
2129 {
2130   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2131   {
2132     char device[] = "/dev/sda";
2133     device[5] = devchar;
2134     int r;
2135     suppress_error = 0;
2136     r = guestfs_blockdev_setrw (g, device);
2137     if (r == -1)
2138       return -1;
2139   }
2140   {
2141     int r;
2142     suppress_error = 0;
2143     r = guestfs_umount_all (g);
2144     if (r == -1)
2145       return -1;
2146   }
2147   {
2148     int r;
2149     suppress_error = 0;
2150     r = guestfs_lvm_remove_all (g);
2151     if (r == -1)
2152       return -1;
2153   }
2154   {
2155     char device[] = "/dev/sda";
2156     device[5] = devchar;
2157     char lines_0[] = ",";
2158     char *lines[] = {
2159       lines_0,
2160       NULL
2161     };
2162     int r;
2163     suppress_error = 0;
2164     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2165     if (r == -1)
2166       return -1;
2167   }
2168   {
2169     char fstype[] = "ext2";
2170     char device[] = "/dev/sda1";
2171     device[5] = devchar;
2172     int r;
2173     suppress_error = 0;
2174     r = guestfs_mkfs (g, fstype, device);
2175     if (r == -1)
2176       return -1;
2177   }
2178   {
2179     char device[] = "/dev/sda1";
2180     device[5] = devchar;
2181     char mountpoint[] = "/";
2182     int r;
2183     suppress_error = 0;
2184     r = guestfs_mount (g, device, mountpoint);
2185     if (r == -1)
2186       return -1;
2187   }
2188   /* TestOutputTrue for grub_install (0) */
2189   {
2190     char root[] = "/";
2191     char device[] = "/dev/sda1";
2192     device[5] = devchar;
2193     int r;
2194     suppress_error = 0;
2195     r = guestfs_grub_install (g, root, device);
2196     if (r == -1)
2197       return -1;
2198   }
2199   {
2200     char path[] = "/boot";
2201     int r;
2202     suppress_error = 0;
2203     r = guestfs_is_dir (g, path);
2204     if (r == -1)
2205       return -1;
2206     if (!r) {
2207       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2208       return -1;
2209     }
2210   }
2211   return 0;
2212 }
2213
2214 static int test_zero_0 (void)
2215 {
2216   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2217   {
2218     char device[] = "/dev/sda";
2219     device[5] = devchar;
2220     int r;
2221     suppress_error = 0;
2222     r = guestfs_blockdev_setrw (g, device);
2223     if (r == -1)
2224       return -1;
2225   }
2226   {
2227     int r;
2228     suppress_error = 0;
2229     r = guestfs_umount_all (g);
2230     if (r == -1)
2231       return -1;
2232   }
2233   {
2234     int r;
2235     suppress_error = 0;
2236     r = guestfs_lvm_remove_all (g);
2237     if (r == -1)
2238       return -1;
2239   }
2240   {
2241     char device[] = "/dev/sda";
2242     device[5] = devchar;
2243     char lines_0[] = ",";
2244     char *lines[] = {
2245       lines_0,
2246       NULL
2247     };
2248     int r;
2249     suppress_error = 0;
2250     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2251     if (r == -1)
2252       return -1;
2253   }
2254   {
2255     char fstype[] = "ext2";
2256     char device[] = "/dev/sda1";
2257     device[5] = devchar;
2258     int r;
2259     suppress_error = 0;
2260     r = guestfs_mkfs (g, fstype, device);
2261     if (r == -1)
2262       return -1;
2263   }
2264   {
2265     char device[] = "/dev/sda1";
2266     device[5] = devchar;
2267     char mountpoint[] = "/";
2268     int r;
2269     suppress_error = 0;
2270     r = guestfs_mount (g, device, mountpoint);
2271     if (r == -1)
2272       return -1;
2273   }
2274   /* TestOutput for zero (0) */
2275   char expected[] = "data";
2276   {
2277     char pathordevice[] = "/dev/sda1";
2278     pathordevice[5] = devchar;
2279     int r;
2280     suppress_error = 0;
2281     r = guestfs_umount (g, pathordevice);
2282     if (r == -1)
2283       return -1;
2284   }
2285   {
2286     char device[] = "/dev/sda1";
2287     device[5] = devchar;
2288     int r;
2289     suppress_error = 0;
2290     r = guestfs_zero (g, device);
2291     if (r == -1)
2292       return -1;
2293   }
2294   {
2295     char path[] = "/dev/sda1";
2296     path[5] = devchar;
2297     char *r;
2298     suppress_error = 0;
2299     r = guestfs_file (g, path);
2300     if (r == NULL)
2301       return -1;
2302     if (strcmp (r, expected) != 0) {
2303       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2304       return -1;
2305     }
2306     free (r);
2307   }
2308   return 0;
2309 }
2310
2311 static int test_fsck_0 (void)
2312 {
2313   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2314   {
2315     char device[] = "/dev/sda";
2316     device[5] = devchar;
2317     int r;
2318     suppress_error = 0;
2319     r = guestfs_blockdev_setrw (g, device);
2320     if (r == -1)
2321       return -1;
2322   }
2323   {
2324     int r;
2325     suppress_error = 0;
2326     r = guestfs_umount_all (g);
2327     if (r == -1)
2328       return -1;
2329   }
2330   {
2331     int r;
2332     suppress_error = 0;
2333     r = guestfs_lvm_remove_all (g);
2334     if (r == -1)
2335       return -1;
2336   }
2337   {
2338     char device[] = "/dev/sda";
2339     device[5] = devchar;
2340     char lines_0[] = ",";
2341     char *lines[] = {
2342       lines_0,
2343       NULL
2344     };
2345     int r;
2346     suppress_error = 0;
2347     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2348     if (r == -1)
2349       return -1;
2350   }
2351   {
2352     char fstype[] = "ext2";
2353     char device[] = "/dev/sda1";
2354     device[5] = devchar;
2355     int r;
2356     suppress_error = 0;
2357     r = guestfs_mkfs (g, fstype, device);
2358     if (r == -1)
2359       return -1;
2360   }
2361   {
2362     char device[] = "/dev/sda1";
2363     device[5] = devchar;
2364     char mountpoint[] = "/";
2365     int r;
2366     suppress_error = 0;
2367     r = guestfs_mount (g, device, mountpoint);
2368     if (r == -1)
2369       return -1;
2370   }
2371   /* TestOutputInt for fsck (0) */
2372   {
2373     char pathordevice[] = "/dev/sda1";
2374     pathordevice[5] = devchar;
2375     int r;
2376     suppress_error = 0;
2377     r = guestfs_umount (g, pathordevice);
2378     if (r == -1)
2379       return -1;
2380   }
2381   {
2382     char fstype[] = "ext2";
2383     char device[] = "/dev/sda1";
2384     device[5] = devchar;
2385     int r;
2386     suppress_error = 0;
2387     r = guestfs_fsck (g, fstype, device);
2388     if (r == -1)
2389       return -1;
2390     if (r != 0) {
2391       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
2392       return -1;
2393     }
2394   }
2395   return 0;
2396 }
2397
2398 static int test_fsck_1 (void)
2399 {
2400   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2401   {
2402     char device[] = "/dev/sda";
2403     device[5] = devchar;
2404     int r;
2405     suppress_error = 0;
2406     r = guestfs_blockdev_setrw (g, device);
2407     if (r == -1)
2408       return -1;
2409   }
2410   {
2411     int r;
2412     suppress_error = 0;
2413     r = guestfs_umount_all (g);
2414     if (r == -1)
2415       return -1;
2416   }
2417   {
2418     int r;
2419     suppress_error = 0;
2420     r = guestfs_lvm_remove_all (g);
2421     if (r == -1)
2422       return -1;
2423   }
2424   {
2425     char device[] = "/dev/sda";
2426     device[5] = devchar;
2427     char lines_0[] = ",";
2428     char *lines[] = {
2429       lines_0,
2430       NULL
2431     };
2432     int r;
2433     suppress_error = 0;
2434     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2435     if (r == -1)
2436       return -1;
2437   }
2438   {
2439     char fstype[] = "ext2";
2440     char device[] = "/dev/sda1";
2441     device[5] = devchar;
2442     int r;
2443     suppress_error = 0;
2444     r = guestfs_mkfs (g, fstype, device);
2445     if (r == -1)
2446       return -1;
2447   }
2448   {
2449     char device[] = "/dev/sda1";
2450     device[5] = devchar;
2451     char mountpoint[] = "/";
2452     int r;
2453     suppress_error = 0;
2454     r = guestfs_mount (g, device, mountpoint);
2455     if (r == -1)
2456       return -1;
2457   }
2458   /* TestOutputInt for fsck (1) */
2459   {
2460     char pathordevice[] = "/dev/sda1";
2461     pathordevice[5] = devchar;
2462     int r;
2463     suppress_error = 0;
2464     r = guestfs_umount (g, pathordevice);
2465     if (r == -1)
2466       return -1;
2467   }
2468   {
2469     char device[] = "/dev/sda1";
2470     device[5] = devchar;
2471     int r;
2472     suppress_error = 0;
2473     r = guestfs_zero (g, device);
2474     if (r == -1)
2475       return -1;
2476   }
2477   {
2478     char fstype[] = "ext2";
2479     char device[] = "/dev/sda1";
2480     device[5] = devchar;
2481     int r;
2482     suppress_error = 0;
2483     r = guestfs_fsck (g, fstype, device);
2484     if (r == -1)
2485       return -1;
2486     if (r != 8) {
2487       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
2488       return -1;
2489     }
2490   }
2491   return 0;
2492 }
2493
2494 static int test_set_e2uuid_0 (void)
2495 {
2496   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2497   {
2498     char device[] = "/dev/sda";
2499     device[5] = devchar;
2500     int r;
2501     suppress_error = 0;
2502     r = guestfs_blockdev_setrw (g, device);
2503     if (r == -1)
2504       return -1;
2505   }
2506   {
2507     int r;
2508     suppress_error = 0;
2509     r = guestfs_umount_all (g);
2510     if (r == -1)
2511       return -1;
2512   }
2513   {
2514     int r;
2515     suppress_error = 0;
2516     r = guestfs_lvm_remove_all (g);
2517     if (r == -1)
2518       return -1;
2519   }
2520   {
2521     char device[] = "/dev/sda";
2522     device[5] = devchar;
2523     char lines_0[] = ",";
2524     char *lines[] = {
2525       lines_0,
2526       NULL
2527     };
2528     int r;
2529     suppress_error = 0;
2530     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2531     if (r == -1)
2532       return -1;
2533   }
2534   {
2535     char fstype[] = "ext2";
2536     char device[] = "/dev/sda1";
2537     device[5] = devchar;
2538     int r;
2539     suppress_error = 0;
2540     r = guestfs_mkfs (g, fstype, device);
2541     if (r == -1)
2542       return -1;
2543   }
2544   {
2545     char device[] = "/dev/sda1";
2546     device[5] = devchar;
2547     char mountpoint[] = "/";
2548     int r;
2549     suppress_error = 0;
2550     r = guestfs_mount (g, device, mountpoint);
2551     if (r == -1)
2552       return -1;
2553   }
2554   /* TestOutput for set_e2uuid (0) */
2555   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2556   {
2557     char device[] = "/dev/sda1";
2558     device[5] = devchar;
2559     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2560     int r;
2561     suppress_error = 0;
2562     r = guestfs_set_e2uuid (g, device, uuid);
2563     if (r == -1)
2564       return -1;
2565   }
2566   {
2567     char device[] = "/dev/sda1";
2568     device[5] = devchar;
2569     char *r;
2570     suppress_error = 0;
2571     r = guestfs_get_e2uuid (g, device);
2572     if (r == NULL)
2573       return -1;
2574     if (strcmp (r, expected) != 0) {
2575       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2576       return -1;
2577     }
2578     free (r);
2579   }
2580   return 0;
2581 }
2582
2583 static int test_set_e2uuid_1 (void)
2584 {
2585   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
2586   {
2587     char device[] = "/dev/sda";
2588     device[5] = devchar;
2589     int r;
2590     suppress_error = 0;
2591     r = guestfs_blockdev_setrw (g, device);
2592     if (r == -1)
2593       return -1;
2594   }
2595   {
2596     int r;
2597     suppress_error = 0;
2598     r = guestfs_umount_all (g);
2599     if (r == -1)
2600       return -1;
2601   }
2602   {
2603     int r;
2604     suppress_error = 0;
2605     r = guestfs_lvm_remove_all (g);
2606     if (r == -1)
2607       return -1;
2608   }
2609   {
2610     char device[] = "/dev/sda";
2611     device[5] = devchar;
2612     char lines_0[] = ",";
2613     char *lines[] = {
2614       lines_0,
2615       NULL
2616     };
2617     int r;
2618     suppress_error = 0;
2619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2620     if (r == -1)
2621       return -1;
2622   }
2623   {
2624     char fstype[] = "ext2";
2625     char device[] = "/dev/sda1";
2626     device[5] = devchar;
2627     int r;
2628     suppress_error = 0;
2629     r = guestfs_mkfs (g, fstype, device);
2630     if (r == -1)
2631       return -1;
2632   }
2633   {
2634     char device[] = "/dev/sda1";
2635     device[5] = devchar;
2636     char mountpoint[] = "/";
2637     int r;
2638     suppress_error = 0;
2639     r = guestfs_mount (g, device, mountpoint);
2640     if (r == -1)
2641       return -1;
2642   }
2643   /* TestOutput for set_e2uuid (1) */
2644   char expected[] = "";
2645   {
2646     char device[] = "/dev/sda1";
2647     device[5] = devchar;
2648     char uuid[] = "clear";
2649     int r;
2650     suppress_error = 0;
2651     r = guestfs_set_e2uuid (g, device, uuid);
2652     if (r == -1)
2653       return -1;
2654   }
2655   {
2656     char device[] = "/dev/sda1";
2657     device[5] = devchar;
2658     char *r;
2659     suppress_error = 0;
2660     r = guestfs_get_e2uuid (g, device);
2661     if (r == NULL)
2662       return -1;
2663     if (strcmp (r, expected) != 0) {
2664       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2665       return -1;
2666     }
2667     free (r);
2668   }
2669   return 0;
2670 }
2671
2672 static int test_set_e2uuid_2 (void)
2673 {
2674   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
2675   {
2676     char device[] = "/dev/sda";
2677     device[5] = devchar;
2678     int r;
2679     suppress_error = 0;
2680     r = guestfs_blockdev_setrw (g, device);
2681     if (r == -1)
2682       return -1;
2683   }
2684   {
2685     int r;
2686     suppress_error = 0;
2687     r = guestfs_umount_all (g);
2688     if (r == -1)
2689       return -1;
2690   }
2691   {
2692     int r;
2693     suppress_error = 0;
2694     r = guestfs_lvm_remove_all (g);
2695     if (r == -1)
2696       return -1;
2697   }
2698   {
2699     char device[] = "/dev/sda";
2700     device[5] = devchar;
2701     char lines_0[] = ",";
2702     char *lines[] = {
2703       lines_0,
2704       NULL
2705     };
2706     int r;
2707     suppress_error = 0;
2708     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2709     if (r == -1)
2710       return -1;
2711   }
2712   {
2713     char fstype[] = "ext2";
2714     char device[] = "/dev/sda1";
2715     device[5] = devchar;
2716     int r;
2717     suppress_error = 0;
2718     r = guestfs_mkfs (g, fstype, device);
2719     if (r == -1)
2720       return -1;
2721   }
2722   {
2723     char device[] = "/dev/sda1";
2724     device[5] = devchar;
2725     char mountpoint[] = "/";
2726     int r;
2727     suppress_error = 0;
2728     r = guestfs_mount (g, device, mountpoint);
2729     if (r == -1)
2730       return -1;
2731   }
2732   /* TestRun for set_e2uuid (2) */
2733   {
2734     char device[] = "/dev/sda1";
2735     device[5] = devchar;
2736     char uuid[] = "random";
2737     int r;
2738     suppress_error = 0;
2739     r = guestfs_set_e2uuid (g, device, uuid);
2740     if (r == -1)
2741       return -1;
2742   }
2743   return 0;
2744 }
2745
2746 static int test_set_e2uuid_3 (void)
2747 {
2748   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
2749   {
2750     char device[] = "/dev/sda";
2751     device[5] = devchar;
2752     int r;
2753     suppress_error = 0;
2754     r = guestfs_blockdev_setrw (g, device);
2755     if (r == -1)
2756       return -1;
2757   }
2758   {
2759     int r;
2760     suppress_error = 0;
2761     r = guestfs_umount_all (g);
2762     if (r == -1)
2763       return -1;
2764   }
2765   {
2766     int r;
2767     suppress_error = 0;
2768     r = guestfs_lvm_remove_all (g);
2769     if (r == -1)
2770       return -1;
2771   }
2772   {
2773     char device[] = "/dev/sda";
2774     device[5] = devchar;
2775     char lines_0[] = ",";
2776     char *lines[] = {
2777       lines_0,
2778       NULL
2779     };
2780     int r;
2781     suppress_error = 0;
2782     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2783     if (r == -1)
2784       return -1;
2785   }
2786   {
2787     char fstype[] = "ext2";
2788     char device[] = "/dev/sda1";
2789     device[5] = devchar;
2790     int r;
2791     suppress_error = 0;
2792     r = guestfs_mkfs (g, fstype, device);
2793     if (r == -1)
2794       return -1;
2795   }
2796   {
2797     char device[] = "/dev/sda1";
2798     device[5] = devchar;
2799     char mountpoint[] = "/";
2800     int r;
2801     suppress_error = 0;
2802     r = guestfs_mount (g, device, mountpoint);
2803     if (r == -1)
2804       return -1;
2805   }
2806   /* TestRun for set_e2uuid (3) */
2807   {
2808     char device[] = "/dev/sda1";
2809     device[5] = devchar;
2810     char uuid[] = "time";
2811     int r;
2812     suppress_error = 0;
2813     r = guestfs_set_e2uuid (g, device, uuid);
2814     if (r == -1)
2815       return -1;
2816   }
2817   return 0;
2818 }
2819
2820 static int test_set_e2label_0 (void)
2821 {
2822   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
2823   {
2824     char device[] = "/dev/sda";
2825     device[5] = devchar;
2826     int r;
2827     suppress_error = 0;
2828     r = guestfs_blockdev_setrw (g, device);
2829     if (r == -1)
2830       return -1;
2831   }
2832   {
2833     int r;
2834     suppress_error = 0;
2835     r = guestfs_umount_all (g);
2836     if (r == -1)
2837       return -1;
2838   }
2839   {
2840     int r;
2841     suppress_error = 0;
2842     r = guestfs_lvm_remove_all (g);
2843     if (r == -1)
2844       return -1;
2845   }
2846   {
2847     char device[] = "/dev/sda";
2848     device[5] = devchar;
2849     char lines_0[] = ",";
2850     char *lines[] = {
2851       lines_0,
2852       NULL
2853     };
2854     int r;
2855     suppress_error = 0;
2856     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2857     if (r == -1)
2858       return -1;
2859   }
2860   {
2861     char fstype[] = "ext2";
2862     char device[] = "/dev/sda1";
2863     device[5] = devchar;
2864     int r;
2865     suppress_error = 0;
2866     r = guestfs_mkfs (g, fstype, device);
2867     if (r == -1)
2868       return -1;
2869   }
2870   {
2871     char device[] = "/dev/sda1";
2872     device[5] = devchar;
2873     char mountpoint[] = "/";
2874     int r;
2875     suppress_error = 0;
2876     r = guestfs_mount (g, device, mountpoint);
2877     if (r == -1)
2878       return -1;
2879   }
2880   /* TestOutput for set_e2label (0) */
2881   char expected[] = "testlabel";
2882   {
2883     char device[] = "/dev/sda1";
2884     device[5] = devchar;
2885     char label[] = "testlabel";
2886     int r;
2887     suppress_error = 0;
2888     r = guestfs_set_e2label (g, device, label);
2889     if (r == -1)
2890       return -1;
2891   }
2892   {
2893     char device[] = "/dev/sda1";
2894     device[5] = devchar;
2895     char *r;
2896     suppress_error = 0;
2897     r = guestfs_get_e2label (g, device);
2898     if (r == NULL)
2899       return -1;
2900     if (strcmp (r, expected) != 0) {
2901       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2902       return -1;
2903     }
2904     free (r);
2905   }
2906   return 0;
2907 }
2908
2909 static int test_pvremove_0 (void)
2910 {
2911   /* InitNone|InitEmpty for test_pvremove_0 */
2912   {
2913     char device[] = "/dev/sda";
2914     device[5] = devchar;
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_blockdev_setrw (g, device);
2918     if (r == -1)
2919       return -1;
2920   }
2921   {
2922     int r;
2923     suppress_error = 0;
2924     r = guestfs_umount_all (g);
2925     if (r == -1)
2926       return -1;
2927   }
2928   {
2929     int r;
2930     suppress_error = 0;
2931     r = guestfs_lvm_remove_all (g);
2932     if (r == -1)
2933       return -1;
2934   }
2935   /* TestOutputList for pvremove (0) */
2936   {
2937     char device[] = "/dev/sda";
2938     device[5] = devchar;
2939     char lines_0[] = ",";
2940     char *lines[] = {
2941       lines_0,
2942       NULL
2943     };
2944     int r;
2945     suppress_error = 0;
2946     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2947     if (r == -1)
2948       return -1;
2949   }
2950   {
2951     char device[] = "/dev/sda1";
2952     device[5] = devchar;
2953     int r;
2954     suppress_error = 0;
2955     r = guestfs_pvcreate (g, device);
2956     if (r == -1)
2957       return -1;
2958   }
2959   {
2960     char volgroup[] = "VG";
2961     char physvols_0[] = "/dev/sda1";
2962     physvols_0[5] = devchar;
2963     char *physvols[] = {
2964       physvols_0,
2965       NULL
2966     };
2967     int r;
2968     suppress_error = 0;
2969     r = guestfs_vgcreate (g, volgroup, physvols);
2970     if (r == -1)
2971       return -1;
2972   }
2973   {
2974     char logvol[] = "LV1";
2975     char volgroup[] = "VG";
2976     int r;
2977     suppress_error = 0;
2978     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2979     if (r == -1)
2980       return -1;
2981   }
2982   {
2983     char logvol[] = "LV2";
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 vgname[] = "VG";
2993     int r;
2994     suppress_error = 0;
2995     r = guestfs_vgremove (g, vgname);
2996     if (r == -1)
2997       return -1;
2998   }
2999   {
3000     char device[] = "/dev/sda1";
3001     device[5] = devchar;
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_pvremove (g, device);
3005     if (r == -1)
3006       return -1;
3007   }
3008   {
3009     char **r;
3010     int i;
3011     suppress_error = 0;
3012     r = guestfs_lvs (g);
3013     if (r == NULL)
3014       return -1;
3015     if (r[0] != NULL) {
3016       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3017       print_strings (r);
3018       return -1;
3019     }
3020     for (i = 0; r[i] != NULL; ++i)
3021       free (r[i]);
3022     free (r);
3023   }
3024   return 0;
3025 }
3026
3027 static int test_pvremove_1 (void)
3028 {
3029   /* InitNone|InitEmpty for test_pvremove_1 */
3030   {
3031     char device[] = "/dev/sda";
3032     device[5] = devchar;
3033     int r;
3034     suppress_error = 0;
3035     r = guestfs_blockdev_setrw (g, device);
3036     if (r == -1)
3037       return -1;
3038   }
3039   {
3040     int r;
3041     suppress_error = 0;
3042     r = guestfs_umount_all (g);
3043     if (r == -1)
3044       return -1;
3045   }
3046   {
3047     int r;
3048     suppress_error = 0;
3049     r = guestfs_lvm_remove_all (g);
3050     if (r == -1)
3051       return -1;
3052   }
3053   /* TestOutputList for pvremove (1) */
3054   {
3055     char device[] = "/dev/sda";
3056     device[5] = devchar;
3057     char lines_0[] = ",";
3058     char *lines[] = {
3059       lines_0,
3060       NULL
3061     };
3062     int r;
3063     suppress_error = 0;
3064     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3065     if (r == -1)
3066       return -1;
3067   }
3068   {
3069     char device[] = "/dev/sda1";
3070     device[5] = devchar;
3071     int r;
3072     suppress_error = 0;
3073     r = guestfs_pvcreate (g, device);
3074     if (r == -1)
3075       return -1;
3076   }
3077   {
3078     char volgroup[] = "VG";
3079     char physvols_0[] = "/dev/sda1";
3080     physvols_0[5] = devchar;
3081     char *physvols[] = {
3082       physvols_0,
3083       NULL
3084     };
3085     int r;
3086     suppress_error = 0;
3087     r = guestfs_vgcreate (g, volgroup, physvols);
3088     if (r == -1)
3089       return -1;
3090   }
3091   {
3092     char logvol[] = "LV1";
3093     char volgroup[] = "VG";
3094     int r;
3095     suppress_error = 0;
3096     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3097     if (r == -1)
3098       return -1;
3099   }
3100   {
3101     char logvol[] = "LV2";
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 vgname[] = "VG";
3111     int r;
3112     suppress_error = 0;
3113     r = guestfs_vgremove (g, vgname);
3114     if (r == -1)
3115       return -1;
3116   }
3117   {
3118     char device[] = "/dev/sda1";
3119     device[5] = devchar;
3120     int r;
3121     suppress_error = 0;
3122     r = guestfs_pvremove (g, device);
3123     if (r == -1)
3124       return -1;
3125   }
3126   {
3127     char **r;
3128     int i;
3129     suppress_error = 0;
3130     r = guestfs_vgs (g);
3131     if (r == NULL)
3132       return -1;
3133     if (r[0] != NULL) {
3134       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3135       print_strings (r);
3136       return -1;
3137     }
3138     for (i = 0; r[i] != NULL; ++i)
3139       free (r[i]);
3140     free (r);
3141   }
3142   return 0;
3143 }
3144
3145 static int test_pvremove_2 (void)
3146 {
3147   /* InitNone|InitEmpty for test_pvremove_2 */
3148   {
3149     char device[] = "/dev/sda";
3150     device[5] = devchar;
3151     int r;
3152     suppress_error = 0;
3153     r = guestfs_blockdev_setrw (g, device);
3154     if (r == -1)
3155       return -1;
3156   }
3157   {
3158     int r;
3159     suppress_error = 0;
3160     r = guestfs_umount_all (g);
3161     if (r == -1)
3162       return -1;
3163   }
3164   {
3165     int r;
3166     suppress_error = 0;
3167     r = guestfs_lvm_remove_all (g);
3168     if (r == -1)
3169       return -1;
3170   }
3171   /* TestOutputList for pvremove (2) */
3172   {
3173     char device[] = "/dev/sda";
3174     device[5] = devchar;
3175     char lines_0[] = ",";
3176     char *lines[] = {
3177       lines_0,
3178       NULL
3179     };
3180     int r;
3181     suppress_error = 0;
3182     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3183     if (r == -1)
3184       return -1;
3185   }
3186   {
3187     char device[] = "/dev/sda1";
3188     device[5] = devchar;
3189     int r;
3190     suppress_error = 0;
3191     r = guestfs_pvcreate (g, device);
3192     if (r == -1)
3193       return -1;
3194   }
3195   {
3196     char volgroup[] = "VG";
3197     char physvols_0[] = "/dev/sda1";
3198     physvols_0[5] = devchar;
3199     char *physvols[] = {
3200       physvols_0,
3201       NULL
3202     };
3203     int r;
3204     suppress_error = 0;
3205     r = guestfs_vgcreate (g, volgroup, physvols);
3206     if (r == -1)
3207       return -1;
3208   }
3209   {
3210     char logvol[] = "LV1";
3211     char volgroup[] = "VG";
3212     int r;
3213     suppress_error = 0;
3214     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3215     if (r == -1)
3216       return -1;
3217   }
3218   {
3219     char logvol[] = "LV2";
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 vgname[] = "VG";
3229     int r;
3230     suppress_error = 0;
3231     r = guestfs_vgremove (g, vgname);
3232     if (r == -1)
3233       return -1;
3234   }
3235   {
3236     char device[] = "/dev/sda1";
3237     device[5] = devchar;
3238     int r;
3239     suppress_error = 0;
3240     r = guestfs_pvremove (g, device);
3241     if (r == -1)
3242       return -1;
3243   }
3244   {
3245     char **r;
3246     int i;
3247     suppress_error = 0;
3248     r = guestfs_pvs (g);
3249     if (r == NULL)
3250       return -1;
3251     if (r[0] != NULL) {
3252       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3253       print_strings (r);
3254       return -1;
3255     }
3256     for (i = 0; r[i] != NULL; ++i)
3257       free (r[i]);
3258     free (r);
3259   }
3260   return 0;
3261 }
3262
3263 static int test_vgremove_0 (void)
3264 {
3265   /* InitNone|InitEmpty for test_vgremove_0 */
3266   {
3267     char device[] = "/dev/sda";
3268     device[5] = devchar;
3269     int r;
3270     suppress_error = 0;
3271     r = guestfs_blockdev_setrw (g, device);
3272     if (r == -1)
3273       return -1;
3274   }
3275   {
3276     int r;
3277     suppress_error = 0;
3278     r = guestfs_umount_all (g);
3279     if (r == -1)
3280       return -1;
3281   }
3282   {
3283     int r;
3284     suppress_error = 0;
3285     r = guestfs_lvm_remove_all (g);
3286     if (r == -1)
3287       return -1;
3288   }
3289   /* TestOutputList for vgremove (0) */
3290   {
3291     char device[] = "/dev/sda";
3292     device[5] = devchar;
3293     char lines_0[] = ",";
3294     char *lines[] = {
3295       lines_0,
3296       NULL
3297     };
3298     int r;
3299     suppress_error = 0;
3300     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3301     if (r == -1)
3302       return -1;
3303   }
3304   {
3305     char device[] = "/dev/sda1";
3306     device[5] = devchar;
3307     int r;
3308     suppress_error = 0;
3309     r = guestfs_pvcreate (g, device);
3310     if (r == -1)
3311       return -1;
3312   }
3313   {
3314     char volgroup[] = "VG";
3315     char physvols_0[] = "/dev/sda1";
3316     physvols_0[5] = devchar;
3317     char *physvols[] = {
3318       physvols_0,
3319       NULL
3320     };
3321     int r;
3322     suppress_error = 0;
3323     r = guestfs_vgcreate (g, volgroup, physvols);
3324     if (r == -1)
3325       return -1;
3326   }
3327   {
3328     char logvol[] = "LV1";
3329     char volgroup[] = "VG";
3330     int r;
3331     suppress_error = 0;
3332     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3333     if (r == -1)
3334       return -1;
3335   }
3336   {
3337     char logvol[] = "LV2";
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 vgname[] = "VG";
3347     int r;
3348     suppress_error = 0;
3349     r = guestfs_vgremove (g, vgname);
3350     if (r == -1)
3351       return -1;
3352   }
3353   {
3354     char **r;
3355     int i;
3356     suppress_error = 0;
3357     r = guestfs_lvs (g);
3358     if (r == NULL)
3359       return -1;
3360     if (r[0] != NULL) {
3361       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3362       print_strings (r);
3363       return -1;
3364     }
3365     for (i = 0; r[i] != NULL; ++i)
3366       free (r[i]);
3367     free (r);
3368   }
3369   return 0;
3370 }
3371
3372 static int test_vgremove_1 (void)
3373 {
3374   /* InitNone|InitEmpty for test_vgremove_1 */
3375   {
3376     char device[] = "/dev/sda";
3377     device[5] = devchar;
3378     int r;
3379     suppress_error = 0;
3380     r = guestfs_blockdev_setrw (g, device);
3381     if (r == -1)
3382       return -1;
3383   }
3384   {
3385     int r;
3386     suppress_error = 0;
3387     r = guestfs_umount_all (g);
3388     if (r == -1)
3389       return -1;
3390   }
3391   {
3392     int r;
3393     suppress_error = 0;
3394     r = guestfs_lvm_remove_all (g);
3395     if (r == -1)
3396       return -1;
3397   }
3398   /* TestOutputList for vgremove (1) */
3399   {
3400     char device[] = "/dev/sda";
3401     device[5] = devchar;
3402     char lines_0[] = ",";
3403     char *lines[] = {
3404       lines_0,
3405       NULL
3406     };
3407     int r;
3408     suppress_error = 0;
3409     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3410     if (r == -1)
3411       return -1;
3412   }
3413   {
3414     char device[] = "/dev/sda1";
3415     device[5] = devchar;
3416     int r;
3417     suppress_error = 0;
3418     r = guestfs_pvcreate (g, device);
3419     if (r == -1)
3420       return -1;
3421   }
3422   {
3423     char volgroup[] = "VG";
3424     char physvols_0[] = "/dev/sda1";
3425     physvols_0[5] = devchar;
3426     char *physvols[] = {
3427       physvols_0,
3428       NULL
3429     };
3430     int r;
3431     suppress_error = 0;
3432     r = guestfs_vgcreate (g, volgroup, physvols);
3433     if (r == -1)
3434       return -1;
3435   }
3436   {
3437     char logvol[] = "LV1";
3438     char volgroup[] = "VG";
3439     int r;
3440     suppress_error = 0;
3441     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3442     if (r == -1)
3443       return -1;
3444   }
3445   {
3446     char logvol[] = "LV2";
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 vgname[] = "VG";
3456     int r;
3457     suppress_error = 0;
3458     r = guestfs_vgremove (g, vgname);
3459     if (r == -1)
3460       return -1;
3461   }
3462   {
3463     char **r;
3464     int i;
3465     suppress_error = 0;
3466     r = guestfs_vgs (g);
3467     if (r == NULL)
3468       return -1;
3469     if (r[0] != NULL) {
3470       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
3471       print_strings (r);
3472       return -1;
3473     }
3474     for (i = 0; r[i] != NULL; ++i)
3475       free (r[i]);
3476     free (r);
3477   }
3478   return 0;
3479 }
3480
3481 static int test_lvremove_0 (void)
3482 {
3483   /* InitNone|InitEmpty for test_lvremove_0 */
3484   {
3485     char device[] = "/dev/sda";
3486     device[5] = devchar;
3487     int r;
3488     suppress_error = 0;
3489     r = guestfs_blockdev_setrw (g, device);
3490     if (r == -1)
3491       return -1;
3492   }
3493   {
3494     int r;
3495     suppress_error = 0;
3496     r = guestfs_umount_all (g);
3497     if (r == -1)
3498       return -1;
3499   }
3500   {
3501     int r;
3502     suppress_error = 0;
3503     r = guestfs_lvm_remove_all (g);
3504     if (r == -1)
3505       return -1;
3506   }
3507   /* TestOutputList for lvremove (0) */
3508   {
3509     char device[] = "/dev/sda";
3510     device[5] = devchar;
3511     char lines_0[] = ",";
3512     char *lines[] = {
3513       lines_0,
3514       NULL
3515     };
3516     int r;
3517     suppress_error = 0;
3518     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3519     if (r == -1)
3520       return -1;
3521   }
3522   {
3523     char device[] = "/dev/sda1";
3524     device[5] = devchar;
3525     int r;
3526     suppress_error = 0;
3527     r = guestfs_pvcreate (g, device);
3528     if (r == -1)
3529       return -1;
3530   }
3531   {
3532     char volgroup[] = "VG";
3533     char physvols_0[] = "/dev/sda1";
3534     physvols_0[5] = devchar;
3535     char *physvols[] = {
3536       physvols_0,
3537       NULL
3538     };
3539     int r;
3540     suppress_error = 0;
3541     r = guestfs_vgcreate (g, volgroup, physvols);
3542     if (r == -1)
3543       return -1;
3544   }
3545   {
3546     char logvol[] = "LV1";
3547     char volgroup[] = "VG";
3548     int r;
3549     suppress_error = 0;
3550     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3551     if (r == -1)
3552       return -1;
3553   }
3554   {
3555     char logvol[] = "LV2";
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 device[] = "/dev/VG/LV1";
3565     int r;
3566     suppress_error = 0;
3567     r = guestfs_lvremove (g, device);
3568     if (r == -1)
3569       return -1;
3570   }
3571   {
3572     char **r;
3573     int i;
3574     suppress_error = 0;
3575     r = guestfs_lvs (g);
3576     if (r == NULL)
3577       return -1;
3578     if (!r[0]) {
3579       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
3580       print_strings (r);
3581       return -1;
3582     }
3583     {
3584       char expected[] = "/dev/VG/LV2";
3585       if (strcmp (r[0], expected) != 0) {
3586         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3587         return -1;
3588       }
3589     }
3590     if (r[1] != NULL) {
3591       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
3592       print_strings (r);
3593       return -1;
3594     }
3595     for (i = 0; r[i] != NULL; ++i)
3596       free (r[i]);
3597     free (r);
3598   }
3599   return 0;
3600 }
3601
3602 static int test_lvremove_1 (void)
3603 {
3604   /* InitNone|InitEmpty for test_lvremove_1 */
3605   {
3606     char device[] = "/dev/sda";
3607     device[5] = devchar;
3608     int r;
3609     suppress_error = 0;
3610     r = guestfs_blockdev_setrw (g, device);
3611     if (r == -1)
3612       return -1;
3613   }
3614   {
3615     int r;
3616     suppress_error = 0;
3617     r = guestfs_umount_all (g);
3618     if (r == -1)
3619       return -1;
3620   }
3621   {
3622     int r;
3623     suppress_error = 0;
3624     r = guestfs_lvm_remove_all (g);
3625     if (r == -1)
3626       return -1;
3627   }
3628   /* TestOutputList for lvremove (1) */
3629   {
3630     char device[] = "/dev/sda";
3631     device[5] = devchar;
3632     char lines_0[] = ",";
3633     char *lines[] = {
3634       lines_0,
3635       NULL
3636     };
3637     int r;
3638     suppress_error = 0;
3639     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3640     if (r == -1)
3641       return -1;
3642   }
3643   {
3644     char device[] = "/dev/sda1";
3645     device[5] = devchar;
3646     int r;
3647     suppress_error = 0;
3648     r = guestfs_pvcreate (g, device);
3649     if (r == -1)
3650       return -1;
3651   }
3652   {
3653     char volgroup[] = "VG";
3654     char physvols_0[] = "/dev/sda1";
3655     physvols_0[5] = devchar;
3656     char *physvols[] = {
3657       physvols_0,
3658       NULL
3659     };
3660     int r;
3661     suppress_error = 0;
3662     r = guestfs_vgcreate (g, volgroup, physvols);
3663     if (r == -1)
3664       return -1;
3665   }
3666   {
3667     char logvol[] = "LV1";
3668     char volgroup[] = "VG";
3669     int r;
3670     suppress_error = 0;
3671     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3672     if (r == -1)
3673       return -1;
3674   }
3675   {
3676     char logvol[] = "LV2";
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 device[] = "/dev/VG";
3686     int r;
3687     suppress_error = 0;
3688     r = guestfs_lvremove (g, device);
3689     if (r == -1)
3690       return -1;
3691   }
3692   {
3693     char **r;
3694     int i;
3695     suppress_error = 0;
3696     r = guestfs_lvs (g);
3697     if (r == NULL)
3698       return -1;
3699     if (r[0] != NULL) {
3700       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3701       print_strings (r);
3702       return -1;
3703     }
3704     for (i = 0; r[i] != NULL; ++i)
3705       free (r[i]);
3706     free (r);
3707   }
3708   return 0;
3709 }
3710
3711 static int test_lvremove_2 (void)
3712 {
3713   /* InitNone|InitEmpty for test_lvremove_2 */
3714   {
3715     char device[] = "/dev/sda";
3716     device[5] = devchar;
3717     int r;
3718     suppress_error = 0;
3719     r = guestfs_blockdev_setrw (g, device);
3720     if (r == -1)
3721       return -1;
3722   }
3723   {
3724     int r;
3725     suppress_error = 0;
3726     r = guestfs_umount_all (g);
3727     if (r == -1)
3728       return -1;
3729   }
3730   {
3731     int r;
3732     suppress_error = 0;
3733     r = guestfs_lvm_remove_all (g);
3734     if (r == -1)
3735       return -1;
3736   }
3737   /* TestOutputList for lvremove (2) */
3738   {
3739     char device[] = "/dev/sda";
3740     device[5] = devchar;
3741     char lines_0[] = ",";
3742     char *lines[] = {
3743       lines_0,
3744       NULL
3745     };
3746     int r;
3747     suppress_error = 0;
3748     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3749     if (r == -1)
3750       return -1;
3751   }
3752   {
3753     char device[] = "/dev/sda1";
3754     device[5] = devchar;
3755     int r;
3756     suppress_error = 0;
3757     r = guestfs_pvcreate (g, device);
3758     if (r == -1)
3759       return -1;
3760   }
3761   {
3762     char volgroup[] = "VG";
3763     char physvols_0[] = "/dev/sda1";
3764     physvols_0[5] = devchar;
3765     char *physvols[] = {
3766       physvols_0,
3767       NULL
3768     };
3769     int r;
3770     suppress_error = 0;
3771     r = guestfs_vgcreate (g, volgroup, physvols);
3772     if (r == -1)
3773       return -1;
3774   }
3775   {
3776     char logvol[] = "LV1";
3777     char volgroup[] = "VG";
3778     int r;
3779     suppress_error = 0;
3780     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3781     if (r == -1)
3782       return -1;
3783   }
3784   {
3785     char logvol[] = "LV2";
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 device[] = "/dev/VG";
3795     int r;
3796     suppress_error = 0;
3797     r = guestfs_lvremove (g, device);
3798     if (r == -1)
3799       return -1;
3800   }
3801   {
3802     char **r;
3803     int i;
3804     suppress_error = 0;
3805     r = guestfs_vgs (g);
3806     if (r == NULL)
3807       return -1;
3808     if (!r[0]) {
3809       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3810       print_strings (r);
3811       return -1;
3812     }
3813     {
3814       char expected[] = "VG";
3815       if (strcmp (r[0], expected) != 0) {
3816         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3817         return -1;
3818       }
3819     }
3820     if (r[1] != NULL) {
3821       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3822       print_strings (r);
3823       return -1;
3824     }
3825     for (i = 0; r[i] != NULL; ++i)
3826       free (r[i]);
3827     free (r);
3828   }
3829   return 0;
3830 }
3831
3832 static int test_mount_ro_0 (void)
3833 {
3834   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
3835   {
3836     char device[] = "/dev/sda";
3837     device[5] = devchar;
3838     int r;
3839     suppress_error = 0;
3840     r = guestfs_blockdev_setrw (g, device);
3841     if (r == -1)
3842       return -1;
3843   }
3844   {
3845     int r;
3846     suppress_error = 0;
3847     r = guestfs_umount_all (g);
3848     if (r == -1)
3849       return -1;
3850   }
3851   {
3852     int r;
3853     suppress_error = 0;
3854     r = guestfs_lvm_remove_all (g);
3855     if (r == -1)
3856       return -1;
3857   }
3858   {
3859     char device[] = "/dev/sda";
3860     device[5] = devchar;
3861     char lines_0[] = ",";
3862     char *lines[] = {
3863       lines_0,
3864       NULL
3865     };
3866     int r;
3867     suppress_error = 0;
3868     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3869     if (r == -1)
3870       return -1;
3871   }
3872   {
3873     char fstype[] = "ext2";
3874     char device[] = "/dev/sda1";
3875     device[5] = devchar;
3876     int r;
3877     suppress_error = 0;
3878     r = guestfs_mkfs (g, fstype, device);
3879     if (r == -1)
3880       return -1;
3881   }
3882   {
3883     char device[] = "/dev/sda1";
3884     device[5] = devchar;
3885     char mountpoint[] = "/";
3886     int r;
3887     suppress_error = 0;
3888     r = guestfs_mount (g, device, mountpoint);
3889     if (r == -1)
3890       return -1;
3891   }
3892   /* TestLastFail for mount_ro (0) */
3893   {
3894     char pathordevice[] = "/";
3895     int r;
3896     suppress_error = 0;
3897     r = guestfs_umount (g, pathordevice);
3898     if (r == -1)
3899       return -1;
3900   }
3901   {
3902     char device[] = "/dev/sda1";
3903     device[5] = devchar;
3904     char mountpoint[] = "/";
3905     int r;
3906     suppress_error = 0;
3907     r = guestfs_mount_ro (g, device, mountpoint);
3908     if (r == -1)
3909       return -1;
3910   }
3911   {
3912     char path[] = "/new";
3913     int r;
3914     suppress_error = 1;
3915     r = guestfs_touch (g, path);
3916     if (r != -1)
3917       return -1;
3918   }
3919   return 0;
3920 }
3921
3922 static int test_mount_ro_1 (void)
3923 {
3924   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
3925   {
3926     char device[] = "/dev/sda";
3927     device[5] = devchar;
3928     int r;
3929     suppress_error = 0;
3930     r = guestfs_blockdev_setrw (g, device);
3931     if (r == -1)
3932       return -1;
3933   }
3934   {
3935     int r;
3936     suppress_error = 0;
3937     r = guestfs_umount_all (g);
3938     if (r == -1)
3939       return -1;
3940   }
3941   {
3942     int r;
3943     suppress_error = 0;
3944     r = guestfs_lvm_remove_all (g);
3945     if (r == -1)
3946       return -1;
3947   }
3948   {
3949     char device[] = "/dev/sda";
3950     device[5] = devchar;
3951     char lines_0[] = ",";
3952     char *lines[] = {
3953       lines_0,
3954       NULL
3955     };
3956     int r;
3957     suppress_error = 0;
3958     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3959     if (r == -1)
3960       return -1;
3961   }
3962   {
3963     char fstype[] = "ext2";
3964     char device[] = "/dev/sda1";
3965     device[5] = devchar;
3966     int r;
3967     suppress_error = 0;
3968     r = guestfs_mkfs (g, fstype, device);
3969     if (r == -1)
3970       return -1;
3971   }
3972   {
3973     char device[] = "/dev/sda1";
3974     device[5] = devchar;
3975     char mountpoint[] = "/";
3976     int r;
3977     suppress_error = 0;
3978     r = guestfs_mount (g, device, mountpoint);
3979     if (r == -1)
3980       return -1;
3981   }
3982   /* TestOutput for mount_ro (1) */
3983   char expected[] = "data";
3984   {
3985     char path[] = "/new";
3986     char content[] = "data";
3987     int r;
3988     suppress_error = 0;
3989     r = guestfs_write_file (g, path, content, 0);
3990     if (r == -1)
3991       return -1;
3992   }
3993   {
3994     char pathordevice[] = "/";
3995     int r;
3996     suppress_error = 0;
3997     r = guestfs_umount (g, pathordevice);
3998     if (r == -1)
3999       return -1;
4000   }
4001   {
4002     char device[] = "/dev/sda1";
4003     device[5] = devchar;
4004     char mountpoint[] = "/";
4005     int r;
4006     suppress_error = 0;
4007     r = guestfs_mount_ro (g, device, mountpoint);
4008     if (r == -1)
4009       return -1;
4010   }
4011   {
4012     char path[] = "/new";
4013     char *r;
4014     suppress_error = 0;
4015     r = guestfs_cat (g, path);
4016     if (r == NULL)
4017       return -1;
4018     if (strcmp (r, expected) != 0) {
4019       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4020       return -1;
4021     }
4022     free (r);
4023   }
4024   return 0;
4025 }
4026
4027 static int test_tgz_in_0 (void)
4028 {
4029   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4030   {
4031     char device[] = "/dev/sda";
4032     device[5] = devchar;
4033     int r;
4034     suppress_error = 0;
4035     r = guestfs_blockdev_setrw (g, device);
4036     if (r == -1)
4037       return -1;
4038   }
4039   {
4040     int r;
4041     suppress_error = 0;
4042     r = guestfs_umount_all (g);
4043     if (r == -1)
4044       return -1;
4045   }
4046   {
4047     int r;
4048     suppress_error = 0;
4049     r = guestfs_lvm_remove_all (g);
4050     if (r == -1)
4051       return -1;
4052   }
4053   {
4054     char device[] = "/dev/sda";
4055     device[5] = devchar;
4056     char lines_0[] = ",";
4057     char *lines[] = {
4058       lines_0,
4059       NULL
4060     };
4061     int r;
4062     suppress_error = 0;
4063     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4064     if (r == -1)
4065       return -1;
4066   }
4067   {
4068     char fstype[] = "ext2";
4069     char device[] = "/dev/sda1";
4070     device[5] = devchar;
4071     int r;
4072     suppress_error = 0;
4073     r = guestfs_mkfs (g, fstype, device);
4074     if (r == -1)
4075       return -1;
4076   }
4077   {
4078     char device[] = "/dev/sda1";
4079     device[5] = devchar;
4080     char mountpoint[] = "/";
4081     int r;
4082     suppress_error = 0;
4083     r = guestfs_mount (g, device, mountpoint);
4084     if (r == -1)
4085       return -1;
4086   }
4087   /* TestOutput for tgz_in (0) */
4088   char expected[] = "hello\n";
4089   {
4090     char directory[] = "/";
4091     int r;
4092     suppress_error = 0;
4093     r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
4094     if (r == -1)
4095       return -1;
4096   }
4097   {
4098     char path[] = "/hello";
4099     char *r;
4100     suppress_error = 0;
4101     r = guestfs_cat (g, path);
4102     if (r == NULL)
4103       return -1;
4104     if (strcmp (r, expected) != 0) {
4105       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4106       return -1;
4107     }
4108     free (r);
4109   }
4110   return 0;
4111 }
4112
4113 static int test_tar_in_0 (void)
4114 {
4115   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4116   {
4117     char device[] = "/dev/sda";
4118     device[5] = devchar;
4119     int r;
4120     suppress_error = 0;
4121     r = guestfs_blockdev_setrw (g, device);
4122     if (r == -1)
4123       return -1;
4124   }
4125   {
4126     int r;
4127     suppress_error = 0;
4128     r = guestfs_umount_all (g);
4129     if (r == -1)
4130       return -1;
4131   }
4132   {
4133     int r;
4134     suppress_error = 0;
4135     r = guestfs_lvm_remove_all (g);
4136     if (r == -1)
4137       return -1;
4138   }
4139   {
4140     char device[] = "/dev/sda";
4141     device[5] = devchar;
4142     char lines_0[] = ",";
4143     char *lines[] = {
4144       lines_0,
4145       NULL
4146     };
4147     int r;
4148     suppress_error = 0;
4149     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4150     if (r == -1)
4151       return -1;
4152   }
4153   {
4154     char fstype[] = "ext2";
4155     char device[] = "/dev/sda1";
4156     device[5] = devchar;
4157     int r;
4158     suppress_error = 0;
4159     r = guestfs_mkfs (g, fstype, device);
4160     if (r == -1)
4161       return -1;
4162   }
4163   {
4164     char device[] = "/dev/sda1";
4165     device[5] = devchar;
4166     char mountpoint[] = "/";
4167     int r;
4168     suppress_error = 0;
4169     r = guestfs_mount (g, device, mountpoint);
4170     if (r == -1)
4171       return -1;
4172   }
4173   /* TestOutput for tar_in (0) */
4174   char expected[] = "hello\n";
4175   {
4176     char directory[] = "/";
4177     int r;
4178     suppress_error = 0;
4179     r = guestfs_tar_in (g, "images/helloworld.tar", directory);
4180     if (r == -1)
4181       return -1;
4182   }
4183   {
4184     char path[] = "/hello";
4185     char *r;
4186     suppress_error = 0;
4187     r = guestfs_cat (g, path);
4188     if (r == NULL)
4189       return -1;
4190     if (strcmp (r, expected) != 0) {
4191       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4192       return -1;
4193     }
4194     free (r);
4195   }
4196   return 0;
4197 }
4198
4199 static int test_checksum_0 (void)
4200 {
4201   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4202   {
4203     char device[] = "/dev/sda";
4204     device[5] = devchar;
4205     int r;
4206     suppress_error = 0;
4207     r = guestfs_blockdev_setrw (g, device);
4208     if (r == -1)
4209       return -1;
4210   }
4211   {
4212     int r;
4213     suppress_error = 0;
4214     r = guestfs_umount_all (g);
4215     if (r == -1)
4216       return -1;
4217   }
4218   {
4219     int r;
4220     suppress_error = 0;
4221     r = guestfs_lvm_remove_all (g);
4222     if (r == -1)
4223       return -1;
4224   }
4225   {
4226     char device[] = "/dev/sda";
4227     device[5] = devchar;
4228     char lines_0[] = ",";
4229     char *lines[] = {
4230       lines_0,
4231       NULL
4232     };
4233     int r;
4234     suppress_error = 0;
4235     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4236     if (r == -1)
4237       return -1;
4238   }
4239   {
4240     char fstype[] = "ext2";
4241     char device[] = "/dev/sda1";
4242     device[5] = devchar;
4243     int r;
4244     suppress_error = 0;
4245     r = guestfs_mkfs (g, fstype, device);
4246     if (r == -1)
4247       return -1;
4248   }
4249   {
4250     char device[] = "/dev/sda1";
4251     device[5] = devchar;
4252     char mountpoint[] = "/";
4253     int r;
4254     suppress_error = 0;
4255     r = guestfs_mount (g, device, mountpoint);
4256     if (r == -1)
4257       return -1;
4258   }
4259   /* TestOutput for checksum (0) */
4260   char expected[] = "935282863";
4261   {
4262     char path[] = "/new";
4263     char content[] = "test\n";
4264     int r;
4265     suppress_error = 0;
4266     r = guestfs_write_file (g, path, content, 0);
4267     if (r == -1)
4268       return -1;
4269   }
4270   {
4271     char csumtype[] = "crc";
4272     char path[] = "/new";
4273     char *r;
4274     suppress_error = 0;
4275     r = guestfs_checksum (g, csumtype, path);
4276     if (r == NULL)
4277       return -1;
4278     if (strcmp (r, expected) != 0) {
4279       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
4280       return -1;
4281     }
4282     free (r);
4283   }
4284   return 0;
4285 }
4286
4287 static int test_checksum_1 (void)
4288 {
4289   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
4290   {
4291     char device[] = "/dev/sda";
4292     device[5] = devchar;
4293     int r;
4294     suppress_error = 0;
4295     r = guestfs_blockdev_setrw (g, device);
4296     if (r == -1)
4297       return -1;
4298   }
4299   {
4300     int r;
4301     suppress_error = 0;
4302     r = guestfs_umount_all (g);
4303     if (r == -1)
4304       return -1;
4305   }
4306   {
4307     int r;
4308     suppress_error = 0;
4309     r = guestfs_lvm_remove_all (g);
4310     if (r == -1)
4311       return -1;
4312   }
4313   {
4314     char device[] = "/dev/sda";
4315     device[5] = devchar;
4316     char lines_0[] = ",";
4317     char *lines[] = {
4318       lines_0,
4319       NULL
4320     };
4321     int r;
4322     suppress_error = 0;
4323     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4324     if (r == -1)
4325       return -1;
4326   }
4327   {
4328     char fstype[] = "ext2";
4329     char device[] = "/dev/sda1";
4330     device[5] = devchar;
4331     int r;
4332     suppress_error = 0;
4333     r = guestfs_mkfs (g, fstype, device);
4334     if (r == -1)
4335       return -1;
4336   }
4337   {
4338     char device[] = "/dev/sda1";
4339     device[5] = devchar;
4340     char mountpoint[] = "/";
4341     int r;
4342     suppress_error = 0;
4343     r = guestfs_mount (g, device, mountpoint);
4344     if (r == -1)
4345       return -1;
4346   }
4347   /* TestLastFail for checksum (1) */
4348   {
4349     char csumtype[] = "crc";
4350     char path[] = "/new";
4351     char *r;
4352     suppress_error = 1;
4353     r = guestfs_checksum (g, csumtype, path);
4354     if (r != NULL)
4355       return -1;
4356     free (r);
4357   }
4358   return 0;
4359 }
4360
4361 static int test_checksum_2 (void)
4362 {
4363   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
4364   {
4365     char device[] = "/dev/sda";
4366     device[5] = devchar;
4367     int r;
4368     suppress_error = 0;
4369     r = guestfs_blockdev_setrw (g, device);
4370     if (r == -1)
4371       return -1;
4372   }
4373   {
4374     int r;
4375     suppress_error = 0;
4376     r = guestfs_umount_all (g);
4377     if (r == -1)
4378       return -1;
4379   }
4380   {
4381     int r;
4382     suppress_error = 0;
4383     r = guestfs_lvm_remove_all (g);
4384     if (r == -1)
4385       return -1;
4386   }
4387   {
4388     char device[] = "/dev/sda";
4389     device[5] = devchar;
4390     char lines_0[] = ",";
4391     char *lines[] = {
4392       lines_0,
4393       NULL
4394     };
4395     int r;
4396     suppress_error = 0;
4397     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4398     if (r == -1)
4399       return -1;
4400   }
4401   {
4402     char fstype[] = "ext2";
4403     char device[] = "/dev/sda1";
4404     device[5] = devchar;
4405     int r;
4406     suppress_error = 0;
4407     r = guestfs_mkfs (g, fstype, device);
4408     if (r == -1)
4409       return -1;
4410   }
4411   {
4412     char device[] = "/dev/sda1";
4413     device[5] = devchar;
4414     char mountpoint[] = "/";
4415     int r;
4416     suppress_error = 0;
4417     r = guestfs_mount (g, device, mountpoint);
4418     if (r == -1)
4419       return -1;
4420   }
4421   /* TestOutput for checksum (2) */
4422   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
4423   {
4424     char path[] = "/new";
4425     char content[] = "test\n";
4426     int r;
4427     suppress_error = 0;
4428     r = guestfs_write_file (g, path, content, 0);
4429     if (r == -1)
4430       return -1;
4431   }
4432   {
4433     char csumtype[] = "md5";
4434     char path[] = "/new";
4435     char *r;
4436     suppress_error = 0;
4437     r = guestfs_checksum (g, csumtype, path);
4438     if (r == NULL)
4439       return -1;
4440     if (strcmp (r, expected) != 0) {
4441       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
4442       return -1;
4443     }
4444     free (r);
4445   }
4446   return 0;
4447 }
4448
4449 static int test_checksum_3 (void)
4450 {
4451   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
4452   {
4453     char device[] = "/dev/sda";
4454     device[5] = devchar;
4455     int r;
4456     suppress_error = 0;
4457     r = guestfs_blockdev_setrw (g, device);
4458     if (r == -1)
4459       return -1;
4460   }
4461   {
4462     int r;
4463     suppress_error = 0;
4464     r = guestfs_umount_all (g);
4465     if (r == -1)
4466       return -1;
4467   }
4468   {
4469     int r;
4470     suppress_error = 0;
4471     r = guestfs_lvm_remove_all (g);
4472     if (r == -1)
4473       return -1;
4474   }
4475   {
4476     char device[] = "/dev/sda";
4477     device[5] = devchar;
4478     char lines_0[] = ",";
4479     char *lines[] = {
4480       lines_0,
4481       NULL
4482     };
4483     int r;
4484     suppress_error = 0;
4485     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4486     if (r == -1)
4487       return -1;
4488   }
4489   {
4490     char fstype[] = "ext2";
4491     char device[] = "/dev/sda1";
4492     device[5] = devchar;
4493     int r;
4494     suppress_error = 0;
4495     r = guestfs_mkfs (g, fstype, device);
4496     if (r == -1)
4497       return -1;
4498   }
4499   {
4500     char device[] = "/dev/sda1";
4501     device[5] = devchar;
4502     char mountpoint[] = "/";
4503     int r;
4504     suppress_error = 0;
4505     r = guestfs_mount (g, device, mountpoint);
4506     if (r == -1)
4507       return -1;
4508   }
4509   /* TestOutput for checksum (3) */
4510   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
4511   {
4512     char path[] = "/new";
4513     char content[] = "test\n";
4514     int r;
4515     suppress_error = 0;
4516     r = guestfs_write_file (g, path, content, 0);
4517     if (r == -1)
4518       return -1;
4519   }
4520   {
4521     char csumtype[] = "sha1";
4522     char path[] = "/new";
4523     char *r;
4524     suppress_error = 0;
4525     r = guestfs_checksum (g, csumtype, path);
4526     if (r == NULL)
4527       return -1;
4528     if (strcmp (r, expected) != 0) {
4529       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
4530       return -1;
4531     }
4532     free (r);
4533   }
4534   return 0;
4535 }
4536
4537 static int test_checksum_4 (void)
4538 {
4539   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
4540   {
4541     char device[] = "/dev/sda";
4542     device[5] = devchar;
4543     int r;
4544     suppress_error = 0;
4545     r = guestfs_blockdev_setrw (g, device);
4546     if (r == -1)
4547       return -1;
4548   }
4549   {
4550     int r;
4551     suppress_error = 0;
4552     r = guestfs_umount_all (g);
4553     if (r == -1)
4554       return -1;
4555   }
4556   {
4557     int r;
4558     suppress_error = 0;
4559     r = guestfs_lvm_remove_all (g);
4560     if (r == -1)
4561       return -1;
4562   }
4563   {
4564     char device[] = "/dev/sda";
4565     device[5] = devchar;
4566     char lines_0[] = ",";
4567     char *lines[] = {
4568       lines_0,
4569       NULL
4570     };
4571     int r;
4572     suppress_error = 0;
4573     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4574     if (r == -1)
4575       return -1;
4576   }
4577   {
4578     char fstype[] = "ext2";
4579     char device[] = "/dev/sda1";
4580     device[5] = devchar;
4581     int r;
4582     suppress_error = 0;
4583     r = guestfs_mkfs (g, fstype, device);
4584     if (r == -1)
4585       return -1;
4586   }
4587   {
4588     char device[] = "/dev/sda1";
4589     device[5] = devchar;
4590     char mountpoint[] = "/";
4591     int r;
4592     suppress_error = 0;
4593     r = guestfs_mount (g, device, mountpoint);
4594     if (r == -1)
4595       return -1;
4596   }
4597   /* TestOutput for checksum (4) */
4598   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
4599   {
4600     char path[] = "/new";
4601     char content[] = "test\n";
4602     int r;
4603     suppress_error = 0;
4604     r = guestfs_write_file (g, path, content, 0);
4605     if (r == -1)
4606       return -1;
4607   }
4608   {
4609     char csumtype[] = "sha224";
4610     char path[] = "/new";
4611     char *r;
4612     suppress_error = 0;
4613     r = guestfs_checksum (g, csumtype, path);
4614     if (r == NULL)
4615       return -1;
4616     if (strcmp (r, expected) != 0) {
4617       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
4618       return -1;
4619     }
4620     free (r);
4621   }
4622   return 0;
4623 }
4624
4625 static int test_checksum_5 (void)
4626 {
4627   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
4628   {
4629     char device[] = "/dev/sda";
4630     device[5] = devchar;
4631     int r;
4632     suppress_error = 0;
4633     r = guestfs_blockdev_setrw (g, device);
4634     if (r == -1)
4635       return -1;
4636   }
4637   {
4638     int r;
4639     suppress_error = 0;
4640     r = guestfs_umount_all (g);
4641     if (r == -1)
4642       return -1;
4643   }
4644   {
4645     int r;
4646     suppress_error = 0;
4647     r = guestfs_lvm_remove_all (g);
4648     if (r == -1)
4649       return -1;
4650   }
4651   {
4652     char device[] = "/dev/sda";
4653     device[5] = devchar;
4654     char lines_0[] = ",";
4655     char *lines[] = {
4656       lines_0,
4657       NULL
4658     };
4659     int r;
4660     suppress_error = 0;
4661     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4662     if (r == -1)
4663       return -1;
4664   }
4665   {
4666     char fstype[] = "ext2";
4667     char device[] = "/dev/sda1";
4668     device[5] = devchar;
4669     int r;
4670     suppress_error = 0;
4671     r = guestfs_mkfs (g, fstype, device);
4672     if (r == -1)
4673       return -1;
4674   }
4675   {
4676     char device[] = "/dev/sda1";
4677     device[5] = devchar;
4678     char mountpoint[] = "/";
4679     int r;
4680     suppress_error = 0;
4681     r = guestfs_mount (g, device, mountpoint);
4682     if (r == -1)
4683       return -1;
4684   }
4685   /* TestOutput for checksum (5) */
4686   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4687   {
4688     char path[] = "/new";
4689     char content[] = "test\n";
4690     int r;
4691     suppress_error = 0;
4692     r = guestfs_write_file (g, path, content, 0);
4693     if (r == -1)
4694       return -1;
4695   }
4696   {
4697     char csumtype[] = "sha256";
4698     char path[] = "/new";
4699     char *r;
4700     suppress_error = 0;
4701     r = guestfs_checksum (g, csumtype, path);
4702     if (r == NULL)
4703       return -1;
4704     if (strcmp (r, expected) != 0) {
4705       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4706       return -1;
4707     }
4708     free (r);
4709   }
4710   return 0;
4711 }
4712
4713 static int test_checksum_6 (void)
4714 {
4715   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
4716   {
4717     char device[] = "/dev/sda";
4718     device[5] = devchar;
4719     int r;
4720     suppress_error = 0;
4721     r = guestfs_blockdev_setrw (g, device);
4722     if (r == -1)
4723       return -1;
4724   }
4725   {
4726     int r;
4727     suppress_error = 0;
4728     r = guestfs_umount_all (g);
4729     if (r == -1)
4730       return -1;
4731   }
4732   {
4733     int r;
4734     suppress_error = 0;
4735     r = guestfs_lvm_remove_all (g);
4736     if (r == -1)
4737       return -1;
4738   }
4739   {
4740     char device[] = "/dev/sda";
4741     device[5] = devchar;
4742     char lines_0[] = ",";
4743     char *lines[] = {
4744       lines_0,
4745       NULL
4746     };
4747     int r;
4748     suppress_error = 0;
4749     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4750     if (r == -1)
4751       return -1;
4752   }
4753   {
4754     char fstype[] = "ext2";
4755     char device[] = "/dev/sda1";
4756     device[5] = devchar;
4757     int r;
4758     suppress_error = 0;
4759     r = guestfs_mkfs (g, fstype, device);
4760     if (r == -1)
4761       return -1;
4762   }
4763   {
4764     char device[] = "/dev/sda1";
4765     device[5] = devchar;
4766     char mountpoint[] = "/";
4767     int r;
4768     suppress_error = 0;
4769     r = guestfs_mount (g, device, mountpoint);
4770     if (r == -1)
4771       return -1;
4772   }
4773   /* TestOutput for checksum (6) */
4774   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4775   {
4776     char path[] = "/new";
4777     char content[] = "test\n";
4778     int r;
4779     suppress_error = 0;
4780     r = guestfs_write_file (g, path, content, 0);
4781     if (r == -1)
4782       return -1;
4783   }
4784   {
4785     char csumtype[] = "sha384";
4786     char path[] = "/new";
4787     char *r;
4788     suppress_error = 0;
4789     r = guestfs_checksum (g, csumtype, path);
4790     if (r == NULL)
4791       return -1;
4792     if (strcmp (r, expected) != 0) {
4793       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4794       return -1;
4795     }
4796     free (r);
4797   }
4798   return 0;
4799 }
4800
4801 static int test_checksum_7 (void)
4802 {
4803   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
4804   {
4805     char device[] = "/dev/sda";
4806     device[5] = devchar;
4807     int r;
4808     suppress_error = 0;
4809     r = guestfs_blockdev_setrw (g, device);
4810     if (r == -1)
4811       return -1;
4812   }
4813   {
4814     int r;
4815     suppress_error = 0;
4816     r = guestfs_umount_all (g);
4817     if (r == -1)
4818       return -1;
4819   }
4820   {
4821     int r;
4822     suppress_error = 0;
4823     r = guestfs_lvm_remove_all (g);
4824     if (r == -1)
4825       return -1;
4826   }
4827   {
4828     char device[] = "/dev/sda";
4829     device[5] = devchar;
4830     char lines_0[] = ",";
4831     char *lines[] = {
4832       lines_0,
4833       NULL
4834     };
4835     int r;
4836     suppress_error = 0;
4837     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4838     if (r == -1)
4839       return -1;
4840   }
4841   {
4842     char fstype[] = "ext2";
4843     char device[] = "/dev/sda1";
4844     device[5] = devchar;
4845     int r;
4846     suppress_error = 0;
4847     r = guestfs_mkfs (g, fstype, device);
4848     if (r == -1)
4849       return -1;
4850   }
4851   {
4852     char device[] = "/dev/sda1";
4853     device[5] = devchar;
4854     char mountpoint[] = "/";
4855     int r;
4856     suppress_error = 0;
4857     r = guestfs_mount (g, device, mountpoint);
4858     if (r == -1)
4859       return -1;
4860   }
4861   /* TestOutput for checksum (7) */
4862   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4863   {
4864     char path[] = "/new";
4865     char content[] = "test\n";
4866     int r;
4867     suppress_error = 0;
4868     r = guestfs_write_file (g, path, content, 0);
4869     if (r == -1)
4870       return -1;
4871   }
4872   {
4873     char csumtype[] = "sha512";
4874     char path[] = "/new";
4875     char *r;
4876     suppress_error = 0;
4877     r = guestfs_checksum (g, csumtype, path);
4878     if (r == NULL)
4879       return -1;
4880     if (strcmp (r, expected) != 0) {
4881       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4882       return -1;
4883     }
4884     free (r);
4885   }
4886   return 0;
4887 }
4888
4889 static int test_download_0 (void)
4890 {
4891   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
4892   {
4893     char device[] = "/dev/sda";
4894     device[5] = devchar;
4895     int r;
4896     suppress_error = 0;
4897     r = guestfs_blockdev_setrw (g, device);
4898     if (r == -1)
4899       return -1;
4900   }
4901   {
4902     int r;
4903     suppress_error = 0;
4904     r = guestfs_umount_all (g);
4905     if (r == -1)
4906       return -1;
4907   }
4908   {
4909     int r;
4910     suppress_error = 0;
4911     r = guestfs_lvm_remove_all (g);
4912     if (r == -1)
4913       return -1;
4914   }
4915   {
4916     char device[] = "/dev/sda";
4917     device[5] = devchar;
4918     char lines_0[] = ",";
4919     char *lines[] = {
4920       lines_0,
4921       NULL
4922     };
4923     int r;
4924     suppress_error = 0;
4925     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4926     if (r == -1)
4927       return -1;
4928   }
4929   {
4930     char fstype[] = "ext2";
4931     char device[] = "/dev/sda1";
4932     device[5] = devchar;
4933     int r;
4934     suppress_error = 0;
4935     r = guestfs_mkfs (g, fstype, device);
4936     if (r == -1)
4937       return -1;
4938   }
4939   {
4940     char device[] = "/dev/sda1";
4941     device[5] = devchar;
4942     char mountpoint[] = "/";
4943     int r;
4944     suppress_error = 0;
4945     r = guestfs_mount (g, device, mountpoint);
4946     if (r == -1)
4947       return -1;
4948   }
4949   /* TestOutput for download (0) */
4950   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4951   {
4952     char remotefilename[] = "/COPYING.LIB";
4953     int r;
4954     suppress_error = 0;
4955     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4956     if (r == -1)
4957       return -1;
4958   }
4959   {
4960     char remotefilename[] = "/COPYING.LIB";
4961     int r;
4962     suppress_error = 0;
4963     r = guestfs_download (g, remotefilename, "testdownload.tmp");
4964     if (r == -1)
4965       return -1;
4966   }
4967   {
4968     char remotefilename[] = "/upload";
4969     int r;
4970     suppress_error = 0;
4971     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4972     if (r == -1)
4973       return -1;
4974   }
4975   {
4976     char csumtype[] = "md5";
4977     char path[] = "/upload";
4978     char *r;
4979     suppress_error = 0;
4980     r = guestfs_checksum (g, csumtype, path);
4981     if (r == NULL)
4982       return -1;
4983     if (strcmp (r, expected) != 0) {
4984       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4985       return -1;
4986     }
4987     free (r);
4988   }
4989   return 0;
4990 }
4991
4992 static int test_upload_0 (void)
4993 {
4994   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
4995   {
4996     char device[] = "/dev/sda";
4997     device[5] = devchar;
4998     int r;
4999     suppress_error = 0;
5000     r = guestfs_blockdev_setrw (g, device);
5001     if (r == -1)
5002       return -1;
5003   }
5004   {
5005     int r;
5006     suppress_error = 0;
5007     r = guestfs_umount_all (g);
5008     if (r == -1)
5009       return -1;
5010   }
5011   {
5012     int r;
5013     suppress_error = 0;
5014     r = guestfs_lvm_remove_all (g);
5015     if (r == -1)
5016       return -1;
5017   }
5018   {
5019     char device[] = "/dev/sda";
5020     device[5] = devchar;
5021     char lines_0[] = ",";
5022     char *lines[] = {
5023       lines_0,
5024       NULL
5025     };
5026     int r;
5027     suppress_error = 0;
5028     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5029     if (r == -1)
5030       return -1;
5031   }
5032   {
5033     char fstype[] = "ext2";
5034     char device[] = "/dev/sda1";
5035     device[5] = devchar;
5036     int r;
5037     suppress_error = 0;
5038     r = guestfs_mkfs (g, fstype, device);
5039     if (r == -1)
5040       return -1;
5041   }
5042   {
5043     char device[] = "/dev/sda1";
5044     device[5] = devchar;
5045     char mountpoint[] = "/";
5046     int r;
5047     suppress_error = 0;
5048     r = guestfs_mount (g, device, mountpoint);
5049     if (r == -1)
5050       return -1;
5051   }
5052   /* TestOutput for upload (0) */
5053   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5054   {
5055     char remotefilename[] = "/COPYING.LIB";
5056     int r;
5057     suppress_error = 0;
5058     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
5059     if (r == -1)
5060       return -1;
5061   }
5062   {
5063     char csumtype[] = "md5";
5064     char path[] = "/COPYING.LIB";
5065     char *r;
5066     suppress_error = 0;
5067     r = guestfs_checksum (g, csumtype, path);
5068     if (r == NULL)
5069       return -1;
5070     if (strcmp (r, expected) != 0) {
5071       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
5072       return -1;
5073     }
5074     free (r);
5075   }
5076   return 0;
5077 }
5078
5079 static int test_blockdev_rereadpt_0 (void)
5080 {
5081   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
5082   {
5083     char device[] = "/dev/sda";
5084     device[5] = devchar;
5085     int r;
5086     suppress_error = 0;
5087     r = guestfs_blockdev_setrw (g, device);
5088     if (r == -1)
5089       return -1;
5090   }
5091   {
5092     int r;
5093     suppress_error = 0;
5094     r = guestfs_umount_all (g);
5095     if (r == -1)
5096       return -1;
5097   }
5098   {
5099     int r;
5100     suppress_error = 0;
5101     r = guestfs_lvm_remove_all (g);
5102     if (r == -1)
5103       return -1;
5104   }
5105   /* TestRun for blockdev_rereadpt (0) */
5106   {
5107     char device[] = "/dev/sda";
5108     device[5] = devchar;
5109     int r;
5110     suppress_error = 0;
5111     r = guestfs_blockdev_rereadpt (g, device);
5112     if (r == -1)
5113       return -1;
5114   }
5115   return 0;
5116 }
5117
5118 static int test_blockdev_flushbufs_0 (void)
5119 {
5120   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
5121   {
5122     char device[] = "/dev/sda";
5123     device[5] = devchar;
5124     int r;
5125     suppress_error = 0;
5126     r = guestfs_blockdev_setrw (g, device);
5127     if (r == -1)
5128       return -1;
5129   }
5130   {
5131     int r;
5132     suppress_error = 0;
5133     r = guestfs_umount_all (g);
5134     if (r == -1)
5135       return -1;
5136   }
5137   {
5138     int r;
5139     suppress_error = 0;
5140     r = guestfs_lvm_remove_all (g);
5141     if (r == -1)
5142       return -1;
5143   }
5144   /* TestRun for blockdev_flushbufs (0) */
5145   {
5146     char device[] = "/dev/sda";
5147     device[5] = devchar;
5148     int r;
5149     suppress_error = 0;
5150     r = guestfs_blockdev_flushbufs (g, device);
5151     if (r == -1)
5152       return -1;
5153   }
5154   return 0;
5155 }
5156
5157 static int test_blockdev_getsize64_0 (void)
5158 {
5159   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
5160   {
5161     char device[] = "/dev/sda";
5162     device[5] = devchar;
5163     int r;
5164     suppress_error = 0;
5165     r = guestfs_blockdev_setrw (g, device);
5166     if (r == -1)
5167       return -1;
5168   }
5169   {
5170     int r;
5171     suppress_error = 0;
5172     r = guestfs_umount_all (g);
5173     if (r == -1)
5174       return -1;
5175   }
5176   {
5177     int r;
5178     suppress_error = 0;
5179     r = guestfs_lvm_remove_all (g);
5180     if (r == -1)
5181       return -1;
5182   }
5183   /* TestOutputInt for blockdev_getsize64 (0) */
5184   {
5185     char device[] = "/dev/sda";
5186     device[5] = devchar;
5187     int64_t r;
5188     suppress_error = 0;
5189     r = guestfs_blockdev_getsize64 (g, device);
5190     if (r == -1)
5191       return -1;
5192     if (r != 524288000) {
5193       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
5194       return -1;
5195     }
5196   }
5197   return 0;
5198 }
5199
5200 static int test_blockdev_getsz_0 (void)
5201 {
5202   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
5203   {
5204     char device[] = "/dev/sda";
5205     device[5] = devchar;
5206     int r;
5207     suppress_error = 0;
5208     r = guestfs_blockdev_setrw (g, device);
5209     if (r == -1)
5210       return -1;
5211   }
5212   {
5213     int r;
5214     suppress_error = 0;
5215     r = guestfs_umount_all (g);
5216     if (r == -1)
5217       return -1;
5218   }
5219   {
5220     int r;
5221     suppress_error = 0;
5222     r = guestfs_lvm_remove_all (g);
5223     if (r == -1)
5224       return -1;
5225   }
5226   /* TestOutputInt for blockdev_getsz (0) */
5227   {
5228     char device[] = "/dev/sda";
5229     device[5] = devchar;
5230     int64_t r;
5231     suppress_error = 0;
5232     r = guestfs_blockdev_getsz (g, device);
5233     if (r == -1)
5234       return -1;
5235     if (r != 1024000) {
5236       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
5237       return -1;
5238     }
5239   }
5240   return 0;
5241 }
5242
5243 static int test_blockdev_getbsz_0 (void)
5244 {
5245   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
5246   {
5247     char device[] = "/dev/sda";
5248     device[5] = devchar;
5249     int r;
5250     suppress_error = 0;
5251     r = guestfs_blockdev_setrw (g, device);
5252     if (r == -1)
5253       return -1;
5254   }
5255   {
5256     int r;
5257     suppress_error = 0;
5258     r = guestfs_umount_all (g);
5259     if (r == -1)
5260       return -1;
5261   }
5262   {
5263     int r;
5264     suppress_error = 0;
5265     r = guestfs_lvm_remove_all (g);
5266     if (r == -1)
5267       return -1;
5268   }
5269   /* TestOutputInt for blockdev_getbsz (0) */
5270   {
5271     char device[] = "/dev/sda";
5272     device[5] = devchar;
5273     int r;
5274     suppress_error = 0;
5275     r = guestfs_blockdev_getbsz (g, device);
5276     if (r == -1)
5277       return -1;
5278     if (r != 4096) {
5279       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
5280       return -1;
5281     }
5282   }
5283   return 0;
5284 }
5285
5286 static int test_blockdev_getss_0 (void)
5287 {
5288   /* InitNone|InitEmpty for test_blockdev_getss_0 */
5289   {
5290     char device[] = "/dev/sda";
5291     device[5] = devchar;
5292     int r;
5293     suppress_error = 0;
5294     r = guestfs_blockdev_setrw (g, device);
5295     if (r == -1)
5296       return -1;
5297   }
5298   {
5299     int r;
5300     suppress_error = 0;
5301     r = guestfs_umount_all (g);
5302     if (r == -1)
5303       return -1;
5304   }
5305   {
5306     int r;
5307     suppress_error = 0;
5308     r = guestfs_lvm_remove_all (g);
5309     if (r == -1)
5310       return -1;
5311   }
5312   /* TestOutputInt for blockdev_getss (0) */
5313   {
5314     char device[] = "/dev/sda";
5315     device[5] = devchar;
5316     int r;
5317     suppress_error = 0;
5318     r = guestfs_blockdev_getss (g, device);
5319     if (r == -1)
5320       return -1;
5321     if (r != 512) {
5322       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
5323       return -1;
5324     }
5325   }
5326   return 0;
5327 }
5328
5329 static int test_blockdev_getro_0 (void)
5330 {
5331   /* InitNone|InitEmpty for test_blockdev_getro_0 */
5332   {
5333     char device[] = "/dev/sda";
5334     device[5] = devchar;
5335     int r;
5336     suppress_error = 0;
5337     r = guestfs_blockdev_setrw (g, device);
5338     if (r == -1)
5339       return -1;
5340   }
5341   {
5342     int r;
5343     suppress_error = 0;
5344     r = guestfs_umount_all (g);
5345     if (r == -1)
5346       return -1;
5347   }
5348   {
5349     int r;
5350     suppress_error = 0;
5351     r = guestfs_lvm_remove_all (g);
5352     if (r == -1)
5353       return -1;
5354   }
5355   /* TestOutputTrue for blockdev_getro (0) */
5356   {
5357     char device[] = "/dev/sda";
5358     device[5] = devchar;
5359     int r;
5360     suppress_error = 0;
5361     r = guestfs_blockdev_setro (g, device);
5362     if (r == -1)
5363       return -1;
5364   }
5365   {
5366     char device[] = "/dev/sda";
5367     device[5] = devchar;
5368     int r;
5369     suppress_error = 0;
5370     r = guestfs_blockdev_getro (g, device);
5371     if (r == -1)
5372       return -1;
5373     if (!r) {
5374       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
5375       return -1;
5376     }
5377   }
5378   return 0;
5379 }
5380
5381 static int test_blockdev_setrw_0 (void)
5382 {
5383   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
5384   {
5385     char device[] = "/dev/sda";
5386     device[5] = devchar;
5387     int r;
5388     suppress_error = 0;
5389     r = guestfs_blockdev_setrw (g, device);
5390     if (r == -1)
5391       return -1;
5392   }
5393   {
5394     int r;
5395     suppress_error = 0;
5396     r = guestfs_umount_all (g);
5397     if (r == -1)
5398       return -1;
5399   }
5400   {
5401     int r;
5402     suppress_error = 0;
5403     r = guestfs_lvm_remove_all (g);
5404     if (r == -1)
5405       return -1;
5406   }
5407   /* TestOutputFalse for blockdev_setrw (0) */
5408   {
5409     char device[] = "/dev/sda";
5410     device[5] = devchar;
5411     int r;
5412     suppress_error = 0;
5413     r = guestfs_blockdev_setrw (g, device);
5414     if (r == -1)
5415       return -1;
5416   }
5417   {
5418     char device[] = "/dev/sda";
5419     device[5] = devchar;
5420     int r;
5421     suppress_error = 0;
5422     r = guestfs_blockdev_getro (g, device);
5423     if (r == -1)
5424       return -1;
5425     if (r) {
5426       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
5427       return -1;
5428     }
5429   }
5430   return 0;
5431 }
5432
5433 static int test_blockdev_setro_0 (void)
5434 {
5435   /* InitNone|InitEmpty for test_blockdev_setro_0 */
5436   {
5437     char device[] = "/dev/sda";
5438     device[5] = devchar;
5439     int r;
5440     suppress_error = 0;
5441     r = guestfs_blockdev_setrw (g, device);
5442     if (r == -1)
5443       return -1;
5444   }
5445   {
5446     int r;
5447     suppress_error = 0;
5448     r = guestfs_umount_all (g);
5449     if (r == -1)
5450       return -1;
5451   }
5452   {
5453     int r;
5454     suppress_error = 0;
5455     r = guestfs_lvm_remove_all (g);
5456     if (r == -1)
5457       return -1;
5458   }
5459   /* TestOutputTrue for blockdev_setro (0) */
5460   {
5461     char device[] = "/dev/sda";
5462     device[5] = devchar;
5463     int r;
5464     suppress_error = 0;
5465     r = guestfs_blockdev_setro (g, device);
5466     if (r == -1)
5467       return -1;
5468   }
5469   {
5470     char device[] = "/dev/sda";
5471     device[5] = devchar;
5472     int r;
5473     suppress_error = 0;
5474     r = guestfs_blockdev_getro (g, device);
5475     if (r == -1)
5476       return -1;
5477     if (!r) {
5478       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
5479       return -1;
5480     }
5481   }
5482   return 0;
5483 }
5484
5485 static int test_statvfs_0 (void)
5486 {
5487   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
5488   {
5489     char device[] = "/dev/sda";
5490     device[5] = devchar;
5491     int r;
5492     suppress_error = 0;
5493     r = guestfs_blockdev_setrw (g, device);
5494     if (r == -1)
5495       return -1;
5496   }
5497   {
5498     int r;
5499     suppress_error = 0;
5500     r = guestfs_umount_all (g);
5501     if (r == -1)
5502       return -1;
5503   }
5504   {
5505     int r;
5506     suppress_error = 0;
5507     r = guestfs_lvm_remove_all (g);
5508     if (r == -1)
5509       return -1;
5510   }
5511   {
5512     char device[] = "/dev/sda";
5513     device[5] = devchar;
5514     char lines_0[] = ",";
5515     char *lines[] = {
5516       lines_0,
5517       NULL
5518     };
5519     int r;
5520     suppress_error = 0;
5521     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5522     if (r == -1)
5523       return -1;
5524   }
5525   {
5526     char fstype[] = "ext2";
5527     char device[] = "/dev/sda1";
5528     device[5] = devchar;
5529     int r;
5530     suppress_error = 0;
5531     r = guestfs_mkfs (g, fstype, device);
5532     if (r == -1)
5533       return -1;
5534   }
5535   {
5536     char device[] = "/dev/sda1";
5537     device[5] = devchar;
5538     char mountpoint[] = "/";
5539     int r;
5540     suppress_error = 0;
5541     r = guestfs_mount (g, device, mountpoint);
5542     if (r == -1)
5543       return -1;
5544   }
5545   /* TestOutputStruct for statvfs (0) */
5546   {
5547     char path[] = "/";
5548     struct guestfs_statvfs *r;
5549     suppress_error = 0;
5550     r = guestfs_statvfs (g, path);
5551     if (r == NULL)
5552       return -1;
5553     if (r->bfree != 487702) {
5554       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
5555                (int) r->bfree);
5556       return -1;
5557     }
5558     if (r->blocks != 490020) {
5559       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
5560                (int) r->blocks);
5561       return -1;
5562     }
5563     if (r->bsize != 1024) {
5564       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
5565                (int) r->bsize);
5566       return -1;
5567     }
5568     free (r);
5569   }
5570   return 0;
5571 }
5572
5573 static int test_lstat_0 (void)
5574 {
5575   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
5576   {
5577     char device[] = "/dev/sda";
5578     device[5] = devchar;
5579     int r;
5580     suppress_error = 0;
5581     r = guestfs_blockdev_setrw (g, device);
5582     if (r == -1)
5583       return -1;
5584   }
5585   {
5586     int r;
5587     suppress_error = 0;
5588     r = guestfs_umount_all (g);
5589     if (r == -1)
5590       return -1;
5591   }
5592   {
5593     int r;
5594     suppress_error = 0;
5595     r = guestfs_lvm_remove_all (g);
5596     if (r == -1)
5597       return -1;
5598   }
5599   {
5600     char device[] = "/dev/sda";
5601     device[5] = devchar;
5602     char lines_0[] = ",";
5603     char *lines[] = {
5604       lines_0,
5605       NULL
5606     };
5607     int r;
5608     suppress_error = 0;
5609     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5610     if (r == -1)
5611       return -1;
5612   }
5613   {
5614     char fstype[] = "ext2";
5615     char device[] = "/dev/sda1";
5616     device[5] = devchar;
5617     int r;
5618     suppress_error = 0;
5619     r = guestfs_mkfs (g, fstype, device);
5620     if (r == -1)
5621       return -1;
5622   }
5623   {
5624     char device[] = "/dev/sda1";
5625     device[5] = devchar;
5626     char mountpoint[] = "/";
5627     int r;
5628     suppress_error = 0;
5629     r = guestfs_mount (g, device, mountpoint);
5630     if (r == -1)
5631       return -1;
5632   }
5633   /* TestOutputStruct for lstat (0) */
5634   {
5635     char path[] = "/new";
5636     int r;
5637     suppress_error = 0;
5638     r = guestfs_touch (g, path);
5639     if (r == -1)
5640       return -1;
5641   }
5642   {
5643     char path[] = "/new";
5644     struct guestfs_stat *r;
5645     suppress_error = 0;
5646     r = guestfs_lstat (g, path);
5647     if (r == NULL)
5648       return -1;
5649     if (r->size != 0) {
5650       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
5651                (int) r->size);
5652       return -1;
5653     }
5654     free (r);
5655   }
5656   return 0;
5657 }
5658
5659 static int test_stat_0 (void)
5660 {
5661   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
5662   {
5663     char device[] = "/dev/sda";
5664     device[5] = devchar;
5665     int r;
5666     suppress_error = 0;
5667     r = guestfs_blockdev_setrw (g, device);
5668     if (r == -1)
5669       return -1;
5670   }
5671   {
5672     int r;
5673     suppress_error = 0;
5674     r = guestfs_umount_all (g);
5675     if (r == -1)
5676       return -1;
5677   }
5678   {
5679     int r;
5680     suppress_error = 0;
5681     r = guestfs_lvm_remove_all (g);
5682     if (r == -1)
5683       return -1;
5684   }
5685   {
5686     char device[] = "/dev/sda";
5687     device[5] = devchar;
5688     char lines_0[] = ",";
5689     char *lines[] = {
5690       lines_0,
5691       NULL
5692     };
5693     int r;
5694     suppress_error = 0;
5695     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5696     if (r == -1)
5697       return -1;
5698   }
5699   {
5700     char fstype[] = "ext2";
5701     char device[] = "/dev/sda1";
5702     device[5] = devchar;
5703     int r;
5704     suppress_error = 0;
5705     r = guestfs_mkfs (g, fstype, device);
5706     if (r == -1)
5707       return -1;
5708   }
5709   {
5710     char device[] = "/dev/sda1";
5711     device[5] = devchar;
5712     char mountpoint[] = "/";
5713     int r;
5714     suppress_error = 0;
5715     r = guestfs_mount (g, device, mountpoint);
5716     if (r == -1)
5717       return -1;
5718   }
5719   /* TestOutputStruct for stat (0) */
5720   {
5721     char path[] = "/new";
5722     int r;
5723     suppress_error = 0;
5724     r = guestfs_touch (g, path);
5725     if (r == -1)
5726       return -1;
5727   }
5728   {
5729     char path[] = "/new";
5730     struct guestfs_stat *r;
5731     suppress_error = 0;
5732     r = guestfs_stat (g, path);
5733     if (r == NULL)
5734       return -1;
5735     if (r->size != 0) {
5736       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5737                (int) r->size);
5738       return -1;
5739     }
5740     free (r);
5741   }
5742   return 0;
5743 }
5744
5745 static int test_command_lines_0_prereq (void)
5746 {
5747   const char *str = getenv ("SKIP_TEST_COMMAND");
5748   return str && strcmp (str, "1") == 0;
5749 }
5750
5751 static int test_command_lines_0 (void)
5752 {
5753   if (! test_command_lines_0_prereq ()) {
5754   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
5755   {
5756     char device[] = "/dev/sda";
5757     device[5] = devchar;
5758     int r;
5759     suppress_error = 0;
5760     r = guestfs_blockdev_setrw (g, device);
5761     if (r == -1)
5762       return -1;
5763   }
5764   {
5765     int r;
5766     suppress_error = 0;
5767     r = guestfs_umount_all (g);
5768     if (r == -1)
5769       return -1;
5770   }
5771   {
5772     int r;
5773     suppress_error = 0;
5774     r = guestfs_lvm_remove_all (g);
5775     if (r == -1)
5776       return -1;
5777   }
5778   {
5779     char device[] = "/dev/sda";
5780     device[5] = devchar;
5781     char lines_0[] = ",";
5782     char *lines[] = {
5783       lines_0,
5784       NULL
5785     };
5786     int r;
5787     suppress_error = 0;
5788     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5789     if (r == -1)
5790       return -1;
5791   }
5792   {
5793     char fstype[] = "ext2";
5794     char device[] = "/dev/sda1";
5795     device[5] = devchar;
5796     int r;
5797     suppress_error = 0;
5798     r = guestfs_mkfs (g, fstype, device);
5799     if (r == -1)
5800       return -1;
5801   }
5802   {
5803     char device[] = "/dev/sda1";
5804     device[5] = devchar;
5805     char mountpoint[] = "/";
5806     int r;
5807     suppress_error = 0;
5808     r = guestfs_mount (g, device, mountpoint);
5809     if (r == -1)
5810       return -1;
5811   }
5812   /* TestOutputList for command_lines (0) */
5813   {
5814     char remotefilename[] = "/test-command";
5815     int r;
5816     suppress_error = 0;
5817     r = guestfs_upload (g, "test-command", remotefilename);
5818     if (r == -1)
5819       return -1;
5820   }
5821   {
5822     char path[] = "/test-command";
5823     int r;
5824     suppress_error = 0;
5825     r = guestfs_chmod (g, 493, path);
5826     if (r == -1)
5827       return -1;
5828   }
5829   {
5830     char arguments_0[] = "/test-command";
5831     char arguments_1[] = "1";
5832     char *arguments[] = {
5833       arguments_0,
5834       arguments_1,
5835       NULL
5836     };
5837     char **r;
5838     int i;
5839     suppress_error = 0;
5840     r = guestfs_command_lines (g, arguments);
5841     if (r == NULL)
5842       return -1;
5843     if (!r[0]) {
5844       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5845       print_strings (r);
5846       return -1;
5847     }
5848     {
5849       char expected[] = "Result1";
5850       if (strcmp (r[0], expected) != 0) {
5851         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5852         return -1;
5853       }
5854     }
5855     if (r[1] != NULL) {
5856       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5857       print_strings (r);
5858       return -1;
5859     }
5860     for (i = 0; r[i] != NULL; ++i)
5861       free (r[i]);
5862     free (r);
5863   }
5864   } else
5865     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5866   return 0;
5867 }
5868
5869 static int test_command_lines_1_prereq (void)
5870 {
5871   const char *str = getenv ("SKIP_TEST_COMMAND");
5872   return str && strcmp (str, "1") == 0;
5873 }
5874
5875 static int test_command_lines_1 (void)
5876 {
5877   if (! test_command_lines_1_prereq ()) {
5878   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
5879   {
5880     char device[] = "/dev/sda";
5881     device[5] = devchar;
5882     int r;
5883     suppress_error = 0;
5884     r = guestfs_blockdev_setrw (g, device);
5885     if (r == -1)
5886       return -1;
5887   }
5888   {
5889     int r;
5890     suppress_error = 0;
5891     r = guestfs_umount_all (g);
5892     if (r == -1)
5893       return -1;
5894   }
5895   {
5896     int r;
5897     suppress_error = 0;
5898     r = guestfs_lvm_remove_all (g);
5899     if (r == -1)
5900       return -1;
5901   }
5902   {
5903     char device[] = "/dev/sda";
5904     device[5] = devchar;
5905     char lines_0[] = ",";
5906     char *lines[] = {
5907       lines_0,
5908       NULL
5909     };
5910     int r;
5911     suppress_error = 0;
5912     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5913     if (r == -1)
5914       return -1;
5915   }
5916   {
5917     char fstype[] = "ext2";
5918     char device[] = "/dev/sda1";
5919     device[5] = devchar;
5920     int r;
5921     suppress_error = 0;
5922     r = guestfs_mkfs (g, fstype, device);
5923     if (r == -1)
5924       return -1;
5925   }
5926   {
5927     char device[] = "/dev/sda1";
5928     device[5] = devchar;
5929     char mountpoint[] = "/";
5930     int r;
5931     suppress_error = 0;
5932     r = guestfs_mount (g, device, mountpoint);
5933     if (r == -1)
5934       return -1;
5935   }
5936   /* TestOutputList for command_lines (1) */
5937   {
5938     char remotefilename[] = "/test-command";
5939     int r;
5940     suppress_error = 0;
5941     r = guestfs_upload (g, "test-command", remotefilename);
5942     if (r == -1)
5943       return -1;
5944   }
5945   {
5946     char path[] = "/test-command";
5947     int r;
5948     suppress_error = 0;
5949     r = guestfs_chmod (g, 493, path);
5950     if (r == -1)
5951       return -1;
5952   }
5953   {
5954     char arguments_0[] = "/test-command";
5955     char arguments_1[] = "2";
5956     char *arguments[] = {
5957       arguments_0,
5958       arguments_1,
5959       NULL
5960     };
5961     char **r;
5962     int i;
5963     suppress_error = 0;
5964     r = guestfs_command_lines (g, arguments);
5965     if (r == NULL)
5966       return -1;
5967     if (!r[0]) {
5968       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5969       print_strings (r);
5970       return -1;
5971     }
5972     {
5973       char expected[] = "Result2";
5974       if (strcmp (r[0], expected) != 0) {
5975         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5976         return -1;
5977       }
5978     }
5979     if (r[1] != NULL) {
5980       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5981       print_strings (r);
5982       return -1;
5983     }
5984     for (i = 0; r[i] != NULL; ++i)
5985       free (r[i]);
5986     free (r);
5987   }
5988   } else
5989     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5990   return 0;
5991 }
5992
5993 static int test_command_lines_2_prereq (void)
5994 {
5995   const char *str = getenv ("SKIP_TEST_COMMAND");
5996   return str && strcmp (str, "1") == 0;
5997 }
5998
5999 static int test_command_lines_2 (void)
6000 {
6001   if (! test_command_lines_2_prereq ()) {
6002   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
6003   {
6004     char device[] = "/dev/sda";
6005     device[5] = devchar;
6006     int r;
6007     suppress_error = 0;
6008     r = guestfs_blockdev_setrw (g, device);
6009     if (r == -1)
6010       return -1;
6011   }
6012   {
6013     int r;
6014     suppress_error = 0;
6015     r = guestfs_umount_all (g);
6016     if (r == -1)
6017       return -1;
6018   }
6019   {
6020     int r;
6021     suppress_error = 0;
6022     r = guestfs_lvm_remove_all (g);
6023     if (r == -1)
6024       return -1;
6025   }
6026   {
6027     char device[] = "/dev/sda";
6028     device[5] = devchar;
6029     char lines_0[] = ",";
6030     char *lines[] = {
6031       lines_0,
6032       NULL
6033     };
6034     int r;
6035     suppress_error = 0;
6036     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6037     if (r == -1)
6038       return -1;
6039   }
6040   {
6041     char fstype[] = "ext2";
6042     char device[] = "/dev/sda1";
6043     device[5] = devchar;
6044     int r;
6045     suppress_error = 0;
6046     r = guestfs_mkfs (g, fstype, device);
6047     if (r == -1)
6048       return -1;
6049   }
6050   {
6051     char device[] = "/dev/sda1";
6052     device[5] = devchar;
6053     char mountpoint[] = "/";
6054     int r;
6055     suppress_error = 0;
6056     r = guestfs_mount (g, device, mountpoint);
6057     if (r == -1)
6058       return -1;
6059   }
6060   /* TestOutputList for command_lines (2) */
6061   {
6062     char remotefilename[] = "/test-command";
6063     int r;
6064     suppress_error = 0;
6065     r = guestfs_upload (g, "test-command", remotefilename);
6066     if (r == -1)
6067       return -1;
6068   }
6069   {
6070     char path[] = "/test-command";
6071     int r;
6072     suppress_error = 0;
6073     r = guestfs_chmod (g, 493, path);
6074     if (r == -1)
6075       return -1;
6076   }
6077   {
6078     char arguments_0[] = "/test-command";
6079     char arguments_1[] = "3";
6080     char *arguments[] = {
6081       arguments_0,
6082       arguments_1,
6083       NULL
6084     };
6085     char **r;
6086     int i;
6087     suppress_error = 0;
6088     r = guestfs_command_lines (g, arguments);
6089     if (r == NULL)
6090       return -1;
6091     if (!r[0]) {
6092       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
6093       print_strings (r);
6094       return -1;
6095     }
6096     {
6097       char expected[] = "";
6098       if (strcmp (r[0], expected) != 0) {
6099         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6100         return -1;
6101       }
6102     }
6103     if (!r[1]) {
6104       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
6105       print_strings (r);
6106       return -1;
6107     }
6108     {
6109       char expected[] = "Result3";
6110       if (strcmp (r[1], expected) != 0) {
6111         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6112         return -1;
6113       }
6114     }
6115     if (r[2] != NULL) {
6116       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
6117       print_strings (r);
6118       return -1;
6119     }
6120     for (i = 0; r[i] != NULL; ++i)
6121       free (r[i]);
6122     free (r);
6123   }
6124   } else
6125     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
6126   return 0;
6127 }
6128
6129 static int test_command_lines_3_prereq (void)
6130 {
6131   const char *str = getenv ("SKIP_TEST_COMMAND");
6132   return str && strcmp (str, "1") == 0;
6133 }
6134
6135 static int test_command_lines_3 (void)
6136 {
6137   if (! test_command_lines_3_prereq ()) {
6138   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
6139   {
6140     char device[] = "/dev/sda";
6141     device[5] = devchar;
6142     int r;
6143     suppress_error = 0;
6144     r = guestfs_blockdev_setrw (g, device);
6145     if (r == -1)
6146       return -1;
6147   }
6148   {
6149     int r;
6150     suppress_error = 0;
6151     r = guestfs_umount_all (g);
6152     if (r == -1)
6153       return -1;
6154   }
6155   {
6156     int r;
6157     suppress_error = 0;
6158     r = guestfs_lvm_remove_all (g);
6159     if (r == -1)
6160       return -1;
6161   }
6162   {
6163     char device[] = "/dev/sda";
6164     device[5] = devchar;
6165     char lines_0[] = ",";
6166     char *lines[] = {
6167       lines_0,
6168       NULL
6169     };
6170     int r;
6171     suppress_error = 0;
6172     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6173     if (r == -1)
6174       return -1;
6175   }
6176   {
6177     char fstype[] = "ext2";
6178     char device[] = "/dev/sda1";
6179     device[5] = devchar;
6180     int r;
6181     suppress_error = 0;
6182     r = guestfs_mkfs (g, fstype, device);
6183     if (r == -1)
6184       return -1;
6185   }
6186   {
6187     char device[] = "/dev/sda1";
6188     device[5] = devchar;
6189     char mountpoint[] = "/";
6190     int r;
6191     suppress_error = 0;
6192     r = guestfs_mount (g, device, mountpoint);
6193     if (r == -1)
6194       return -1;
6195   }
6196   /* TestOutputList for command_lines (3) */
6197   {
6198     char remotefilename[] = "/test-command";
6199     int r;
6200     suppress_error = 0;
6201     r = guestfs_upload (g, "test-command", remotefilename);
6202     if (r == -1)
6203       return -1;
6204   }
6205   {
6206     char path[] = "/test-command";
6207     int r;
6208     suppress_error = 0;
6209     r = guestfs_chmod (g, 493, path);
6210     if (r == -1)
6211       return -1;
6212   }
6213   {
6214     char arguments_0[] = "/test-command";
6215     char arguments_1[] = "4";
6216     char *arguments[] = {
6217       arguments_0,
6218       arguments_1,
6219       NULL
6220     };
6221     char **r;
6222     int i;
6223     suppress_error = 0;
6224     r = guestfs_command_lines (g, arguments);
6225     if (r == NULL)
6226       return -1;
6227     if (!r[0]) {
6228       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6229       print_strings (r);
6230       return -1;
6231     }
6232     {
6233       char expected[] = "";
6234       if (strcmp (r[0], expected) != 0) {
6235         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6236         return -1;
6237       }
6238     }
6239     if (!r[1]) {
6240       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6241       print_strings (r);
6242       return -1;
6243     }
6244     {
6245       char expected[] = "Result4";
6246       if (strcmp (r[1], expected) != 0) {
6247         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6248         return -1;
6249       }
6250     }
6251     if (r[2] != NULL) {
6252       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
6253       print_strings (r);
6254       return -1;
6255     }
6256     for (i = 0; r[i] != NULL; ++i)
6257       free (r[i]);
6258     free (r);
6259   }
6260   } else
6261     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
6262   return 0;
6263 }
6264
6265 static int test_command_lines_4_prereq (void)
6266 {
6267   const char *str = getenv ("SKIP_TEST_COMMAND");
6268   return str && strcmp (str, "1") == 0;
6269 }
6270
6271 static int test_command_lines_4 (void)
6272 {
6273   if (! test_command_lines_4_prereq ()) {
6274   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
6275   {
6276     char device[] = "/dev/sda";
6277     device[5] = devchar;
6278     int r;
6279     suppress_error = 0;
6280     r = guestfs_blockdev_setrw (g, device);
6281     if (r == -1)
6282       return -1;
6283   }
6284   {
6285     int r;
6286     suppress_error = 0;
6287     r = guestfs_umount_all (g);
6288     if (r == -1)
6289       return -1;
6290   }
6291   {
6292     int r;
6293     suppress_error = 0;
6294     r = guestfs_lvm_remove_all (g);
6295     if (r == -1)
6296       return -1;
6297   }
6298   {
6299     char device[] = "/dev/sda";
6300     device[5] = devchar;
6301     char lines_0[] = ",";
6302     char *lines[] = {
6303       lines_0,
6304       NULL
6305     };
6306     int r;
6307     suppress_error = 0;
6308     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6309     if (r == -1)
6310       return -1;
6311   }
6312   {
6313     char fstype[] = "ext2";
6314     char device[] = "/dev/sda1";
6315     device[5] = devchar;
6316     int r;
6317     suppress_error = 0;
6318     r = guestfs_mkfs (g, fstype, device);
6319     if (r == -1)
6320       return -1;
6321   }
6322   {
6323     char device[] = "/dev/sda1";
6324     device[5] = devchar;
6325     char mountpoint[] = "/";
6326     int r;
6327     suppress_error = 0;
6328     r = guestfs_mount (g, device, mountpoint);
6329     if (r == -1)
6330       return -1;
6331   }
6332   /* TestOutputList for command_lines (4) */
6333   {
6334     char remotefilename[] = "/test-command";
6335     int r;
6336     suppress_error = 0;
6337     r = guestfs_upload (g, "test-command", remotefilename);
6338     if (r == -1)
6339       return -1;
6340   }
6341   {
6342     char path[] = "/test-command";
6343     int r;
6344     suppress_error = 0;
6345     r = guestfs_chmod (g, 493, path);
6346     if (r == -1)
6347       return -1;
6348   }
6349   {
6350     char arguments_0[] = "/test-command";
6351     char arguments_1[] = "5";
6352     char *arguments[] = {
6353       arguments_0,
6354       arguments_1,
6355       NULL
6356     };
6357     char **r;
6358     int i;
6359     suppress_error = 0;
6360     r = guestfs_command_lines (g, arguments);
6361     if (r == NULL)
6362       return -1;
6363     if (!r[0]) {
6364       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6365       print_strings (r);
6366       return -1;
6367     }
6368     {
6369       char expected[] = "";
6370       if (strcmp (r[0], expected) != 0) {
6371         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6372         return -1;
6373       }
6374     }
6375     if (!r[1]) {
6376       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6377       print_strings (r);
6378       return -1;
6379     }
6380     {
6381       char expected[] = "Result5";
6382       if (strcmp (r[1], expected) != 0) {
6383         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6384         return -1;
6385       }
6386     }
6387     if (!r[2]) {
6388       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6389       print_strings (r);
6390       return -1;
6391     }
6392     {
6393       char expected[] = "";
6394       if (strcmp (r[2], expected) != 0) {
6395         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6396         return -1;
6397       }
6398     }
6399     if (r[3] != NULL) {
6400       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
6401       print_strings (r);
6402       return -1;
6403     }
6404     for (i = 0; r[i] != NULL; ++i)
6405       free (r[i]);
6406     free (r);
6407   }
6408   } else
6409     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
6410   return 0;
6411 }
6412
6413 static int test_command_lines_5_prereq (void)
6414 {
6415   const char *str = getenv ("SKIP_TEST_COMMAND");
6416   return str && strcmp (str, "1") == 0;
6417 }
6418
6419 static int test_command_lines_5 (void)
6420 {
6421   if (! test_command_lines_5_prereq ()) {
6422   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
6423   {
6424     char device[] = "/dev/sda";
6425     device[5] = devchar;
6426     int r;
6427     suppress_error = 0;
6428     r = guestfs_blockdev_setrw (g, device);
6429     if (r == -1)
6430       return -1;
6431   }
6432   {
6433     int r;
6434     suppress_error = 0;
6435     r = guestfs_umount_all (g);
6436     if (r == -1)
6437       return -1;
6438   }
6439   {
6440     int r;
6441     suppress_error = 0;
6442     r = guestfs_lvm_remove_all (g);
6443     if (r == -1)
6444       return -1;
6445   }
6446   {
6447     char device[] = "/dev/sda";
6448     device[5] = devchar;
6449     char lines_0[] = ",";
6450     char *lines[] = {
6451       lines_0,
6452       NULL
6453     };
6454     int r;
6455     suppress_error = 0;
6456     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6457     if (r == -1)
6458       return -1;
6459   }
6460   {
6461     char fstype[] = "ext2";
6462     char device[] = "/dev/sda1";
6463     device[5] = devchar;
6464     int r;
6465     suppress_error = 0;
6466     r = guestfs_mkfs (g, fstype, device);
6467     if (r == -1)
6468       return -1;
6469   }
6470   {
6471     char device[] = "/dev/sda1";
6472     device[5] = devchar;
6473     char mountpoint[] = "/";
6474     int r;
6475     suppress_error = 0;
6476     r = guestfs_mount (g, device, mountpoint);
6477     if (r == -1)
6478       return -1;
6479   }
6480   /* TestOutputList for command_lines (5) */
6481   {
6482     char remotefilename[] = "/test-command";
6483     int r;
6484     suppress_error = 0;
6485     r = guestfs_upload (g, "test-command", remotefilename);
6486     if (r == -1)
6487       return -1;
6488   }
6489   {
6490     char path[] = "/test-command";
6491     int r;
6492     suppress_error = 0;
6493     r = guestfs_chmod (g, 493, path);
6494     if (r == -1)
6495       return -1;
6496   }
6497   {
6498     char arguments_0[] = "/test-command";
6499     char arguments_1[] = "6";
6500     char *arguments[] = {
6501       arguments_0,
6502       arguments_1,
6503       NULL
6504     };
6505     char **r;
6506     int i;
6507     suppress_error = 0;
6508     r = guestfs_command_lines (g, arguments);
6509     if (r == NULL)
6510       return -1;
6511     if (!r[0]) {
6512       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6513       print_strings (r);
6514       return -1;
6515     }
6516     {
6517       char expected[] = "";
6518       if (strcmp (r[0], expected) != 0) {
6519         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6520         return -1;
6521       }
6522     }
6523     if (!r[1]) {
6524       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6525       print_strings (r);
6526       return -1;
6527     }
6528     {
6529       char expected[] = "";
6530       if (strcmp (r[1], expected) != 0) {
6531         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6532         return -1;
6533       }
6534     }
6535     if (!r[2]) {
6536       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6537       print_strings (r);
6538       return -1;
6539     }
6540     {
6541       char expected[] = "Result6";
6542       if (strcmp (r[2], expected) != 0) {
6543         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6544         return -1;
6545       }
6546     }
6547     if (!r[3]) {
6548       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6549       print_strings (r);
6550       return -1;
6551     }
6552     {
6553       char expected[] = "";
6554       if (strcmp (r[3], expected) != 0) {
6555         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
6556         return -1;
6557       }
6558     }
6559     if (r[4] != NULL) {
6560       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
6561       print_strings (r);
6562       return -1;
6563     }
6564     for (i = 0; r[i] != NULL; ++i)
6565       free (r[i]);
6566     free (r);
6567   }
6568   } else
6569     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
6570   return 0;
6571 }
6572
6573 static int test_command_lines_6_prereq (void)
6574 {
6575   const char *str = getenv ("SKIP_TEST_COMMAND");
6576   return str && strcmp (str, "1") == 0;
6577 }
6578
6579 static int test_command_lines_6 (void)
6580 {
6581   if (! test_command_lines_6_prereq ()) {
6582   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
6583   {
6584     char device[] = "/dev/sda";
6585     device[5] = devchar;
6586     int r;
6587     suppress_error = 0;
6588     r = guestfs_blockdev_setrw (g, device);
6589     if (r == -1)
6590       return -1;
6591   }
6592   {
6593     int r;
6594     suppress_error = 0;
6595     r = guestfs_umount_all (g);
6596     if (r == -1)
6597       return -1;
6598   }
6599   {
6600     int r;
6601     suppress_error = 0;
6602     r = guestfs_lvm_remove_all (g);
6603     if (r == -1)
6604       return -1;
6605   }
6606   {
6607     char device[] = "/dev/sda";
6608     device[5] = devchar;
6609     char lines_0[] = ",";
6610     char *lines[] = {
6611       lines_0,
6612       NULL
6613     };
6614     int r;
6615     suppress_error = 0;
6616     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6617     if (r == -1)
6618       return -1;
6619   }
6620   {
6621     char fstype[] = "ext2";
6622     char device[] = "/dev/sda1";
6623     device[5] = devchar;
6624     int r;
6625     suppress_error = 0;
6626     r = guestfs_mkfs (g, fstype, device);
6627     if (r == -1)
6628       return -1;
6629   }
6630   {
6631     char device[] = "/dev/sda1";
6632     device[5] = devchar;
6633     char mountpoint[] = "/";
6634     int r;
6635     suppress_error = 0;
6636     r = guestfs_mount (g, device, mountpoint);
6637     if (r == -1)
6638       return -1;
6639   }
6640   /* TestOutputList for command_lines (6) */
6641   {
6642     char remotefilename[] = "/test-command";
6643     int r;
6644     suppress_error = 0;
6645     r = guestfs_upload (g, "test-command", remotefilename);
6646     if (r == -1)
6647       return -1;
6648   }
6649   {
6650     char path[] = "/test-command";
6651     int r;
6652     suppress_error = 0;
6653     r = guestfs_chmod (g, 493, path);
6654     if (r == -1)
6655       return -1;
6656   }
6657   {
6658     char arguments_0[] = "/test-command";
6659     char arguments_1[] = "7";
6660     char *arguments[] = {
6661       arguments_0,
6662       arguments_1,
6663       NULL
6664     };
6665     char **r;
6666     int i;
6667     suppress_error = 0;
6668     r = guestfs_command_lines (g, arguments);
6669     if (r == NULL)
6670       return -1;
6671     if (r[0] != NULL) {
6672       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6673       print_strings (r);
6674       return -1;
6675     }
6676     for (i = 0; r[i] != NULL; ++i)
6677       free (r[i]);
6678     free (r);
6679   }
6680   } else
6681     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6682   return 0;
6683 }
6684
6685 static int test_command_lines_7_prereq (void)
6686 {
6687   const char *str = getenv ("SKIP_TEST_COMMAND");
6688   return str && strcmp (str, "1") == 0;
6689 }
6690
6691 static int test_command_lines_7 (void)
6692 {
6693   if (! test_command_lines_7_prereq ()) {
6694   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
6695   {
6696     char device[] = "/dev/sda";
6697     device[5] = devchar;
6698     int r;
6699     suppress_error = 0;
6700     r = guestfs_blockdev_setrw (g, device);
6701     if (r == -1)
6702       return -1;
6703   }
6704   {
6705     int r;
6706     suppress_error = 0;
6707     r = guestfs_umount_all (g);
6708     if (r == -1)
6709       return -1;
6710   }
6711   {
6712     int r;
6713     suppress_error = 0;
6714     r = guestfs_lvm_remove_all (g);
6715     if (r == -1)
6716       return -1;
6717   }
6718   {
6719     char device[] = "/dev/sda";
6720     device[5] = devchar;
6721     char lines_0[] = ",";
6722     char *lines[] = {
6723       lines_0,
6724       NULL
6725     };
6726     int r;
6727     suppress_error = 0;
6728     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6729     if (r == -1)
6730       return -1;
6731   }
6732   {
6733     char fstype[] = "ext2";
6734     char device[] = "/dev/sda1";
6735     device[5] = devchar;
6736     int r;
6737     suppress_error = 0;
6738     r = guestfs_mkfs (g, fstype, device);
6739     if (r == -1)
6740       return -1;
6741   }
6742   {
6743     char device[] = "/dev/sda1";
6744     device[5] = devchar;
6745     char mountpoint[] = "/";
6746     int r;
6747     suppress_error = 0;
6748     r = guestfs_mount (g, device, mountpoint);
6749     if (r == -1)
6750       return -1;
6751   }
6752   /* TestOutputList for command_lines (7) */
6753   {
6754     char remotefilename[] = "/test-command";
6755     int r;
6756     suppress_error = 0;
6757     r = guestfs_upload (g, "test-command", remotefilename);
6758     if (r == -1)
6759       return -1;
6760   }
6761   {
6762     char path[] = "/test-command";
6763     int r;
6764     suppress_error = 0;
6765     r = guestfs_chmod (g, 493, path);
6766     if (r == -1)
6767       return -1;
6768   }
6769   {
6770     char arguments_0[] = "/test-command";
6771     char arguments_1[] = "8";
6772     char *arguments[] = {
6773       arguments_0,
6774       arguments_1,
6775       NULL
6776     };
6777     char **r;
6778     int i;
6779     suppress_error = 0;
6780     r = guestfs_command_lines (g, arguments);
6781     if (r == NULL)
6782       return -1;
6783     if (!r[0]) {
6784       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6785       print_strings (r);
6786       return -1;
6787     }
6788     {
6789       char expected[] = "";
6790       if (strcmp (r[0], expected) != 0) {
6791         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6792         return -1;
6793       }
6794     }
6795     if (r[1] != NULL) {
6796       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6797       print_strings (r);
6798       return -1;
6799     }
6800     for (i = 0; r[i] != NULL; ++i)
6801       free (r[i]);
6802     free (r);
6803   }
6804   } else
6805     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6806   return 0;
6807 }
6808
6809 static int test_command_lines_8_prereq (void)
6810 {
6811   const char *str = getenv ("SKIP_TEST_COMMAND");
6812   return str && strcmp (str, "1") == 0;
6813 }
6814
6815 static int test_command_lines_8 (void)
6816 {
6817   if (! test_command_lines_8_prereq ()) {
6818   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
6819   {
6820     char device[] = "/dev/sda";
6821     device[5] = devchar;
6822     int r;
6823     suppress_error = 0;
6824     r = guestfs_blockdev_setrw (g, device);
6825     if (r == -1)
6826       return -1;
6827   }
6828   {
6829     int r;
6830     suppress_error = 0;
6831     r = guestfs_umount_all (g);
6832     if (r == -1)
6833       return -1;
6834   }
6835   {
6836     int r;
6837     suppress_error = 0;
6838     r = guestfs_lvm_remove_all (g);
6839     if (r == -1)
6840       return -1;
6841   }
6842   {
6843     char device[] = "/dev/sda";
6844     device[5] = devchar;
6845     char lines_0[] = ",";
6846     char *lines[] = {
6847       lines_0,
6848       NULL
6849     };
6850     int r;
6851     suppress_error = 0;
6852     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6853     if (r == -1)
6854       return -1;
6855   }
6856   {
6857     char fstype[] = "ext2";
6858     char device[] = "/dev/sda1";
6859     device[5] = devchar;
6860     int r;
6861     suppress_error = 0;
6862     r = guestfs_mkfs (g, fstype, device);
6863     if (r == -1)
6864       return -1;
6865   }
6866   {
6867     char device[] = "/dev/sda1";
6868     device[5] = devchar;
6869     char mountpoint[] = "/";
6870     int r;
6871     suppress_error = 0;
6872     r = guestfs_mount (g, device, mountpoint);
6873     if (r == -1)
6874       return -1;
6875   }
6876   /* TestOutputList for command_lines (8) */
6877   {
6878     char remotefilename[] = "/test-command";
6879     int r;
6880     suppress_error = 0;
6881     r = guestfs_upload (g, "test-command", remotefilename);
6882     if (r == -1)
6883       return -1;
6884   }
6885   {
6886     char path[] = "/test-command";
6887     int r;
6888     suppress_error = 0;
6889     r = guestfs_chmod (g, 493, path);
6890     if (r == -1)
6891       return -1;
6892   }
6893   {
6894     char arguments_0[] = "/test-command";
6895     char arguments_1[] = "9";
6896     char *arguments[] = {
6897       arguments_0,
6898       arguments_1,
6899       NULL
6900     };
6901     char **r;
6902     int i;
6903     suppress_error = 0;
6904     r = guestfs_command_lines (g, arguments);
6905     if (r == NULL)
6906       return -1;
6907     if (!r[0]) {
6908       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6909       print_strings (r);
6910       return -1;
6911     }
6912     {
6913       char expected[] = "";
6914       if (strcmp (r[0], expected) != 0) {
6915         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6916         return -1;
6917       }
6918     }
6919     if (!r[1]) {
6920       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6921       print_strings (r);
6922       return -1;
6923     }
6924     {
6925       char expected[] = "";
6926       if (strcmp (r[1], expected) != 0) {
6927         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6928         return -1;
6929       }
6930     }
6931     if (r[2] != NULL) {
6932       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6933       print_strings (r);
6934       return -1;
6935     }
6936     for (i = 0; r[i] != NULL; ++i)
6937       free (r[i]);
6938     free (r);
6939   }
6940   } else
6941     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6942   return 0;
6943 }
6944
6945 static int test_command_lines_9_prereq (void)
6946 {
6947   const char *str = getenv ("SKIP_TEST_COMMAND");
6948   return str && strcmp (str, "1") == 0;
6949 }
6950
6951 static int test_command_lines_9 (void)
6952 {
6953   if (! test_command_lines_9_prereq ()) {
6954   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
6955   {
6956     char device[] = "/dev/sda";
6957     device[5] = devchar;
6958     int r;
6959     suppress_error = 0;
6960     r = guestfs_blockdev_setrw (g, device);
6961     if (r == -1)
6962       return -1;
6963   }
6964   {
6965     int r;
6966     suppress_error = 0;
6967     r = guestfs_umount_all (g);
6968     if (r == -1)
6969       return -1;
6970   }
6971   {
6972     int r;
6973     suppress_error = 0;
6974     r = guestfs_lvm_remove_all (g);
6975     if (r == -1)
6976       return -1;
6977   }
6978   {
6979     char device[] = "/dev/sda";
6980     device[5] = devchar;
6981     char lines_0[] = ",";
6982     char *lines[] = {
6983       lines_0,
6984       NULL
6985     };
6986     int r;
6987     suppress_error = 0;
6988     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6989     if (r == -1)
6990       return -1;
6991   }
6992   {
6993     char fstype[] = "ext2";
6994     char device[] = "/dev/sda1";
6995     device[5] = devchar;
6996     int r;
6997     suppress_error = 0;
6998     r = guestfs_mkfs (g, fstype, device);
6999     if (r == -1)
7000       return -1;
7001   }
7002   {
7003     char device[] = "/dev/sda1";
7004     device[5] = devchar;
7005     char mountpoint[] = "/";
7006     int r;
7007     suppress_error = 0;
7008     r = guestfs_mount (g, device, mountpoint);
7009     if (r == -1)
7010       return -1;
7011   }
7012   /* TestOutputList for command_lines (9) */
7013   {
7014     char remotefilename[] = "/test-command";
7015     int r;
7016     suppress_error = 0;
7017     r = guestfs_upload (g, "test-command", remotefilename);
7018     if (r == -1)
7019       return -1;
7020   }
7021   {
7022     char path[] = "/test-command";
7023     int r;
7024     suppress_error = 0;
7025     r = guestfs_chmod (g, 493, path);
7026     if (r == -1)
7027       return -1;
7028   }
7029   {
7030     char arguments_0[] = "/test-command";
7031     char arguments_1[] = "10";
7032     char *arguments[] = {
7033       arguments_0,
7034       arguments_1,
7035       NULL
7036     };
7037     char **r;
7038     int i;
7039     suppress_error = 0;
7040     r = guestfs_command_lines (g, arguments);
7041     if (r == NULL)
7042       return -1;
7043     if (!r[0]) {
7044       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
7045       print_strings (r);
7046       return -1;
7047     }
7048     {
7049       char expected[] = "Result10-1";
7050       if (strcmp (r[0], expected) != 0) {
7051         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7052         return -1;
7053       }
7054     }
7055     if (!r[1]) {
7056       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
7057       print_strings (r);
7058       return -1;
7059     }
7060     {
7061       char expected[] = "Result10-2";
7062       if (strcmp (r[1], expected) != 0) {
7063         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7064         return -1;
7065       }
7066     }
7067     if (r[2] != NULL) {
7068       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
7069       print_strings (r);
7070       return -1;
7071     }
7072     for (i = 0; r[i] != NULL; ++i)
7073       free (r[i]);
7074     free (r);
7075   }
7076   } else
7077     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
7078   return 0;
7079 }
7080
7081 static int test_command_lines_10_prereq (void)
7082 {
7083   const char *str = getenv ("SKIP_TEST_COMMAND");
7084   return str && strcmp (str, "1") == 0;
7085 }
7086
7087 static int test_command_lines_10 (void)
7088 {
7089   if (! test_command_lines_10_prereq ()) {
7090   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
7091   {
7092     char device[] = "/dev/sda";
7093     device[5] = devchar;
7094     int r;
7095     suppress_error = 0;
7096     r = guestfs_blockdev_setrw (g, device);
7097     if (r == -1)
7098       return -1;
7099   }
7100   {
7101     int r;
7102     suppress_error = 0;
7103     r = guestfs_umount_all (g);
7104     if (r == -1)
7105       return -1;
7106   }
7107   {
7108     int r;
7109     suppress_error = 0;
7110     r = guestfs_lvm_remove_all (g);
7111     if (r == -1)
7112       return -1;
7113   }
7114   {
7115     char device[] = "/dev/sda";
7116     device[5] = devchar;
7117     char lines_0[] = ",";
7118     char *lines[] = {
7119       lines_0,
7120       NULL
7121     };
7122     int r;
7123     suppress_error = 0;
7124     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7125     if (r == -1)
7126       return -1;
7127   }
7128   {
7129     char fstype[] = "ext2";
7130     char device[] = "/dev/sda1";
7131     device[5] = devchar;
7132     int r;
7133     suppress_error = 0;
7134     r = guestfs_mkfs (g, fstype, device);
7135     if (r == -1)
7136       return -1;
7137   }
7138   {
7139     char device[] = "/dev/sda1";
7140     device[5] = devchar;
7141     char mountpoint[] = "/";
7142     int r;
7143     suppress_error = 0;
7144     r = guestfs_mount (g, device, mountpoint);
7145     if (r == -1)
7146       return -1;
7147   }
7148   /* TestOutputList for command_lines (10) */
7149   {
7150     char remotefilename[] = "/test-command";
7151     int r;
7152     suppress_error = 0;
7153     r = guestfs_upload (g, "test-command", remotefilename);
7154     if (r == -1)
7155       return -1;
7156   }
7157   {
7158     char path[] = "/test-command";
7159     int r;
7160     suppress_error = 0;
7161     r = guestfs_chmod (g, 493, path);
7162     if (r == -1)
7163       return -1;
7164   }
7165   {
7166     char arguments_0[] = "/test-command";
7167     char arguments_1[] = "11";
7168     char *arguments[] = {
7169       arguments_0,
7170       arguments_1,
7171       NULL
7172     };
7173     char **r;
7174     int i;
7175     suppress_error = 0;
7176     r = guestfs_command_lines (g, arguments);
7177     if (r == NULL)
7178       return -1;
7179     if (!r[0]) {
7180       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7181       print_strings (r);
7182       return -1;
7183     }
7184     {
7185       char expected[] = "Result11-1";
7186       if (strcmp (r[0], expected) != 0) {
7187         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7188         return -1;
7189       }
7190     }
7191     if (!r[1]) {
7192       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7193       print_strings (r);
7194       return -1;
7195     }
7196     {
7197       char expected[] = "Result11-2";
7198       if (strcmp (r[1], expected) != 0) {
7199         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7200         return -1;
7201       }
7202     }
7203     if (r[2] != NULL) {
7204       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
7205       print_strings (r);
7206       return -1;
7207     }
7208     for (i = 0; r[i] != NULL; ++i)
7209       free (r[i]);
7210     free (r);
7211   }
7212   } else
7213     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
7214   return 0;
7215 }
7216
7217 static int test_command_0_prereq (void)
7218 {
7219   const char *str = getenv ("SKIP_TEST_COMMAND");
7220   return str && strcmp (str, "1") == 0;
7221 }
7222
7223 static int test_command_0 (void)
7224 {
7225   if (! test_command_0_prereq ()) {
7226   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
7227   {
7228     char device[] = "/dev/sda";
7229     device[5] = devchar;
7230     int r;
7231     suppress_error = 0;
7232     r = guestfs_blockdev_setrw (g, device);
7233     if (r == -1)
7234       return -1;
7235   }
7236   {
7237     int r;
7238     suppress_error = 0;
7239     r = guestfs_umount_all (g);
7240     if (r == -1)
7241       return -1;
7242   }
7243   {
7244     int r;
7245     suppress_error = 0;
7246     r = guestfs_lvm_remove_all (g);
7247     if (r == -1)
7248       return -1;
7249   }
7250   {
7251     char device[] = "/dev/sda";
7252     device[5] = devchar;
7253     char lines_0[] = ",";
7254     char *lines[] = {
7255       lines_0,
7256       NULL
7257     };
7258     int r;
7259     suppress_error = 0;
7260     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7261     if (r == -1)
7262       return -1;
7263   }
7264   {
7265     char fstype[] = "ext2";
7266     char device[] = "/dev/sda1";
7267     device[5] = devchar;
7268     int r;
7269     suppress_error = 0;
7270     r = guestfs_mkfs (g, fstype, device);
7271     if (r == -1)
7272       return -1;
7273   }
7274   {
7275     char device[] = "/dev/sda1";
7276     device[5] = devchar;
7277     char mountpoint[] = "/";
7278     int r;
7279     suppress_error = 0;
7280     r = guestfs_mount (g, device, mountpoint);
7281     if (r == -1)
7282       return -1;
7283   }
7284   /* TestOutput for command (0) */
7285   char expected[] = "Result1";
7286   {
7287     char remotefilename[] = "/test-command";
7288     int r;
7289     suppress_error = 0;
7290     r = guestfs_upload (g, "test-command", remotefilename);
7291     if (r == -1)
7292       return -1;
7293   }
7294   {
7295     char path[] = "/test-command";
7296     int r;
7297     suppress_error = 0;
7298     r = guestfs_chmod (g, 493, path);
7299     if (r == -1)
7300       return -1;
7301   }
7302   {
7303     char arguments_0[] = "/test-command";
7304     char arguments_1[] = "1";
7305     char *arguments[] = {
7306       arguments_0,
7307       arguments_1,
7308       NULL
7309     };
7310     char *r;
7311     suppress_error = 0;
7312     r = guestfs_command (g, arguments);
7313     if (r == NULL)
7314       return -1;
7315     if (strcmp (r, expected) != 0) {
7316       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
7317       return -1;
7318     }
7319     free (r);
7320   }
7321   } else
7322     printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
7323   return 0;
7324 }
7325
7326 static int test_command_1_prereq (void)
7327 {
7328   const char *str = getenv ("SKIP_TEST_COMMAND");
7329   return str && strcmp (str, "1") == 0;
7330 }
7331
7332 static int test_command_1 (void)
7333 {
7334   if (! test_command_1_prereq ()) {
7335   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
7336   {
7337     char device[] = "/dev/sda";
7338     device[5] = devchar;
7339     int r;
7340     suppress_error = 0;
7341     r = guestfs_blockdev_setrw (g, device);
7342     if (r == -1)
7343       return -1;
7344   }
7345   {
7346     int r;
7347     suppress_error = 0;
7348     r = guestfs_umount_all (g);
7349     if (r == -1)
7350       return -1;
7351   }
7352   {
7353     int r;
7354     suppress_error = 0;
7355     r = guestfs_lvm_remove_all (g);
7356     if (r == -1)
7357       return -1;
7358   }
7359   {
7360     char device[] = "/dev/sda";
7361     device[5] = devchar;
7362     char lines_0[] = ",";
7363     char *lines[] = {
7364       lines_0,
7365       NULL
7366     };
7367     int r;
7368     suppress_error = 0;
7369     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7370     if (r == -1)
7371       return -1;
7372   }
7373   {
7374     char fstype[] = "ext2";
7375     char device[] = "/dev/sda1";
7376     device[5] = devchar;
7377     int r;
7378     suppress_error = 0;
7379     r = guestfs_mkfs (g, fstype, device);
7380     if (r == -1)
7381       return -1;
7382   }
7383   {
7384     char device[] = "/dev/sda1";
7385     device[5] = devchar;
7386     char mountpoint[] = "/";
7387     int r;
7388     suppress_error = 0;
7389     r = guestfs_mount (g, device, mountpoint);
7390     if (r == -1)
7391       return -1;
7392   }
7393   /* TestOutput for command (1) */
7394   char expected[] = "Result2\n";
7395   {
7396     char remotefilename[] = "/test-command";
7397     int r;
7398     suppress_error = 0;
7399     r = guestfs_upload (g, "test-command", remotefilename);
7400     if (r == -1)
7401       return -1;
7402   }
7403   {
7404     char path[] = "/test-command";
7405     int r;
7406     suppress_error = 0;
7407     r = guestfs_chmod (g, 493, path);
7408     if (r == -1)
7409       return -1;
7410   }
7411   {
7412     char arguments_0[] = "/test-command";
7413     char arguments_1[] = "2";
7414     char *arguments[] = {
7415       arguments_0,
7416       arguments_1,
7417       NULL
7418     };
7419     char *r;
7420     suppress_error = 0;
7421     r = guestfs_command (g, arguments);
7422     if (r == NULL)
7423       return -1;
7424     if (strcmp (r, expected) != 0) {
7425       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
7426       return -1;
7427     }
7428     free (r);
7429   }
7430   } else
7431     printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
7432   return 0;
7433 }
7434
7435 static int test_command_2_prereq (void)
7436 {
7437   const char *str = getenv ("SKIP_TEST_COMMAND");
7438   return str && strcmp (str, "1") == 0;
7439 }
7440
7441 static int test_command_2 (void)
7442 {
7443   if (! test_command_2_prereq ()) {
7444   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
7445   {
7446     char device[] = "/dev/sda";
7447     device[5] = devchar;
7448     int r;
7449     suppress_error = 0;
7450     r = guestfs_blockdev_setrw (g, device);
7451     if (r == -1)
7452       return -1;
7453   }
7454   {
7455     int r;
7456     suppress_error = 0;
7457     r = guestfs_umount_all (g);
7458     if (r == -1)
7459       return -1;
7460   }
7461   {
7462     int r;
7463     suppress_error = 0;
7464     r = guestfs_lvm_remove_all (g);
7465     if (r == -1)
7466       return -1;
7467   }
7468   {
7469     char device[] = "/dev/sda";
7470     device[5] = devchar;
7471     char lines_0[] = ",";
7472     char *lines[] = {
7473       lines_0,
7474       NULL
7475     };
7476     int r;
7477     suppress_error = 0;
7478     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7479     if (r == -1)
7480       return -1;
7481   }
7482   {
7483     char fstype[] = "ext2";
7484     char device[] = "/dev/sda1";
7485     device[5] = devchar;
7486     int r;
7487     suppress_error = 0;
7488     r = guestfs_mkfs (g, fstype, device);
7489     if (r == -1)
7490       return -1;
7491   }
7492   {
7493     char device[] = "/dev/sda1";
7494     device[5] = devchar;
7495     char mountpoint[] = "/";
7496     int r;
7497     suppress_error = 0;
7498     r = guestfs_mount (g, device, mountpoint);
7499     if (r == -1)
7500       return -1;
7501   }
7502   /* TestOutput for command (2) */
7503   char expected[] = "\nResult3";
7504   {
7505     char remotefilename[] = "/test-command";
7506     int r;
7507     suppress_error = 0;
7508     r = guestfs_upload (g, "test-command", remotefilename);
7509     if (r == -1)
7510       return -1;
7511   }
7512   {
7513     char path[] = "/test-command";
7514     int r;
7515     suppress_error = 0;
7516     r = guestfs_chmod (g, 493, path);
7517     if (r == -1)
7518       return -1;
7519   }
7520   {
7521     char arguments_0[] = "/test-command";
7522     char arguments_1[] = "3";
7523     char *arguments[] = {
7524       arguments_0,
7525       arguments_1,
7526       NULL
7527     };
7528     char *r;
7529     suppress_error = 0;
7530     r = guestfs_command (g, arguments);
7531     if (r == NULL)
7532       return -1;
7533     if (strcmp (r, expected) != 0) {
7534       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
7535       return -1;
7536     }
7537     free (r);
7538   }
7539   } else
7540     printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
7541   return 0;
7542 }
7543
7544 static int test_command_3_prereq (void)
7545 {
7546   const char *str = getenv ("SKIP_TEST_COMMAND");
7547   return str && strcmp (str, "1") == 0;
7548 }
7549
7550 static int test_command_3 (void)
7551 {
7552   if (! test_command_3_prereq ()) {
7553   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
7554   {
7555     char device[] = "/dev/sda";
7556     device[5] = devchar;
7557     int r;
7558     suppress_error = 0;
7559     r = guestfs_blockdev_setrw (g, device);
7560     if (r == -1)
7561       return -1;
7562   }
7563   {
7564     int r;
7565     suppress_error = 0;
7566     r = guestfs_umount_all (g);
7567     if (r == -1)
7568       return -1;
7569   }
7570   {
7571     int r;
7572     suppress_error = 0;
7573     r = guestfs_lvm_remove_all (g);
7574     if (r == -1)
7575       return -1;
7576   }
7577   {
7578     char device[] = "/dev/sda";
7579     device[5] = devchar;
7580     char lines_0[] = ",";
7581     char *lines[] = {
7582       lines_0,
7583       NULL
7584     };
7585     int r;
7586     suppress_error = 0;
7587     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7588     if (r == -1)
7589       return -1;
7590   }
7591   {
7592     char fstype[] = "ext2";
7593     char device[] = "/dev/sda1";
7594     device[5] = devchar;
7595     int r;
7596     suppress_error = 0;
7597     r = guestfs_mkfs (g, fstype, device);
7598     if (r == -1)
7599       return -1;
7600   }
7601   {
7602     char device[] = "/dev/sda1";
7603     device[5] = devchar;
7604     char mountpoint[] = "/";
7605     int r;
7606     suppress_error = 0;
7607     r = guestfs_mount (g, device, mountpoint);
7608     if (r == -1)
7609       return -1;
7610   }
7611   /* TestOutput for command (3) */
7612   char expected[] = "\nResult4\n";
7613   {
7614     char remotefilename[] = "/test-command";
7615     int r;
7616     suppress_error = 0;
7617     r = guestfs_upload (g, "test-command", remotefilename);
7618     if (r == -1)
7619       return -1;
7620   }
7621   {
7622     char path[] = "/test-command";
7623     int r;
7624     suppress_error = 0;
7625     r = guestfs_chmod (g, 493, path);
7626     if (r == -1)
7627       return -1;
7628   }
7629   {
7630     char arguments_0[] = "/test-command";
7631     char arguments_1[] = "4";
7632     char *arguments[] = {
7633       arguments_0,
7634       arguments_1,
7635       NULL
7636     };
7637     char *r;
7638     suppress_error = 0;
7639     r = guestfs_command (g, arguments);
7640     if (r == NULL)
7641       return -1;
7642     if (strcmp (r, expected) != 0) {
7643       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
7644       return -1;
7645     }
7646     free (r);
7647   }
7648   } else
7649     printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
7650   return 0;
7651 }
7652
7653 static int test_command_4_prereq (void)
7654 {
7655   const char *str = getenv ("SKIP_TEST_COMMAND");
7656   return str && strcmp (str, "1") == 0;
7657 }
7658
7659 static int test_command_4 (void)
7660 {
7661   if (! test_command_4_prereq ()) {
7662   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
7663   {
7664     char device[] = "/dev/sda";
7665     device[5] = devchar;
7666     int r;
7667     suppress_error = 0;
7668     r = guestfs_blockdev_setrw (g, device);
7669     if (r == -1)
7670       return -1;
7671   }
7672   {
7673     int r;
7674     suppress_error = 0;
7675     r = guestfs_umount_all (g);
7676     if (r == -1)
7677       return -1;
7678   }
7679   {
7680     int r;
7681     suppress_error = 0;
7682     r = guestfs_lvm_remove_all (g);
7683     if (r == -1)
7684       return -1;
7685   }
7686   {
7687     char device[] = "/dev/sda";
7688     device[5] = devchar;
7689     char lines_0[] = ",";
7690     char *lines[] = {
7691       lines_0,
7692       NULL
7693     };
7694     int r;
7695     suppress_error = 0;
7696     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7697     if (r == -1)
7698       return -1;
7699   }
7700   {
7701     char fstype[] = "ext2";
7702     char device[] = "/dev/sda1";
7703     device[5] = devchar;
7704     int r;
7705     suppress_error = 0;
7706     r = guestfs_mkfs (g, fstype, device);
7707     if (r == -1)
7708       return -1;
7709   }
7710   {
7711     char device[] = "/dev/sda1";
7712     device[5] = devchar;
7713     char mountpoint[] = "/";
7714     int r;
7715     suppress_error = 0;
7716     r = guestfs_mount (g, device, mountpoint);
7717     if (r == -1)
7718       return -1;
7719   }
7720   /* TestOutput for command (4) */
7721   char expected[] = "\nResult5\n\n";
7722   {
7723     char remotefilename[] = "/test-command";
7724     int r;
7725     suppress_error = 0;
7726     r = guestfs_upload (g, "test-command", remotefilename);
7727     if (r == -1)
7728       return -1;
7729   }
7730   {
7731     char path[] = "/test-command";
7732     int r;
7733     suppress_error = 0;
7734     r = guestfs_chmod (g, 493, path);
7735     if (r == -1)
7736       return -1;
7737   }
7738   {
7739     char arguments_0[] = "/test-command";
7740     char arguments_1[] = "5";
7741     char *arguments[] = {
7742       arguments_0,
7743       arguments_1,
7744       NULL
7745     };
7746     char *r;
7747     suppress_error = 0;
7748     r = guestfs_command (g, arguments);
7749     if (r == NULL)
7750       return -1;
7751     if (strcmp (r, expected) != 0) {
7752       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7753       return -1;
7754     }
7755     free (r);
7756   }
7757   } else
7758     printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7759   return 0;
7760 }
7761
7762 static int test_command_5_prereq (void)
7763 {
7764   const char *str = getenv ("SKIP_TEST_COMMAND");
7765   return str && strcmp (str, "1") == 0;
7766 }
7767
7768 static int test_command_5 (void)
7769 {
7770   if (! test_command_5_prereq ()) {
7771   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
7772   {
7773     char device[] = "/dev/sda";
7774     device[5] = devchar;
7775     int r;
7776     suppress_error = 0;
7777     r = guestfs_blockdev_setrw (g, device);
7778     if (r == -1)
7779       return -1;
7780   }
7781   {
7782     int r;
7783     suppress_error = 0;
7784     r = guestfs_umount_all (g);
7785     if (r == -1)
7786       return -1;
7787   }
7788   {
7789     int r;
7790     suppress_error = 0;
7791     r = guestfs_lvm_remove_all (g);
7792     if (r == -1)
7793       return -1;
7794   }
7795   {
7796     char device[] = "/dev/sda";
7797     device[5] = devchar;
7798     char lines_0[] = ",";
7799     char *lines[] = {
7800       lines_0,
7801       NULL
7802     };
7803     int r;
7804     suppress_error = 0;
7805     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7806     if (r == -1)
7807       return -1;
7808   }
7809   {
7810     char fstype[] = "ext2";
7811     char device[] = "/dev/sda1";
7812     device[5] = devchar;
7813     int r;
7814     suppress_error = 0;
7815     r = guestfs_mkfs (g, fstype, device);
7816     if (r == -1)
7817       return -1;
7818   }
7819   {
7820     char device[] = "/dev/sda1";
7821     device[5] = devchar;
7822     char mountpoint[] = "/";
7823     int r;
7824     suppress_error = 0;
7825     r = guestfs_mount (g, device, mountpoint);
7826     if (r == -1)
7827       return -1;
7828   }
7829   /* TestOutput for command (5) */
7830   char expected[] = "\n\nResult6\n\n";
7831   {
7832     char remotefilename[] = "/test-command";
7833     int r;
7834     suppress_error = 0;
7835     r = guestfs_upload (g, "test-command", remotefilename);
7836     if (r == -1)
7837       return -1;
7838   }
7839   {
7840     char path[] = "/test-command";
7841     int r;
7842     suppress_error = 0;
7843     r = guestfs_chmod (g, 493, path);
7844     if (r == -1)
7845       return -1;
7846   }
7847   {
7848     char arguments_0[] = "/test-command";
7849     char arguments_1[] = "6";
7850     char *arguments[] = {
7851       arguments_0,
7852       arguments_1,
7853       NULL
7854     };
7855     char *r;
7856     suppress_error = 0;
7857     r = guestfs_command (g, arguments);
7858     if (r == NULL)
7859       return -1;
7860     if (strcmp (r, expected) != 0) {
7861       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7862       return -1;
7863     }
7864     free (r);
7865   }
7866   } else
7867     printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7868   return 0;
7869 }
7870
7871 static int test_command_6_prereq (void)
7872 {
7873   const char *str = getenv ("SKIP_TEST_COMMAND");
7874   return str && strcmp (str, "1") == 0;
7875 }
7876
7877 static int test_command_6 (void)
7878 {
7879   if (! test_command_6_prereq ()) {
7880   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
7881   {
7882     char device[] = "/dev/sda";
7883     device[5] = devchar;
7884     int r;
7885     suppress_error = 0;
7886     r = guestfs_blockdev_setrw (g, device);
7887     if (r == -1)
7888       return -1;
7889   }
7890   {
7891     int r;
7892     suppress_error = 0;
7893     r = guestfs_umount_all (g);
7894     if (r == -1)
7895       return -1;
7896   }
7897   {
7898     int r;
7899     suppress_error = 0;
7900     r = guestfs_lvm_remove_all (g);
7901     if (r == -1)
7902       return -1;
7903   }
7904   {
7905     char device[] = "/dev/sda";
7906     device[5] = devchar;
7907     char lines_0[] = ",";
7908     char *lines[] = {
7909       lines_0,
7910       NULL
7911     };
7912     int r;
7913     suppress_error = 0;
7914     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7915     if (r == -1)
7916       return -1;
7917   }
7918   {
7919     char fstype[] = "ext2";
7920     char device[] = "/dev/sda1";
7921     device[5] = devchar;
7922     int r;
7923     suppress_error = 0;
7924     r = guestfs_mkfs (g, fstype, device);
7925     if (r == -1)
7926       return -1;
7927   }
7928   {
7929     char device[] = "/dev/sda1";
7930     device[5] = devchar;
7931     char mountpoint[] = "/";
7932     int r;
7933     suppress_error = 0;
7934     r = guestfs_mount (g, device, mountpoint);
7935     if (r == -1)
7936       return -1;
7937   }
7938   /* TestOutput for command (6) */
7939   char expected[] = "";
7940   {
7941     char remotefilename[] = "/test-command";
7942     int r;
7943     suppress_error = 0;
7944     r = guestfs_upload (g, "test-command", remotefilename);
7945     if (r == -1)
7946       return -1;
7947   }
7948   {
7949     char path[] = "/test-command";
7950     int r;
7951     suppress_error = 0;
7952     r = guestfs_chmod (g, 493, path);
7953     if (r == -1)
7954       return -1;
7955   }
7956   {
7957     char arguments_0[] = "/test-command";
7958     char arguments_1[] = "7";
7959     char *arguments[] = {
7960       arguments_0,
7961       arguments_1,
7962       NULL
7963     };
7964     char *r;
7965     suppress_error = 0;
7966     r = guestfs_command (g, arguments);
7967     if (r == NULL)
7968       return -1;
7969     if (strcmp (r, expected) != 0) {
7970       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7971       return -1;
7972     }
7973     free (r);
7974   }
7975   } else
7976     printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7977   return 0;
7978 }
7979
7980 static int test_command_7_prereq (void)
7981 {
7982   const char *str = getenv ("SKIP_TEST_COMMAND");
7983   return str && strcmp (str, "1") == 0;
7984 }
7985
7986 static int test_command_7 (void)
7987 {
7988   if (! test_command_7_prereq ()) {
7989   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
7990   {
7991     char device[] = "/dev/sda";
7992     device[5] = devchar;
7993     int r;
7994     suppress_error = 0;
7995     r = guestfs_blockdev_setrw (g, device);
7996     if (r == -1)
7997       return -1;
7998   }
7999   {
8000     int r;
8001     suppress_error = 0;
8002     r = guestfs_umount_all (g);
8003     if (r == -1)
8004       return -1;
8005   }
8006   {
8007     int r;
8008     suppress_error = 0;
8009     r = guestfs_lvm_remove_all (g);
8010     if (r == -1)
8011       return -1;
8012   }
8013   {
8014     char device[] = "/dev/sda";
8015     device[5] = devchar;
8016     char lines_0[] = ",";
8017     char *lines[] = {
8018       lines_0,
8019       NULL
8020     };
8021     int r;
8022     suppress_error = 0;
8023     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8024     if (r == -1)
8025       return -1;
8026   }
8027   {
8028     char fstype[] = "ext2";
8029     char device[] = "/dev/sda1";
8030     device[5] = devchar;
8031     int r;
8032     suppress_error = 0;
8033     r = guestfs_mkfs (g, fstype, device);
8034     if (r == -1)
8035       return -1;
8036   }
8037   {
8038     char device[] = "/dev/sda1";
8039     device[5] = devchar;
8040     char mountpoint[] = "/";
8041     int r;
8042     suppress_error = 0;
8043     r = guestfs_mount (g, device, mountpoint);
8044     if (r == -1)
8045       return -1;
8046   }
8047   /* TestOutput for command (7) */
8048   char expected[] = "\n";
8049   {
8050     char remotefilename[] = "/test-command";
8051     int r;
8052     suppress_error = 0;
8053     r = guestfs_upload (g, "test-command", remotefilename);
8054     if (r == -1)
8055       return -1;
8056   }
8057   {
8058     char path[] = "/test-command";
8059     int r;
8060     suppress_error = 0;
8061     r = guestfs_chmod (g, 493, path);
8062     if (r == -1)
8063       return -1;
8064   }
8065   {
8066     char arguments_0[] = "/test-command";
8067     char arguments_1[] = "8";
8068     char *arguments[] = {
8069       arguments_0,
8070       arguments_1,
8071       NULL
8072     };
8073     char *r;
8074     suppress_error = 0;
8075     r = guestfs_command (g, arguments);
8076     if (r == NULL)
8077       return -1;
8078     if (strcmp (r, expected) != 0) {
8079       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
8080       return -1;
8081     }
8082     free (r);
8083   }
8084   } else
8085     printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
8086   return 0;
8087 }
8088
8089 static int test_command_8_prereq (void)
8090 {
8091   const char *str = getenv ("SKIP_TEST_COMMAND");
8092   return str && strcmp (str, "1") == 0;
8093 }
8094
8095 static int test_command_8 (void)
8096 {
8097   if (! test_command_8_prereq ()) {
8098   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
8099   {
8100     char device[] = "/dev/sda";
8101     device[5] = devchar;
8102     int r;
8103     suppress_error = 0;
8104     r = guestfs_blockdev_setrw (g, device);
8105     if (r == -1)
8106       return -1;
8107   }
8108   {
8109     int r;
8110     suppress_error = 0;
8111     r = guestfs_umount_all (g);
8112     if (r == -1)
8113       return -1;
8114   }
8115   {
8116     int r;
8117     suppress_error = 0;
8118     r = guestfs_lvm_remove_all (g);
8119     if (r == -1)
8120       return -1;
8121   }
8122   {
8123     char device[] = "/dev/sda";
8124     device[5] = devchar;
8125     char lines_0[] = ",";
8126     char *lines[] = {
8127       lines_0,
8128       NULL
8129     };
8130     int r;
8131     suppress_error = 0;
8132     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8133     if (r == -1)
8134       return -1;
8135   }
8136   {
8137     char fstype[] = "ext2";
8138     char device[] = "/dev/sda1";
8139     device[5] = devchar;
8140     int r;
8141     suppress_error = 0;
8142     r = guestfs_mkfs (g, fstype, device);
8143     if (r == -1)
8144       return -1;
8145   }
8146   {
8147     char device[] = "/dev/sda1";
8148     device[5] = devchar;
8149     char mountpoint[] = "/";
8150     int r;
8151     suppress_error = 0;
8152     r = guestfs_mount (g, device, mountpoint);
8153     if (r == -1)
8154       return -1;
8155   }
8156   /* TestOutput for command (8) */
8157   char expected[] = "\n\n";
8158   {
8159     char remotefilename[] = "/test-command";
8160     int r;
8161     suppress_error = 0;
8162     r = guestfs_upload (g, "test-command", remotefilename);
8163     if (r == -1)
8164       return -1;
8165   }
8166   {
8167     char path[] = "/test-command";
8168     int r;
8169     suppress_error = 0;
8170     r = guestfs_chmod (g, 493, path);
8171     if (r == -1)
8172       return -1;
8173   }
8174   {
8175     char arguments_0[] = "/test-command";
8176     char arguments_1[] = "9";
8177     char *arguments[] = {
8178       arguments_0,
8179       arguments_1,
8180       NULL
8181     };
8182     char *r;
8183     suppress_error = 0;
8184     r = guestfs_command (g, arguments);
8185     if (r == NULL)
8186       return -1;
8187     if (strcmp (r, expected) != 0) {
8188       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
8189       return -1;
8190     }
8191     free (r);
8192   }
8193   } else
8194     printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
8195   return 0;
8196 }
8197
8198 static int test_command_9_prereq (void)
8199 {
8200   const char *str = getenv ("SKIP_TEST_COMMAND");
8201   return str && strcmp (str, "1") == 0;
8202 }
8203
8204 static int test_command_9 (void)
8205 {
8206   if (! test_command_9_prereq ()) {
8207   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
8208   {
8209     char device[] = "/dev/sda";
8210     device[5] = devchar;
8211     int r;
8212     suppress_error = 0;
8213     r = guestfs_blockdev_setrw (g, device);
8214     if (r == -1)
8215       return -1;
8216   }
8217   {
8218     int r;
8219     suppress_error = 0;
8220     r = guestfs_umount_all (g);
8221     if (r == -1)
8222       return -1;
8223   }
8224   {
8225     int r;
8226     suppress_error = 0;
8227     r = guestfs_lvm_remove_all (g);
8228     if (r == -1)
8229       return -1;
8230   }
8231   {
8232     char device[] = "/dev/sda";
8233     device[5] = devchar;
8234     char lines_0[] = ",";
8235     char *lines[] = {
8236       lines_0,
8237       NULL
8238     };
8239     int r;
8240     suppress_error = 0;
8241     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8242     if (r == -1)
8243       return -1;
8244   }
8245   {
8246     char fstype[] = "ext2";
8247     char device[] = "/dev/sda1";
8248     device[5] = devchar;
8249     int r;
8250     suppress_error = 0;
8251     r = guestfs_mkfs (g, fstype, device);
8252     if (r == -1)
8253       return -1;
8254   }
8255   {
8256     char device[] = "/dev/sda1";
8257     device[5] = devchar;
8258     char mountpoint[] = "/";
8259     int r;
8260     suppress_error = 0;
8261     r = guestfs_mount (g, device, mountpoint);
8262     if (r == -1)
8263       return -1;
8264   }
8265   /* TestOutput for command (9) */
8266   char expected[] = "Result10-1\nResult10-2\n";
8267   {
8268     char remotefilename[] = "/test-command";
8269     int r;
8270     suppress_error = 0;
8271     r = guestfs_upload (g, "test-command", remotefilename);
8272     if (r == -1)
8273       return -1;
8274   }
8275   {
8276     char path[] = "/test-command";
8277     int r;
8278     suppress_error = 0;
8279     r = guestfs_chmod (g, 493, path);
8280     if (r == -1)
8281       return -1;
8282   }
8283   {
8284     char arguments_0[] = "/test-command";
8285     char arguments_1[] = "10";
8286     char *arguments[] = {
8287       arguments_0,
8288       arguments_1,
8289       NULL
8290     };
8291     char *r;
8292     suppress_error = 0;
8293     r = guestfs_command (g, arguments);
8294     if (r == NULL)
8295       return -1;
8296     if (strcmp (r, expected) != 0) {
8297       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
8298       return -1;
8299     }
8300     free (r);
8301   }
8302   } else
8303     printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
8304   return 0;
8305 }
8306
8307 static int test_command_10_prereq (void)
8308 {
8309   const char *str = getenv ("SKIP_TEST_COMMAND");
8310   return str && strcmp (str, "1") == 0;
8311 }
8312
8313 static int test_command_10 (void)
8314 {
8315   if (! test_command_10_prereq ()) {
8316   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
8317   {
8318     char device[] = "/dev/sda";
8319     device[5] = devchar;
8320     int r;
8321     suppress_error = 0;
8322     r = guestfs_blockdev_setrw (g, device);
8323     if (r == -1)
8324       return -1;
8325   }
8326   {
8327     int r;
8328     suppress_error = 0;
8329     r = guestfs_umount_all (g);
8330     if (r == -1)
8331       return -1;
8332   }
8333   {
8334     int r;
8335     suppress_error = 0;
8336     r = guestfs_lvm_remove_all (g);
8337     if (r == -1)
8338       return -1;
8339   }
8340   {
8341     char device[] = "/dev/sda";
8342     device[5] = devchar;
8343     char lines_0[] = ",";
8344     char *lines[] = {
8345       lines_0,
8346       NULL
8347     };
8348     int r;
8349     suppress_error = 0;
8350     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8351     if (r == -1)
8352       return -1;
8353   }
8354   {
8355     char fstype[] = "ext2";
8356     char device[] = "/dev/sda1";
8357     device[5] = devchar;
8358     int r;
8359     suppress_error = 0;
8360     r = guestfs_mkfs (g, fstype, device);
8361     if (r == -1)
8362       return -1;
8363   }
8364   {
8365     char device[] = "/dev/sda1";
8366     device[5] = devchar;
8367     char mountpoint[] = "/";
8368     int r;
8369     suppress_error = 0;
8370     r = guestfs_mount (g, device, mountpoint);
8371     if (r == -1)
8372       return -1;
8373   }
8374   /* TestOutput for command (10) */
8375   char expected[] = "Result11-1\nResult11-2";
8376   {
8377     char remotefilename[] = "/test-command";
8378     int r;
8379     suppress_error = 0;
8380     r = guestfs_upload (g, "test-command", remotefilename);
8381     if (r == -1)
8382       return -1;
8383   }
8384   {
8385     char path[] = "/test-command";
8386     int r;
8387     suppress_error = 0;
8388     r = guestfs_chmod (g, 493, path);
8389     if (r == -1)
8390       return -1;
8391   }
8392   {
8393     char arguments_0[] = "/test-command";
8394     char arguments_1[] = "11";
8395     char *arguments[] = {
8396       arguments_0,
8397       arguments_1,
8398       NULL
8399     };
8400     char *r;
8401     suppress_error = 0;
8402     r = guestfs_command (g, arguments);
8403     if (r == NULL)
8404       return -1;
8405     if (strcmp (r, expected) != 0) {
8406       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
8407       return -1;
8408     }
8409     free (r);
8410   }
8411   } else
8412     printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
8413   return 0;
8414 }
8415
8416 static int test_command_11_prereq (void)
8417 {
8418   const char *str = getenv ("SKIP_TEST_COMMAND");
8419   return str && strcmp (str, "1") == 0;
8420 }
8421
8422 static int test_command_11 (void)
8423 {
8424   if (! test_command_11_prereq ()) {
8425   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
8426   {
8427     char device[] = "/dev/sda";
8428     device[5] = devchar;
8429     int r;
8430     suppress_error = 0;
8431     r = guestfs_blockdev_setrw (g, device);
8432     if (r == -1)
8433       return -1;
8434   }
8435   {
8436     int r;
8437     suppress_error = 0;
8438     r = guestfs_umount_all (g);
8439     if (r == -1)
8440       return -1;
8441   }
8442   {
8443     int r;
8444     suppress_error = 0;
8445     r = guestfs_lvm_remove_all (g);
8446     if (r == -1)
8447       return -1;
8448   }
8449   {
8450     char device[] = "/dev/sda";
8451     device[5] = devchar;
8452     char lines_0[] = ",";
8453     char *lines[] = {
8454       lines_0,
8455       NULL
8456     };
8457     int r;
8458     suppress_error = 0;
8459     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8460     if (r == -1)
8461       return -1;
8462   }
8463   {
8464     char fstype[] = "ext2";
8465     char device[] = "/dev/sda1";
8466     device[5] = devchar;
8467     int r;
8468     suppress_error = 0;
8469     r = guestfs_mkfs (g, fstype, device);
8470     if (r == -1)
8471       return -1;
8472   }
8473   {
8474     char device[] = "/dev/sda1";
8475     device[5] = devchar;
8476     char mountpoint[] = "/";
8477     int r;
8478     suppress_error = 0;
8479     r = guestfs_mount (g, device, mountpoint);
8480     if (r == -1)
8481       return -1;
8482   }
8483   /* TestLastFail for command (11) */
8484   {
8485     char remotefilename[] = "/test-command";
8486     int r;
8487     suppress_error = 0;
8488     r = guestfs_upload (g, "test-command", remotefilename);
8489     if (r == -1)
8490       return -1;
8491   }
8492   {
8493     char path[] = "/test-command";
8494     int r;
8495     suppress_error = 0;
8496     r = guestfs_chmod (g, 493, path);
8497     if (r == -1)
8498       return -1;
8499   }
8500   {
8501     char arguments_0[] = "/test-command";
8502     char *arguments[] = {
8503       arguments_0,
8504       NULL
8505     };
8506     char *r;
8507     suppress_error = 1;
8508     r = guestfs_command (g, arguments);
8509     if (r != NULL)
8510       return -1;
8511     free (r);
8512   }
8513   } else
8514     printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
8515   return 0;
8516 }
8517
8518 static int test_file_0 (void)
8519 {
8520   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
8521   {
8522     char device[] = "/dev/sda";
8523     device[5] = devchar;
8524     int r;
8525     suppress_error = 0;
8526     r = guestfs_blockdev_setrw (g, device);
8527     if (r == -1)
8528       return -1;
8529   }
8530   {
8531     int r;
8532     suppress_error = 0;
8533     r = guestfs_umount_all (g);
8534     if (r == -1)
8535       return -1;
8536   }
8537   {
8538     int r;
8539     suppress_error = 0;
8540     r = guestfs_lvm_remove_all (g);
8541     if (r == -1)
8542       return -1;
8543   }
8544   {
8545     char device[] = "/dev/sda";
8546     device[5] = devchar;
8547     char lines_0[] = ",";
8548     char *lines[] = {
8549       lines_0,
8550       NULL
8551     };
8552     int r;
8553     suppress_error = 0;
8554     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8555     if (r == -1)
8556       return -1;
8557   }
8558   {
8559     char fstype[] = "ext2";
8560     char device[] = "/dev/sda1";
8561     device[5] = devchar;
8562     int r;
8563     suppress_error = 0;
8564     r = guestfs_mkfs (g, fstype, device);
8565     if (r == -1)
8566       return -1;
8567   }
8568   {
8569     char device[] = "/dev/sda1";
8570     device[5] = devchar;
8571     char mountpoint[] = "/";
8572     int r;
8573     suppress_error = 0;
8574     r = guestfs_mount (g, device, mountpoint);
8575     if (r == -1)
8576       return -1;
8577   }
8578   /* TestOutput for file (0) */
8579   char expected[] = "empty";
8580   {
8581     char path[] = "/new";
8582     int r;
8583     suppress_error = 0;
8584     r = guestfs_touch (g, path);
8585     if (r == -1)
8586       return -1;
8587   }
8588   {
8589     char path[] = "/new";
8590     char *r;
8591     suppress_error = 0;
8592     r = guestfs_file (g, path);
8593     if (r == NULL)
8594       return -1;
8595     if (strcmp (r, expected) != 0) {
8596       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8597       return -1;
8598     }
8599     free (r);
8600   }
8601   return 0;
8602 }
8603
8604 static int test_file_1 (void)
8605 {
8606   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
8607   {
8608     char device[] = "/dev/sda";
8609     device[5] = devchar;
8610     int r;
8611     suppress_error = 0;
8612     r = guestfs_blockdev_setrw (g, device);
8613     if (r == -1)
8614       return -1;
8615   }
8616   {
8617     int r;
8618     suppress_error = 0;
8619     r = guestfs_umount_all (g);
8620     if (r == -1)
8621       return -1;
8622   }
8623   {
8624     int r;
8625     suppress_error = 0;
8626     r = guestfs_lvm_remove_all (g);
8627     if (r == -1)
8628       return -1;
8629   }
8630   {
8631     char device[] = "/dev/sda";
8632     device[5] = devchar;
8633     char lines_0[] = ",";
8634     char *lines[] = {
8635       lines_0,
8636       NULL
8637     };
8638     int r;
8639     suppress_error = 0;
8640     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8641     if (r == -1)
8642       return -1;
8643   }
8644   {
8645     char fstype[] = "ext2";
8646     char device[] = "/dev/sda1";
8647     device[5] = devchar;
8648     int r;
8649     suppress_error = 0;
8650     r = guestfs_mkfs (g, fstype, device);
8651     if (r == -1)
8652       return -1;
8653   }
8654   {
8655     char device[] = "/dev/sda1";
8656     device[5] = devchar;
8657     char mountpoint[] = "/";
8658     int r;
8659     suppress_error = 0;
8660     r = guestfs_mount (g, device, mountpoint);
8661     if (r == -1)
8662       return -1;
8663   }
8664   /* TestOutput for file (1) */
8665   char expected[] = "ASCII text";
8666   {
8667     char path[] = "/new";
8668     char content[] = "some content\n";
8669     int r;
8670     suppress_error = 0;
8671     r = guestfs_write_file (g, path, content, 0);
8672     if (r == -1)
8673       return -1;
8674   }
8675   {
8676     char path[] = "/new";
8677     char *r;
8678     suppress_error = 0;
8679     r = guestfs_file (g, path);
8680     if (r == NULL)
8681       return -1;
8682     if (strcmp (r, expected) != 0) {
8683       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8684       return -1;
8685     }
8686     free (r);
8687   }
8688   return 0;
8689 }
8690
8691 static int test_file_2 (void)
8692 {
8693   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
8694   {
8695     char device[] = "/dev/sda";
8696     device[5] = devchar;
8697     int r;
8698     suppress_error = 0;
8699     r = guestfs_blockdev_setrw (g, device);
8700     if (r == -1)
8701       return -1;
8702   }
8703   {
8704     int r;
8705     suppress_error = 0;
8706     r = guestfs_umount_all (g);
8707     if (r == -1)
8708       return -1;
8709   }
8710   {
8711     int r;
8712     suppress_error = 0;
8713     r = guestfs_lvm_remove_all (g);
8714     if (r == -1)
8715       return -1;
8716   }
8717   {
8718     char device[] = "/dev/sda";
8719     device[5] = devchar;
8720     char lines_0[] = ",";
8721     char *lines[] = {
8722       lines_0,
8723       NULL
8724     };
8725     int r;
8726     suppress_error = 0;
8727     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8728     if (r == -1)
8729       return -1;
8730   }
8731   {
8732     char fstype[] = "ext2";
8733     char device[] = "/dev/sda1";
8734     device[5] = devchar;
8735     int r;
8736     suppress_error = 0;
8737     r = guestfs_mkfs (g, fstype, device);
8738     if (r == -1)
8739       return -1;
8740   }
8741   {
8742     char device[] = "/dev/sda1";
8743     device[5] = devchar;
8744     char mountpoint[] = "/";
8745     int r;
8746     suppress_error = 0;
8747     r = guestfs_mount (g, device, mountpoint);
8748     if (r == -1)
8749       return -1;
8750   }
8751   /* TestLastFail for file (2) */
8752   {
8753     char path[] = "/nofile";
8754     char *r;
8755     suppress_error = 1;
8756     r = guestfs_file (g, path);
8757     if (r != NULL)
8758       return -1;
8759     free (r);
8760   }
8761   return 0;
8762 }
8763
8764 static int test_umount_all_0 (void)
8765 {
8766   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
8767   {
8768     char device[] = "/dev/sda";
8769     device[5] = devchar;
8770     int r;
8771     suppress_error = 0;
8772     r = guestfs_blockdev_setrw (g, device);
8773     if (r == -1)
8774       return -1;
8775   }
8776   {
8777     int r;
8778     suppress_error = 0;
8779     r = guestfs_umount_all (g);
8780     if (r == -1)
8781       return -1;
8782   }
8783   {
8784     int r;
8785     suppress_error = 0;
8786     r = guestfs_lvm_remove_all (g);
8787     if (r == -1)
8788       return -1;
8789   }
8790   {
8791     char device[] = "/dev/sda";
8792     device[5] = devchar;
8793     char lines_0[] = ",";
8794     char *lines[] = {
8795       lines_0,
8796       NULL
8797     };
8798     int r;
8799     suppress_error = 0;
8800     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8801     if (r == -1)
8802       return -1;
8803   }
8804   {
8805     char fstype[] = "ext2";
8806     char device[] = "/dev/sda1";
8807     device[5] = devchar;
8808     int r;
8809     suppress_error = 0;
8810     r = guestfs_mkfs (g, fstype, device);
8811     if (r == -1)
8812       return -1;
8813   }
8814   {
8815     char device[] = "/dev/sda1";
8816     device[5] = devchar;
8817     char mountpoint[] = "/";
8818     int r;
8819     suppress_error = 0;
8820     r = guestfs_mount (g, device, mountpoint);
8821     if (r == -1)
8822       return -1;
8823   }
8824   /* TestOutputList for umount_all (0) */
8825   {
8826     int r;
8827     suppress_error = 0;
8828     r = guestfs_umount_all (g);
8829     if (r == -1)
8830       return -1;
8831   }
8832   {
8833     char **r;
8834     int i;
8835     suppress_error = 0;
8836     r = guestfs_mounts (g);
8837     if (r == NULL)
8838       return -1;
8839     if (r[0] != NULL) {
8840       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8841       print_strings (r);
8842       return -1;
8843     }
8844     for (i = 0; r[i] != NULL; ++i)
8845       free (r[i]);
8846     free (r);
8847   }
8848   return 0;
8849 }
8850
8851 static int test_umount_all_1 (void)
8852 {
8853   /* InitNone|InitEmpty for test_umount_all_1 */
8854   {
8855     char device[] = "/dev/sda";
8856     device[5] = devchar;
8857     int r;
8858     suppress_error = 0;
8859     r = guestfs_blockdev_setrw (g, device);
8860     if (r == -1)
8861       return -1;
8862   }
8863   {
8864     int r;
8865     suppress_error = 0;
8866     r = guestfs_umount_all (g);
8867     if (r == -1)
8868       return -1;
8869   }
8870   {
8871     int r;
8872     suppress_error = 0;
8873     r = guestfs_lvm_remove_all (g);
8874     if (r == -1)
8875       return -1;
8876   }
8877   /* TestOutputList for umount_all (1) */
8878   {
8879     char device[] = "/dev/sda";
8880     device[5] = devchar;
8881     char lines_0[] = ",10";
8882     char lines_1[] = ",20";
8883     char lines_2[] = ",";
8884     char *lines[] = {
8885       lines_0,
8886       lines_1,
8887       lines_2,
8888       NULL
8889     };
8890     int r;
8891     suppress_error = 0;
8892     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8893     if (r == -1)
8894       return -1;
8895   }
8896   {
8897     char fstype[] = "ext2";
8898     char device[] = "/dev/sda1";
8899     device[5] = devchar;
8900     int r;
8901     suppress_error = 0;
8902     r = guestfs_mkfs (g, fstype, device);
8903     if (r == -1)
8904       return -1;
8905   }
8906   {
8907     char fstype[] = "ext2";
8908     char device[] = "/dev/sda2";
8909     device[5] = devchar;
8910     int r;
8911     suppress_error = 0;
8912     r = guestfs_mkfs (g, fstype, device);
8913     if (r == -1)
8914       return -1;
8915   }
8916   {
8917     char fstype[] = "ext2";
8918     char device[] = "/dev/sda3";
8919     device[5] = devchar;
8920     int r;
8921     suppress_error = 0;
8922     r = guestfs_mkfs (g, fstype, device);
8923     if (r == -1)
8924       return -1;
8925   }
8926   {
8927     char device[] = "/dev/sda1";
8928     device[5] = devchar;
8929     char mountpoint[] = "/";
8930     int r;
8931     suppress_error = 0;
8932     r = guestfs_mount (g, device, mountpoint);
8933     if (r == -1)
8934       return -1;
8935   }
8936   {
8937     char path[] = "/mp1";
8938     int r;
8939     suppress_error = 0;
8940     r = guestfs_mkdir (g, path);
8941     if (r == -1)
8942       return -1;
8943   }
8944   {
8945     char device[] = "/dev/sda2";
8946     device[5] = devchar;
8947     char mountpoint[] = "/mp1";
8948     int r;
8949     suppress_error = 0;
8950     r = guestfs_mount (g, device, mountpoint);
8951     if (r == -1)
8952       return -1;
8953   }
8954   {
8955     char path[] = "/mp1/mp2";
8956     int r;
8957     suppress_error = 0;
8958     r = guestfs_mkdir (g, path);
8959     if (r == -1)
8960       return -1;
8961   }
8962   {
8963     char device[] = "/dev/sda3";
8964     device[5] = devchar;
8965     char mountpoint[] = "/mp1/mp2";
8966     int r;
8967     suppress_error = 0;
8968     r = guestfs_mount (g, device, mountpoint);
8969     if (r == -1)
8970       return -1;
8971   }
8972   {
8973     char path[] = "/mp1/mp2/mp3";
8974     int r;
8975     suppress_error = 0;
8976     r = guestfs_mkdir (g, path);
8977     if (r == -1)
8978       return -1;
8979   }
8980   {
8981     int r;
8982     suppress_error = 0;
8983     r = guestfs_umount_all (g);
8984     if (r == -1)
8985       return -1;
8986   }
8987   {
8988     char **r;
8989     int i;
8990     suppress_error = 0;
8991     r = guestfs_mounts (g);
8992     if (r == NULL)
8993       return -1;
8994     if (r[0] != NULL) {
8995       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8996       print_strings (r);
8997       return -1;
8998     }
8999     for (i = 0; r[i] != NULL; ++i)
9000       free (r[i]);
9001     free (r);
9002   }
9003   return 0;
9004 }
9005
9006 static int test_mounts_0 (void)
9007 {
9008   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
9009   {
9010     char device[] = "/dev/sda";
9011     device[5] = devchar;
9012     int r;
9013     suppress_error = 0;
9014     r = guestfs_blockdev_setrw (g, device);
9015     if (r == -1)
9016       return -1;
9017   }
9018   {
9019     int r;
9020     suppress_error = 0;
9021     r = guestfs_umount_all (g);
9022     if (r == -1)
9023       return -1;
9024   }
9025   {
9026     int r;
9027     suppress_error = 0;
9028     r = guestfs_lvm_remove_all (g);
9029     if (r == -1)
9030       return -1;
9031   }
9032   {
9033     char device[] = "/dev/sda";
9034     device[5] = devchar;
9035     char lines_0[] = ",";
9036     char *lines[] = {
9037       lines_0,
9038       NULL
9039     };
9040     int r;
9041     suppress_error = 0;
9042     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9043     if (r == -1)
9044       return -1;
9045   }
9046   {
9047     char fstype[] = "ext2";
9048     char device[] = "/dev/sda1";
9049     device[5] = devchar;
9050     int r;
9051     suppress_error = 0;
9052     r = guestfs_mkfs (g, fstype, device);
9053     if (r == -1)
9054       return -1;
9055   }
9056   {
9057     char device[] = "/dev/sda1";
9058     device[5] = devchar;
9059     char mountpoint[] = "/";
9060     int r;
9061     suppress_error = 0;
9062     r = guestfs_mount (g, device, mountpoint);
9063     if (r == -1)
9064       return -1;
9065   }
9066   /* TestOutputList for mounts (0) */
9067   {
9068     char **r;
9069     int i;
9070     suppress_error = 0;
9071     r = guestfs_mounts (g);
9072     if (r == NULL)
9073       return -1;
9074     if (!r[0]) {
9075       fprintf (stderr, "test_mounts_0: short list returned from command\n");
9076       print_strings (r);
9077       return -1;
9078     }
9079     {
9080       char expected[] = "/dev/sda1";
9081       expected[5] = devchar;
9082       if (strcmp (r[0], expected) != 0) {
9083         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9084         return -1;
9085       }
9086     }
9087     if (r[1] != NULL) {
9088       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
9089       print_strings (r);
9090       return -1;
9091     }
9092     for (i = 0; r[i] != NULL; ++i)
9093       free (r[i]);
9094     free (r);
9095   }
9096   return 0;
9097 }
9098
9099 static int test_umount_0 (void)
9100 {
9101   /* InitNone|InitEmpty for test_umount_0 */
9102   {
9103     char device[] = "/dev/sda";
9104     device[5] = devchar;
9105     int r;
9106     suppress_error = 0;
9107     r = guestfs_blockdev_setrw (g, device);
9108     if (r == -1)
9109       return -1;
9110   }
9111   {
9112     int r;
9113     suppress_error = 0;
9114     r = guestfs_umount_all (g);
9115     if (r == -1)
9116       return -1;
9117   }
9118   {
9119     int r;
9120     suppress_error = 0;
9121     r = guestfs_lvm_remove_all (g);
9122     if (r == -1)
9123       return -1;
9124   }
9125   /* TestOutputList for umount (0) */
9126   {
9127     char device[] = "/dev/sda";
9128     device[5] = devchar;
9129     char lines_0[] = ",";
9130     char *lines[] = {
9131       lines_0,
9132       NULL
9133     };
9134     int r;
9135     suppress_error = 0;
9136     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9137     if (r == -1)
9138       return -1;
9139   }
9140   {
9141     char fstype[] = "ext2";
9142     char device[] = "/dev/sda1";
9143     device[5] = devchar;
9144     int r;
9145     suppress_error = 0;
9146     r = guestfs_mkfs (g, fstype, device);
9147     if (r == -1)
9148       return -1;
9149   }
9150   {
9151     char device[] = "/dev/sda1";
9152     device[5] = devchar;
9153     char mountpoint[] = "/";
9154     int r;
9155     suppress_error = 0;
9156     r = guestfs_mount (g, device, mountpoint);
9157     if (r == -1)
9158       return -1;
9159   }
9160   {
9161     char **r;
9162     int i;
9163     suppress_error = 0;
9164     r = guestfs_mounts (g);
9165     if (r == NULL)
9166       return -1;
9167     if (!r[0]) {
9168       fprintf (stderr, "test_umount_0: short list returned from command\n");
9169       print_strings (r);
9170       return -1;
9171     }
9172     {
9173       char expected[] = "/dev/sda1";
9174       expected[5] = devchar;
9175       if (strcmp (r[0], expected) != 0) {
9176         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9177         return -1;
9178       }
9179     }
9180     if (r[1] != NULL) {
9181       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
9182       print_strings (r);
9183       return -1;
9184     }
9185     for (i = 0; r[i] != NULL; ++i)
9186       free (r[i]);
9187     free (r);
9188   }
9189   return 0;
9190 }
9191
9192 static int test_umount_1 (void)
9193 {
9194   /* InitNone|InitEmpty for test_umount_1 */
9195   {
9196     char device[] = "/dev/sda";
9197     device[5] = devchar;
9198     int r;
9199     suppress_error = 0;
9200     r = guestfs_blockdev_setrw (g, device);
9201     if (r == -1)
9202       return -1;
9203   }
9204   {
9205     int r;
9206     suppress_error = 0;
9207     r = guestfs_umount_all (g);
9208     if (r == -1)
9209       return -1;
9210   }
9211   {
9212     int r;
9213     suppress_error = 0;
9214     r = guestfs_lvm_remove_all (g);
9215     if (r == -1)
9216       return -1;
9217   }
9218   /* TestOutputList for umount (1) */
9219   {
9220     char device[] = "/dev/sda";
9221     device[5] = devchar;
9222     char lines_0[] = ",";
9223     char *lines[] = {
9224       lines_0,
9225       NULL
9226     };
9227     int r;
9228     suppress_error = 0;
9229     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9230     if (r == -1)
9231       return -1;
9232   }
9233   {
9234     char fstype[] = "ext2";
9235     char device[] = "/dev/sda1";
9236     device[5] = devchar;
9237     int r;
9238     suppress_error = 0;
9239     r = guestfs_mkfs (g, fstype, device);
9240     if (r == -1)
9241       return -1;
9242   }
9243   {
9244     char device[] = "/dev/sda1";
9245     device[5] = devchar;
9246     char mountpoint[] = "/";
9247     int r;
9248     suppress_error = 0;
9249     r = guestfs_mount (g, device, mountpoint);
9250     if (r == -1)
9251       return -1;
9252   }
9253   {
9254     char pathordevice[] = "/";
9255     int r;
9256     suppress_error = 0;
9257     r = guestfs_umount (g, pathordevice);
9258     if (r == -1)
9259       return -1;
9260   }
9261   {
9262     char **r;
9263     int i;
9264     suppress_error = 0;
9265     r = guestfs_mounts (g);
9266     if (r == NULL)
9267       return -1;
9268     if (r[0] != NULL) {
9269       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
9270       print_strings (r);
9271       return -1;
9272     }
9273     for (i = 0; r[i] != NULL; ++i)
9274       free (r[i]);
9275     free (r);
9276   }
9277   return 0;
9278 }
9279
9280 static int test_write_file_0 (void)
9281 {
9282   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
9283   {
9284     char device[] = "/dev/sda";
9285     device[5] = devchar;
9286     int r;
9287     suppress_error = 0;
9288     r = guestfs_blockdev_setrw (g, device);
9289     if (r == -1)
9290       return -1;
9291   }
9292   {
9293     int r;
9294     suppress_error = 0;
9295     r = guestfs_umount_all (g);
9296     if (r == -1)
9297       return -1;
9298   }
9299   {
9300     int r;
9301     suppress_error = 0;
9302     r = guestfs_lvm_remove_all (g);
9303     if (r == -1)
9304       return -1;
9305   }
9306   {
9307     char device[] = "/dev/sda";
9308     device[5] = devchar;
9309     char lines_0[] = ",";
9310     char *lines[] = {
9311       lines_0,
9312       NULL
9313     };
9314     int r;
9315     suppress_error = 0;
9316     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9317     if (r == -1)
9318       return -1;
9319   }
9320   {
9321     char fstype[] = "ext2";
9322     char device[] = "/dev/sda1";
9323     device[5] = devchar;
9324     int r;
9325     suppress_error = 0;
9326     r = guestfs_mkfs (g, fstype, device);
9327     if (r == -1)
9328       return -1;
9329   }
9330   {
9331     char device[] = "/dev/sda1";
9332     device[5] = devchar;
9333     char mountpoint[] = "/";
9334     int r;
9335     suppress_error = 0;
9336     r = guestfs_mount (g, device, mountpoint);
9337     if (r == -1)
9338       return -1;
9339   }
9340   /* TestOutput for write_file (0) */
9341   char expected[] = "new file contents";
9342   {
9343     char path[] = "/new";
9344     char content[] = "new file contents";
9345     int r;
9346     suppress_error = 0;
9347     r = guestfs_write_file (g, path, content, 0);
9348     if (r == -1)
9349       return -1;
9350   }
9351   {
9352     char path[] = "/new";
9353     char *r;
9354     suppress_error = 0;
9355     r = guestfs_cat (g, path);
9356     if (r == NULL)
9357       return -1;
9358     if (strcmp (r, expected) != 0) {
9359       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9360       return -1;
9361     }
9362     free (r);
9363   }
9364   return 0;
9365 }
9366
9367 static int test_write_file_1 (void)
9368 {
9369   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
9370   {
9371     char device[] = "/dev/sda";
9372     device[5] = devchar;
9373     int r;
9374     suppress_error = 0;
9375     r = guestfs_blockdev_setrw (g, device);
9376     if (r == -1)
9377       return -1;
9378   }
9379   {
9380     int r;
9381     suppress_error = 0;
9382     r = guestfs_umount_all (g);
9383     if (r == -1)
9384       return -1;
9385   }
9386   {
9387     int r;
9388     suppress_error = 0;
9389     r = guestfs_lvm_remove_all (g);
9390     if (r == -1)
9391       return -1;
9392   }
9393   {
9394     char device[] = "/dev/sda";
9395     device[5] = devchar;
9396     char lines_0[] = ",";
9397     char *lines[] = {
9398       lines_0,
9399       NULL
9400     };
9401     int r;
9402     suppress_error = 0;
9403     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9404     if (r == -1)
9405       return -1;
9406   }
9407   {
9408     char fstype[] = "ext2";
9409     char device[] = "/dev/sda1";
9410     device[5] = devchar;
9411     int r;
9412     suppress_error = 0;
9413     r = guestfs_mkfs (g, fstype, device);
9414     if (r == -1)
9415       return -1;
9416   }
9417   {
9418     char device[] = "/dev/sda1";
9419     device[5] = devchar;
9420     char mountpoint[] = "/";
9421     int r;
9422     suppress_error = 0;
9423     r = guestfs_mount (g, device, mountpoint);
9424     if (r == -1)
9425       return -1;
9426   }
9427   /* TestOutput for write_file (1) */
9428   char expected[] = "\nnew file contents\n";
9429   {
9430     char path[] = "/new";
9431     char content[] = "\nnew file contents\n";
9432     int r;
9433     suppress_error = 0;
9434     r = guestfs_write_file (g, path, content, 0);
9435     if (r == -1)
9436       return -1;
9437   }
9438   {
9439     char path[] = "/new";
9440     char *r;
9441     suppress_error = 0;
9442     r = guestfs_cat (g, path);
9443     if (r == NULL)
9444       return -1;
9445     if (strcmp (r, expected) != 0) {
9446       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9447       return -1;
9448     }
9449     free (r);
9450   }
9451   return 0;
9452 }
9453
9454 static int test_write_file_2 (void)
9455 {
9456   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
9457   {
9458     char device[] = "/dev/sda";
9459     device[5] = devchar;
9460     int r;
9461     suppress_error = 0;
9462     r = guestfs_blockdev_setrw (g, device);
9463     if (r == -1)
9464       return -1;
9465   }
9466   {
9467     int r;
9468     suppress_error = 0;
9469     r = guestfs_umount_all (g);
9470     if (r == -1)
9471       return -1;
9472   }
9473   {
9474     int r;
9475     suppress_error = 0;
9476     r = guestfs_lvm_remove_all (g);
9477     if (r == -1)
9478       return -1;
9479   }
9480   {
9481     char device[] = "/dev/sda";
9482     device[5] = devchar;
9483     char lines_0[] = ",";
9484     char *lines[] = {
9485       lines_0,
9486       NULL
9487     };
9488     int r;
9489     suppress_error = 0;
9490     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9491     if (r == -1)
9492       return -1;
9493   }
9494   {
9495     char fstype[] = "ext2";
9496     char device[] = "/dev/sda1";
9497     device[5] = devchar;
9498     int r;
9499     suppress_error = 0;
9500     r = guestfs_mkfs (g, fstype, device);
9501     if (r == -1)
9502       return -1;
9503   }
9504   {
9505     char device[] = "/dev/sda1";
9506     device[5] = devchar;
9507     char mountpoint[] = "/";
9508     int r;
9509     suppress_error = 0;
9510     r = guestfs_mount (g, device, mountpoint);
9511     if (r == -1)
9512       return -1;
9513   }
9514   /* TestOutput for write_file (2) */
9515   char expected[] = "\n\n";
9516   {
9517     char path[] = "/new";
9518     char content[] = "\n\n";
9519     int r;
9520     suppress_error = 0;
9521     r = guestfs_write_file (g, path, content, 0);
9522     if (r == -1)
9523       return -1;
9524   }
9525   {
9526     char path[] = "/new";
9527     char *r;
9528     suppress_error = 0;
9529     r = guestfs_cat (g, path);
9530     if (r == NULL)
9531       return -1;
9532     if (strcmp (r, expected) != 0) {
9533       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
9534       return -1;
9535     }
9536     free (r);
9537   }
9538   return 0;
9539 }
9540
9541 static int test_write_file_3 (void)
9542 {
9543   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
9544   {
9545     char device[] = "/dev/sda";
9546     device[5] = devchar;
9547     int r;
9548     suppress_error = 0;
9549     r = guestfs_blockdev_setrw (g, device);
9550     if (r == -1)
9551       return -1;
9552   }
9553   {
9554     int r;
9555     suppress_error = 0;
9556     r = guestfs_umount_all (g);
9557     if (r == -1)
9558       return -1;
9559   }
9560   {
9561     int r;
9562     suppress_error = 0;
9563     r = guestfs_lvm_remove_all (g);
9564     if (r == -1)
9565       return -1;
9566   }
9567   {
9568     char device[] = "/dev/sda";
9569     device[5] = devchar;
9570     char lines_0[] = ",";
9571     char *lines[] = {
9572       lines_0,
9573       NULL
9574     };
9575     int r;
9576     suppress_error = 0;
9577     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9578     if (r == -1)
9579       return -1;
9580   }
9581   {
9582     char fstype[] = "ext2";
9583     char device[] = "/dev/sda1";
9584     device[5] = devchar;
9585     int r;
9586     suppress_error = 0;
9587     r = guestfs_mkfs (g, fstype, device);
9588     if (r == -1)
9589       return -1;
9590   }
9591   {
9592     char device[] = "/dev/sda1";
9593     device[5] = devchar;
9594     char mountpoint[] = "/";
9595     int r;
9596     suppress_error = 0;
9597     r = guestfs_mount (g, device, mountpoint);
9598     if (r == -1)
9599       return -1;
9600   }
9601   /* TestOutput for write_file (3) */
9602   char expected[] = "";
9603   {
9604     char path[] = "/new";
9605     char content[] = "";
9606     int r;
9607     suppress_error = 0;
9608     r = guestfs_write_file (g, path, content, 0);
9609     if (r == -1)
9610       return -1;
9611   }
9612   {
9613     char path[] = "/new";
9614     char *r;
9615     suppress_error = 0;
9616     r = guestfs_cat (g, path);
9617     if (r == NULL)
9618       return -1;
9619     if (strcmp (r, expected) != 0) {
9620       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
9621       return -1;
9622     }
9623     free (r);
9624   }
9625   return 0;
9626 }
9627
9628 static int test_write_file_4 (void)
9629 {
9630   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
9631   {
9632     char device[] = "/dev/sda";
9633     device[5] = devchar;
9634     int r;
9635     suppress_error = 0;
9636     r = guestfs_blockdev_setrw (g, device);
9637     if (r == -1)
9638       return -1;
9639   }
9640   {
9641     int r;
9642     suppress_error = 0;
9643     r = guestfs_umount_all (g);
9644     if (r == -1)
9645       return -1;
9646   }
9647   {
9648     int r;
9649     suppress_error = 0;
9650     r = guestfs_lvm_remove_all (g);
9651     if (r == -1)
9652       return -1;
9653   }
9654   {
9655     char device[] = "/dev/sda";
9656     device[5] = devchar;
9657     char lines_0[] = ",";
9658     char *lines[] = {
9659       lines_0,
9660       NULL
9661     };
9662     int r;
9663     suppress_error = 0;
9664     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9665     if (r == -1)
9666       return -1;
9667   }
9668   {
9669     char fstype[] = "ext2";
9670     char device[] = "/dev/sda1";
9671     device[5] = devchar;
9672     int r;
9673     suppress_error = 0;
9674     r = guestfs_mkfs (g, fstype, device);
9675     if (r == -1)
9676       return -1;
9677   }
9678   {
9679     char device[] = "/dev/sda1";
9680     device[5] = devchar;
9681     char mountpoint[] = "/";
9682     int r;
9683     suppress_error = 0;
9684     r = guestfs_mount (g, device, mountpoint);
9685     if (r == -1)
9686       return -1;
9687   }
9688   /* TestOutput for write_file (4) */
9689   char expected[] = "\n\n\n";
9690   {
9691     char path[] = "/new";
9692     char content[] = "\n\n\n";
9693     int r;
9694     suppress_error = 0;
9695     r = guestfs_write_file (g, path, content, 0);
9696     if (r == -1)
9697       return -1;
9698   }
9699   {
9700     char path[] = "/new";
9701     char *r;
9702     suppress_error = 0;
9703     r = guestfs_cat (g, path);
9704     if (r == NULL)
9705       return -1;
9706     if (strcmp (r, expected) != 0) {
9707       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9708       return -1;
9709     }
9710     free (r);
9711   }
9712   return 0;
9713 }
9714
9715 static int test_write_file_5 (void)
9716 {
9717   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
9718   {
9719     char device[] = "/dev/sda";
9720     device[5] = devchar;
9721     int r;
9722     suppress_error = 0;
9723     r = guestfs_blockdev_setrw (g, device);
9724     if (r == -1)
9725       return -1;
9726   }
9727   {
9728     int r;
9729     suppress_error = 0;
9730     r = guestfs_umount_all (g);
9731     if (r == -1)
9732       return -1;
9733   }
9734   {
9735     int r;
9736     suppress_error = 0;
9737     r = guestfs_lvm_remove_all (g);
9738     if (r == -1)
9739       return -1;
9740   }
9741   {
9742     char device[] = "/dev/sda";
9743     device[5] = devchar;
9744     char lines_0[] = ",";
9745     char *lines[] = {
9746       lines_0,
9747       NULL
9748     };
9749     int r;
9750     suppress_error = 0;
9751     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9752     if (r == -1)
9753       return -1;
9754   }
9755   {
9756     char fstype[] = "ext2";
9757     char device[] = "/dev/sda1";
9758     device[5] = devchar;
9759     int r;
9760     suppress_error = 0;
9761     r = guestfs_mkfs (g, fstype, device);
9762     if (r == -1)
9763       return -1;
9764   }
9765   {
9766     char device[] = "/dev/sda1";
9767     device[5] = devchar;
9768     char mountpoint[] = "/";
9769     int r;
9770     suppress_error = 0;
9771     r = guestfs_mount (g, device, mountpoint);
9772     if (r == -1)
9773       return -1;
9774   }
9775   /* TestOutput for write_file (5) */
9776   char expected[] = "\n";
9777   {
9778     char path[] = "/new";
9779     char content[] = "\n";
9780     int r;
9781     suppress_error = 0;
9782     r = guestfs_write_file (g, path, content, 0);
9783     if (r == -1)
9784       return -1;
9785   }
9786   {
9787     char path[] = "/new";
9788     char *r;
9789     suppress_error = 0;
9790     r = guestfs_cat (g, path);
9791     if (r == NULL)
9792       return -1;
9793     if (strcmp (r, expected) != 0) {
9794       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9795       return -1;
9796     }
9797     free (r);
9798   }
9799   return 0;
9800 }
9801
9802 static int test_mkfs_0 (void)
9803 {
9804   /* InitNone|InitEmpty for test_mkfs_0 */
9805   {
9806     char device[] = "/dev/sda";
9807     device[5] = devchar;
9808     int r;
9809     suppress_error = 0;
9810     r = guestfs_blockdev_setrw (g, device);
9811     if (r == -1)
9812       return -1;
9813   }
9814   {
9815     int r;
9816     suppress_error = 0;
9817     r = guestfs_umount_all (g);
9818     if (r == -1)
9819       return -1;
9820   }
9821   {
9822     int r;
9823     suppress_error = 0;
9824     r = guestfs_lvm_remove_all (g);
9825     if (r == -1)
9826       return -1;
9827   }
9828   /* TestOutput for mkfs (0) */
9829   char expected[] = "new file contents";
9830   {
9831     char device[] = "/dev/sda";
9832     device[5] = devchar;
9833     char lines_0[] = ",";
9834     char *lines[] = {
9835       lines_0,
9836       NULL
9837     };
9838     int r;
9839     suppress_error = 0;
9840     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9841     if (r == -1)
9842       return -1;
9843   }
9844   {
9845     char fstype[] = "ext2";
9846     char device[] = "/dev/sda1";
9847     device[5] = devchar;
9848     int r;
9849     suppress_error = 0;
9850     r = guestfs_mkfs (g, fstype, device);
9851     if (r == -1)
9852       return -1;
9853   }
9854   {
9855     char device[] = "/dev/sda1";
9856     device[5] = devchar;
9857     char mountpoint[] = "/";
9858     int r;
9859     suppress_error = 0;
9860     r = guestfs_mount (g, device, mountpoint);
9861     if (r == -1)
9862       return -1;
9863   }
9864   {
9865     char path[] = "/new";
9866     char content[] = "new file contents";
9867     int r;
9868     suppress_error = 0;
9869     r = guestfs_write_file (g, path, content, 0);
9870     if (r == -1)
9871       return -1;
9872   }
9873   {
9874     char path[] = "/new";
9875     char *r;
9876     suppress_error = 0;
9877     r = guestfs_cat (g, path);
9878     if (r == NULL)
9879       return -1;
9880     if (strcmp (r, expected) != 0) {
9881       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9882       return -1;
9883     }
9884     free (r);
9885   }
9886   return 0;
9887 }
9888
9889 static int test_lvcreate_0 (void)
9890 {
9891   /* InitNone|InitEmpty for test_lvcreate_0 */
9892   {
9893     char device[] = "/dev/sda";
9894     device[5] = devchar;
9895     int r;
9896     suppress_error = 0;
9897     r = guestfs_blockdev_setrw (g, device);
9898     if (r == -1)
9899       return -1;
9900   }
9901   {
9902     int r;
9903     suppress_error = 0;
9904     r = guestfs_umount_all (g);
9905     if (r == -1)
9906       return -1;
9907   }
9908   {
9909     int r;
9910     suppress_error = 0;
9911     r = guestfs_lvm_remove_all (g);
9912     if (r == -1)
9913       return -1;
9914   }
9915   /* TestOutputList for lvcreate (0) */
9916   {
9917     char device[] = "/dev/sda";
9918     device[5] = devchar;
9919     char lines_0[] = ",10";
9920     char lines_1[] = ",20";
9921     char lines_2[] = ",";
9922     char *lines[] = {
9923       lines_0,
9924       lines_1,
9925       lines_2,
9926       NULL
9927     };
9928     int r;
9929     suppress_error = 0;
9930     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9931     if (r == -1)
9932       return -1;
9933   }
9934   {
9935     char device[] = "/dev/sda1";
9936     device[5] = devchar;
9937     int r;
9938     suppress_error = 0;
9939     r = guestfs_pvcreate (g, device);
9940     if (r == -1)
9941       return -1;
9942   }
9943   {
9944     char device[] = "/dev/sda2";
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/sda3";
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 volgroup[] = "VG1";
9963     char physvols_0[] = "/dev/sda1";
9964     physvols_0[5] = devchar;
9965     char physvols_1[] = "/dev/sda2";
9966     physvols_1[5] = devchar;
9967     char *physvols[] = {
9968       physvols_0,
9969       physvols_1,
9970       NULL
9971     };
9972     int r;
9973     suppress_error = 0;
9974     r = guestfs_vgcreate (g, volgroup, physvols);
9975     if (r == -1)
9976       return -1;
9977   }
9978   {
9979     char volgroup[] = "VG2";
9980     char physvols_0[] = "/dev/sda3";
9981     physvols_0[5] = devchar;
9982     char *physvols[] = {
9983       physvols_0,
9984       NULL
9985     };
9986     int r;
9987     suppress_error = 0;
9988     r = guestfs_vgcreate (g, volgroup, physvols);
9989     if (r == -1)
9990       return -1;
9991   }
9992   {
9993     char logvol[] = "LV1";
9994     char volgroup[] = "VG1";
9995     int r;
9996     suppress_error = 0;
9997     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9998     if (r == -1)
9999       return -1;
10000   }
10001   {
10002     char logvol[] = "LV2";
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[] = "LV3";
10012     char volgroup[] = "VG2";
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[] = "LV4";
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[] = "LV5";
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 **r;
10039     int i;
10040     suppress_error = 0;
10041     r = guestfs_lvs (g);
10042     if (r == NULL)
10043       return -1;
10044     if (!r[0]) {
10045       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10046       print_strings (r);
10047       return -1;
10048     }
10049     {
10050       char expected[] = "/dev/VG1/LV1";
10051       if (strcmp (r[0], expected) != 0) {
10052         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10053         return -1;
10054       }
10055     }
10056     if (!r[1]) {
10057       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10058       print_strings (r);
10059       return -1;
10060     }
10061     {
10062       char expected[] = "/dev/VG1/LV2";
10063       if (strcmp (r[1], expected) != 0) {
10064         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10065         return -1;
10066       }
10067     }
10068     if (!r[2]) {
10069       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10070       print_strings (r);
10071       return -1;
10072     }
10073     {
10074       char expected[] = "/dev/VG2/LV3";
10075       if (strcmp (r[2], expected) != 0) {
10076         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10077         return -1;
10078       }
10079     }
10080     if (!r[3]) {
10081       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10082       print_strings (r);
10083       return -1;
10084     }
10085     {
10086       char expected[] = "/dev/VG2/LV4";
10087       if (strcmp (r[3], expected) != 0) {
10088         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10089         return -1;
10090       }
10091     }
10092     if (!r[4]) {
10093       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10094       print_strings (r);
10095       return -1;
10096     }
10097     {
10098       char expected[] = "/dev/VG2/LV5";
10099       if (strcmp (r[4], expected) != 0) {
10100         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
10101         return -1;
10102       }
10103     }
10104     if (r[5] != NULL) {
10105       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
10106       print_strings (r);
10107       return -1;
10108     }
10109     for (i = 0; r[i] != NULL; ++i)
10110       free (r[i]);
10111     free (r);
10112   }
10113   return 0;
10114 }
10115
10116 static int test_vgcreate_0 (void)
10117 {
10118   /* InitNone|InitEmpty for test_vgcreate_0 */
10119   {
10120     char device[] = "/dev/sda";
10121     device[5] = devchar;
10122     int r;
10123     suppress_error = 0;
10124     r = guestfs_blockdev_setrw (g, device);
10125     if (r == -1)
10126       return -1;
10127   }
10128   {
10129     int r;
10130     suppress_error = 0;
10131     r = guestfs_umount_all (g);
10132     if (r == -1)
10133       return -1;
10134   }
10135   {
10136     int r;
10137     suppress_error = 0;
10138     r = guestfs_lvm_remove_all (g);
10139     if (r == -1)
10140       return -1;
10141   }
10142   /* TestOutputList for vgcreate (0) */
10143   {
10144     char device[] = "/dev/sda";
10145     device[5] = devchar;
10146     char lines_0[] = ",10";
10147     char lines_1[] = ",20";
10148     char lines_2[] = ",";
10149     char *lines[] = {
10150       lines_0,
10151       lines_1,
10152       lines_2,
10153       NULL
10154     };
10155     int r;
10156     suppress_error = 0;
10157     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10158     if (r == -1)
10159       return -1;
10160   }
10161   {
10162     char device[] = "/dev/sda1";
10163     device[5] = devchar;
10164     int r;
10165     suppress_error = 0;
10166     r = guestfs_pvcreate (g, device);
10167     if (r == -1)
10168       return -1;
10169   }
10170   {
10171     char device[] = "/dev/sda2";
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/sda3";
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 volgroup[] = "VG1";
10190     char physvols_0[] = "/dev/sda1";
10191     physvols_0[5] = devchar;
10192     char physvols_1[] = "/dev/sda2";
10193     physvols_1[5] = devchar;
10194     char *physvols[] = {
10195       physvols_0,
10196       physvols_1,
10197       NULL
10198     };
10199     int r;
10200     suppress_error = 0;
10201     r = guestfs_vgcreate (g, volgroup, physvols);
10202     if (r == -1)
10203       return -1;
10204   }
10205   {
10206     char volgroup[] = "VG2";
10207     char physvols_0[] = "/dev/sda3";
10208     physvols_0[5] = devchar;
10209     char *physvols[] = {
10210       physvols_0,
10211       NULL
10212     };
10213     int r;
10214     suppress_error = 0;
10215     r = guestfs_vgcreate (g, volgroup, physvols);
10216     if (r == -1)
10217       return -1;
10218   }
10219   {
10220     char **r;
10221     int i;
10222     suppress_error = 0;
10223     r = guestfs_vgs (g);
10224     if (r == NULL)
10225       return -1;
10226     if (!r[0]) {
10227       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10228       print_strings (r);
10229       return -1;
10230     }
10231     {
10232       char expected[] = "VG1";
10233       if (strcmp (r[0], expected) != 0) {
10234         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10235         return -1;
10236       }
10237     }
10238     if (!r[1]) {
10239       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10240       print_strings (r);
10241       return -1;
10242     }
10243     {
10244       char expected[] = "VG2";
10245       if (strcmp (r[1], expected) != 0) {
10246         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10247         return -1;
10248       }
10249     }
10250     if (r[2] != NULL) {
10251       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
10252       print_strings (r);
10253       return -1;
10254     }
10255     for (i = 0; r[i] != NULL; ++i)
10256       free (r[i]);
10257     free (r);
10258   }
10259   return 0;
10260 }
10261
10262 static int test_pvcreate_0 (void)
10263 {
10264   /* InitNone|InitEmpty for test_pvcreate_0 */
10265   {
10266     char device[] = "/dev/sda";
10267     device[5] = devchar;
10268     int r;
10269     suppress_error = 0;
10270     r = guestfs_blockdev_setrw (g, device);
10271     if (r == -1)
10272       return -1;
10273   }
10274   {
10275     int r;
10276     suppress_error = 0;
10277     r = guestfs_umount_all (g);
10278     if (r == -1)
10279       return -1;
10280   }
10281   {
10282     int r;
10283     suppress_error = 0;
10284     r = guestfs_lvm_remove_all (g);
10285     if (r == -1)
10286       return -1;
10287   }
10288   /* TestOutputList for pvcreate (0) */
10289   {
10290     char device[] = "/dev/sda";
10291     device[5] = devchar;
10292     char lines_0[] = ",10";
10293     char lines_1[] = ",20";
10294     char lines_2[] = ",";
10295     char *lines[] = {
10296       lines_0,
10297       lines_1,
10298       lines_2,
10299       NULL
10300     };
10301     int r;
10302     suppress_error = 0;
10303     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10304     if (r == -1)
10305       return -1;
10306   }
10307   {
10308     char device[] = "/dev/sda1";
10309     device[5] = devchar;
10310     int r;
10311     suppress_error = 0;
10312     r = guestfs_pvcreate (g, device);
10313     if (r == -1)
10314       return -1;
10315   }
10316   {
10317     char device[] = "/dev/sda2";
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/sda3";
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 **r;
10336     int i;
10337     suppress_error = 0;
10338     r = guestfs_pvs (g);
10339     if (r == NULL)
10340       return -1;
10341     if (!r[0]) {
10342       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10343       print_strings (r);
10344       return -1;
10345     }
10346     {
10347       char expected[] = "/dev/sda1";
10348       expected[5] = devchar;
10349       if (strcmp (r[0], expected) != 0) {
10350         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10351         return -1;
10352       }
10353     }
10354     if (!r[1]) {
10355       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10356       print_strings (r);
10357       return -1;
10358     }
10359     {
10360       char expected[] = "/dev/sda2";
10361       expected[5] = devchar;
10362       if (strcmp (r[1], expected) != 0) {
10363         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10364         return -1;
10365       }
10366     }
10367     if (!r[2]) {
10368       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10369       print_strings (r);
10370       return -1;
10371     }
10372     {
10373       char expected[] = "/dev/sda3";
10374       expected[5] = devchar;
10375       if (strcmp (r[2], expected) != 0) {
10376         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10377         return -1;
10378       }
10379     }
10380     if (r[3] != NULL) {
10381       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
10382       print_strings (r);
10383       return -1;
10384     }
10385     for (i = 0; r[i] != NULL; ++i)
10386       free (r[i]);
10387     free (r);
10388   }
10389   return 0;
10390 }
10391
10392 static int test_is_dir_0 (void)
10393 {
10394   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
10395   {
10396     char device[] = "/dev/sda";
10397     device[5] = devchar;
10398     int r;
10399     suppress_error = 0;
10400     r = guestfs_blockdev_setrw (g, device);
10401     if (r == -1)
10402       return -1;
10403   }
10404   {
10405     int r;
10406     suppress_error = 0;
10407     r = guestfs_umount_all (g);
10408     if (r == -1)
10409       return -1;
10410   }
10411   {
10412     int r;
10413     suppress_error = 0;
10414     r = guestfs_lvm_remove_all (g);
10415     if (r == -1)
10416       return -1;
10417   }
10418   {
10419     char device[] = "/dev/sda";
10420     device[5] = devchar;
10421     char lines_0[] = ",";
10422     char *lines[] = {
10423       lines_0,
10424       NULL
10425     };
10426     int r;
10427     suppress_error = 0;
10428     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10429     if (r == -1)
10430       return -1;
10431   }
10432   {
10433     char fstype[] = "ext2";
10434     char device[] = "/dev/sda1";
10435     device[5] = devchar;
10436     int r;
10437     suppress_error = 0;
10438     r = guestfs_mkfs (g, fstype, device);
10439     if (r == -1)
10440       return -1;
10441   }
10442   {
10443     char device[] = "/dev/sda1";
10444     device[5] = devchar;
10445     char mountpoint[] = "/";
10446     int r;
10447     suppress_error = 0;
10448     r = guestfs_mount (g, device, mountpoint);
10449     if (r == -1)
10450       return -1;
10451   }
10452   /* TestOutputFalse for is_dir (0) */
10453   {
10454     char path[] = "/new";
10455     int r;
10456     suppress_error = 0;
10457     r = guestfs_touch (g, path);
10458     if (r == -1)
10459       return -1;
10460   }
10461   {
10462     char path[] = "/new";
10463     int r;
10464     suppress_error = 0;
10465     r = guestfs_is_dir (g, path);
10466     if (r == -1)
10467       return -1;
10468     if (r) {
10469       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
10470       return -1;
10471     }
10472   }
10473   return 0;
10474 }
10475
10476 static int test_is_dir_1 (void)
10477 {
10478   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
10479   {
10480     char device[] = "/dev/sda";
10481     device[5] = devchar;
10482     int r;
10483     suppress_error = 0;
10484     r = guestfs_blockdev_setrw (g, device);
10485     if (r == -1)
10486       return -1;
10487   }
10488   {
10489     int r;
10490     suppress_error = 0;
10491     r = guestfs_umount_all (g);
10492     if (r == -1)
10493       return -1;
10494   }
10495   {
10496     int r;
10497     suppress_error = 0;
10498     r = guestfs_lvm_remove_all (g);
10499     if (r == -1)
10500       return -1;
10501   }
10502   {
10503     char device[] = "/dev/sda";
10504     device[5] = devchar;
10505     char lines_0[] = ",";
10506     char *lines[] = {
10507       lines_0,
10508       NULL
10509     };
10510     int r;
10511     suppress_error = 0;
10512     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10513     if (r == -1)
10514       return -1;
10515   }
10516   {
10517     char fstype[] = "ext2";
10518     char device[] = "/dev/sda1";
10519     device[5] = devchar;
10520     int r;
10521     suppress_error = 0;
10522     r = guestfs_mkfs (g, fstype, device);
10523     if (r == -1)
10524       return -1;
10525   }
10526   {
10527     char device[] = "/dev/sda1";
10528     device[5] = devchar;
10529     char mountpoint[] = "/";
10530     int r;
10531     suppress_error = 0;
10532     r = guestfs_mount (g, device, mountpoint);
10533     if (r == -1)
10534       return -1;
10535   }
10536   /* TestOutputTrue for is_dir (1) */
10537   {
10538     char path[] = "/new";
10539     int r;
10540     suppress_error = 0;
10541     r = guestfs_mkdir (g, path);
10542     if (r == -1)
10543       return -1;
10544   }
10545   {
10546     char path[] = "/new";
10547     int r;
10548     suppress_error = 0;
10549     r = guestfs_is_dir (g, path);
10550     if (r == -1)
10551       return -1;
10552     if (!r) {
10553       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
10554       return -1;
10555     }
10556   }
10557   return 0;
10558 }
10559
10560 static int test_is_file_0 (void)
10561 {
10562   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
10563   {
10564     char device[] = "/dev/sda";
10565     device[5] = devchar;
10566     int r;
10567     suppress_error = 0;
10568     r = guestfs_blockdev_setrw (g, device);
10569     if (r == -1)
10570       return -1;
10571   }
10572   {
10573     int r;
10574     suppress_error = 0;
10575     r = guestfs_umount_all (g);
10576     if (r == -1)
10577       return -1;
10578   }
10579   {
10580     int r;
10581     suppress_error = 0;
10582     r = guestfs_lvm_remove_all (g);
10583     if (r == -1)
10584       return -1;
10585   }
10586   {
10587     char device[] = "/dev/sda";
10588     device[5] = devchar;
10589     char lines_0[] = ",";
10590     char *lines[] = {
10591       lines_0,
10592       NULL
10593     };
10594     int r;
10595     suppress_error = 0;
10596     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10597     if (r == -1)
10598       return -1;
10599   }
10600   {
10601     char fstype[] = "ext2";
10602     char device[] = "/dev/sda1";
10603     device[5] = devchar;
10604     int r;
10605     suppress_error = 0;
10606     r = guestfs_mkfs (g, fstype, device);
10607     if (r == -1)
10608       return -1;
10609   }
10610   {
10611     char device[] = "/dev/sda1";
10612     device[5] = devchar;
10613     char mountpoint[] = "/";
10614     int r;
10615     suppress_error = 0;
10616     r = guestfs_mount (g, device, mountpoint);
10617     if (r == -1)
10618       return -1;
10619   }
10620   /* TestOutputTrue for is_file (0) */
10621   {
10622     char path[] = "/new";
10623     int r;
10624     suppress_error = 0;
10625     r = guestfs_touch (g, path);
10626     if (r == -1)
10627       return -1;
10628   }
10629   {
10630     char path[] = "/new";
10631     int r;
10632     suppress_error = 0;
10633     r = guestfs_is_file (g, path);
10634     if (r == -1)
10635       return -1;
10636     if (!r) {
10637       fprintf (stderr, "test_is_file_0: expected true, got false\n");
10638       return -1;
10639     }
10640   }
10641   return 0;
10642 }
10643
10644 static int test_is_file_1 (void)
10645 {
10646   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
10647   {
10648     char device[] = "/dev/sda";
10649     device[5] = devchar;
10650     int r;
10651     suppress_error = 0;
10652     r = guestfs_blockdev_setrw (g, device);
10653     if (r == -1)
10654       return -1;
10655   }
10656   {
10657     int r;
10658     suppress_error = 0;
10659     r = guestfs_umount_all (g);
10660     if (r == -1)
10661       return -1;
10662   }
10663   {
10664     int r;
10665     suppress_error = 0;
10666     r = guestfs_lvm_remove_all (g);
10667     if (r == -1)
10668       return -1;
10669   }
10670   {
10671     char device[] = "/dev/sda";
10672     device[5] = devchar;
10673     char lines_0[] = ",";
10674     char *lines[] = {
10675       lines_0,
10676       NULL
10677     };
10678     int r;
10679     suppress_error = 0;
10680     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10681     if (r == -1)
10682       return -1;
10683   }
10684   {
10685     char fstype[] = "ext2";
10686     char device[] = "/dev/sda1";
10687     device[5] = devchar;
10688     int r;
10689     suppress_error = 0;
10690     r = guestfs_mkfs (g, fstype, device);
10691     if (r == -1)
10692       return -1;
10693   }
10694   {
10695     char device[] = "/dev/sda1";
10696     device[5] = devchar;
10697     char mountpoint[] = "/";
10698     int r;
10699     suppress_error = 0;
10700     r = guestfs_mount (g, device, mountpoint);
10701     if (r == -1)
10702       return -1;
10703   }
10704   /* TestOutputFalse for is_file (1) */
10705   {
10706     char path[] = "/new";
10707     int r;
10708     suppress_error = 0;
10709     r = guestfs_mkdir (g, path);
10710     if (r == -1)
10711       return -1;
10712   }
10713   {
10714     char path[] = "/new";
10715     int r;
10716     suppress_error = 0;
10717     r = guestfs_is_file (g, path);
10718     if (r == -1)
10719       return -1;
10720     if (r) {
10721       fprintf (stderr, "test_is_file_1: expected false, got true\n");
10722       return -1;
10723     }
10724   }
10725   return 0;
10726 }
10727
10728 static int test_exists_0 (void)
10729 {
10730   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
10731   {
10732     char device[] = "/dev/sda";
10733     device[5] = devchar;
10734     int r;
10735     suppress_error = 0;
10736     r = guestfs_blockdev_setrw (g, device);
10737     if (r == -1)
10738       return -1;
10739   }
10740   {
10741     int r;
10742     suppress_error = 0;
10743     r = guestfs_umount_all (g);
10744     if (r == -1)
10745       return -1;
10746   }
10747   {
10748     int r;
10749     suppress_error = 0;
10750     r = guestfs_lvm_remove_all (g);
10751     if (r == -1)
10752       return -1;
10753   }
10754   {
10755     char device[] = "/dev/sda";
10756     device[5] = devchar;
10757     char lines_0[] = ",";
10758     char *lines[] = {
10759       lines_0,
10760       NULL
10761     };
10762     int r;
10763     suppress_error = 0;
10764     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10765     if (r == -1)
10766       return -1;
10767   }
10768   {
10769     char fstype[] = "ext2";
10770     char device[] = "/dev/sda1";
10771     device[5] = devchar;
10772     int r;
10773     suppress_error = 0;
10774     r = guestfs_mkfs (g, fstype, device);
10775     if (r == -1)
10776       return -1;
10777   }
10778   {
10779     char device[] = "/dev/sda1";
10780     device[5] = devchar;
10781     char mountpoint[] = "/";
10782     int r;
10783     suppress_error = 0;
10784     r = guestfs_mount (g, device, mountpoint);
10785     if (r == -1)
10786       return -1;
10787   }
10788   /* TestOutputTrue for exists (0) */
10789   {
10790     char path[] = "/new";
10791     int r;
10792     suppress_error = 0;
10793     r = guestfs_touch (g, path);
10794     if (r == -1)
10795       return -1;
10796   }
10797   {
10798     char path[] = "/new";
10799     int r;
10800     suppress_error = 0;
10801     r = guestfs_exists (g, path);
10802     if (r == -1)
10803       return -1;
10804     if (!r) {
10805       fprintf (stderr, "test_exists_0: expected true, got false\n");
10806       return -1;
10807     }
10808   }
10809   return 0;
10810 }
10811
10812 static int test_exists_1 (void)
10813 {
10814   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
10815   {
10816     char device[] = "/dev/sda";
10817     device[5] = devchar;
10818     int r;
10819     suppress_error = 0;
10820     r = guestfs_blockdev_setrw (g, device);
10821     if (r == -1)
10822       return -1;
10823   }
10824   {
10825     int r;
10826     suppress_error = 0;
10827     r = guestfs_umount_all (g);
10828     if (r == -1)
10829       return -1;
10830   }
10831   {
10832     int r;
10833     suppress_error = 0;
10834     r = guestfs_lvm_remove_all (g);
10835     if (r == -1)
10836       return -1;
10837   }
10838   {
10839     char device[] = "/dev/sda";
10840     device[5] = devchar;
10841     char lines_0[] = ",";
10842     char *lines[] = {
10843       lines_0,
10844       NULL
10845     };
10846     int r;
10847     suppress_error = 0;
10848     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10849     if (r == -1)
10850       return -1;
10851   }
10852   {
10853     char fstype[] = "ext2";
10854     char device[] = "/dev/sda1";
10855     device[5] = devchar;
10856     int r;
10857     suppress_error = 0;
10858     r = guestfs_mkfs (g, fstype, device);
10859     if (r == -1)
10860       return -1;
10861   }
10862   {
10863     char device[] = "/dev/sda1";
10864     device[5] = devchar;
10865     char mountpoint[] = "/";
10866     int r;
10867     suppress_error = 0;
10868     r = guestfs_mount (g, device, mountpoint);
10869     if (r == -1)
10870       return -1;
10871   }
10872   /* TestOutputTrue for exists (1) */
10873   {
10874     char path[] = "/new";
10875     int r;
10876     suppress_error = 0;
10877     r = guestfs_mkdir (g, path);
10878     if (r == -1)
10879       return -1;
10880   }
10881   {
10882     char path[] = "/new";
10883     int r;
10884     suppress_error = 0;
10885     r = guestfs_exists (g, path);
10886     if (r == -1)
10887       return -1;
10888     if (!r) {
10889       fprintf (stderr, "test_exists_1: expected true, got false\n");
10890       return -1;
10891     }
10892   }
10893   return 0;
10894 }
10895
10896 static int test_mkdir_p_0 (void)
10897 {
10898   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
10899   {
10900     char device[] = "/dev/sda";
10901     device[5] = devchar;
10902     int r;
10903     suppress_error = 0;
10904     r = guestfs_blockdev_setrw (g, device);
10905     if (r == -1)
10906       return -1;
10907   }
10908   {
10909     int r;
10910     suppress_error = 0;
10911     r = guestfs_umount_all (g);
10912     if (r == -1)
10913       return -1;
10914   }
10915   {
10916     int r;
10917     suppress_error = 0;
10918     r = guestfs_lvm_remove_all (g);
10919     if (r == -1)
10920       return -1;
10921   }
10922   {
10923     char device[] = "/dev/sda";
10924     device[5] = devchar;
10925     char lines_0[] = ",";
10926     char *lines[] = {
10927       lines_0,
10928       NULL
10929     };
10930     int r;
10931     suppress_error = 0;
10932     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10933     if (r == -1)
10934       return -1;
10935   }
10936   {
10937     char fstype[] = "ext2";
10938     char device[] = "/dev/sda1";
10939     device[5] = devchar;
10940     int r;
10941     suppress_error = 0;
10942     r = guestfs_mkfs (g, fstype, device);
10943     if (r == -1)
10944       return -1;
10945   }
10946   {
10947     char device[] = "/dev/sda1";
10948     device[5] = devchar;
10949     char mountpoint[] = "/";
10950     int r;
10951     suppress_error = 0;
10952     r = guestfs_mount (g, device, mountpoint);
10953     if (r == -1)
10954       return -1;
10955   }
10956   /* TestOutputTrue for mkdir_p (0) */
10957   {
10958     char path[] = "/new/foo/bar";
10959     int r;
10960     suppress_error = 0;
10961     r = guestfs_mkdir_p (g, path);
10962     if (r == -1)
10963       return -1;
10964   }
10965   {
10966     char path[] = "/new/foo/bar";
10967     int r;
10968     suppress_error = 0;
10969     r = guestfs_is_dir (g, path);
10970     if (r == -1)
10971       return -1;
10972     if (!r) {
10973       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10974       return -1;
10975     }
10976   }
10977   return 0;
10978 }
10979
10980 static int test_mkdir_p_1 (void)
10981 {
10982   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
10983   {
10984     char device[] = "/dev/sda";
10985     device[5] = devchar;
10986     int r;
10987     suppress_error = 0;
10988     r = guestfs_blockdev_setrw (g, device);
10989     if (r == -1)
10990       return -1;
10991   }
10992   {
10993     int r;
10994     suppress_error = 0;
10995     r = guestfs_umount_all (g);
10996     if (r == -1)
10997       return -1;
10998   }
10999   {
11000     int r;
11001     suppress_error = 0;
11002     r = guestfs_lvm_remove_all (g);
11003     if (r == -1)
11004       return -1;
11005   }
11006   {
11007     char device[] = "/dev/sda";
11008     device[5] = devchar;
11009     char lines_0[] = ",";
11010     char *lines[] = {
11011       lines_0,
11012       NULL
11013     };
11014     int r;
11015     suppress_error = 0;
11016     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11017     if (r == -1)
11018       return -1;
11019   }
11020   {
11021     char fstype[] = "ext2";
11022     char device[] = "/dev/sda1";
11023     device[5] = devchar;
11024     int r;
11025     suppress_error = 0;
11026     r = guestfs_mkfs (g, fstype, device);
11027     if (r == -1)
11028       return -1;
11029   }
11030   {
11031     char device[] = "/dev/sda1";
11032     device[5] = devchar;
11033     char mountpoint[] = "/";
11034     int r;
11035     suppress_error = 0;
11036     r = guestfs_mount (g, device, mountpoint);
11037     if (r == -1)
11038       return -1;
11039   }
11040   /* TestOutputTrue for mkdir_p (1) */
11041   {
11042     char path[] = "/new/foo/bar";
11043     int r;
11044     suppress_error = 0;
11045     r = guestfs_mkdir_p (g, path);
11046     if (r == -1)
11047       return -1;
11048   }
11049   {
11050     char path[] = "/new/foo";
11051     int r;
11052     suppress_error = 0;
11053     r = guestfs_is_dir (g, path);
11054     if (r == -1)
11055       return -1;
11056     if (!r) {
11057       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
11058       return -1;
11059     }
11060   }
11061   return 0;
11062 }
11063
11064 static int test_mkdir_p_2 (void)
11065 {
11066   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
11067   {
11068     char device[] = "/dev/sda";
11069     device[5] = devchar;
11070     int r;
11071     suppress_error = 0;
11072     r = guestfs_blockdev_setrw (g, device);
11073     if (r == -1)
11074       return -1;
11075   }
11076   {
11077     int r;
11078     suppress_error = 0;
11079     r = guestfs_umount_all (g);
11080     if (r == -1)
11081       return -1;
11082   }
11083   {
11084     int r;
11085     suppress_error = 0;
11086     r = guestfs_lvm_remove_all (g);
11087     if (r == -1)
11088       return -1;
11089   }
11090   {
11091     char device[] = "/dev/sda";
11092     device[5] = devchar;
11093     char lines_0[] = ",";
11094     char *lines[] = {
11095       lines_0,
11096       NULL
11097     };
11098     int r;
11099     suppress_error = 0;
11100     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11101     if (r == -1)
11102       return -1;
11103   }
11104   {
11105     char fstype[] = "ext2";
11106     char device[] = "/dev/sda1";
11107     device[5] = devchar;
11108     int r;
11109     suppress_error = 0;
11110     r = guestfs_mkfs (g, fstype, device);
11111     if (r == -1)
11112       return -1;
11113   }
11114   {
11115     char device[] = "/dev/sda1";
11116     device[5] = devchar;
11117     char mountpoint[] = "/";
11118     int r;
11119     suppress_error = 0;
11120     r = guestfs_mount (g, device, mountpoint);
11121     if (r == -1)
11122       return -1;
11123   }
11124   /* TestOutputTrue for mkdir_p (2) */
11125   {
11126     char path[] = "/new/foo/bar";
11127     int r;
11128     suppress_error = 0;
11129     r = guestfs_mkdir_p (g, path);
11130     if (r == -1)
11131       return -1;
11132   }
11133   {
11134     char path[] = "/new";
11135     int r;
11136     suppress_error = 0;
11137     r = guestfs_is_dir (g, path);
11138     if (r == -1)
11139       return -1;
11140     if (!r) {
11141       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
11142       return -1;
11143     }
11144   }
11145   return 0;
11146 }
11147
11148 static int test_mkdir_0 (void)
11149 {
11150   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
11151   {
11152     char device[] = "/dev/sda";
11153     device[5] = devchar;
11154     int r;
11155     suppress_error = 0;
11156     r = guestfs_blockdev_setrw (g, device);
11157     if (r == -1)
11158       return -1;
11159   }
11160   {
11161     int r;
11162     suppress_error = 0;
11163     r = guestfs_umount_all (g);
11164     if (r == -1)
11165       return -1;
11166   }
11167   {
11168     int r;
11169     suppress_error = 0;
11170     r = guestfs_lvm_remove_all (g);
11171     if (r == -1)
11172       return -1;
11173   }
11174   {
11175     char device[] = "/dev/sda";
11176     device[5] = devchar;
11177     char lines_0[] = ",";
11178     char *lines[] = {
11179       lines_0,
11180       NULL
11181     };
11182     int r;
11183     suppress_error = 0;
11184     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11185     if (r == -1)
11186       return -1;
11187   }
11188   {
11189     char fstype[] = "ext2";
11190     char device[] = "/dev/sda1";
11191     device[5] = devchar;
11192     int r;
11193     suppress_error = 0;
11194     r = guestfs_mkfs (g, fstype, device);
11195     if (r == -1)
11196       return -1;
11197   }
11198   {
11199     char device[] = "/dev/sda1";
11200     device[5] = devchar;
11201     char mountpoint[] = "/";
11202     int r;
11203     suppress_error = 0;
11204     r = guestfs_mount (g, device, mountpoint);
11205     if (r == -1)
11206       return -1;
11207   }
11208   /* TestOutputTrue for mkdir (0) */
11209   {
11210     char path[] = "/new";
11211     int r;
11212     suppress_error = 0;
11213     r = guestfs_mkdir (g, path);
11214     if (r == -1)
11215       return -1;
11216   }
11217   {
11218     char path[] = "/new";
11219     int r;
11220     suppress_error = 0;
11221     r = guestfs_is_dir (g, path);
11222     if (r == -1)
11223       return -1;
11224     if (!r) {
11225       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
11226       return -1;
11227     }
11228   }
11229   return 0;
11230 }
11231
11232 static int test_mkdir_1 (void)
11233 {
11234   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
11235   {
11236     char device[] = "/dev/sda";
11237     device[5] = devchar;
11238     int r;
11239     suppress_error = 0;
11240     r = guestfs_blockdev_setrw (g, device);
11241     if (r == -1)
11242       return -1;
11243   }
11244   {
11245     int r;
11246     suppress_error = 0;
11247     r = guestfs_umount_all (g);
11248     if (r == -1)
11249       return -1;
11250   }
11251   {
11252     int r;
11253     suppress_error = 0;
11254     r = guestfs_lvm_remove_all (g);
11255     if (r == -1)
11256       return -1;
11257   }
11258   {
11259     char device[] = "/dev/sda";
11260     device[5] = devchar;
11261     char lines_0[] = ",";
11262     char *lines[] = {
11263       lines_0,
11264       NULL
11265     };
11266     int r;
11267     suppress_error = 0;
11268     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11269     if (r == -1)
11270       return -1;
11271   }
11272   {
11273     char fstype[] = "ext2";
11274     char device[] = "/dev/sda1";
11275     device[5] = devchar;
11276     int r;
11277     suppress_error = 0;
11278     r = guestfs_mkfs (g, fstype, device);
11279     if (r == -1)
11280       return -1;
11281   }
11282   {
11283     char device[] = "/dev/sda1";
11284     device[5] = devchar;
11285     char mountpoint[] = "/";
11286     int r;
11287     suppress_error = 0;
11288     r = guestfs_mount (g, device, mountpoint);
11289     if (r == -1)
11290       return -1;
11291   }
11292   /* TestLastFail for mkdir (1) */
11293   {
11294     char path[] = "/new/foo/bar";
11295     int r;
11296     suppress_error = 1;
11297     r = guestfs_mkdir (g, path);
11298     if (r != -1)
11299       return -1;
11300   }
11301   return 0;
11302 }
11303
11304 static int test_rm_rf_0 (void)
11305 {
11306   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
11307   {
11308     char device[] = "/dev/sda";
11309     device[5] = devchar;
11310     int r;
11311     suppress_error = 0;
11312     r = guestfs_blockdev_setrw (g, device);
11313     if (r == -1)
11314       return -1;
11315   }
11316   {
11317     int r;
11318     suppress_error = 0;
11319     r = guestfs_umount_all (g);
11320     if (r == -1)
11321       return -1;
11322   }
11323   {
11324     int r;
11325     suppress_error = 0;
11326     r = guestfs_lvm_remove_all (g);
11327     if (r == -1)
11328       return -1;
11329   }
11330   {
11331     char device[] = "/dev/sda";
11332     device[5] = devchar;
11333     char lines_0[] = ",";
11334     char *lines[] = {
11335       lines_0,
11336       NULL
11337     };
11338     int r;
11339     suppress_error = 0;
11340     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11341     if (r == -1)
11342       return -1;
11343   }
11344   {
11345     char fstype[] = "ext2";
11346     char device[] = "/dev/sda1";
11347     device[5] = devchar;
11348     int r;
11349     suppress_error = 0;
11350     r = guestfs_mkfs (g, fstype, device);
11351     if (r == -1)
11352       return -1;
11353   }
11354   {
11355     char device[] = "/dev/sda1";
11356     device[5] = devchar;
11357     char mountpoint[] = "/";
11358     int r;
11359     suppress_error = 0;
11360     r = guestfs_mount (g, device, mountpoint);
11361     if (r == -1)
11362       return -1;
11363   }
11364   /* TestOutputFalse for rm_rf (0) */
11365   {
11366     char path[] = "/new";
11367     int r;
11368     suppress_error = 0;
11369     r = guestfs_mkdir (g, path);
11370     if (r == -1)
11371       return -1;
11372   }
11373   {
11374     char path[] = "/new/foo";
11375     int r;
11376     suppress_error = 0;
11377     r = guestfs_mkdir (g, path);
11378     if (r == -1)
11379       return -1;
11380   }
11381   {
11382     char path[] = "/new/foo/bar";
11383     int r;
11384     suppress_error = 0;
11385     r = guestfs_touch (g, path);
11386     if (r == -1)
11387       return -1;
11388   }
11389   {
11390     char path[] = "/new";
11391     int r;
11392     suppress_error = 0;
11393     r = guestfs_rm_rf (g, path);
11394     if (r == -1)
11395       return -1;
11396   }
11397   {
11398     char path[] = "/new";
11399     int r;
11400     suppress_error = 0;
11401     r = guestfs_exists (g, path);
11402     if (r == -1)
11403       return -1;
11404     if (r) {
11405       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
11406       return -1;
11407     }
11408   }
11409   return 0;
11410 }
11411
11412 static int test_rmdir_0 (void)
11413 {
11414   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
11415   {
11416     char device[] = "/dev/sda";
11417     device[5] = devchar;
11418     int r;
11419     suppress_error = 0;
11420     r = guestfs_blockdev_setrw (g, device);
11421     if (r == -1)
11422       return -1;
11423   }
11424   {
11425     int r;
11426     suppress_error = 0;
11427     r = guestfs_umount_all (g);
11428     if (r == -1)
11429       return -1;
11430   }
11431   {
11432     int r;
11433     suppress_error = 0;
11434     r = guestfs_lvm_remove_all (g);
11435     if (r == -1)
11436       return -1;
11437   }
11438   {
11439     char device[] = "/dev/sda";
11440     device[5] = devchar;
11441     char lines_0[] = ",";
11442     char *lines[] = {
11443       lines_0,
11444       NULL
11445     };
11446     int r;
11447     suppress_error = 0;
11448     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11449     if (r == -1)
11450       return -1;
11451   }
11452   {
11453     char fstype[] = "ext2";
11454     char device[] = "/dev/sda1";
11455     device[5] = devchar;
11456     int r;
11457     suppress_error = 0;
11458     r = guestfs_mkfs (g, fstype, device);
11459     if (r == -1)
11460       return -1;
11461   }
11462   {
11463     char device[] = "/dev/sda1";
11464     device[5] = devchar;
11465     char mountpoint[] = "/";
11466     int r;
11467     suppress_error = 0;
11468     r = guestfs_mount (g, device, mountpoint);
11469     if (r == -1)
11470       return -1;
11471   }
11472   /* TestRun for rmdir (0) */
11473   {
11474     char path[] = "/new";
11475     int r;
11476     suppress_error = 0;
11477     r = guestfs_mkdir (g, path);
11478     if (r == -1)
11479       return -1;
11480   }
11481   {
11482     char path[] = "/new";
11483     int r;
11484     suppress_error = 0;
11485     r = guestfs_rmdir (g, path);
11486     if (r == -1)
11487       return -1;
11488   }
11489   return 0;
11490 }
11491
11492 static int test_rmdir_1 (void)
11493 {
11494   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
11495   {
11496     char device[] = "/dev/sda";
11497     device[5] = devchar;
11498     int r;
11499     suppress_error = 0;
11500     r = guestfs_blockdev_setrw (g, device);
11501     if (r == -1)
11502       return -1;
11503   }
11504   {
11505     int r;
11506     suppress_error = 0;
11507     r = guestfs_umount_all (g);
11508     if (r == -1)
11509       return -1;
11510   }
11511   {
11512     int r;
11513     suppress_error = 0;
11514     r = guestfs_lvm_remove_all (g);
11515     if (r == -1)
11516       return -1;
11517   }
11518   {
11519     char device[] = "/dev/sda";
11520     device[5] = devchar;
11521     char lines_0[] = ",";
11522     char *lines[] = {
11523       lines_0,
11524       NULL
11525     };
11526     int r;
11527     suppress_error = 0;
11528     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11529     if (r == -1)
11530       return -1;
11531   }
11532   {
11533     char fstype[] = "ext2";
11534     char device[] = "/dev/sda1";
11535     device[5] = devchar;
11536     int r;
11537     suppress_error = 0;
11538     r = guestfs_mkfs (g, fstype, device);
11539     if (r == -1)
11540       return -1;
11541   }
11542   {
11543     char device[] = "/dev/sda1";
11544     device[5] = devchar;
11545     char mountpoint[] = "/";
11546     int r;
11547     suppress_error = 0;
11548     r = guestfs_mount (g, device, mountpoint);
11549     if (r == -1)
11550       return -1;
11551   }
11552   /* TestLastFail for rmdir (1) */
11553   {
11554     char path[] = "/new";
11555     int r;
11556     suppress_error = 1;
11557     r = guestfs_rmdir (g, path);
11558     if (r != -1)
11559       return -1;
11560   }
11561   return 0;
11562 }
11563
11564 static int test_rmdir_2 (void)
11565 {
11566   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
11567   {
11568     char device[] = "/dev/sda";
11569     device[5] = devchar;
11570     int r;
11571     suppress_error = 0;
11572     r = guestfs_blockdev_setrw (g, device);
11573     if (r == -1)
11574       return -1;
11575   }
11576   {
11577     int r;
11578     suppress_error = 0;
11579     r = guestfs_umount_all (g);
11580     if (r == -1)
11581       return -1;
11582   }
11583   {
11584     int r;
11585     suppress_error = 0;
11586     r = guestfs_lvm_remove_all (g);
11587     if (r == -1)
11588       return -1;
11589   }
11590   {
11591     char device[] = "/dev/sda";
11592     device[5] = devchar;
11593     char lines_0[] = ",";
11594     char *lines[] = {
11595       lines_0,
11596       NULL
11597     };
11598     int r;
11599     suppress_error = 0;
11600     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11601     if (r == -1)
11602       return -1;
11603   }
11604   {
11605     char fstype[] = "ext2";
11606     char device[] = "/dev/sda1";
11607     device[5] = devchar;
11608     int r;
11609     suppress_error = 0;
11610     r = guestfs_mkfs (g, fstype, device);
11611     if (r == -1)
11612       return -1;
11613   }
11614   {
11615     char device[] = "/dev/sda1";
11616     device[5] = devchar;
11617     char mountpoint[] = "/";
11618     int r;
11619     suppress_error = 0;
11620     r = guestfs_mount (g, device, mountpoint);
11621     if (r == -1)
11622       return -1;
11623   }
11624   /* TestLastFail for rmdir (2) */
11625   {
11626     char path[] = "/new";
11627     int r;
11628     suppress_error = 0;
11629     r = guestfs_touch (g, path);
11630     if (r == -1)
11631       return -1;
11632   }
11633   {
11634     char path[] = "/new";
11635     int r;
11636     suppress_error = 1;
11637     r = guestfs_rmdir (g, path);
11638     if (r != -1)
11639       return -1;
11640   }
11641   return 0;
11642 }
11643
11644 static int test_rm_0 (void)
11645 {
11646   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
11647   {
11648     char device[] = "/dev/sda";
11649     device[5] = devchar;
11650     int r;
11651     suppress_error = 0;
11652     r = guestfs_blockdev_setrw (g, device);
11653     if (r == -1)
11654       return -1;
11655   }
11656   {
11657     int r;
11658     suppress_error = 0;
11659     r = guestfs_umount_all (g);
11660     if (r == -1)
11661       return -1;
11662   }
11663   {
11664     int r;
11665     suppress_error = 0;
11666     r = guestfs_lvm_remove_all (g);
11667     if (r == -1)
11668       return -1;
11669   }
11670   {
11671     char device[] = "/dev/sda";
11672     device[5] = devchar;
11673     char lines_0[] = ",";
11674     char *lines[] = {
11675       lines_0,
11676       NULL
11677     };
11678     int r;
11679     suppress_error = 0;
11680     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11681     if (r == -1)
11682       return -1;
11683   }
11684   {
11685     char fstype[] = "ext2";
11686     char device[] = "/dev/sda1";
11687     device[5] = devchar;
11688     int r;
11689     suppress_error = 0;
11690     r = guestfs_mkfs (g, fstype, device);
11691     if (r == -1)
11692       return -1;
11693   }
11694   {
11695     char device[] = "/dev/sda1";
11696     device[5] = devchar;
11697     char mountpoint[] = "/";
11698     int r;
11699     suppress_error = 0;
11700     r = guestfs_mount (g, device, mountpoint);
11701     if (r == -1)
11702       return -1;
11703   }
11704   /* TestRun for rm (0) */
11705   {
11706     char path[] = "/new";
11707     int r;
11708     suppress_error = 0;
11709     r = guestfs_touch (g, path);
11710     if (r == -1)
11711       return -1;
11712   }
11713   {
11714     char path[] = "/new";
11715     int r;
11716     suppress_error = 0;
11717     r = guestfs_rm (g, path);
11718     if (r == -1)
11719       return -1;
11720   }
11721   return 0;
11722 }
11723
11724 static int test_rm_1 (void)
11725 {
11726   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
11727   {
11728     char device[] = "/dev/sda";
11729     device[5] = devchar;
11730     int r;
11731     suppress_error = 0;
11732     r = guestfs_blockdev_setrw (g, device);
11733     if (r == -1)
11734       return -1;
11735   }
11736   {
11737     int r;
11738     suppress_error = 0;
11739     r = guestfs_umount_all (g);
11740     if (r == -1)
11741       return -1;
11742   }
11743   {
11744     int r;
11745     suppress_error = 0;
11746     r = guestfs_lvm_remove_all (g);
11747     if (r == -1)
11748       return -1;
11749   }
11750   {
11751     char device[] = "/dev/sda";
11752     device[5] = devchar;
11753     char lines_0[] = ",";
11754     char *lines[] = {
11755       lines_0,
11756       NULL
11757     };
11758     int r;
11759     suppress_error = 0;
11760     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11761     if (r == -1)
11762       return -1;
11763   }
11764   {
11765     char fstype[] = "ext2";
11766     char device[] = "/dev/sda1";
11767     device[5] = devchar;
11768     int r;
11769     suppress_error = 0;
11770     r = guestfs_mkfs (g, fstype, device);
11771     if (r == -1)
11772       return -1;
11773   }
11774   {
11775     char device[] = "/dev/sda1";
11776     device[5] = devchar;
11777     char mountpoint[] = "/";
11778     int r;
11779     suppress_error = 0;
11780     r = guestfs_mount (g, device, mountpoint);
11781     if (r == -1)
11782       return -1;
11783   }
11784   /* TestLastFail for rm (1) */
11785   {
11786     char path[] = "/new";
11787     int r;
11788     suppress_error = 1;
11789     r = guestfs_rm (g, path);
11790     if (r != -1)
11791       return -1;
11792   }
11793   return 0;
11794 }
11795
11796 static int test_rm_2 (void)
11797 {
11798   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
11799   {
11800     char device[] = "/dev/sda";
11801     device[5] = devchar;
11802     int r;
11803     suppress_error = 0;
11804     r = guestfs_blockdev_setrw (g, device);
11805     if (r == -1)
11806       return -1;
11807   }
11808   {
11809     int r;
11810     suppress_error = 0;
11811     r = guestfs_umount_all (g);
11812     if (r == -1)
11813       return -1;
11814   }
11815   {
11816     int r;
11817     suppress_error = 0;
11818     r = guestfs_lvm_remove_all (g);
11819     if (r == -1)
11820       return -1;
11821   }
11822   {
11823     char device[] = "/dev/sda";
11824     device[5] = devchar;
11825     char lines_0[] = ",";
11826     char *lines[] = {
11827       lines_0,
11828       NULL
11829     };
11830     int r;
11831     suppress_error = 0;
11832     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11833     if (r == -1)
11834       return -1;
11835   }
11836   {
11837     char fstype[] = "ext2";
11838     char device[] = "/dev/sda1";
11839     device[5] = devchar;
11840     int r;
11841     suppress_error = 0;
11842     r = guestfs_mkfs (g, fstype, device);
11843     if (r == -1)
11844       return -1;
11845   }
11846   {
11847     char device[] = "/dev/sda1";
11848     device[5] = devchar;
11849     char mountpoint[] = "/";
11850     int r;
11851     suppress_error = 0;
11852     r = guestfs_mount (g, device, mountpoint);
11853     if (r == -1)
11854       return -1;
11855   }
11856   /* TestLastFail for rm (2) */
11857   {
11858     char path[] = "/new";
11859     int r;
11860     suppress_error = 0;
11861     r = guestfs_mkdir (g, path);
11862     if (r == -1)
11863       return -1;
11864   }
11865   {
11866     char path[] = "/new";
11867     int r;
11868     suppress_error = 1;
11869     r = guestfs_rm (g, path);
11870     if (r != -1)
11871       return -1;
11872   }
11873   return 0;
11874 }
11875
11876 static int test_read_lines_0 (void)
11877 {
11878   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
11879   {
11880     char device[] = "/dev/sda";
11881     device[5] = devchar;
11882     int r;
11883     suppress_error = 0;
11884     r = guestfs_blockdev_setrw (g, device);
11885     if (r == -1)
11886       return -1;
11887   }
11888   {
11889     int r;
11890     suppress_error = 0;
11891     r = guestfs_umount_all (g);
11892     if (r == -1)
11893       return -1;
11894   }
11895   {
11896     int r;
11897     suppress_error = 0;
11898     r = guestfs_lvm_remove_all (g);
11899     if (r == -1)
11900       return -1;
11901   }
11902   {
11903     char device[] = "/dev/sda";
11904     device[5] = devchar;
11905     char lines_0[] = ",";
11906     char *lines[] = {
11907       lines_0,
11908       NULL
11909     };
11910     int r;
11911     suppress_error = 0;
11912     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11913     if (r == -1)
11914       return -1;
11915   }
11916   {
11917     char fstype[] = "ext2";
11918     char device[] = "/dev/sda1";
11919     device[5] = devchar;
11920     int r;
11921     suppress_error = 0;
11922     r = guestfs_mkfs (g, fstype, device);
11923     if (r == -1)
11924       return -1;
11925   }
11926   {
11927     char device[] = "/dev/sda1";
11928     device[5] = devchar;
11929     char mountpoint[] = "/";
11930     int r;
11931     suppress_error = 0;
11932     r = guestfs_mount (g, device, mountpoint);
11933     if (r == -1)
11934       return -1;
11935   }
11936   /* TestOutputList for read_lines (0) */
11937   {
11938     char path[] = "/new";
11939     char content[] = "line1\r\nline2\nline3";
11940     int r;
11941     suppress_error = 0;
11942     r = guestfs_write_file (g, path, content, 0);
11943     if (r == -1)
11944       return -1;
11945   }
11946   {
11947     char path[] = "/new";
11948     char **r;
11949     int i;
11950     suppress_error = 0;
11951     r = guestfs_read_lines (g, path);
11952     if (r == NULL)
11953       return -1;
11954     if (!r[0]) {
11955       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11956       print_strings (r);
11957       return -1;
11958     }
11959     {
11960       char expected[] = "line1";
11961       if (strcmp (r[0], expected) != 0) {
11962         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11963         return -1;
11964       }
11965     }
11966     if (!r[1]) {
11967       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11968       print_strings (r);
11969       return -1;
11970     }
11971     {
11972       char expected[] = "line2";
11973       if (strcmp (r[1], expected) != 0) {
11974         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11975         return -1;
11976       }
11977     }
11978     if (!r[2]) {
11979       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11980       print_strings (r);
11981       return -1;
11982     }
11983     {
11984       char expected[] = "line3";
11985       if (strcmp (r[2], expected) != 0) {
11986         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11987         return -1;
11988       }
11989     }
11990     if (r[3] != NULL) {
11991       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11992       print_strings (r);
11993       return -1;
11994     }
11995     for (i = 0; r[i] != NULL; ++i)
11996       free (r[i]);
11997     free (r);
11998   }
11999   return 0;
12000 }
12001
12002 static int test_read_lines_1 (void)
12003 {
12004   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
12005   {
12006     char device[] = "/dev/sda";
12007     device[5] = devchar;
12008     int r;
12009     suppress_error = 0;
12010     r = guestfs_blockdev_setrw (g, device);
12011     if (r == -1)
12012       return -1;
12013   }
12014   {
12015     int r;
12016     suppress_error = 0;
12017     r = guestfs_umount_all (g);
12018     if (r == -1)
12019       return -1;
12020   }
12021   {
12022     int r;
12023     suppress_error = 0;
12024     r = guestfs_lvm_remove_all (g);
12025     if (r == -1)
12026       return -1;
12027   }
12028   {
12029     char device[] = "/dev/sda";
12030     device[5] = devchar;
12031     char lines_0[] = ",";
12032     char *lines[] = {
12033       lines_0,
12034       NULL
12035     };
12036     int r;
12037     suppress_error = 0;
12038     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12039     if (r == -1)
12040       return -1;
12041   }
12042   {
12043     char fstype[] = "ext2";
12044     char device[] = "/dev/sda1";
12045     device[5] = devchar;
12046     int r;
12047     suppress_error = 0;
12048     r = guestfs_mkfs (g, fstype, device);
12049     if (r == -1)
12050       return -1;
12051   }
12052   {
12053     char device[] = "/dev/sda1";
12054     device[5] = devchar;
12055     char mountpoint[] = "/";
12056     int r;
12057     suppress_error = 0;
12058     r = guestfs_mount (g, device, mountpoint);
12059     if (r == -1)
12060       return -1;
12061   }
12062   /* TestOutputList for read_lines (1) */
12063   {
12064     char path[] = "/new";
12065     char content[] = "";
12066     int r;
12067     suppress_error = 0;
12068     r = guestfs_write_file (g, path, content, 0);
12069     if (r == -1)
12070       return -1;
12071   }
12072   {
12073     char path[] = "/new";
12074     char **r;
12075     int i;
12076     suppress_error = 0;
12077     r = guestfs_read_lines (g, path);
12078     if (r == NULL)
12079       return -1;
12080     if (r[0] != NULL) {
12081       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
12082       print_strings (r);
12083       return -1;
12084     }
12085     for (i = 0; r[i] != NULL; ++i)
12086       free (r[i]);
12087     free (r);
12088   }
12089   return 0;
12090 }
12091
12092 static int test_lvs_0 (void)
12093 {
12094   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
12095   {
12096     char device[] = "/dev/sda";
12097     device[5] = devchar;
12098     int r;
12099     suppress_error = 0;
12100     r = guestfs_blockdev_setrw (g, device);
12101     if (r == -1)
12102       return -1;
12103   }
12104   {
12105     int r;
12106     suppress_error = 0;
12107     r = guestfs_umount_all (g);
12108     if (r == -1)
12109       return -1;
12110   }
12111   {
12112     int r;
12113     suppress_error = 0;
12114     r = guestfs_lvm_remove_all (g);
12115     if (r == -1)
12116       return -1;
12117   }
12118   {
12119     char device[] = "/dev/sda";
12120     device[5] = devchar;
12121     char lines_0[] = ",";
12122     char *lines[] = {
12123       lines_0,
12124       NULL
12125     };
12126     int r;
12127     suppress_error = 0;
12128     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12129     if (r == -1)
12130       return -1;
12131   }
12132   {
12133     char device[] = "/dev/sda1";
12134     device[5] = devchar;
12135     int r;
12136     suppress_error = 0;
12137     r = guestfs_pvcreate (g, device);
12138     if (r == -1)
12139       return -1;
12140   }
12141   {
12142     char volgroup[] = "VG";
12143     char physvols_0[] = "/dev/sda1";
12144     physvols_0[5] = devchar;
12145     char *physvols[] = {
12146       physvols_0,
12147       NULL
12148     };
12149     int r;
12150     suppress_error = 0;
12151     r = guestfs_vgcreate (g, volgroup, physvols);
12152     if (r == -1)
12153       return -1;
12154   }
12155   {
12156     char logvol[] = "LV";
12157     char volgroup[] = "VG";
12158     int r;
12159     suppress_error = 0;
12160     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12161     if (r == -1)
12162       return -1;
12163   }
12164   {
12165     char fstype[] = "ext2";
12166     char device[] = "/dev/VG/LV";
12167     int r;
12168     suppress_error = 0;
12169     r = guestfs_mkfs (g, fstype, device);
12170     if (r == -1)
12171       return -1;
12172   }
12173   {
12174     char device[] = "/dev/VG/LV";
12175     char mountpoint[] = "/";
12176     int r;
12177     suppress_error = 0;
12178     r = guestfs_mount (g, device, mountpoint);
12179     if (r == -1)
12180       return -1;
12181   }
12182   /* TestOutputList for lvs (0) */
12183   {
12184     char **r;
12185     int i;
12186     suppress_error = 0;
12187     r = guestfs_lvs (g);
12188     if (r == NULL)
12189       return -1;
12190     if (!r[0]) {
12191       fprintf (stderr, "test_lvs_0: short list returned from command\n");
12192       print_strings (r);
12193       return -1;
12194     }
12195     {
12196       char expected[] = "/dev/VG/LV";
12197       if (strcmp (r[0], expected) != 0) {
12198         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12199         return -1;
12200       }
12201     }
12202     if (r[1] != NULL) {
12203       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
12204       print_strings (r);
12205       return -1;
12206     }
12207     for (i = 0; r[i] != NULL; ++i)
12208       free (r[i]);
12209     free (r);
12210   }
12211   return 0;
12212 }
12213
12214 static int test_lvs_1 (void)
12215 {
12216   /* InitNone|InitEmpty for test_lvs_1 */
12217   {
12218     char device[] = "/dev/sda";
12219     device[5] = devchar;
12220     int r;
12221     suppress_error = 0;
12222     r = guestfs_blockdev_setrw (g, device);
12223     if (r == -1)
12224       return -1;
12225   }
12226   {
12227     int r;
12228     suppress_error = 0;
12229     r = guestfs_umount_all (g);
12230     if (r == -1)
12231       return -1;
12232   }
12233   {
12234     int r;
12235     suppress_error = 0;
12236     r = guestfs_lvm_remove_all (g);
12237     if (r == -1)
12238       return -1;
12239   }
12240   /* TestOutputList for lvs (1) */
12241   {
12242     char device[] = "/dev/sda";
12243     device[5] = devchar;
12244     char lines_0[] = ",10";
12245     char lines_1[] = ",20";
12246     char lines_2[] = ",";
12247     char *lines[] = {
12248       lines_0,
12249       lines_1,
12250       lines_2,
12251       NULL
12252     };
12253     int r;
12254     suppress_error = 0;
12255     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12256     if (r == -1)
12257       return -1;
12258   }
12259   {
12260     char device[] = "/dev/sda1";
12261     device[5] = devchar;
12262     int r;
12263     suppress_error = 0;
12264     r = guestfs_pvcreate (g, device);
12265     if (r == -1)
12266       return -1;
12267   }
12268   {
12269     char device[] = "/dev/sda2";
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/sda3";
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 volgroup[] = "VG1";
12288     char physvols_0[] = "/dev/sda1";
12289     physvols_0[5] = devchar;
12290     char physvols_1[] = "/dev/sda2";
12291     physvols_1[5] = devchar;
12292     char *physvols[] = {
12293       physvols_0,
12294       physvols_1,
12295       NULL
12296     };
12297     int r;
12298     suppress_error = 0;
12299     r = guestfs_vgcreate (g, volgroup, physvols);
12300     if (r == -1)
12301       return -1;
12302   }
12303   {
12304     char volgroup[] = "VG2";
12305     char physvols_0[] = "/dev/sda3";
12306     physvols_0[5] = devchar;
12307     char *physvols[] = {
12308       physvols_0,
12309       NULL
12310     };
12311     int r;
12312     suppress_error = 0;
12313     r = guestfs_vgcreate (g, volgroup, physvols);
12314     if (r == -1)
12315       return -1;
12316   }
12317   {
12318     char logvol[] = "LV1";
12319     char volgroup[] = "VG1";
12320     int r;
12321     suppress_error = 0;
12322     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12323     if (r == -1)
12324       return -1;
12325   }
12326   {
12327     char logvol[] = "LV2";
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[] = "LV3";
12337     char volgroup[] = "VG2";
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 **r;
12346     int i;
12347     suppress_error = 0;
12348     r = guestfs_lvs (g);
12349     if (r == NULL)
12350       return -1;
12351     if (!r[0]) {
12352       fprintf (stderr, "test_lvs_1: short list returned from command\n");
12353       print_strings (r);
12354       return -1;
12355     }
12356     {
12357       char expected[] = "/dev/VG1/LV1";
12358       if (strcmp (r[0], expected) != 0) {
12359         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12360         return -1;
12361       }
12362     }
12363     if (!r[1]) {
12364       fprintf (stderr, "test_lvs_1: short list returned from command\n");
12365       print_strings (r);
12366       return -1;
12367     }
12368     {
12369       char expected[] = "/dev/VG1/LV2";
12370       if (strcmp (r[1], expected) != 0) {
12371         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12372         return -1;
12373       }
12374     }
12375     if (!r[2]) {
12376       fprintf (stderr, "test_lvs_1: short list returned from command\n");
12377       print_strings (r);
12378       return -1;
12379     }
12380     {
12381       char expected[] = "/dev/VG2/LV3";
12382       if (strcmp (r[2], expected) != 0) {
12383         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12384         return -1;
12385       }
12386     }
12387     if (r[3] != NULL) {
12388       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
12389       print_strings (r);
12390       return -1;
12391     }
12392     for (i = 0; r[i] != NULL; ++i)
12393       free (r[i]);
12394     free (r);
12395   }
12396   return 0;
12397 }
12398
12399 static int test_vgs_0 (void)
12400 {
12401   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
12402   {
12403     char device[] = "/dev/sda";
12404     device[5] = devchar;
12405     int r;
12406     suppress_error = 0;
12407     r = guestfs_blockdev_setrw (g, device);
12408     if (r == -1)
12409       return -1;
12410   }
12411   {
12412     int r;
12413     suppress_error = 0;
12414     r = guestfs_umount_all (g);
12415     if (r == -1)
12416       return -1;
12417   }
12418   {
12419     int r;
12420     suppress_error = 0;
12421     r = guestfs_lvm_remove_all (g);
12422     if (r == -1)
12423       return -1;
12424   }
12425   {
12426     char device[] = "/dev/sda";
12427     device[5] = devchar;
12428     char lines_0[] = ",";
12429     char *lines[] = {
12430       lines_0,
12431       NULL
12432     };
12433     int r;
12434     suppress_error = 0;
12435     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12436     if (r == -1)
12437       return -1;
12438   }
12439   {
12440     char device[] = "/dev/sda1";
12441     device[5] = devchar;
12442     int r;
12443     suppress_error = 0;
12444     r = guestfs_pvcreate (g, device);
12445     if (r == -1)
12446       return -1;
12447   }
12448   {
12449     char volgroup[] = "VG";
12450     char physvols_0[] = "/dev/sda1";
12451     physvols_0[5] = devchar;
12452     char *physvols[] = {
12453       physvols_0,
12454       NULL
12455     };
12456     int r;
12457     suppress_error = 0;
12458     r = guestfs_vgcreate (g, volgroup, physvols);
12459     if (r == -1)
12460       return -1;
12461   }
12462   {
12463     char logvol[] = "LV";
12464     char volgroup[] = "VG";
12465     int r;
12466     suppress_error = 0;
12467     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12468     if (r == -1)
12469       return -1;
12470   }
12471   {
12472     char fstype[] = "ext2";
12473     char device[] = "/dev/VG/LV";
12474     int r;
12475     suppress_error = 0;
12476     r = guestfs_mkfs (g, fstype, device);
12477     if (r == -1)
12478       return -1;
12479   }
12480   {
12481     char device[] = "/dev/VG/LV";
12482     char mountpoint[] = "/";
12483     int r;
12484     suppress_error = 0;
12485     r = guestfs_mount (g, device, mountpoint);
12486     if (r == -1)
12487       return -1;
12488   }
12489   /* TestOutputList for vgs (0) */
12490   {
12491     char **r;
12492     int i;
12493     suppress_error = 0;
12494     r = guestfs_vgs (g);
12495     if (r == NULL)
12496       return -1;
12497     if (!r[0]) {
12498       fprintf (stderr, "test_vgs_0: short list returned from command\n");
12499       print_strings (r);
12500       return -1;
12501     }
12502     {
12503       char expected[] = "VG";
12504       if (strcmp (r[0], expected) != 0) {
12505         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12506         return -1;
12507       }
12508     }
12509     if (r[1] != NULL) {
12510       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
12511       print_strings (r);
12512       return -1;
12513     }
12514     for (i = 0; r[i] != NULL; ++i)
12515       free (r[i]);
12516     free (r);
12517   }
12518   return 0;
12519 }
12520
12521 static int test_vgs_1 (void)
12522 {
12523   /* InitNone|InitEmpty for test_vgs_1 */
12524   {
12525     char device[] = "/dev/sda";
12526     device[5] = devchar;
12527     int r;
12528     suppress_error = 0;
12529     r = guestfs_blockdev_setrw (g, device);
12530     if (r == -1)
12531       return -1;
12532   }
12533   {
12534     int r;
12535     suppress_error = 0;
12536     r = guestfs_umount_all (g);
12537     if (r == -1)
12538       return -1;
12539   }
12540   {
12541     int r;
12542     suppress_error = 0;
12543     r = guestfs_lvm_remove_all (g);
12544     if (r == -1)
12545       return -1;
12546   }
12547   /* TestOutputList for vgs (1) */
12548   {
12549     char device[] = "/dev/sda";
12550     device[5] = devchar;
12551     char lines_0[] = ",10";
12552     char lines_1[] = ",20";
12553     char lines_2[] = ",";
12554     char *lines[] = {
12555       lines_0,
12556       lines_1,
12557       lines_2,
12558       NULL
12559     };
12560     int r;
12561     suppress_error = 0;
12562     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12563     if (r == -1)
12564       return -1;
12565   }
12566   {
12567     char device[] = "/dev/sda1";
12568     device[5] = devchar;
12569     int r;
12570     suppress_error = 0;
12571     r = guestfs_pvcreate (g, device);
12572     if (r == -1)
12573       return -1;
12574   }
12575   {
12576     char device[] = "/dev/sda2";
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/sda3";
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 volgroup[] = "VG1";
12595     char physvols_0[] = "/dev/sda1";
12596     physvols_0[5] = devchar;
12597     char physvols_1[] = "/dev/sda2";
12598     physvols_1[5] = devchar;
12599     char *physvols[] = {
12600       physvols_0,
12601       physvols_1,
12602       NULL
12603     };
12604     int r;
12605     suppress_error = 0;
12606     r = guestfs_vgcreate (g, volgroup, physvols);
12607     if (r == -1)
12608       return -1;
12609   }
12610   {
12611     char volgroup[] = "VG2";
12612     char physvols_0[] = "/dev/sda3";
12613     physvols_0[5] = devchar;
12614     char *physvols[] = {
12615       physvols_0,
12616       NULL
12617     };
12618     int r;
12619     suppress_error = 0;
12620     r = guestfs_vgcreate (g, volgroup, physvols);
12621     if (r == -1)
12622       return -1;
12623   }
12624   {
12625     char **r;
12626     int i;
12627     suppress_error = 0;
12628     r = guestfs_vgs (g);
12629     if (r == NULL)
12630       return -1;
12631     if (!r[0]) {
12632       fprintf (stderr, "test_vgs_1: short list returned from command\n");
12633       print_strings (r);
12634       return -1;
12635     }
12636     {
12637       char expected[] = "VG1";
12638       if (strcmp (r[0], expected) != 0) {
12639         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12640         return -1;
12641       }
12642     }
12643     if (!r[1]) {
12644       fprintf (stderr, "test_vgs_1: short list returned from command\n");
12645       print_strings (r);
12646       return -1;
12647     }
12648     {
12649       char expected[] = "VG2";
12650       if (strcmp (r[1], expected) != 0) {
12651         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12652         return -1;
12653       }
12654     }
12655     if (r[2] != NULL) {
12656       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
12657       print_strings (r);
12658       return -1;
12659     }
12660     for (i = 0; r[i] != NULL; ++i)
12661       free (r[i]);
12662     free (r);
12663   }
12664   return 0;
12665 }
12666
12667 static int test_pvs_0 (void)
12668 {
12669   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
12670   {
12671     char device[] = "/dev/sda";
12672     device[5] = devchar;
12673     int r;
12674     suppress_error = 0;
12675     r = guestfs_blockdev_setrw (g, device);
12676     if (r == -1)
12677       return -1;
12678   }
12679   {
12680     int r;
12681     suppress_error = 0;
12682     r = guestfs_umount_all (g);
12683     if (r == -1)
12684       return -1;
12685   }
12686   {
12687     int r;
12688     suppress_error = 0;
12689     r = guestfs_lvm_remove_all (g);
12690     if (r == -1)
12691       return -1;
12692   }
12693   {
12694     char device[] = "/dev/sda";
12695     device[5] = devchar;
12696     char lines_0[] = ",";
12697     char *lines[] = {
12698       lines_0,
12699       NULL
12700     };
12701     int r;
12702     suppress_error = 0;
12703     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12704     if (r == -1)
12705       return -1;
12706   }
12707   {
12708     char device[] = "/dev/sda1";
12709     device[5] = devchar;
12710     int r;
12711     suppress_error = 0;
12712     r = guestfs_pvcreate (g, device);
12713     if (r == -1)
12714       return -1;
12715   }
12716   {
12717     char volgroup[] = "VG";
12718     char physvols_0[] = "/dev/sda1";
12719     physvols_0[5] = devchar;
12720     char *physvols[] = {
12721       physvols_0,
12722       NULL
12723     };
12724     int r;
12725     suppress_error = 0;
12726     r = guestfs_vgcreate (g, volgroup, physvols);
12727     if (r == -1)
12728       return -1;
12729   }
12730   {
12731     char logvol[] = "LV";
12732     char volgroup[] = "VG";
12733     int r;
12734     suppress_error = 0;
12735     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12736     if (r == -1)
12737       return -1;
12738   }
12739   {
12740     char fstype[] = "ext2";
12741     char device[] = "/dev/VG/LV";
12742     int r;
12743     suppress_error = 0;
12744     r = guestfs_mkfs (g, fstype, device);
12745     if (r == -1)
12746       return -1;
12747   }
12748   {
12749     char device[] = "/dev/VG/LV";
12750     char mountpoint[] = "/";
12751     int r;
12752     suppress_error = 0;
12753     r = guestfs_mount (g, device, mountpoint);
12754     if (r == -1)
12755       return -1;
12756   }
12757   /* TestOutputList for pvs (0) */
12758   {
12759     char **r;
12760     int i;
12761     suppress_error = 0;
12762     r = guestfs_pvs (g);
12763     if (r == NULL)
12764       return -1;
12765     if (!r[0]) {
12766       fprintf (stderr, "test_pvs_0: short list returned from command\n");
12767       print_strings (r);
12768       return -1;
12769     }
12770     {
12771       char expected[] = "/dev/sda1";
12772       expected[5] = devchar;
12773       if (strcmp (r[0], expected) != 0) {
12774         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12775         return -1;
12776       }
12777     }
12778     if (r[1] != NULL) {
12779       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12780       print_strings (r);
12781       return -1;
12782     }
12783     for (i = 0; r[i] != NULL; ++i)
12784       free (r[i]);
12785     free (r);
12786   }
12787   return 0;
12788 }
12789
12790 static int test_pvs_1 (void)
12791 {
12792   /* InitNone|InitEmpty for test_pvs_1 */
12793   {
12794     char device[] = "/dev/sda";
12795     device[5] = devchar;
12796     int r;
12797     suppress_error = 0;
12798     r = guestfs_blockdev_setrw (g, device);
12799     if (r == -1)
12800       return -1;
12801   }
12802   {
12803     int r;
12804     suppress_error = 0;
12805     r = guestfs_umount_all (g);
12806     if (r == -1)
12807       return -1;
12808   }
12809   {
12810     int r;
12811     suppress_error = 0;
12812     r = guestfs_lvm_remove_all (g);
12813     if (r == -1)
12814       return -1;
12815   }
12816   /* TestOutputList for pvs (1) */
12817   {
12818     char device[] = "/dev/sda";
12819     device[5] = devchar;
12820     char lines_0[] = ",10";
12821     char lines_1[] = ",20";
12822     char lines_2[] = ",";
12823     char *lines[] = {
12824       lines_0,
12825       lines_1,
12826       lines_2,
12827       NULL
12828     };
12829     int r;
12830     suppress_error = 0;
12831     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12832     if (r == -1)
12833       return -1;
12834   }
12835   {
12836     char device[] = "/dev/sda1";
12837     device[5] = devchar;
12838     int r;
12839     suppress_error = 0;
12840     r = guestfs_pvcreate (g, device);
12841     if (r == -1)
12842       return -1;
12843   }
12844   {
12845     char device[] = "/dev/sda2";
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/sda3";
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 **r;
12864     int i;
12865     suppress_error = 0;
12866     r = guestfs_pvs (g);
12867     if (r == NULL)
12868       return -1;
12869     if (!r[0]) {
12870       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12871       print_strings (r);
12872       return -1;
12873     }
12874     {
12875       char expected[] = "/dev/sda1";
12876       expected[5] = devchar;
12877       if (strcmp (r[0], expected) != 0) {
12878         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12879         return -1;
12880       }
12881     }
12882     if (!r[1]) {
12883       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12884       print_strings (r);
12885       return -1;
12886     }
12887     {
12888       char expected[] = "/dev/sda2";
12889       expected[5] = devchar;
12890       if (strcmp (r[1], expected) != 0) {
12891         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12892         return -1;
12893       }
12894     }
12895     if (!r[2]) {
12896       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12897       print_strings (r);
12898       return -1;
12899     }
12900     {
12901       char expected[] = "/dev/sda3";
12902       expected[5] = devchar;
12903       if (strcmp (r[2], expected) != 0) {
12904         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12905         return -1;
12906       }
12907     }
12908     if (r[3] != NULL) {
12909       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12910       print_strings (r);
12911       return -1;
12912     }
12913     for (i = 0; r[i] != NULL; ++i)
12914       free (r[i]);
12915     free (r);
12916   }
12917   return 0;
12918 }
12919
12920 static int test_list_partitions_0 (void)
12921 {
12922   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
12923   {
12924     char device[] = "/dev/sda";
12925     device[5] = devchar;
12926     int r;
12927     suppress_error = 0;
12928     r = guestfs_blockdev_setrw (g, device);
12929     if (r == -1)
12930       return -1;
12931   }
12932   {
12933     int r;
12934     suppress_error = 0;
12935     r = guestfs_umount_all (g);
12936     if (r == -1)
12937       return -1;
12938   }
12939   {
12940     int r;
12941     suppress_error = 0;
12942     r = guestfs_lvm_remove_all (g);
12943     if (r == -1)
12944       return -1;
12945   }
12946   {
12947     char device[] = "/dev/sda";
12948     device[5] = devchar;
12949     char lines_0[] = ",";
12950     char *lines[] = {
12951       lines_0,
12952       NULL
12953     };
12954     int r;
12955     suppress_error = 0;
12956     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12957     if (r == -1)
12958       return -1;
12959   }
12960   {
12961     char fstype[] = "ext2";
12962     char device[] = "/dev/sda1";
12963     device[5] = devchar;
12964     int r;
12965     suppress_error = 0;
12966     r = guestfs_mkfs (g, fstype, device);
12967     if (r == -1)
12968       return -1;
12969   }
12970   {
12971     char device[] = "/dev/sda1";
12972     device[5] = devchar;
12973     char mountpoint[] = "/";
12974     int r;
12975     suppress_error = 0;
12976     r = guestfs_mount (g, device, mountpoint);
12977     if (r == -1)
12978       return -1;
12979   }
12980   /* TestOutputList for list_partitions (0) */
12981   {
12982     char **r;
12983     int i;
12984     suppress_error = 0;
12985     r = guestfs_list_partitions (g);
12986     if (r == NULL)
12987       return -1;
12988     if (!r[0]) {
12989       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12990       print_strings (r);
12991       return -1;
12992     }
12993     {
12994       char expected[] = "/dev/sda1";
12995       expected[5] = devchar;
12996       if (strcmp (r[0], expected) != 0) {
12997         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12998         return -1;
12999       }
13000     }
13001     if (r[1] != NULL) {
13002       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
13003       print_strings (r);
13004       return -1;
13005     }
13006     for (i = 0; r[i] != NULL; ++i)
13007       free (r[i]);
13008     free (r);
13009   }
13010   return 0;
13011 }
13012
13013 static int test_list_partitions_1 (void)
13014 {
13015   /* InitNone|InitEmpty for test_list_partitions_1 */
13016   {
13017     char device[] = "/dev/sda";
13018     device[5] = devchar;
13019     int r;
13020     suppress_error = 0;
13021     r = guestfs_blockdev_setrw (g, device);
13022     if (r == -1)
13023       return -1;
13024   }
13025   {
13026     int r;
13027     suppress_error = 0;
13028     r = guestfs_umount_all (g);
13029     if (r == -1)
13030       return -1;
13031   }
13032   {
13033     int r;
13034     suppress_error = 0;
13035     r = guestfs_lvm_remove_all (g);
13036     if (r == -1)
13037       return -1;
13038   }
13039   /* TestOutputList for list_partitions (1) */
13040   {
13041     char device[] = "/dev/sda";
13042     device[5] = devchar;
13043     char lines_0[] = ",10";
13044     char lines_1[] = ",20";
13045     char lines_2[] = ",";
13046     char *lines[] = {
13047       lines_0,
13048       lines_1,
13049       lines_2,
13050       NULL
13051     };
13052     int r;
13053     suppress_error = 0;
13054     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13055     if (r == -1)
13056       return -1;
13057   }
13058   {
13059     char **r;
13060     int i;
13061     suppress_error = 0;
13062     r = guestfs_list_partitions (g);
13063     if (r == NULL)
13064       return -1;
13065     if (!r[0]) {
13066       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13067       print_strings (r);
13068       return -1;
13069     }
13070     {
13071       char expected[] = "/dev/sda1";
13072       expected[5] = devchar;
13073       if (strcmp (r[0], expected) != 0) {
13074         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13075         return -1;
13076       }
13077     }
13078     if (!r[1]) {
13079       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13080       print_strings (r);
13081       return -1;
13082     }
13083     {
13084       char expected[] = "/dev/sda2";
13085       expected[5] = devchar;
13086       if (strcmp (r[1], expected) != 0) {
13087         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13088         return -1;
13089       }
13090     }
13091     if (!r[2]) {
13092       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13093       print_strings (r);
13094       return -1;
13095     }
13096     {
13097       char expected[] = "/dev/sda3";
13098       expected[5] = devchar;
13099       if (strcmp (r[2], expected) != 0) {
13100         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13101         return -1;
13102       }
13103     }
13104     if (r[3] != NULL) {
13105       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
13106       print_strings (r);
13107       return -1;
13108     }
13109     for (i = 0; r[i] != NULL; ++i)
13110       free (r[i]);
13111     free (r);
13112   }
13113   return 0;
13114 }
13115
13116 static int test_list_devices_0 (void)
13117 {
13118   /* InitNone|InitEmpty for test_list_devices_0 */
13119   {
13120     char device[] = "/dev/sda";
13121     device[5] = devchar;
13122     int r;
13123     suppress_error = 0;
13124     r = guestfs_blockdev_setrw (g, device);
13125     if (r == -1)
13126       return -1;
13127   }
13128   {
13129     int r;
13130     suppress_error = 0;
13131     r = guestfs_umount_all (g);
13132     if (r == -1)
13133       return -1;
13134   }
13135   {
13136     int r;
13137     suppress_error = 0;
13138     r = guestfs_lvm_remove_all (g);
13139     if (r == -1)
13140       return -1;
13141   }
13142   /* TestOutputList for list_devices (0) */
13143   {
13144     char **r;
13145     int i;
13146     suppress_error = 0;
13147     r = guestfs_list_devices (g);
13148     if (r == NULL)
13149       return -1;
13150     if (!r[0]) {
13151       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13152       print_strings (r);
13153       return -1;
13154     }
13155     {
13156       char expected[] = "/dev/sda";
13157       expected[5] = devchar;
13158       if (strcmp (r[0], expected) != 0) {
13159         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13160         return -1;
13161       }
13162     }
13163     if (!r[1]) {
13164       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13165       print_strings (r);
13166       return -1;
13167     }
13168     {
13169       char expected[] = "/dev/sdb";
13170       expected[5] = devchar;
13171       if (strcmp (r[1], expected) != 0) {
13172         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13173         return -1;
13174       }
13175     }
13176     if (!r[2]) {
13177       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13178       print_strings (r);
13179       return -1;
13180     }
13181     {
13182       char expected[] = "/dev/sdc";
13183       expected[5] = devchar;
13184       if (strcmp (r[2], expected) != 0) {
13185         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13186         return -1;
13187       }
13188     }
13189     if (r[3] != NULL) {
13190       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
13191       print_strings (r);
13192       return -1;
13193     }
13194     for (i = 0; r[i] != NULL; ++i)
13195       free (r[i]);
13196     free (r);
13197   }
13198   return 0;
13199 }
13200
13201 static int test_ls_0 (void)
13202 {
13203   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
13204   {
13205     char device[] = "/dev/sda";
13206     device[5] = devchar;
13207     int r;
13208     suppress_error = 0;
13209     r = guestfs_blockdev_setrw (g, device);
13210     if (r == -1)
13211       return -1;
13212   }
13213   {
13214     int r;
13215     suppress_error = 0;
13216     r = guestfs_umount_all (g);
13217     if (r == -1)
13218       return -1;
13219   }
13220   {
13221     int r;
13222     suppress_error = 0;
13223     r = guestfs_lvm_remove_all (g);
13224     if (r == -1)
13225       return -1;
13226   }
13227   {
13228     char device[] = "/dev/sda";
13229     device[5] = devchar;
13230     char lines_0[] = ",";
13231     char *lines[] = {
13232       lines_0,
13233       NULL
13234     };
13235     int r;
13236     suppress_error = 0;
13237     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13238     if (r == -1)
13239       return -1;
13240   }
13241   {
13242     char fstype[] = "ext2";
13243     char device[] = "/dev/sda1";
13244     device[5] = devchar;
13245     int r;
13246     suppress_error = 0;
13247     r = guestfs_mkfs (g, fstype, device);
13248     if (r == -1)
13249       return -1;
13250   }
13251   {
13252     char device[] = "/dev/sda1";
13253     device[5] = devchar;
13254     char mountpoint[] = "/";
13255     int r;
13256     suppress_error = 0;
13257     r = guestfs_mount (g, device, mountpoint);
13258     if (r == -1)
13259       return -1;
13260   }
13261   /* TestOutputList for ls (0) */
13262   {
13263     char path[] = "/new";
13264     int r;
13265     suppress_error = 0;
13266     r = guestfs_touch (g, path);
13267     if (r == -1)
13268       return -1;
13269   }
13270   {
13271     char path[] = "/newer";
13272     int r;
13273     suppress_error = 0;
13274     r = guestfs_touch (g, path);
13275     if (r == -1)
13276       return -1;
13277   }
13278   {
13279     char path[] = "/newest";
13280     int r;
13281     suppress_error = 0;
13282     r = guestfs_touch (g, path);
13283     if (r == -1)
13284       return -1;
13285   }
13286   {
13287     char directory[] = "/";
13288     char **r;
13289     int i;
13290     suppress_error = 0;
13291     r = guestfs_ls (g, directory);
13292     if (r == NULL)
13293       return -1;
13294     if (!r[0]) {
13295       fprintf (stderr, "test_ls_0: short list returned from command\n");
13296       print_strings (r);
13297       return -1;
13298     }
13299     {
13300       char expected[] = "lost+found";
13301       if (strcmp (r[0], expected) != 0) {
13302         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13303         return -1;
13304       }
13305     }
13306     if (!r[1]) {
13307       fprintf (stderr, "test_ls_0: short list returned from command\n");
13308       print_strings (r);
13309       return -1;
13310     }
13311     {
13312       char expected[] = "new";
13313       if (strcmp (r[1], expected) != 0) {
13314         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13315         return -1;
13316       }
13317     }
13318     if (!r[2]) {
13319       fprintf (stderr, "test_ls_0: short list returned from command\n");
13320       print_strings (r);
13321       return -1;
13322     }
13323     {
13324       char expected[] = "newer";
13325       if (strcmp (r[2], expected) != 0) {
13326         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13327         return -1;
13328       }
13329     }
13330     if (!r[3]) {
13331       fprintf (stderr, "test_ls_0: short list returned from command\n");
13332       print_strings (r);
13333       return -1;
13334     }
13335     {
13336       char expected[] = "newest";
13337       if (strcmp (r[3], expected) != 0) {
13338         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
13339         return -1;
13340       }
13341     }
13342     if (r[4] != NULL) {
13343       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
13344       print_strings (r);
13345       return -1;
13346     }
13347     for (i = 0; r[i] != NULL; ++i)
13348       free (r[i]);
13349     free (r);
13350   }
13351   return 0;
13352 }
13353
13354 static int test_cat_0 (void)
13355 {
13356   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
13357   {
13358     char device[] = "/dev/sda";
13359     device[5] = devchar;
13360     int r;
13361     suppress_error = 0;
13362     r = guestfs_blockdev_setrw (g, device);
13363     if (r == -1)
13364       return -1;
13365   }
13366   {
13367     int r;
13368     suppress_error = 0;
13369     r = guestfs_umount_all (g);
13370     if (r == -1)
13371       return -1;
13372   }
13373   {
13374     int r;
13375     suppress_error = 0;
13376     r = guestfs_lvm_remove_all (g);
13377     if (r == -1)
13378       return -1;
13379   }
13380   {
13381     char device[] = "/dev/sda";
13382     device[5] = devchar;
13383     char lines_0[] = ",";
13384     char *lines[] = {
13385       lines_0,
13386       NULL
13387     };
13388     int r;
13389     suppress_error = 0;
13390     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13391     if (r == -1)
13392       return -1;
13393   }
13394   {
13395     char fstype[] = "ext2";
13396     char device[] = "/dev/sda1";
13397     device[5] = devchar;
13398     int r;
13399     suppress_error = 0;
13400     r = guestfs_mkfs (g, fstype, device);
13401     if (r == -1)
13402       return -1;
13403   }
13404   {
13405     char device[] = "/dev/sda1";
13406     device[5] = devchar;
13407     char mountpoint[] = "/";
13408     int r;
13409     suppress_error = 0;
13410     r = guestfs_mount (g, device, mountpoint);
13411     if (r == -1)
13412       return -1;
13413   }
13414   /* TestOutput for cat (0) */
13415   char expected[] = "new file contents";
13416   {
13417     char path[] = "/new";
13418     char content[] = "new file contents";
13419     int r;
13420     suppress_error = 0;
13421     r = guestfs_write_file (g, path, content, 0);
13422     if (r == -1)
13423       return -1;
13424   }
13425   {
13426     char path[] = "/new";
13427     char *r;
13428     suppress_error = 0;
13429     r = guestfs_cat (g, path);
13430     if (r == NULL)
13431       return -1;
13432     if (strcmp (r, expected) != 0) {
13433       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
13434       return -1;
13435     }
13436     free (r);
13437   }
13438   return 0;
13439 }
13440
13441 static int test_touch_0 (void)
13442 {
13443   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
13444   {
13445     char device[] = "/dev/sda";
13446     device[5] = devchar;
13447     int r;
13448     suppress_error = 0;
13449     r = guestfs_blockdev_setrw (g, device);
13450     if (r == -1)
13451       return -1;
13452   }
13453   {
13454     int r;
13455     suppress_error = 0;
13456     r = guestfs_umount_all (g);
13457     if (r == -1)
13458       return -1;
13459   }
13460   {
13461     int r;
13462     suppress_error = 0;
13463     r = guestfs_lvm_remove_all (g);
13464     if (r == -1)
13465       return -1;
13466   }
13467   {
13468     char device[] = "/dev/sda";
13469     device[5] = devchar;
13470     char lines_0[] = ",";
13471     char *lines[] = {
13472       lines_0,
13473       NULL
13474     };
13475     int r;
13476     suppress_error = 0;
13477     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13478     if (r == -1)
13479       return -1;
13480   }
13481   {
13482     char fstype[] = "ext2";
13483     char device[] = "/dev/sda1";
13484     device[5] = devchar;
13485     int r;
13486     suppress_error = 0;
13487     r = guestfs_mkfs (g, fstype, device);
13488     if (r == -1)
13489       return -1;
13490   }
13491   {
13492     char device[] = "/dev/sda1";
13493     device[5] = devchar;
13494     char mountpoint[] = "/";
13495     int r;
13496     suppress_error = 0;
13497     r = guestfs_mount (g, device, mountpoint);
13498     if (r == -1)
13499       return -1;
13500   }
13501   /* TestOutputTrue for touch (0) */
13502   {
13503     char path[] = "/new";
13504     int r;
13505     suppress_error = 0;
13506     r = guestfs_touch (g, path);
13507     if (r == -1)
13508       return -1;
13509   }
13510   {
13511     char path[] = "/new";
13512     int r;
13513     suppress_error = 0;
13514     r = guestfs_exists (g, path);
13515     if (r == -1)
13516       return -1;
13517     if (!r) {
13518       fprintf (stderr, "test_touch_0: expected true, got false\n");
13519       return -1;
13520     }
13521   }
13522   return 0;
13523 }
13524
13525 static int test_sync_0 (void)
13526 {
13527   /* InitNone|InitEmpty for test_sync_0 */
13528   {
13529     char device[] = "/dev/sda";
13530     device[5] = devchar;
13531     int r;
13532     suppress_error = 0;
13533     r = guestfs_blockdev_setrw (g, device);
13534     if (r == -1)
13535       return -1;
13536   }
13537   {
13538     int r;
13539     suppress_error = 0;
13540     r = guestfs_umount_all (g);
13541     if (r == -1)
13542       return -1;
13543   }
13544   {
13545     int r;
13546     suppress_error = 0;
13547     r = guestfs_lvm_remove_all (g);
13548     if (r == -1)
13549       return -1;
13550   }
13551   /* TestRun for sync (0) */
13552   {
13553     int r;
13554     suppress_error = 0;
13555     r = guestfs_sync (g);
13556     if (r == -1)
13557       return -1;
13558   }
13559   return 0;
13560 }
13561
13562 static int test_mount_0 (void)
13563 {
13564   /* InitNone|InitEmpty for test_mount_0 */
13565   {
13566     char device[] = "/dev/sda";
13567     device[5] = devchar;
13568     int r;
13569     suppress_error = 0;
13570     r = guestfs_blockdev_setrw (g, device);
13571     if (r == -1)
13572       return -1;
13573   }
13574   {
13575     int r;
13576     suppress_error = 0;
13577     r = guestfs_umount_all (g);
13578     if (r == -1)
13579       return -1;
13580   }
13581   {
13582     int r;
13583     suppress_error = 0;
13584     r = guestfs_lvm_remove_all (g);
13585     if (r == -1)
13586       return -1;
13587   }
13588   /* TestOutput for mount (0) */
13589   char expected[] = "new file contents";
13590   {
13591     char device[] = "/dev/sda";
13592     device[5] = devchar;
13593     char lines_0[] = ",";
13594     char *lines[] = {
13595       lines_0,
13596       NULL
13597     };
13598     int r;
13599     suppress_error = 0;
13600     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13601     if (r == -1)
13602       return -1;
13603   }
13604   {
13605     char fstype[] = "ext2";
13606     char device[] = "/dev/sda1";
13607     device[5] = devchar;
13608     int r;
13609     suppress_error = 0;
13610     r = guestfs_mkfs (g, fstype, device);
13611     if (r == -1)
13612       return -1;
13613   }
13614   {
13615     char device[] = "/dev/sda1";
13616     device[5] = devchar;
13617     char mountpoint[] = "/";
13618     int r;
13619     suppress_error = 0;
13620     r = guestfs_mount (g, device, mountpoint);
13621     if (r == -1)
13622       return -1;
13623   }
13624   {
13625     char path[] = "/new";
13626     char content[] = "new file contents";
13627     int r;
13628     suppress_error = 0;
13629     r = guestfs_write_file (g, path, content, 0);
13630     if (r == -1)
13631       return -1;
13632   }
13633   {
13634     char path[] = "/new";
13635     char *r;
13636     suppress_error = 0;
13637     r = guestfs_cat (g, path);
13638     if (r == NULL)
13639       return -1;
13640     if (strcmp (r, expected) != 0) {
13641       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
13642       return -1;
13643     }
13644     free (r);
13645   }
13646   return 0;
13647 }
13648
13649 int main (int argc, char *argv[])
13650 {
13651   char c = 0;
13652   int failed = 0;
13653   const char *srcdir;
13654   const char *filename;
13655   int fd, i;
13656   int nr_tests, test_num = 0;
13657   char **devs;
13658
13659   no_test_warnings ();
13660
13661   g = guestfs_create ();
13662   if (g == NULL) {
13663     printf ("guestfs_create FAILED\n");
13664     exit (1);
13665   }
13666
13667   guestfs_set_error_handler (g, print_error, NULL);
13668
13669   srcdir = getenv ("srcdir");
13670   if (!srcdir) srcdir = ".";
13671   chdir (srcdir);
13672   guestfs_set_path (g, ".");
13673
13674   filename = "test1.img";
13675   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13676   if (fd == -1) {
13677     perror (filename);
13678     exit (1);
13679   }
13680   if (lseek (fd, 524288000, SEEK_SET) == -1) {
13681     perror ("lseek");
13682     close (fd);
13683     unlink (filename);
13684     exit (1);
13685   }
13686   if (write (fd, &c, 1) == -1) {
13687     perror ("write");
13688     close (fd);
13689     unlink (filename);
13690     exit (1);
13691   }
13692   if (close (fd) == -1) {
13693     perror (filename);
13694     unlink (filename);
13695     exit (1);
13696   }
13697   if (guestfs_add_drive (g, filename) == -1) {
13698     printf ("guestfs_add_drive %s FAILED\n", filename);
13699     exit (1);
13700   }
13701
13702   filename = "test2.img";
13703   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13704   if (fd == -1) {
13705     perror (filename);
13706     exit (1);
13707   }
13708   if (lseek (fd, 52428800, SEEK_SET) == -1) {
13709     perror ("lseek");
13710     close (fd);
13711     unlink (filename);
13712     exit (1);
13713   }
13714   if (write (fd, &c, 1) == -1) {
13715     perror ("write");
13716     close (fd);
13717     unlink (filename);
13718     exit (1);
13719   }
13720   if (close (fd) == -1) {
13721     perror (filename);
13722     unlink (filename);
13723     exit (1);
13724   }
13725   if (guestfs_add_drive (g, filename) == -1) {
13726     printf ("guestfs_add_drive %s FAILED\n", filename);
13727     exit (1);
13728   }
13729
13730   filename = "test3.img";
13731   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13732   if (fd == -1) {
13733     perror (filename);
13734     exit (1);
13735   }
13736   if (lseek (fd, 10485760, SEEK_SET) == -1) {
13737     perror ("lseek");
13738     close (fd);
13739     unlink (filename);
13740     exit (1);
13741   }
13742   if (write (fd, &c, 1) == -1) {
13743     perror ("write");
13744     close (fd);
13745     unlink (filename);
13746     exit (1);
13747   }
13748   if (close (fd) == -1) {
13749     perror (filename);
13750     unlink (filename);
13751     exit (1);
13752   }
13753   if (guestfs_add_drive (g, filename) == -1) {
13754     printf ("guestfs_add_drive %s FAILED\n", filename);
13755     exit (1);
13756   }
13757
13758   if (guestfs_launch (g) == -1) {
13759     printf ("guestfs_launch FAILED\n");
13760     exit (1);
13761   }
13762   if (guestfs_wait_ready (g) == -1) {
13763     printf ("guestfs_wait_ready FAILED\n");
13764     exit (1);
13765   }
13766
13767   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13768    * names.  This changed between RHEL 5 and RHEL 6 so we have to
13769    * support both.
13770    */
13771   devs = guestfs_list_devices (g);
13772   if (devs == NULL || devs[0] == NULL) {
13773     printf ("guestfs_list_devices FAILED\n");
13774     exit (1);
13775   }
13776   if (strncmp (devs[0], "/dev/sd", 7) == 0)
13777     devchar = 's';
13778   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13779     devchar = 'h';
13780   else {
13781     printf ("guestfs_list_devices returned unexpected string '%s'\n",
13782             devs[0]);
13783     exit (1);
13784   }
13785   for (i = 0; devs[i] != NULL; ++i)
13786     free (devs[i]);
13787   free (devs);
13788
13789   nr_tests = 140;
13790
13791   test_num++;
13792   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
13793   if (test_find_0 () == -1) {
13794     printf ("test_find_0 FAILED\n");
13795     failed++;
13796   }
13797   test_num++;
13798   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
13799   if (test_find_1 () == -1) {
13800     printf ("test_find_1 FAILED\n");
13801     failed++;
13802   }
13803   test_num++;
13804   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
13805   if (test_find_2 () == -1) {
13806     printf ("test_find_2 FAILED\n");
13807     failed++;
13808   }
13809   test_num++;
13810   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
13811   if (test_lvresize_0 () == -1) {
13812     printf ("test_lvresize_0 FAILED\n");
13813     failed++;
13814   }
13815   test_num++;
13816   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13817   if (test_zerofree_0 () == -1) {
13818     printf ("test_zerofree_0 FAILED\n");
13819     failed++;
13820   }
13821   test_num++;
13822   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13823   if (test_hexdump_0 () == -1) {
13824     printf ("test_hexdump_0 FAILED\n");
13825     failed++;
13826   }
13827   test_num++;
13828   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13829   if (test_strings_e_0 () == -1) {
13830     printf ("test_strings_e_0 FAILED\n");
13831     failed++;
13832   }
13833   test_num++;
13834   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13835   if (test_strings_e_1 () == -1) {
13836     printf ("test_strings_e_1 FAILED\n");
13837     failed++;
13838   }
13839   test_num++;
13840   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13841   if (test_strings_0 () == -1) {
13842     printf ("test_strings_0 FAILED\n");
13843     failed++;
13844   }
13845   test_num++;
13846   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13847   if (test_strings_1 () == -1) {
13848     printf ("test_strings_1 FAILED\n");
13849     failed++;
13850   }
13851   test_num++;
13852   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13853   if (test_equal_0 () == -1) {
13854     printf ("test_equal_0 FAILED\n");
13855     failed++;
13856   }
13857   test_num++;
13858   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13859   if (test_equal_1 () == -1) {
13860     printf ("test_equal_1 FAILED\n");
13861     failed++;
13862   }
13863   test_num++;
13864   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13865   if (test_equal_2 () == -1) {
13866     printf ("test_equal_2 FAILED\n");
13867     failed++;
13868   }
13869   test_num++;
13870   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13871   if (test_ping_daemon_0 () == -1) {
13872     printf ("test_ping_daemon_0 FAILED\n");
13873     failed++;
13874   }
13875   test_num++;
13876   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13877   if (test_dmesg_0 () == -1) {
13878     printf ("test_dmesg_0 FAILED\n");
13879     failed++;
13880   }
13881   test_num++;
13882   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13883   if (test_drop_caches_0 () == -1) {
13884     printf ("test_drop_caches_0 FAILED\n");
13885     failed++;
13886   }
13887   test_num++;
13888   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13889   if (test_mv_0 () == -1) {
13890     printf ("test_mv_0 FAILED\n");
13891     failed++;
13892   }
13893   test_num++;
13894   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13895   if (test_mv_1 () == -1) {
13896     printf ("test_mv_1 FAILED\n");
13897     failed++;
13898   }
13899   test_num++;
13900   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13901   if (test_cp_a_0 () == -1) {
13902     printf ("test_cp_a_0 FAILED\n");
13903     failed++;
13904   }
13905   test_num++;
13906   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13907   if (test_cp_0 () == -1) {
13908     printf ("test_cp_0 FAILED\n");
13909     failed++;
13910   }
13911   test_num++;
13912   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13913   if (test_cp_1 () == -1) {
13914     printf ("test_cp_1 FAILED\n");
13915     failed++;
13916   }
13917   test_num++;
13918   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13919   if (test_cp_2 () == -1) {
13920     printf ("test_cp_2 FAILED\n");
13921     failed++;
13922   }
13923   test_num++;
13924   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13925   if (test_grub_install_0 () == -1) {
13926     printf ("test_grub_install_0 FAILED\n");
13927     failed++;
13928   }
13929   test_num++;
13930   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13931   if (test_zero_0 () == -1) {
13932     printf ("test_zero_0 FAILED\n");
13933     failed++;
13934   }
13935   test_num++;
13936   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13937   if (test_fsck_0 () == -1) {
13938     printf ("test_fsck_0 FAILED\n");
13939     failed++;
13940   }
13941   test_num++;
13942   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13943   if (test_fsck_1 () == -1) {
13944     printf ("test_fsck_1 FAILED\n");
13945     failed++;
13946   }
13947   test_num++;
13948   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13949   if (test_set_e2uuid_0 () == -1) {
13950     printf ("test_set_e2uuid_0 FAILED\n");
13951     failed++;
13952   }
13953   test_num++;
13954   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13955   if (test_set_e2uuid_1 () == -1) {
13956     printf ("test_set_e2uuid_1 FAILED\n");
13957     failed++;
13958   }
13959   test_num++;
13960   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13961   if (test_set_e2uuid_2 () == -1) {
13962     printf ("test_set_e2uuid_2 FAILED\n");
13963     failed++;
13964   }
13965   test_num++;
13966   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13967   if (test_set_e2uuid_3 () == -1) {
13968     printf ("test_set_e2uuid_3 FAILED\n");
13969     failed++;
13970   }
13971   test_num++;
13972   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13973   if (test_set_e2label_0 () == -1) {
13974     printf ("test_set_e2label_0 FAILED\n");
13975     failed++;
13976   }
13977   test_num++;
13978   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13979   if (test_pvremove_0 () == -1) {
13980     printf ("test_pvremove_0 FAILED\n");
13981     failed++;
13982   }
13983   test_num++;
13984   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13985   if (test_pvremove_1 () == -1) {
13986     printf ("test_pvremove_1 FAILED\n");
13987     failed++;
13988   }
13989   test_num++;
13990   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13991   if (test_pvremove_2 () == -1) {
13992     printf ("test_pvremove_2 FAILED\n");
13993     failed++;
13994   }
13995   test_num++;
13996   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13997   if (test_vgremove_0 () == -1) {
13998     printf ("test_vgremove_0 FAILED\n");
13999     failed++;
14000   }
14001   test_num++;
14002   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
14003   if (test_vgremove_1 () == -1) {
14004     printf ("test_vgremove_1 FAILED\n");
14005     failed++;
14006   }
14007   test_num++;
14008   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
14009   if (test_lvremove_0 () == -1) {
14010     printf ("test_lvremove_0 FAILED\n");
14011     failed++;
14012   }
14013   test_num++;
14014   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
14015   if (test_lvremove_1 () == -1) {
14016     printf ("test_lvremove_1 FAILED\n");
14017     failed++;
14018   }
14019   test_num++;
14020   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
14021   if (test_lvremove_2 () == -1) {
14022     printf ("test_lvremove_2 FAILED\n");
14023     failed++;
14024   }
14025   test_num++;
14026   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
14027   if (test_mount_ro_0 () == -1) {
14028     printf ("test_mount_ro_0 FAILED\n");
14029     failed++;
14030   }
14031   test_num++;
14032   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
14033   if (test_mount_ro_1 () == -1) {
14034     printf ("test_mount_ro_1 FAILED\n");
14035     failed++;
14036   }
14037   test_num++;
14038   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
14039   if (test_tgz_in_0 () == -1) {
14040     printf ("test_tgz_in_0 FAILED\n");
14041     failed++;
14042   }
14043   test_num++;
14044   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
14045   if (test_tar_in_0 () == -1) {
14046     printf ("test_tar_in_0 FAILED\n");
14047     failed++;
14048   }
14049   test_num++;
14050   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
14051   if (test_checksum_0 () == -1) {
14052     printf ("test_checksum_0 FAILED\n");
14053     failed++;
14054   }
14055   test_num++;
14056   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
14057   if (test_checksum_1 () == -1) {
14058     printf ("test_checksum_1 FAILED\n");
14059     failed++;
14060   }
14061   test_num++;
14062   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
14063   if (test_checksum_2 () == -1) {
14064     printf ("test_checksum_2 FAILED\n");
14065     failed++;
14066   }
14067   test_num++;
14068   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
14069   if (test_checksum_3 () == -1) {
14070     printf ("test_checksum_3 FAILED\n");
14071     failed++;
14072   }
14073   test_num++;
14074   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
14075   if (test_checksum_4 () == -1) {
14076     printf ("test_checksum_4 FAILED\n");
14077     failed++;
14078   }
14079   test_num++;
14080   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
14081   if (test_checksum_5 () == -1) {
14082     printf ("test_checksum_5 FAILED\n");
14083     failed++;
14084   }
14085   test_num++;
14086   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
14087   if (test_checksum_6 () == -1) {
14088     printf ("test_checksum_6 FAILED\n");
14089     failed++;
14090   }
14091   test_num++;
14092   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
14093   if (test_checksum_7 () == -1) {
14094     printf ("test_checksum_7 FAILED\n");
14095     failed++;
14096   }
14097   test_num++;
14098   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
14099   if (test_download_0 () == -1) {
14100     printf ("test_download_0 FAILED\n");
14101     failed++;
14102   }
14103   test_num++;
14104   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
14105   if (test_upload_0 () == -1) {
14106     printf ("test_upload_0 FAILED\n");
14107     failed++;
14108   }
14109   test_num++;
14110   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
14111   if (test_blockdev_rereadpt_0 () == -1) {
14112     printf ("test_blockdev_rereadpt_0 FAILED\n");
14113     failed++;
14114   }
14115   test_num++;
14116   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
14117   if (test_blockdev_flushbufs_0 () == -1) {
14118     printf ("test_blockdev_flushbufs_0 FAILED\n");
14119     failed++;
14120   }
14121   test_num++;
14122   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
14123   if (test_blockdev_getsize64_0 () == -1) {
14124     printf ("test_blockdev_getsize64_0 FAILED\n");
14125     failed++;
14126   }
14127   test_num++;
14128   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
14129   if (test_blockdev_getsz_0 () == -1) {
14130     printf ("test_blockdev_getsz_0 FAILED\n");
14131     failed++;
14132   }
14133   test_num++;
14134   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
14135   if (test_blockdev_getbsz_0 () == -1) {
14136     printf ("test_blockdev_getbsz_0 FAILED\n");
14137     failed++;
14138   }
14139   test_num++;
14140   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
14141   if (test_blockdev_getss_0 () == -1) {
14142     printf ("test_blockdev_getss_0 FAILED\n");
14143     failed++;
14144   }
14145   test_num++;
14146   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
14147   if (test_blockdev_getro_0 () == -1) {
14148     printf ("test_blockdev_getro_0 FAILED\n");
14149     failed++;
14150   }
14151   test_num++;
14152   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
14153   if (test_blockdev_setrw_0 () == -1) {
14154     printf ("test_blockdev_setrw_0 FAILED\n");
14155     failed++;
14156   }
14157   test_num++;
14158   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
14159   if (test_blockdev_setro_0 () == -1) {
14160     printf ("test_blockdev_setro_0 FAILED\n");
14161     failed++;
14162   }
14163   test_num++;
14164   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
14165   if (test_statvfs_0 () == -1) {
14166     printf ("test_statvfs_0 FAILED\n");
14167     failed++;
14168   }
14169   test_num++;
14170   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
14171   if (test_lstat_0 () == -1) {
14172     printf ("test_lstat_0 FAILED\n");
14173     failed++;
14174   }
14175   test_num++;
14176   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
14177   if (test_stat_0 () == -1) {
14178     printf ("test_stat_0 FAILED\n");
14179     failed++;
14180   }
14181   test_num++;
14182   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
14183   if (test_command_lines_0 () == -1) {
14184     printf ("test_command_lines_0 FAILED\n");
14185     failed++;
14186   }
14187   test_num++;
14188   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
14189   if (test_command_lines_1 () == -1) {
14190     printf ("test_command_lines_1 FAILED\n");
14191     failed++;
14192   }
14193   test_num++;
14194   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
14195   if (test_command_lines_2 () == -1) {
14196     printf ("test_command_lines_2 FAILED\n");
14197     failed++;
14198   }
14199   test_num++;
14200   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
14201   if (test_command_lines_3 () == -1) {
14202     printf ("test_command_lines_3 FAILED\n");
14203     failed++;
14204   }
14205   test_num++;
14206   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
14207   if (test_command_lines_4 () == -1) {
14208     printf ("test_command_lines_4 FAILED\n");
14209     failed++;
14210   }
14211   test_num++;
14212   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
14213   if (test_command_lines_5 () == -1) {
14214     printf ("test_command_lines_5 FAILED\n");
14215     failed++;
14216   }
14217   test_num++;
14218   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
14219   if (test_command_lines_6 () == -1) {
14220     printf ("test_command_lines_6 FAILED\n");
14221     failed++;
14222   }
14223   test_num++;
14224   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
14225   if (test_command_lines_7 () == -1) {
14226     printf ("test_command_lines_7 FAILED\n");
14227     failed++;
14228   }
14229   test_num++;
14230   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
14231   if (test_command_lines_8 () == -1) {
14232     printf ("test_command_lines_8 FAILED\n");
14233     failed++;
14234   }
14235   test_num++;
14236   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
14237   if (test_command_lines_9 () == -1) {
14238     printf ("test_command_lines_9 FAILED\n");
14239     failed++;
14240   }
14241   test_num++;
14242   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
14243   if (test_command_lines_10 () == -1) {
14244     printf ("test_command_lines_10 FAILED\n");
14245     failed++;
14246   }
14247   test_num++;
14248   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
14249   if (test_command_0 () == -1) {
14250     printf ("test_command_0 FAILED\n");
14251     failed++;
14252   }
14253   test_num++;
14254   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
14255   if (test_command_1 () == -1) {
14256     printf ("test_command_1 FAILED\n");
14257     failed++;
14258   }
14259   test_num++;
14260   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
14261   if (test_command_2 () == -1) {
14262     printf ("test_command_2 FAILED\n");
14263     failed++;
14264   }
14265   test_num++;
14266   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
14267   if (test_command_3 () == -1) {
14268     printf ("test_command_3 FAILED\n");
14269     failed++;
14270   }
14271   test_num++;
14272   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
14273   if (test_command_4 () == -1) {
14274     printf ("test_command_4 FAILED\n");
14275     failed++;
14276   }
14277   test_num++;
14278   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
14279   if (test_command_5 () == -1) {
14280     printf ("test_command_5 FAILED\n");
14281     failed++;
14282   }
14283   test_num++;
14284   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
14285   if (test_command_6 () == -1) {
14286     printf ("test_command_6 FAILED\n");
14287     failed++;
14288   }
14289   test_num++;
14290   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
14291   if (test_command_7 () == -1) {
14292     printf ("test_command_7 FAILED\n");
14293     failed++;
14294   }
14295   test_num++;
14296   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
14297   if (test_command_8 () == -1) {
14298     printf ("test_command_8 FAILED\n");
14299     failed++;
14300   }
14301   test_num++;
14302   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
14303   if (test_command_9 () == -1) {
14304     printf ("test_command_9 FAILED\n");
14305     failed++;
14306   }
14307   test_num++;
14308   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
14309   if (test_command_10 () == -1) {
14310     printf ("test_command_10 FAILED\n");
14311     failed++;
14312   }
14313   test_num++;
14314   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
14315   if (test_command_11 () == -1) {
14316     printf ("test_command_11 FAILED\n");
14317     failed++;
14318   }
14319   test_num++;
14320   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
14321   if (test_file_0 () == -1) {
14322     printf ("test_file_0 FAILED\n");
14323     failed++;
14324   }
14325   test_num++;
14326   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
14327   if (test_file_1 () == -1) {
14328     printf ("test_file_1 FAILED\n");
14329     failed++;
14330   }
14331   test_num++;
14332   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
14333   if (test_file_2 () == -1) {
14334     printf ("test_file_2 FAILED\n");
14335     failed++;
14336   }
14337   test_num++;
14338   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
14339   if (test_umount_all_0 () == -1) {
14340     printf ("test_umount_all_0 FAILED\n");
14341     failed++;
14342   }
14343   test_num++;
14344   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
14345   if (test_umount_all_1 () == -1) {
14346     printf ("test_umount_all_1 FAILED\n");
14347     failed++;
14348   }
14349   test_num++;
14350   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
14351   if (test_mounts_0 () == -1) {
14352     printf ("test_mounts_0 FAILED\n");
14353     failed++;
14354   }
14355   test_num++;
14356   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
14357   if (test_umount_0 () == -1) {
14358     printf ("test_umount_0 FAILED\n");
14359     failed++;
14360   }
14361   test_num++;
14362   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
14363   if (test_umount_1 () == -1) {
14364     printf ("test_umount_1 FAILED\n");
14365     failed++;
14366   }
14367   test_num++;
14368   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
14369   if (test_write_file_0 () == -1) {
14370     printf ("test_write_file_0 FAILED\n");
14371     failed++;
14372   }
14373   test_num++;
14374   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
14375   if (test_write_file_1 () == -1) {
14376     printf ("test_write_file_1 FAILED\n");
14377     failed++;
14378   }
14379   test_num++;
14380   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
14381   if (test_write_file_2 () == -1) {
14382     printf ("test_write_file_2 FAILED\n");
14383     failed++;
14384   }
14385   test_num++;
14386   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
14387   if (test_write_file_3 () == -1) {
14388     printf ("test_write_file_3 FAILED\n");
14389     failed++;
14390   }
14391   test_num++;
14392   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
14393   if (test_write_file_4 () == -1) {
14394     printf ("test_write_file_4 FAILED\n");
14395     failed++;
14396   }
14397   test_num++;
14398   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
14399   if (test_write_file_5 () == -1) {
14400     printf ("test_write_file_5 FAILED\n");
14401     failed++;
14402   }
14403   test_num++;
14404   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
14405   if (test_mkfs_0 () == -1) {
14406     printf ("test_mkfs_0 FAILED\n");
14407     failed++;
14408   }
14409   test_num++;
14410   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
14411   if (test_lvcreate_0 () == -1) {
14412     printf ("test_lvcreate_0 FAILED\n");
14413     failed++;
14414   }
14415   test_num++;
14416   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
14417   if (test_vgcreate_0 () == -1) {
14418     printf ("test_vgcreate_0 FAILED\n");
14419     failed++;
14420   }
14421   test_num++;
14422   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
14423   if (test_pvcreate_0 () == -1) {
14424     printf ("test_pvcreate_0 FAILED\n");
14425     failed++;
14426   }
14427   test_num++;
14428   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
14429   if (test_is_dir_0 () == -1) {
14430     printf ("test_is_dir_0 FAILED\n");
14431     failed++;
14432   }
14433   test_num++;
14434   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
14435   if (test_is_dir_1 () == -1) {
14436     printf ("test_is_dir_1 FAILED\n");
14437     failed++;
14438   }
14439   test_num++;
14440   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
14441   if (test_is_file_0 () == -1) {
14442     printf ("test_is_file_0 FAILED\n");
14443     failed++;
14444   }
14445   test_num++;
14446   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
14447   if (test_is_file_1 () == -1) {
14448     printf ("test_is_file_1 FAILED\n");
14449     failed++;
14450   }
14451   test_num++;
14452   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
14453   if (test_exists_0 () == -1) {
14454     printf ("test_exists_0 FAILED\n");
14455     failed++;
14456   }
14457   test_num++;
14458   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
14459   if (test_exists_1 () == -1) {
14460     printf ("test_exists_1 FAILED\n");
14461     failed++;
14462   }
14463   test_num++;
14464   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
14465   if (test_mkdir_p_0 () == -1) {
14466     printf ("test_mkdir_p_0 FAILED\n");
14467     failed++;
14468   }
14469   test_num++;
14470   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
14471   if (test_mkdir_p_1 () == -1) {
14472     printf ("test_mkdir_p_1 FAILED\n");
14473     failed++;
14474   }
14475   test_num++;
14476   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
14477   if (test_mkdir_p_2 () == -1) {
14478     printf ("test_mkdir_p_2 FAILED\n");
14479     failed++;
14480   }
14481   test_num++;
14482   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
14483   if (test_mkdir_0 () == -1) {
14484     printf ("test_mkdir_0 FAILED\n");
14485     failed++;
14486   }
14487   test_num++;
14488   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
14489   if (test_mkdir_1 () == -1) {
14490     printf ("test_mkdir_1 FAILED\n");
14491     failed++;
14492   }
14493   test_num++;
14494   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
14495   if (test_rm_rf_0 () == -1) {
14496     printf ("test_rm_rf_0 FAILED\n");
14497     failed++;
14498   }
14499   test_num++;
14500   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
14501   if (test_rmdir_0 () == -1) {
14502     printf ("test_rmdir_0 FAILED\n");
14503     failed++;
14504   }
14505   test_num++;
14506   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
14507   if (test_rmdir_1 () == -1) {
14508     printf ("test_rmdir_1 FAILED\n");
14509     failed++;
14510   }
14511   test_num++;
14512   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
14513   if (test_rmdir_2 () == -1) {
14514     printf ("test_rmdir_2 FAILED\n");
14515     failed++;
14516   }
14517   test_num++;
14518   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
14519   if (test_rm_0 () == -1) {
14520     printf ("test_rm_0 FAILED\n");
14521     failed++;
14522   }
14523   test_num++;
14524   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
14525   if (test_rm_1 () == -1) {
14526     printf ("test_rm_1 FAILED\n");
14527     failed++;
14528   }
14529   test_num++;
14530   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
14531   if (test_rm_2 () == -1) {
14532     printf ("test_rm_2 FAILED\n");
14533     failed++;
14534   }
14535   test_num++;
14536   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
14537   if (test_read_lines_0 () == -1) {
14538     printf ("test_read_lines_0 FAILED\n");
14539     failed++;
14540   }
14541   test_num++;
14542   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
14543   if (test_read_lines_1 () == -1) {
14544     printf ("test_read_lines_1 FAILED\n");
14545     failed++;
14546   }
14547   test_num++;
14548   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
14549   if (test_lvs_0 () == -1) {
14550     printf ("test_lvs_0 FAILED\n");
14551     failed++;
14552   }
14553   test_num++;
14554   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
14555   if (test_lvs_1 () == -1) {
14556     printf ("test_lvs_1 FAILED\n");
14557     failed++;
14558   }
14559   test_num++;
14560   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
14561   if (test_vgs_0 () == -1) {
14562     printf ("test_vgs_0 FAILED\n");
14563     failed++;
14564   }
14565   test_num++;
14566   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
14567   if (test_vgs_1 () == -1) {
14568     printf ("test_vgs_1 FAILED\n");
14569     failed++;
14570   }
14571   test_num++;
14572   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
14573   if (test_pvs_0 () == -1) {
14574     printf ("test_pvs_0 FAILED\n");
14575     failed++;
14576   }
14577   test_num++;
14578   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
14579   if (test_pvs_1 () == -1) {
14580     printf ("test_pvs_1 FAILED\n");
14581     failed++;
14582   }
14583   test_num++;
14584   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
14585   if (test_list_partitions_0 () == -1) {
14586     printf ("test_list_partitions_0 FAILED\n");
14587     failed++;
14588   }
14589   test_num++;
14590   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
14591   if (test_list_partitions_1 () == -1) {
14592     printf ("test_list_partitions_1 FAILED\n");
14593     failed++;
14594   }
14595   test_num++;
14596   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
14597   if (test_list_devices_0 () == -1) {
14598     printf ("test_list_devices_0 FAILED\n");
14599     failed++;
14600   }
14601   test_num++;
14602   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
14603   if (test_ls_0 () == -1) {
14604     printf ("test_ls_0 FAILED\n");
14605     failed++;
14606   }
14607   test_num++;
14608   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
14609   if (test_cat_0 () == -1) {
14610     printf ("test_cat_0 FAILED\n");
14611     failed++;
14612   }
14613   test_num++;
14614   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
14615   if (test_touch_0 () == -1) {
14616     printf ("test_touch_0 FAILED\n");
14617     failed++;
14618   }
14619   test_num++;
14620   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
14621   if (test_sync_0 () == -1) {
14622     printf ("test_sync_0 FAILED\n");
14623     failed++;
14624   }
14625   test_num++;
14626   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
14627   if (test_mount_0 () == -1) {
14628     printf ("test_mount_0 FAILED\n");
14629     failed++;
14630   }
14631
14632   guestfs_close (g);
14633   unlink ("test1.img");
14634   unlink ("test2.img");
14635   unlink ("test3.img");
14636
14637   if (failed > 0) {
14638     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
14639     exit (1);
14640   }
14641
14642   exit (0);
14643 }