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