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 (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 (void)
4985 {
4986   /* InitBasicFS for command_lines (0): create ext2 on /dev/sda1 */
4987   {
4988     char device[] = "/dev/sda";
4989     device[5] = devchar;
4990     int r;
4991     suppress_error = 0;
4992     r = guestfs_blockdev_setrw (g, device);
4993     if (r == -1)
4994       return -1;
4995   }
4996   {
4997     int r;
4998     suppress_error = 0;
4999     r = guestfs_umount_all (g);
5000     if (r == -1)
5001       return -1;
5002   }
5003   {
5004     int r;
5005     suppress_error = 0;
5006     r = guestfs_lvm_remove_all (g);
5007     if (r == -1)
5008       return -1;
5009   }
5010   {
5011     char device[] = "/dev/sda";
5012     device[5] = devchar;
5013     char lines_0[] = ",";
5014     char *lines[] = {
5015       lines_0,
5016       NULL
5017     };
5018     int r;
5019     suppress_error = 0;
5020     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5021     if (r == -1)
5022       return -1;
5023   }
5024   {
5025     char fstype[] = "ext2";
5026     char device[] = "/dev/sda1";
5027     device[5] = devchar;
5028     int r;
5029     suppress_error = 0;
5030     r = guestfs_mkfs (g, fstype, device);
5031     if (r == -1)
5032       return -1;
5033   }
5034   {
5035     char device[] = "/dev/sda1";
5036     device[5] = devchar;
5037     char mountpoint[] = "/";
5038     int r;
5039     suppress_error = 0;
5040     r = guestfs_mount (g, device, mountpoint);
5041     if (r == -1)
5042       return -1;
5043   }
5044   /* TestOutputList for command_lines (0) */
5045   {
5046     char remotefilename[] = "/test-command";
5047     int r;
5048     suppress_error = 0;
5049     r = guestfs_upload (g, "test-command", remotefilename);
5050     if (r == -1)
5051       return -1;
5052   }
5053   {
5054     char path[] = "/test-command";
5055     int r;
5056     suppress_error = 0;
5057     r = guestfs_chmod (g, 493, path);
5058     if (r == -1)
5059       return -1;
5060   }
5061   {
5062     char arguments_0[] = "/test-command";
5063     char arguments_1[] = "1";
5064     char *arguments[] = {
5065       arguments_0,
5066       arguments_1,
5067       NULL
5068     };
5069     char **r;
5070     int i;
5071     suppress_error = 0;
5072     r = guestfs_command_lines (g, arguments);
5073     if (r == NULL)
5074       return -1;
5075     if (!r[0]) {
5076       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5077       print_strings (r);
5078       return -1;
5079     }
5080     {
5081       char expected[] = "Result1";
5082       if (strcmp (r[0], expected) != 0) {
5083         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5084         return -1;
5085       }
5086     }
5087     if (r[1] != NULL) {
5088       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5089       print_strings (r);
5090       return -1;
5091     }
5092     for (i = 0; r[i] != NULL; ++i)
5093       free (r[i]);
5094     free (r);
5095   }
5096   return 0;
5097 }
5098
5099 static int test_command_lines_1 (void)
5100 {
5101   /* InitBasicFS for command_lines (1): create ext2 on /dev/sda1 */
5102   {
5103     char device[] = "/dev/sda";
5104     device[5] = devchar;
5105     int r;
5106     suppress_error = 0;
5107     r = guestfs_blockdev_setrw (g, device);
5108     if (r == -1)
5109       return -1;
5110   }
5111   {
5112     int r;
5113     suppress_error = 0;
5114     r = guestfs_umount_all (g);
5115     if (r == -1)
5116       return -1;
5117   }
5118   {
5119     int r;
5120     suppress_error = 0;
5121     r = guestfs_lvm_remove_all (g);
5122     if (r == -1)
5123       return -1;
5124   }
5125   {
5126     char device[] = "/dev/sda";
5127     device[5] = devchar;
5128     char lines_0[] = ",";
5129     char *lines[] = {
5130       lines_0,
5131       NULL
5132     };
5133     int r;
5134     suppress_error = 0;
5135     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5136     if (r == -1)
5137       return -1;
5138   }
5139   {
5140     char fstype[] = "ext2";
5141     char device[] = "/dev/sda1";
5142     device[5] = devchar;
5143     int r;
5144     suppress_error = 0;
5145     r = guestfs_mkfs (g, fstype, device);
5146     if (r == -1)
5147       return -1;
5148   }
5149   {
5150     char device[] = "/dev/sda1";
5151     device[5] = devchar;
5152     char mountpoint[] = "/";
5153     int r;
5154     suppress_error = 0;
5155     r = guestfs_mount (g, device, mountpoint);
5156     if (r == -1)
5157       return -1;
5158   }
5159   /* TestOutputList for command_lines (1) */
5160   {
5161     char remotefilename[] = "/test-command";
5162     int r;
5163     suppress_error = 0;
5164     r = guestfs_upload (g, "test-command", remotefilename);
5165     if (r == -1)
5166       return -1;
5167   }
5168   {
5169     char path[] = "/test-command";
5170     int r;
5171     suppress_error = 0;
5172     r = guestfs_chmod (g, 493, path);
5173     if (r == -1)
5174       return -1;
5175   }
5176   {
5177     char arguments_0[] = "/test-command";
5178     char arguments_1[] = "2";
5179     char *arguments[] = {
5180       arguments_0,
5181       arguments_1,
5182       NULL
5183     };
5184     char **r;
5185     int i;
5186     suppress_error = 0;
5187     r = guestfs_command_lines (g, arguments);
5188     if (r == NULL)
5189       return -1;
5190     if (!r[0]) {
5191       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5192       print_strings (r);
5193       return -1;
5194     }
5195     {
5196       char expected[] = "Result2";
5197       if (strcmp (r[0], expected) != 0) {
5198         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5199         return -1;
5200       }
5201     }
5202     if (r[1] != NULL) {
5203       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5204       print_strings (r);
5205       return -1;
5206     }
5207     for (i = 0; r[i] != NULL; ++i)
5208       free (r[i]);
5209     free (r);
5210   }
5211   return 0;
5212 }
5213
5214 static int test_command_lines_2 (void)
5215 {
5216   /* InitBasicFS for command_lines (2): create ext2 on /dev/sda1 */
5217   {
5218     char device[] = "/dev/sda";
5219     device[5] = devchar;
5220     int r;
5221     suppress_error = 0;
5222     r = guestfs_blockdev_setrw (g, device);
5223     if (r == -1)
5224       return -1;
5225   }
5226   {
5227     int r;
5228     suppress_error = 0;
5229     r = guestfs_umount_all (g);
5230     if (r == -1)
5231       return -1;
5232   }
5233   {
5234     int r;
5235     suppress_error = 0;
5236     r = guestfs_lvm_remove_all (g);
5237     if (r == -1)
5238       return -1;
5239   }
5240   {
5241     char device[] = "/dev/sda";
5242     device[5] = devchar;
5243     char lines_0[] = ",";
5244     char *lines[] = {
5245       lines_0,
5246       NULL
5247     };
5248     int r;
5249     suppress_error = 0;
5250     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5251     if (r == -1)
5252       return -1;
5253   }
5254   {
5255     char fstype[] = "ext2";
5256     char device[] = "/dev/sda1";
5257     device[5] = devchar;
5258     int r;
5259     suppress_error = 0;
5260     r = guestfs_mkfs (g, fstype, device);
5261     if (r == -1)
5262       return -1;
5263   }
5264   {
5265     char device[] = "/dev/sda1";
5266     device[5] = devchar;
5267     char mountpoint[] = "/";
5268     int r;
5269     suppress_error = 0;
5270     r = guestfs_mount (g, device, mountpoint);
5271     if (r == -1)
5272       return -1;
5273   }
5274   /* TestOutputList for command_lines (2) */
5275   {
5276     char remotefilename[] = "/test-command";
5277     int r;
5278     suppress_error = 0;
5279     r = guestfs_upload (g, "test-command", remotefilename);
5280     if (r == -1)
5281       return -1;
5282   }
5283   {
5284     char path[] = "/test-command";
5285     int r;
5286     suppress_error = 0;
5287     r = guestfs_chmod (g, 493, path);
5288     if (r == -1)
5289       return -1;
5290   }
5291   {
5292     char arguments_0[] = "/test-command";
5293     char arguments_1[] = "3";
5294     char *arguments[] = {
5295       arguments_0,
5296       arguments_1,
5297       NULL
5298     };
5299     char **r;
5300     int i;
5301     suppress_error = 0;
5302     r = guestfs_command_lines (g, arguments);
5303     if (r == NULL)
5304       return -1;
5305     if (!r[0]) {
5306       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5307       print_strings (r);
5308       return -1;
5309     }
5310     {
5311       char expected[] = "";
5312       if (strcmp (r[0], expected) != 0) {
5313         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5314         return -1;
5315       }
5316     }
5317     if (!r[1]) {
5318       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5319       print_strings (r);
5320       return -1;
5321     }
5322     {
5323       char expected[] = "Result3";
5324       if (strcmp (r[1], expected) != 0) {
5325         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5326         return -1;
5327       }
5328     }
5329     if (r[2] != NULL) {
5330       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
5331       print_strings (r);
5332       return -1;
5333     }
5334     for (i = 0; r[i] != NULL; ++i)
5335       free (r[i]);
5336     free (r);
5337   }
5338   return 0;
5339 }
5340
5341 static int test_command_lines_3 (void)
5342 {
5343   /* InitBasicFS for command_lines (3): create ext2 on /dev/sda1 */
5344   {
5345     char device[] = "/dev/sda";
5346     device[5] = devchar;
5347     int r;
5348     suppress_error = 0;
5349     r = guestfs_blockdev_setrw (g, device);
5350     if (r == -1)
5351       return -1;
5352   }
5353   {
5354     int r;
5355     suppress_error = 0;
5356     r = guestfs_umount_all (g);
5357     if (r == -1)
5358       return -1;
5359   }
5360   {
5361     int r;
5362     suppress_error = 0;
5363     r = guestfs_lvm_remove_all (g);
5364     if (r == -1)
5365       return -1;
5366   }
5367   {
5368     char device[] = "/dev/sda";
5369     device[5] = devchar;
5370     char lines_0[] = ",";
5371     char *lines[] = {
5372       lines_0,
5373       NULL
5374     };
5375     int r;
5376     suppress_error = 0;
5377     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5378     if (r == -1)
5379       return -1;
5380   }
5381   {
5382     char fstype[] = "ext2";
5383     char device[] = "/dev/sda1";
5384     device[5] = devchar;
5385     int r;
5386     suppress_error = 0;
5387     r = guestfs_mkfs (g, fstype, device);
5388     if (r == -1)
5389       return -1;
5390   }
5391   {
5392     char device[] = "/dev/sda1";
5393     device[5] = devchar;
5394     char mountpoint[] = "/";
5395     int r;
5396     suppress_error = 0;
5397     r = guestfs_mount (g, device, mountpoint);
5398     if (r == -1)
5399       return -1;
5400   }
5401   /* TestOutputList for command_lines (3) */
5402   {
5403     char remotefilename[] = "/test-command";
5404     int r;
5405     suppress_error = 0;
5406     r = guestfs_upload (g, "test-command", remotefilename);
5407     if (r == -1)
5408       return -1;
5409   }
5410   {
5411     char path[] = "/test-command";
5412     int r;
5413     suppress_error = 0;
5414     r = guestfs_chmod (g, 493, path);
5415     if (r == -1)
5416       return -1;
5417   }
5418   {
5419     char arguments_0[] = "/test-command";
5420     char arguments_1[] = "4";
5421     char *arguments[] = {
5422       arguments_0,
5423       arguments_1,
5424       NULL
5425     };
5426     char **r;
5427     int i;
5428     suppress_error = 0;
5429     r = guestfs_command_lines (g, arguments);
5430     if (r == NULL)
5431       return -1;
5432     if (!r[0]) {
5433       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5434       print_strings (r);
5435       return -1;
5436     }
5437     {
5438       char expected[] = "";
5439       if (strcmp (r[0], expected) != 0) {
5440         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5441         return -1;
5442       }
5443     }
5444     if (!r[1]) {
5445       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5446       print_strings (r);
5447       return -1;
5448     }
5449     {
5450       char expected[] = "Result4";
5451       if (strcmp (r[1], expected) != 0) {
5452         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5453         return -1;
5454       }
5455     }
5456     if (r[2] != NULL) {
5457       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
5458       print_strings (r);
5459       return -1;
5460     }
5461     for (i = 0; r[i] != NULL; ++i)
5462       free (r[i]);
5463     free (r);
5464   }
5465   return 0;
5466 }
5467
5468 static int test_command_lines_4 (void)
5469 {
5470   /* InitBasicFS for command_lines (4): create ext2 on /dev/sda1 */
5471   {
5472     char device[] = "/dev/sda";
5473     device[5] = devchar;
5474     int r;
5475     suppress_error = 0;
5476     r = guestfs_blockdev_setrw (g, device);
5477     if (r == -1)
5478       return -1;
5479   }
5480   {
5481     int r;
5482     suppress_error = 0;
5483     r = guestfs_umount_all (g);
5484     if (r == -1)
5485       return -1;
5486   }
5487   {
5488     int r;
5489     suppress_error = 0;
5490     r = guestfs_lvm_remove_all (g);
5491     if (r == -1)
5492       return -1;
5493   }
5494   {
5495     char device[] = "/dev/sda";
5496     device[5] = devchar;
5497     char lines_0[] = ",";
5498     char *lines[] = {
5499       lines_0,
5500       NULL
5501     };
5502     int r;
5503     suppress_error = 0;
5504     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5505     if (r == -1)
5506       return -1;
5507   }
5508   {
5509     char fstype[] = "ext2";
5510     char device[] = "/dev/sda1";
5511     device[5] = devchar;
5512     int r;
5513     suppress_error = 0;
5514     r = guestfs_mkfs (g, fstype, device);
5515     if (r == -1)
5516       return -1;
5517   }
5518   {
5519     char device[] = "/dev/sda1";
5520     device[5] = devchar;
5521     char mountpoint[] = "/";
5522     int r;
5523     suppress_error = 0;
5524     r = guestfs_mount (g, device, mountpoint);
5525     if (r == -1)
5526       return -1;
5527   }
5528   /* TestOutputList for command_lines (4) */
5529   {
5530     char remotefilename[] = "/test-command";
5531     int r;
5532     suppress_error = 0;
5533     r = guestfs_upload (g, "test-command", remotefilename);
5534     if (r == -1)
5535       return -1;
5536   }
5537   {
5538     char path[] = "/test-command";
5539     int r;
5540     suppress_error = 0;
5541     r = guestfs_chmod (g, 493, path);
5542     if (r == -1)
5543       return -1;
5544   }
5545   {
5546     char arguments_0[] = "/test-command";
5547     char arguments_1[] = "5";
5548     char *arguments[] = {
5549       arguments_0,
5550       arguments_1,
5551       NULL
5552     };
5553     char **r;
5554     int i;
5555     suppress_error = 0;
5556     r = guestfs_command_lines (g, arguments);
5557     if (r == NULL)
5558       return -1;
5559     if (!r[0]) {
5560       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5561       print_strings (r);
5562       return -1;
5563     }
5564     {
5565       char expected[] = "";
5566       if (strcmp (r[0], expected) != 0) {
5567         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5568         return -1;
5569       }
5570     }
5571     if (!r[1]) {
5572       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5573       print_strings (r);
5574       return -1;
5575     }
5576     {
5577       char expected[] = "Result5";
5578       if (strcmp (r[1], expected) != 0) {
5579         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5580         return -1;
5581       }
5582     }
5583     if (!r[2]) {
5584       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5585       print_strings (r);
5586       return -1;
5587     }
5588     {
5589       char expected[] = "";
5590       if (strcmp (r[2], expected) != 0) {
5591         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5592         return -1;
5593       }
5594     }
5595     if (r[3] != NULL) {
5596       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
5597       print_strings (r);
5598       return -1;
5599     }
5600     for (i = 0; r[i] != NULL; ++i)
5601       free (r[i]);
5602     free (r);
5603   }
5604   return 0;
5605 }
5606
5607 static int test_command_lines_5 (void)
5608 {
5609   /* InitBasicFS for command_lines (5): create ext2 on /dev/sda1 */
5610   {
5611     char device[] = "/dev/sda";
5612     device[5] = devchar;
5613     int r;
5614     suppress_error = 0;
5615     r = guestfs_blockdev_setrw (g, device);
5616     if (r == -1)
5617       return -1;
5618   }
5619   {
5620     int r;
5621     suppress_error = 0;
5622     r = guestfs_umount_all (g);
5623     if (r == -1)
5624       return -1;
5625   }
5626   {
5627     int r;
5628     suppress_error = 0;
5629     r = guestfs_lvm_remove_all (g);
5630     if (r == -1)
5631       return -1;
5632   }
5633   {
5634     char device[] = "/dev/sda";
5635     device[5] = devchar;
5636     char lines_0[] = ",";
5637     char *lines[] = {
5638       lines_0,
5639       NULL
5640     };
5641     int r;
5642     suppress_error = 0;
5643     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5644     if (r == -1)
5645       return -1;
5646   }
5647   {
5648     char fstype[] = "ext2";
5649     char device[] = "/dev/sda1";
5650     device[5] = devchar;
5651     int r;
5652     suppress_error = 0;
5653     r = guestfs_mkfs (g, fstype, device);
5654     if (r == -1)
5655       return -1;
5656   }
5657   {
5658     char device[] = "/dev/sda1";
5659     device[5] = devchar;
5660     char mountpoint[] = "/";
5661     int r;
5662     suppress_error = 0;
5663     r = guestfs_mount (g, device, mountpoint);
5664     if (r == -1)
5665       return -1;
5666   }
5667   /* TestOutputList for command_lines (5) */
5668   {
5669     char remotefilename[] = "/test-command";
5670     int r;
5671     suppress_error = 0;
5672     r = guestfs_upload (g, "test-command", remotefilename);
5673     if (r == -1)
5674       return -1;
5675   }
5676   {
5677     char path[] = "/test-command";
5678     int r;
5679     suppress_error = 0;
5680     r = guestfs_chmod (g, 493, path);
5681     if (r == -1)
5682       return -1;
5683   }
5684   {
5685     char arguments_0[] = "/test-command";
5686     char arguments_1[] = "6";
5687     char *arguments[] = {
5688       arguments_0,
5689       arguments_1,
5690       NULL
5691     };
5692     char **r;
5693     int i;
5694     suppress_error = 0;
5695     r = guestfs_command_lines (g, arguments);
5696     if (r == NULL)
5697       return -1;
5698     if (!r[0]) {
5699       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5700       print_strings (r);
5701       return -1;
5702     }
5703     {
5704       char expected[] = "";
5705       if (strcmp (r[0], expected) != 0) {
5706         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5707         return -1;
5708       }
5709     }
5710     if (!r[1]) {
5711       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5712       print_strings (r);
5713       return -1;
5714     }
5715     {
5716       char expected[] = "";
5717       if (strcmp (r[1], expected) != 0) {
5718         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5719         return -1;
5720       }
5721     }
5722     if (!r[2]) {
5723       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5724       print_strings (r);
5725       return -1;
5726     }
5727     {
5728       char expected[] = "Result6";
5729       if (strcmp (r[2], expected) != 0) {
5730         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5731         return -1;
5732       }
5733     }
5734     if (!r[3]) {
5735       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5736       print_strings (r);
5737       return -1;
5738     }
5739     {
5740       char expected[] = "";
5741       if (strcmp (r[3], expected) != 0) {
5742         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
5743         return -1;
5744       }
5745     }
5746     if (r[4] != NULL) {
5747       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
5748       print_strings (r);
5749       return -1;
5750     }
5751     for (i = 0; r[i] != NULL; ++i)
5752       free (r[i]);
5753     free (r);
5754   }
5755   return 0;
5756 }
5757
5758 static int test_command_lines_6 (void)
5759 {
5760   /* InitBasicFS for command_lines (6): create ext2 on /dev/sda1 */
5761   {
5762     char device[] = "/dev/sda";
5763     device[5] = devchar;
5764     int r;
5765     suppress_error = 0;
5766     r = guestfs_blockdev_setrw (g, device);
5767     if (r == -1)
5768       return -1;
5769   }
5770   {
5771     int r;
5772     suppress_error = 0;
5773     r = guestfs_umount_all (g);
5774     if (r == -1)
5775       return -1;
5776   }
5777   {
5778     int r;
5779     suppress_error = 0;
5780     r = guestfs_lvm_remove_all (g);
5781     if (r == -1)
5782       return -1;
5783   }
5784   {
5785     char device[] = "/dev/sda";
5786     device[5] = devchar;
5787     char lines_0[] = ",";
5788     char *lines[] = {
5789       lines_0,
5790       NULL
5791     };
5792     int r;
5793     suppress_error = 0;
5794     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5795     if (r == -1)
5796       return -1;
5797   }
5798   {
5799     char fstype[] = "ext2";
5800     char device[] = "/dev/sda1";
5801     device[5] = devchar;
5802     int r;
5803     suppress_error = 0;
5804     r = guestfs_mkfs (g, fstype, device);
5805     if (r == -1)
5806       return -1;
5807   }
5808   {
5809     char device[] = "/dev/sda1";
5810     device[5] = devchar;
5811     char mountpoint[] = "/";
5812     int r;
5813     suppress_error = 0;
5814     r = guestfs_mount (g, device, mountpoint);
5815     if (r == -1)
5816       return -1;
5817   }
5818   /* TestOutputList for command_lines (6) */
5819   {
5820     char remotefilename[] = "/test-command";
5821     int r;
5822     suppress_error = 0;
5823     r = guestfs_upload (g, "test-command", remotefilename);
5824     if (r == -1)
5825       return -1;
5826   }
5827   {
5828     char path[] = "/test-command";
5829     int r;
5830     suppress_error = 0;
5831     r = guestfs_chmod (g, 493, path);
5832     if (r == -1)
5833       return -1;
5834   }
5835   {
5836     char arguments_0[] = "/test-command";
5837     char arguments_1[] = "7";
5838     char *arguments[] = {
5839       arguments_0,
5840       arguments_1,
5841       NULL
5842     };
5843     char **r;
5844     int i;
5845     suppress_error = 0;
5846     r = guestfs_command_lines (g, arguments);
5847     if (r == NULL)
5848       return -1;
5849     if (r[0] != NULL) {
5850       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
5851       print_strings (r);
5852       return -1;
5853     }
5854     for (i = 0; r[i] != NULL; ++i)
5855       free (r[i]);
5856     free (r);
5857   }
5858   return 0;
5859 }
5860
5861 static int test_command_lines_7 (void)
5862 {
5863   /* InitBasicFS for command_lines (7): create ext2 on /dev/sda1 */
5864   {
5865     char device[] = "/dev/sda";
5866     device[5] = devchar;
5867     int r;
5868     suppress_error = 0;
5869     r = guestfs_blockdev_setrw (g, device);
5870     if (r == -1)
5871       return -1;
5872   }
5873   {
5874     int r;
5875     suppress_error = 0;
5876     r = guestfs_umount_all (g);
5877     if (r == -1)
5878       return -1;
5879   }
5880   {
5881     int r;
5882     suppress_error = 0;
5883     r = guestfs_lvm_remove_all (g);
5884     if (r == -1)
5885       return -1;
5886   }
5887   {
5888     char device[] = "/dev/sda";
5889     device[5] = devchar;
5890     char lines_0[] = ",";
5891     char *lines[] = {
5892       lines_0,
5893       NULL
5894     };
5895     int r;
5896     suppress_error = 0;
5897     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5898     if (r == -1)
5899       return -1;
5900   }
5901   {
5902     char fstype[] = "ext2";
5903     char device[] = "/dev/sda1";
5904     device[5] = devchar;
5905     int r;
5906     suppress_error = 0;
5907     r = guestfs_mkfs (g, fstype, device);
5908     if (r == -1)
5909       return -1;
5910   }
5911   {
5912     char device[] = "/dev/sda1";
5913     device[5] = devchar;
5914     char mountpoint[] = "/";
5915     int r;
5916     suppress_error = 0;
5917     r = guestfs_mount (g, device, mountpoint);
5918     if (r == -1)
5919       return -1;
5920   }
5921   /* TestOutputList for command_lines (7) */
5922   {
5923     char remotefilename[] = "/test-command";
5924     int r;
5925     suppress_error = 0;
5926     r = guestfs_upload (g, "test-command", remotefilename);
5927     if (r == -1)
5928       return -1;
5929   }
5930   {
5931     char path[] = "/test-command";
5932     int r;
5933     suppress_error = 0;
5934     r = guestfs_chmod (g, 493, path);
5935     if (r == -1)
5936       return -1;
5937   }
5938   {
5939     char arguments_0[] = "/test-command";
5940     char arguments_1[] = "8";
5941     char *arguments[] = {
5942       arguments_0,
5943       arguments_1,
5944       NULL
5945     };
5946     char **r;
5947     int i;
5948     suppress_error = 0;
5949     r = guestfs_command_lines (g, arguments);
5950     if (r == NULL)
5951       return -1;
5952     if (!r[0]) {
5953       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
5954       print_strings (r);
5955       return -1;
5956     }
5957     {
5958       char expected[] = "";
5959       if (strcmp (r[0], expected) != 0) {
5960         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5961         return -1;
5962       }
5963     }
5964     if (r[1] != NULL) {
5965       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
5966       print_strings (r);
5967       return -1;
5968     }
5969     for (i = 0; r[i] != NULL; ++i)
5970       free (r[i]);
5971     free (r);
5972   }
5973   return 0;
5974 }
5975
5976 static int test_command_lines_8 (void)
5977 {
5978   /* InitBasicFS for command_lines (8): create ext2 on /dev/sda1 */
5979   {
5980     char device[] = "/dev/sda";
5981     device[5] = devchar;
5982     int r;
5983     suppress_error = 0;
5984     r = guestfs_blockdev_setrw (g, device);
5985     if (r == -1)
5986       return -1;
5987   }
5988   {
5989     int r;
5990     suppress_error = 0;
5991     r = guestfs_umount_all (g);
5992     if (r == -1)
5993       return -1;
5994   }
5995   {
5996     int r;
5997     suppress_error = 0;
5998     r = guestfs_lvm_remove_all (g);
5999     if (r == -1)
6000       return -1;
6001   }
6002   {
6003     char device[] = "/dev/sda";
6004     device[5] = devchar;
6005     char lines_0[] = ",";
6006     char *lines[] = {
6007       lines_0,
6008       NULL
6009     };
6010     int r;
6011     suppress_error = 0;
6012     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6013     if (r == -1)
6014       return -1;
6015   }
6016   {
6017     char fstype[] = "ext2";
6018     char device[] = "/dev/sda1";
6019     device[5] = devchar;
6020     int r;
6021     suppress_error = 0;
6022     r = guestfs_mkfs (g, fstype, device);
6023     if (r == -1)
6024       return -1;
6025   }
6026   {
6027     char device[] = "/dev/sda1";
6028     device[5] = devchar;
6029     char mountpoint[] = "/";
6030     int r;
6031     suppress_error = 0;
6032     r = guestfs_mount (g, device, mountpoint);
6033     if (r == -1)
6034       return -1;
6035   }
6036   /* TestOutputList for command_lines (8) */
6037   {
6038     char remotefilename[] = "/test-command";
6039     int r;
6040     suppress_error = 0;
6041     r = guestfs_upload (g, "test-command", remotefilename);
6042     if (r == -1)
6043       return -1;
6044   }
6045   {
6046     char path[] = "/test-command";
6047     int r;
6048     suppress_error = 0;
6049     r = guestfs_chmod (g, 493, path);
6050     if (r == -1)
6051       return -1;
6052   }
6053   {
6054     char arguments_0[] = "/test-command";
6055     char arguments_1[] = "9";
6056     char *arguments[] = {
6057       arguments_0,
6058       arguments_1,
6059       NULL
6060     };
6061     char **r;
6062     int i;
6063     suppress_error = 0;
6064     r = guestfs_command_lines (g, arguments);
6065     if (r == NULL)
6066       return -1;
6067     if (!r[0]) {
6068       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6069       print_strings (r);
6070       return -1;
6071     }
6072     {
6073       char expected[] = "";
6074       if (strcmp (r[0], expected) != 0) {
6075         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6076         return -1;
6077       }
6078     }
6079     if (!r[1]) {
6080       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6081       print_strings (r);
6082       return -1;
6083     }
6084     {
6085       char expected[] = "";
6086       if (strcmp (r[1], expected) != 0) {
6087         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6088         return -1;
6089       }
6090     }
6091     if (r[2] != NULL) {
6092       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6093       print_strings (r);
6094       return -1;
6095     }
6096     for (i = 0; r[i] != NULL; ++i)
6097       free (r[i]);
6098     free (r);
6099   }
6100   return 0;
6101 }
6102
6103 static int test_command_lines_9 (void)
6104 {
6105   /* InitBasicFS for command_lines (9): create ext2 on /dev/sda1 */
6106   {
6107     char device[] = "/dev/sda";
6108     device[5] = devchar;
6109     int r;
6110     suppress_error = 0;
6111     r = guestfs_blockdev_setrw (g, device);
6112     if (r == -1)
6113       return -1;
6114   }
6115   {
6116     int r;
6117     suppress_error = 0;
6118     r = guestfs_umount_all (g);
6119     if (r == -1)
6120       return -1;
6121   }
6122   {
6123     int r;
6124     suppress_error = 0;
6125     r = guestfs_lvm_remove_all (g);
6126     if (r == -1)
6127       return -1;
6128   }
6129   {
6130     char device[] = "/dev/sda";
6131     device[5] = devchar;
6132     char lines_0[] = ",";
6133     char *lines[] = {
6134       lines_0,
6135       NULL
6136     };
6137     int r;
6138     suppress_error = 0;
6139     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6140     if (r == -1)
6141       return -1;
6142   }
6143   {
6144     char fstype[] = "ext2";
6145     char device[] = "/dev/sda1";
6146     device[5] = devchar;
6147     int r;
6148     suppress_error = 0;
6149     r = guestfs_mkfs (g, fstype, device);
6150     if (r == -1)
6151       return -1;
6152   }
6153   {
6154     char device[] = "/dev/sda1";
6155     device[5] = devchar;
6156     char mountpoint[] = "/";
6157     int r;
6158     suppress_error = 0;
6159     r = guestfs_mount (g, device, mountpoint);
6160     if (r == -1)
6161       return -1;
6162   }
6163   /* TestOutputList for command_lines (9) */
6164   {
6165     char remotefilename[] = "/test-command";
6166     int r;
6167     suppress_error = 0;
6168     r = guestfs_upload (g, "test-command", remotefilename);
6169     if (r == -1)
6170       return -1;
6171   }
6172   {
6173     char path[] = "/test-command";
6174     int r;
6175     suppress_error = 0;
6176     r = guestfs_chmod (g, 493, path);
6177     if (r == -1)
6178       return -1;
6179   }
6180   {
6181     char arguments_0[] = "/test-command";
6182     char arguments_1[] = "10";
6183     char *arguments[] = {
6184       arguments_0,
6185       arguments_1,
6186       NULL
6187     };
6188     char **r;
6189     int i;
6190     suppress_error = 0;
6191     r = guestfs_command_lines (g, arguments);
6192     if (r == NULL)
6193       return -1;
6194     if (!r[0]) {
6195       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6196       print_strings (r);
6197       return -1;
6198     }
6199     {
6200       char expected[] = "Result10-1";
6201       if (strcmp (r[0], expected) != 0) {
6202         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6203         return -1;
6204       }
6205     }
6206     if (!r[1]) {
6207       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6208       print_strings (r);
6209       return -1;
6210     }
6211     {
6212       char expected[] = "Result10-2";
6213       if (strcmp (r[1], expected) != 0) {
6214         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6215         return -1;
6216       }
6217     }
6218     if (r[2] != NULL) {
6219       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6220       print_strings (r);
6221       return -1;
6222     }
6223     for (i = 0; r[i] != NULL; ++i)
6224       free (r[i]);
6225     free (r);
6226   }
6227   return 0;
6228 }
6229
6230 static int test_command_lines_10 (void)
6231 {
6232   /* InitBasicFS for command_lines (10): create ext2 on /dev/sda1 */
6233   {
6234     char device[] = "/dev/sda";
6235     device[5] = devchar;
6236     int r;
6237     suppress_error = 0;
6238     r = guestfs_blockdev_setrw (g, device);
6239     if (r == -1)
6240       return -1;
6241   }
6242   {
6243     int r;
6244     suppress_error = 0;
6245     r = guestfs_umount_all (g);
6246     if (r == -1)
6247       return -1;
6248   }
6249   {
6250     int r;
6251     suppress_error = 0;
6252     r = guestfs_lvm_remove_all (g);
6253     if (r == -1)
6254       return -1;
6255   }
6256   {
6257     char device[] = "/dev/sda";
6258     device[5] = devchar;
6259     char lines_0[] = ",";
6260     char *lines[] = {
6261       lines_0,
6262       NULL
6263     };
6264     int r;
6265     suppress_error = 0;
6266     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6267     if (r == -1)
6268       return -1;
6269   }
6270   {
6271     char fstype[] = "ext2";
6272     char device[] = "/dev/sda1";
6273     device[5] = devchar;
6274     int r;
6275     suppress_error = 0;
6276     r = guestfs_mkfs (g, fstype, device);
6277     if (r == -1)
6278       return -1;
6279   }
6280   {
6281     char device[] = "/dev/sda1";
6282     device[5] = devchar;
6283     char mountpoint[] = "/";
6284     int r;
6285     suppress_error = 0;
6286     r = guestfs_mount (g, device, mountpoint);
6287     if (r == -1)
6288       return -1;
6289   }
6290   /* TestOutputList for command_lines (10) */
6291   {
6292     char remotefilename[] = "/test-command";
6293     int r;
6294     suppress_error = 0;
6295     r = guestfs_upload (g, "test-command", remotefilename);
6296     if (r == -1)
6297       return -1;
6298   }
6299   {
6300     char path[] = "/test-command";
6301     int r;
6302     suppress_error = 0;
6303     r = guestfs_chmod (g, 493, path);
6304     if (r == -1)
6305       return -1;
6306   }
6307   {
6308     char arguments_0[] = "/test-command";
6309     char arguments_1[] = "11";
6310     char *arguments[] = {
6311       arguments_0,
6312       arguments_1,
6313       NULL
6314     };
6315     char **r;
6316     int i;
6317     suppress_error = 0;
6318     r = guestfs_command_lines (g, arguments);
6319     if (r == NULL)
6320       return -1;
6321     if (!r[0]) {
6322       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6323       print_strings (r);
6324       return -1;
6325     }
6326     {
6327       char expected[] = "Result11-1";
6328       if (strcmp (r[0], expected) != 0) {
6329         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6330         return -1;
6331       }
6332     }
6333     if (!r[1]) {
6334       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6335       print_strings (r);
6336       return -1;
6337     }
6338     {
6339       char expected[] = "Result11-2";
6340       if (strcmp (r[1], expected) != 0) {
6341         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6342         return -1;
6343       }
6344     }
6345     if (r[2] != NULL) {
6346       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
6347       print_strings (r);
6348       return -1;
6349     }
6350     for (i = 0; r[i] != NULL; ++i)
6351       free (r[i]);
6352     free (r);
6353   }
6354   return 0;
6355 }
6356
6357 static int test_command_0 (void)
6358 {
6359   /* InitBasicFS for command (0): create ext2 on /dev/sda1 */
6360   {
6361     char device[] = "/dev/sda";
6362     device[5] = devchar;
6363     int r;
6364     suppress_error = 0;
6365     r = guestfs_blockdev_setrw (g, device);
6366     if (r == -1)
6367       return -1;
6368   }
6369   {
6370     int r;
6371     suppress_error = 0;
6372     r = guestfs_umount_all (g);
6373     if (r == -1)
6374       return -1;
6375   }
6376   {
6377     int r;
6378     suppress_error = 0;
6379     r = guestfs_lvm_remove_all (g);
6380     if (r == -1)
6381       return -1;
6382   }
6383   {
6384     char device[] = "/dev/sda";
6385     device[5] = devchar;
6386     char lines_0[] = ",";
6387     char *lines[] = {
6388       lines_0,
6389       NULL
6390     };
6391     int r;
6392     suppress_error = 0;
6393     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6394     if (r == -1)
6395       return -1;
6396   }
6397   {
6398     char fstype[] = "ext2";
6399     char device[] = "/dev/sda1";
6400     device[5] = devchar;
6401     int r;
6402     suppress_error = 0;
6403     r = guestfs_mkfs (g, fstype, device);
6404     if (r == -1)
6405       return -1;
6406   }
6407   {
6408     char device[] = "/dev/sda1";
6409     device[5] = devchar;
6410     char mountpoint[] = "/";
6411     int r;
6412     suppress_error = 0;
6413     r = guestfs_mount (g, device, mountpoint);
6414     if (r == -1)
6415       return -1;
6416   }
6417   /* TestOutput for command (0) */
6418   char expected[] = "Result1";
6419   {
6420     char remotefilename[] = "/test-command";
6421     int r;
6422     suppress_error = 0;
6423     r = guestfs_upload (g, "test-command", remotefilename);
6424     if (r == -1)
6425       return -1;
6426   }
6427   {
6428     char path[] = "/test-command";
6429     int r;
6430     suppress_error = 0;
6431     r = guestfs_chmod (g, 493, path);
6432     if (r == -1)
6433       return -1;
6434   }
6435   {
6436     char arguments_0[] = "/test-command";
6437     char arguments_1[] = "1";
6438     char *arguments[] = {
6439       arguments_0,
6440       arguments_1,
6441       NULL
6442     };
6443     char *r;
6444     suppress_error = 0;
6445     r = guestfs_command (g, arguments);
6446     if (r == NULL)
6447       return -1;
6448     if (strcmp (r, expected) != 0) {
6449       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
6450       return -1;
6451     }
6452     free (r);
6453   }
6454   return 0;
6455 }
6456
6457 static int test_command_1 (void)
6458 {
6459   /* InitBasicFS for command (1): create ext2 on /dev/sda1 */
6460   {
6461     char device[] = "/dev/sda";
6462     device[5] = devchar;
6463     int r;
6464     suppress_error = 0;
6465     r = guestfs_blockdev_setrw (g, device);
6466     if (r == -1)
6467       return -1;
6468   }
6469   {
6470     int r;
6471     suppress_error = 0;
6472     r = guestfs_umount_all (g);
6473     if (r == -1)
6474       return -1;
6475   }
6476   {
6477     int r;
6478     suppress_error = 0;
6479     r = guestfs_lvm_remove_all (g);
6480     if (r == -1)
6481       return -1;
6482   }
6483   {
6484     char device[] = "/dev/sda";
6485     device[5] = devchar;
6486     char lines_0[] = ",";
6487     char *lines[] = {
6488       lines_0,
6489       NULL
6490     };
6491     int r;
6492     suppress_error = 0;
6493     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6494     if (r == -1)
6495       return -1;
6496   }
6497   {
6498     char fstype[] = "ext2";
6499     char device[] = "/dev/sda1";
6500     device[5] = devchar;
6501     int r;
6502     suppress_error = 0;
6503     r = guestfs_mkfs (g, fstype, device);
6504     if (r == -1)
6505       return -1;
6506   }
6507   {
6508     char device[] = "/dev/sda1";
6509     device[5] = devchar;
6510     char mountpoint[] = "/";
6511     int r;
6512     suppress_error = 0;
6513     r = guestfs_mount (g, device, mountpoint);
6514     if (r == -1)
6515       return -1;
6516   }
6517   /* TestOutput for command (1) */
6518   char expected[] = "Result2\n";
6519   {
6520     char remotefilename[] = "/test-command";
6521     int r;
6522     suppress_error = 0;
6523     r = guestfs_upload (g, "test-command", remotefilename);
6524     if (r == -1)
6525       return -1;
6526   }
6527   {
6528     char path[] = "/test-command";
6529     int r;
6530     suppress_error = 0;
6531     r = guestfs_chmod (g, 493, path);
6532     if (r == -1)
6533       return -1;
6534   }
6535   {
6536     char arguments_0[] = "/test-command";
6537     char arguments_1[] = "2";
6538     char *arguments[] = {
6539       arguments_0,
6540       arguments_1,
6541       NULL
6542     };
6543     char *r;
6544     suppress_error = 0;
6545     r = guestfs_command (g, arguments);
6546     if (r == NULL)
6547       return -1;
6548     if (strcmp (r, expected) != 0) {
6549       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
6550       return -1;
6551     }
6552     free (r);
6553   }
6554   return 0;
6555 }
6556
6557 static int test_command_2 (void)
6558 {
6559   /* InitBasicFS for command (2): create ext2 on /dev/sda1 */
6560   {
6561     char device[] = "/dev/sda";
6562     device[5] = devchar;
6563     int r;
6564     suppress_error = 0;
6565     r = guestfs_blockdev_setrw (g, device);
6566     if (r == -1)
6567       return -1;
6568   }
6569   {
6570     int r;
6571     suppress_error = 0;
6572     r = guestfs_umount_all (g);
6573     if (r == -1)
6574       return -1;
6575   }
6576   {
6577     int r;
6578     suppress_error = 0;
6579     r = guestfs_lvm_remove_all (g);
6580     if (r == -1)
6581       return -1;
6582   }
6583   {
6584     char device[] = "/dev/sda";
6585     device[5] = devchar;
6586     char lines_0[] = ",";
6587     char *lines[] = {
6588       lines_0,
6589       NULL
6590     };
6591     int r;
6592     suppress_error = 0;
6593     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6594     if (r == -1)
6595       return -1;
6596   }
6597   {
6598     char fstype[] = "ext2";
6599     char device[] = "/dev/sda1";
6600     device[5] = devchar;
6601     int r;
6602     suppress_error = 0;
6603     r = guestfs_mkfs (g, fstype, device);
6604     if (r == -1)
6605       return -1;
6606   }
6607   {
6608     char device[] = "/dev/sda1";
6609     device[5] = devchar;
6610     char mountpoint[] = "/";
6611     int r;
6612     suppress_error = 0;
6613     r = guestfs_mount (g, device, mountpoint);
6614     if (r == -1)
6615       return -1;
6616   }
6617   /* TestOutput for command (2) */
6618   char expected[] = "\nResult3";
6619   {
6620     char remotefilename[] = "/test-command";
6621     int r;
6622     suppress_error = 0;
6623     r = guestfs_upload (g, "test-command", remotefilename);
6624     if (r == -1)
6625       return -1;
6626   }
6627   {
6628     char path[] = "/test-command";
6629     int r;
6630     suppress_error = 0;
6631     r = guestfs_chmod (g, 493, path);
6632     if (r == -1)
6633       return -1;
6634   }
6635   {
6636     char arguments_0[] = "/test-command";
6637     char arguments_1[] = "3";
6638     char *arguments[] = {
6639       arguments_0,
6640       arguments_1,
6641       NULL
6642     };
6643     char *r;
6644     suppress_error = 0;
6645     r = guestfs_command (g, arguments);
6646     if (r == NULL)
6647       return -1;
6648     if (strcmp (r, expected) != 0) {
6649       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
6650       return -1;
6651     }
6652     free (r);
6653   }
6654   return 0;
6655 }
6656
6657 static int test_command_3 (void)
6658 {
6659   /* InitBasicFS for command (3): create ext2 on /dev/sda1 */
6660   {
6661     char device[] = "/dev/sda";
6662     device[5] = devchar;
6663     int r;
6664     suppress_error = 0;
6665     r = guestfs_blockdev_setrw (g, device);
6666     if (r == -1)
6667       return -1;
6668   }
6669   {
6670     int r;
6671     suppress_error = 0;
6672     r = guestfs_umount_all (g);
6673     if (r == -1)
6674       return -1;
6675   }
6676   {
6677     int r;
6678     suppress_error = 0;
6679     r = guestfs_lvm_remove_all (g);
6680     if (r == -1)
6681       return -1;
6682   }
6683   {
6684     char device[] = "/dev/sda";
6685     device[5] = devchar;
6686     char lines_0[] = ",";
6687     char *lines[] = {
6688       lines_0,
6689       NULL
6690     };
6691     int r;
6692     suppress_error = 0;
6693     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6694     if (r == -1)
6695       return -1;
6696   }
6697   {
6698     char fstype[] = "ext2";
6699     char device[] = "/dev/sda1";
6700     device[5] = devchar;
6701     int r;
6702     suppress_error = 0;
6703     r = guestfs_mkfs (g, fstype, device);
6704     if (r == -1)
6705       return -1;
6706   }
6707   {
6708     char device[] = "/dev/sda1";
6709     device[5] = devchar;
6710     char mountpoint[] = "/";
6711     int r;
6712     suppress_error = 0;
6713     r = guestfs_mount (g, device, mountpoint);
6714     if (r == -1)
6715       return -1;
6716   }
6717   /* TestOutput for command (3) */
6718   char expected[] = "\nResult4\n";
6719   {
6720     char remotefilename[] = "/test-command";
6721     int r;
6722     suppress_error = 0;
6723     r = guestfs_upload (g, "test-command", remotefilename);
6724     if (r == -1)
6725       return -1;
6726   }
6727   {
6728     char path[] = "/test-command";
6729     int r;
6730     suppress_error = 0;
6731     r = guestfs_chmod (g, 493, path);
6732     if (r == -1)
6733       return -1;
6734   }
6735   {
6736     char arguments_0[] = "/test-command";
6737     char arguments_1[] = "4";
6738     char *arguments[] = {
6739       arguments_0,
6740       arguments_1,
6741       NULL
6742     };
6743     char *r;
6744     suppress_error = 0;
6745     r = guestfs_command (g, arguments);
6746     if (r == NULL)
6747       return -1;
6748     if (strcmp (r, expected) != 0) {
6749       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
6750       return -1;
6751     }
6752     free (r);
6753   }
6754   return 0;
6755 }
6756
6757 static int test_command_4 (void)
6758 {
6759   /* InitBasicFS for command (4): create ext2 on /dev/sda1 */
6760   {
6761     char device[] = "/dev/sda";
6762     device[5] = devchar;
6763     int r;
6764     suppress_error = 0;
6765     r = guestfs_blockdev_setrw (g, device);
6766     if (r == -1)
6767       return -1;
6768   }
6769   {
6770     int r;
6771     suppress_error = 0;
6772     r = guestfs_umount_all (g);
6773     if (r == -1)
6774       return -1;
6775   }
6776   {
6777     int r;
6778     suppress_error = 0;
6779     r = guestfs_lvm_remove_all (g);
6780     if (r == -1)
6781       return -1;
6782   }
6783   {
6784     char device[] = "/dev/sda";
6785     device[5] = devchar;
6786     char lines_0[] = ",";
6787     char *lines[] = {
6788       lines_0,
6789       NULL
6790     };
6791     int r;
6792     suppress_error = 0;
6793     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6794     if (r == -1)
6795       return -1;
6796   }
6797   {
6798     char fstype[] = "ext2";
6799     char device[] = "/dev/sda1";
6800     device[5] = devchar;
6801     int r;
6802     suppress_error = 0;
6803     r = guestfs_mkfs (g, fstype, device);
6804     if (r == -1)
6805       return -1;
6806   }
6807   {
6808     char device[] = "/dev/sda1";
6809     device[5] = devchar;
6810     char mountpoint[] = "/";
6811     int r;
6812     suppress_error = 0;
6813     r = guestfs_mount (g, device, mountpoint);
6814     if (r == -1)
6815       return -1;
6816   }
6817   /* TestOutput for command (4) */
6818   char expected[] = "\nResult5\n\n";
6819   {
6820     char remotefilename[] = "/test-command";
6821     int r;
6822     suppress_error = 0;
6823     r = guestfs_upload (g, "test-command", remotefilename);
6824     if (r == -1)
6825       return -1;
6826   }
6827   {
6828     char path[] = "/test-command";
6829     int r;
6830     suppress_error = 0;
6831     r = guestfs_chmod (g, 493, path);
6832     if (r == -1)
6833       return -1;
6834   }
6835   {
6836     char arguments_0[] = "/test-command";
6837     char arguments_1[] = "5";
6838     char *arguments[] = {
6839       arguments_0,
6840       arguments_1,
6841       NULL
6842     };
6843     char *r;
6844     suppress_error = 0;
6845     r = guestfs_command (g, arguments);
6846     if (r == NULL)
6847       return -1;
6848     if (strcmp (r, expected) != 0) {
6849       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
6850       return -1;
6851     }
6852     free (r);
6853   }
6854   return 0;
6855 }
6856
6857 static int test_command_5 (void)
6858 {
6859   /* InitBasicFS for command (5): create ext2 on /dev/sda1 */
6860   {
6861     char device[] = "/dev/sda";
6862     device[5] = devchar;
6863     int r;
6864     suppress_error = 0;
6865     r = guestfs_blockdev_setrw (g, device);
6866     if (r == -1)
6867       return -1;
6868   }
6869   {
6870     int r;
6871     suppress_error = 0;
6872     r = guestfs_umount_all (g);
6873     if (r == -1)
6874       return -1;
6875   }
6876   {
6877     int r;
6878     suppress_error = 0;
6879     r = guestfs_lvm_remove_all (g);
6880     if (r == -1)
6881       return -1;
6882   }
6883   {
6884     char device[] = "/dev/sda";
6885     device[5] = devchar;
6886     char lines_0[] = ",";
6887     char *lines[] = {
6888       lines_0,
6889       NULL
6890     };
6891     int r;
6892     suppress_error = 0;
6893     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6894     if (r == -1)
6895       return -1;
6896   }
6897   {
6898     char fstype[] = "ext2";
6899     char device[] = "/dev/sda1";
6900     device[5] = devchar;
6901     int r;
6902     suppress_error = 0;
6903     r = guestfs_mkfs (g, fstype, device);
6904     if (r == -1)
6905       return -1;
6906   }
6907   {
6908     char device[] = "/dev/sda1";
6909     device[5] = devchar;
6910     char mountpoint[] = "/";
6911     int r;
6912     suppress_error = 0;
6913     r = guestfs_mount (g, device, mountpoint);
6914     if (r == -1)
6915       return -1;
6916   }
6917   /* TestOutput for command (5) */
6918   char expected[] = "\n\nResult6\n\n";
6919   {
6920     char remotefilename[] = "/test-command";
6921     int r;
6922     suppress_error = 0;
6923     r = guestfs_upload (g, "test-command", remotefilename);
6924     if (r == -1)
6925       return -1;
6926   }
6927   {
6928     char path[] = "/test-command";
6929     int r;
6930     suppress_error = 0;
6931     r = guestfs_chmod (g, 493, path);
6932     if (r == -1)
6933       return -1;
6934   }
6935   {
6936     char arguments_0[] = "/test-command";
6937     char arguments_1[] = "6";
6938     char *arguments[] = {
6939       arguments_0,
6940       arguments_1,
6941       NULL
6942     };
6943     char *r;
6944     suppress_error = 0;
6945     r = guestfs_command (g, arguments);
6946     if (r == NULL)
6947       return -1;
6948     if (strcmp (r, expected) != 0) {
6949       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
6950       return -1;
6951     }
6952     free (r);
6953   }
6954   return 0;
6955 }
6956
6957 static int test_command_6 (void)
6958 {
6959   /* InitBasicFS for command (6): create ext2 on /dev/sda1 */
6960   {
6961     char device[] = "/dev/sda";
6962     device[5] = devchar;
6963     int r;
6964     suppress_error = 0;
6965     r = guestfs_blockdev_setrw (g, device);
6966     if (r == -1)
6967       return -1;
6968   }
6969   {
6970     int r;
6971     suppress_error = 0;
6972     r = guestfs_umount_all (g);
6973     if (r == -1)
6974       return -1;
6975   }
6976   {
6977     int r;
6978     suppress_error = 0;
6979     r = guestfs_lvm_remove_all (g);
6980     if (r == -1)
6981       return -1;
6982   }
6983   {
6984     char device[] = "/dev/sda";
6985     device[5] = devchar;
6986     char lines_0[] = ",";
6987     char *lines[] = {
6988       lines_0,
6989       NULL
6990     };
6991     int r;
6992     suppress_error = 0;
6993     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6994     if (r == -1)
6995       return -1;
6996   }
6997   {
6998     char fstype[] = "ext2";
6999     char device[] = "/dev/sda1";
7000     device[5] = devchar;
7001     int r;
7002     suppress_error = 0;
7003     r = guestfs_mkfs (g, fstype, device);
7004     if (r == -1)
7005       return -1;
7006   }
7007   {
7008     char device[] = "/dev/sda1";
7009     device[5] = devchar;
7010     char mountpoint[] = "/";
7011     int r;
7012     suppress_error = 0;
7013     r = guestfs_mount (g, device, mountpoint);
7014     if (r == -1)
7015       return -1;
7016   }
7017   /* TestOutput for command (6) */
7018   char expected[] = "";
7019   {
7020     char remotefilename[] = "/test-command";
7021     int r;
7022     suppress_error = 0;
7023     r = guestfs_upload (g, "test-command", remotefilename);
7024     if (r == -1)
7025       return -1;
7026   }
7027   {
7028     char path[] = "/test-command";
7029     int r;
7030     suppress_error = 0;
7031     r = guestfs_chmod (g, 493, path);
7032     if (r == -1)
7033       return -1;
7034   }
7035   {
7036     char arguments_0[] = "/test-command";
7037     char arguments_1[] = "7";
7038     char *arguments[] = {
7039       arguments_0,
7040       arguments_1,
7041       NULL
7042     };
7043     char *r;
7044     suppress_error = 0;
7045     r = guestfs_command (g, arguments);
7046     if (r == NULL)
7047       return -1;
7048     if (strcmp (r, expected) != 0) {
7049       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7050       return -1;
7051     }
7052     free (r);
7053   }
7054   return 0;
7055 }
7056
7057 static int test_command_7 (void)
7058 {
7059   /* InitBasicFS for command (7): create ext2 on /dev/sda1 */
7060   {
7061     char device[] = "/dev/sda";
7062     device[5] = devchar;
7063     int r;
7064     suppress_error = 0;
7065     r = guestfs_blockdev_setrw (g, device);
7066     if (r == -1)
7067       return -1;
7068   }
7069   {
7070     int r;
7071     suppress_error = 0;
7072     r = guestfs_umount_all (g);
7073     if (r == -1)
7074       return -1;
7075   }
7076   {
7077     int r;
7078     suppress_error = 0;
7079     r = guestfs_lvm_remove_all (g);
7080     if (r == -1)
7081       return -1;
7082   }
7083   {
7084     char device[] = "/dev/sda";
7085     device[5] = devchar;
7086     char lines_0[] = ",";
7087     char *lines[] = {
7088       lines_0,
7089       NULL
7090     };
7091     int r;
7092     suppress_error = 0;
7093     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7094     if (r == -1)
7095       return -1;
7096   }
7097   {
7098     char fstype[] = "ext2";
7099     char device[] = "/dev/sda1";
7100     device[5] = devchar;
7101     int r;
7102     suppress_error = 0;
7103     r = guestfs_mkfs (g, fstype, device);
7104     if (r == -1)
7105       return -1;
7106   }
7107   {
7108     char device[] = "/dev/sda1";
7109     device[5] = devchar;
7110     char mountpoint[] = "/";
7111     int r;
7112     suppress_error = 0;
7113     r = guestfs_mount (g, device, mountpoint);
7114     if (r == -1)
7115       return -1;
7116   }
7117   /* TestOutput for command (7) */
7118   char expected[] = "\n";
7119   {
7120     char remotefilename[] = "/test-command";
7121     int r;
7122     suppress_error = 0;
7123     r = guestfs_upload (g, "test-command", remotefilename);
7124     if (r == -1)
7125       return -1;
7126   }
7127   {
7128     char path[] = "/test-command";
7129     int r;
7130     suppress_error = 0;
7131     r = guestfs_chmod (g, 493, path);
7132     if (r == -1)
7133       return -1;
7134   }
7135   {
7136     char arguments_0[] = "/test-command";
7137     char arguments_1[] = "8";
7138     char *arguments[] = {
7139       arguments_0,
7140       arguments_1,
7141       NULL
7142     };
7143     char *r;
7144     suppress_error = 0;
7145     r = guestfs_command (g, arguments);
7146     if (r == NULL)
7147       return -1;
7148     if (strcmp (r, expected) != 0) {
7149       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7150       return -1;
7151     }
7152     free (r);
7153   }
7154   return 0;
7155 }
7156
7157 static int test_command_8 (void)
7158 {
7159   /* InitBasicFS for command (8): create ext2 on /dev/sda1 */
7160   {
7161     char device[] = "/dev/sda";
7162     device[5] = devchar;
7163     int r;
7164     suppress_error = 0;
7165     r = guestfs_blockdev_setrw (g, device);
7166     if (r == -1)
7167       return -1;
7168   }
7169   {
7170     int r;
7171     suppress_error = 0;
7172     r = guestfs_umount_all (g);
7173     if (r == -1)
7174       return -1;
7175   }
7176   {
7177     int r;
7178     suppress_error = 0;
7179     r = guestfs_lvm_remove_all (g);
7180     if (r == -1)
7181       return -1;
7182   }
7183   {
7184     char device[] = "/dev/sda";
7185     device[5] = devchar;
7186     char lines_0[] = ",";
7187     char *lines[] = {
7188       lines_0,
7189       NULL
7190     };
7191     int r;
7192     suppress_error = 0;
7193     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7194     if (r == -1)
7195       return -1;
7196   }
7197   {
7198     char fstype[] = "ext2";
7199     char device[] = "/dev/sda1";
7200     device[5] = devchar;
7201     int r;
7202     suppress_error = 0;
7203     r = guestfs_mkfs (g, fstype, device);
7204     if (r == -1)
7205       return -1;
7206   }
7207   {
7208     char device[] = "/dev/sda1";
7209     device[5] = devchar;
7210     char mountpoint[] = "/";
7211     int r;
7212     suppress_error = 0;
7213     r = guestfs_mount (g, device, mountpoint);
7214     if (r == -1)
7215       return -1;
7216   }
7217   /* TestOutput for command (8) */
7218   char expected[] = "\n\n";
7219   {
7220     char remotefilename[] = "/test-command";
7221     int r;
7222     suppress_error = 0;
7223     r = guestfs_upload (g, "test-command", remotefilename);
7224     if (r == -1)
7225       return -1;
7226   }
7227   {
7228     char path[] = "/test-command";
7229     int r;
7230     suppress_error = 0;
7231     r = guestfs_chmod (g, 493, path);
7232     if (r == -1)
7233       return -1;
7234   }
7235   {
7236     char arguments_0[] = "/test-command";
7237     char arguments_1[] = "9";
7238     char *arguments[] = {
7239       arguments_0,
7240       arguments_1,
7241       NULL
7242     };
7243     char *r;
7244     suppress_error = 0;
7245     r = guestfs_command (g, arguments);
7246     if (r == NULL)
7247       return -1;
7248     if (strcmp (r, expected) != 0) {
7249       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
7250       return -1;
7251     }
7252     free (r);
7253   }
7254   return 0;
7255 }
7256
7257 static int test_command_9 (void)
7258 {
7259   /* InitBasicFS for command (9): create ext2 on /dev/sda1 */
7260   {
7261     char device[] = "/dev/sda";
7262     device[5] = devchar;
7263     int r;
7264     suppress_error = 0;
7265     r = guestfs_blockdev_setrw (g, device);
7266     if (r == -1)
7267       return -1;
7268   }
7269   {
7270     int r;
7271     suppress_error = 0;
7272     r = guestfs_umount_all (g);
7273     if (r == -1)
7274       return -1;
7275   }
7276   {
7277     int r;
7278     suppress_error = 0;
7279     r = guestfs_lvm_remove_all (g);
7280     if (r == -1)
7281       return -1;
7282   }
7283   {
7284     char device[] = "/dev/sda";
7285     device[5] = devchar;
7286     char lines_0[] = ",";
7287     char *lines[] = {
7288       lines_0,
7289       NULL
7290     };
7291     int r;
7292     suppress_error = 0;
7293     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7294     if (r == -1)
7295       return -1;
7296   }
7297   {
7298     char fstype[] = "ext2";
7299     char device[] = "/dev/sda1";
7300     device[5] = devchar;
7301     int r;
7302     suppress_error = 0;
7303     r = guestfs_mkfs (g, fstype, device);
7304     if (r == -1)
7305       return -1;
7306   }
7307   {
7308     char device[] = "/dev/sda1";
7309     device[5] = devchar;
7310     char mountpoint[] = "/";
7311     int r;
7312     suppress_error = 0;
7313     r = guestfs_mount (g, device, mountpoint);
7314     if (r == -1)
7315       return -1;
7316   }
7317   /* TestOutput for command (9) */
7318   char expected[] = "Result10-1\nResult10-2\n";
7319   {
7320     char remotefilename[] = "/test-command";
7321     int r;
7322     suppress_error = 0;
7323     r = guestfs_upload (g, "test-command", remotefilename);
7324     if (r == -1)
7325       return -1;
7326   }
7327   {
7328     char path[] = "/test-command";
7329     int r;
7330     suppress_error = 0;
7331     r = guestfs_chmod (g, 493, path);
7332     if (r == -1)
7333       return -1;
7334   }
7335   {
7336     char arguments_0[] = "/test-command";
7337     char arguments_1[] = "10";
7338     char *arguments[] = {
7339       arguments_0,
7340       arguments_1,
7341       NULL
7342     };
7343     char *r;
7344     suppress_error = 0;
7345     r = guestfs_command (g, arguments);
7346     if (r == NULL)
7347       return -1;
7348     if (strcmp (r, expected) != 0) {
7349       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
7350       return -1;
7351     }
7352     free (r);
7353   }
7354   return 0;
7355 }
7356
7357 static int test_command_10 (void)
7358 {
7359   /* InitBasicFS for command (10): create ext2 on /dev/sda1 */
7360   {
7361     char device[] = "/dev/sda";
7362     device[5] = devchar;
7363     int r;
7364     suppress_error = 0;
7365     r = guestfs_blockdev_setrw (g, device);
7366     if (r == -1)
7367       return -1;
7368   }
7369   {
7370     int r;
7371     suppress_error = 0;
7372     r = guestfs_umount_all (g);
7373     if (r == -1)
7374       return -1;
7375   }
7376   {
7377     int r;
7378     suppress_error = 0;
7379     r = guestfs_lvm_remove_all (g);
7380     if (r == -1)
7381       return -1;
7382   }
7383   {
7384     char device[] = "/dev/sda";
7385     device[5] = devchar;
7386     char lines_0[] = ",";
7387     char *lines[] = {
7388       lines_0,
7389       NULL
7390     };
7391     int r;
7392     suppress_error = 0;
7393     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7394     if (r == -1)
7395       return -1;
7396   }
7397   {
7398     char fstype[] = "ext2";
7399     char device[] = "/dev/sda1";
7400     device[5] = devchar;
7401     int r;
7402     suppress_error = 0;
7403     r = guestfs_mkfs (g, fstype, device);
7404     if (r == -1)
7405       return -1;
7406   }
7407   {
7408     char device[] = "/dev/sda1";
7409     device[5] = devchar;
7410     char mountpoint[] = "/";
7411     int r;
7412     suppress_error = 0;
7413     r = guestfs_mount (g, device, mountpoint);
7414     if (r == -1)
7415       return -1;
7416   }
7417   /* TestOutput for command (10) */
7418   char expected[] = "Result11-1\nResult11-2";
7419   {
7420     char remotefilename[] = "/test-command";
7421     int r;
7422     suppress_error = 0;
7423     r = guestfs_upload (g, "test-command", remotefilename);
7424     if (r == -1)
7425       return -1;
7426   }
7427   {
7428     char path[] = "/test-command";
7429     int r;
7430     suppress_error = 0;
7431     r = guestfs_chmod (g, 493, path);
7432     if (r == -1)
7433       return -1;
7434   }
7435   {
7436     char arguments_0[] = "/test-command";
7437     char arguments_1[] = "11";
7438     char *arguments[] = {
7439       arguments_0,
7440       arguments_1,
7441       NULL
7442     };
7443     char *r;
7444     suppress_error = 0;
7445     r = guestfs_command (g, arguments);
7446     if (r == NULL)
7447       return -1;
7448     if (strcmp (r, expected) != 0) {
7449       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
7450       return -1;
7451     }
7452     free (r);
7453   }
7454   return 0;
7455 }
7456
7457 static int test_command_11 (void)
7458 {
7459   /* InitBasicFS for command (11): create ext2 on /dev/sda1 */
7460   {
7461     char device[] = "/dev/sda";
7462     device[5] = devchar;
7463     int r;
7464     suppress_error = 0;
7465     r = guestfs_blockdev_setrw (g, device);
7466     if (r == -1)
7467       return -1;
7468   }
7469   {
7470     int r;
7471     suppress_error = 0;
7472     r = guestfs_umount_all (g);
7473     if (r == -1)
7474       return -1;
7475   }
7476   {
7477     int r;
7478     suppress_error = 0;
7479     r = guestfs_lvm_remove_all (g);
7480     if (r == -1)
7481       return -1;
7482   }
7483   {
7484     char device[] = "/dev/sda";
7485     device[5] = devchar;
7486     char lines_0[] = ",";
7487     char *lines[] = {
7488       lines_0,
7489       NULL
7490     };
7491     int r;
7492     suppress_error = 0;
7493     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7494     if (r == -1)
7495       return -1;
7496   }
7497   {
7498     char fstype[] = "ext2";
7499     char device[] = "/dev/sda1";
7500     device[5] = devchar;
7501     int r;
7502     suppress_error = 0;
7503     r = guestfs_mkfs (g, fstype, device);
7504     if (r == -1)
7505       return -1;
7506   }
7507   {
7508     char device[] = "/dev/sda1";
7509     device[5] = devchar;
7510     char mountpoint[] = "/";
7511     int r;
7512     suppress_error = 0;
7513     r = guestfs_mount (g, device, mountpoint);
7514     if (r == -1)
7515       return -1;
7516   }
7517   /* TestLastFail for command (11) */
7518   {
7519     char remotefilename[] = "/test-command";
7520     int r;
7521     suppress_error = 0;
7522     r = guestfs_upload (g, "test-command", remotefilename);
7523     if (r == -1)
7524       return -1;
7525   }
7526   {
7527     char path[] = "/test-command";
7528     int r;
7529     suppress_error = 0;
7530     r = guestfs_chmod (g, 493, path);
7531     if (r == -1)
7532       return -1;
7533   }
7534   {
7535     char arguments_0[] = "/test-command";
7536     char *arguments[] = {
7537       arguments_0,
7538       NULL
7539     };
7540     char *r;
7541     suppress_error = 1;
7542     r = guestfs_command (g, arguments);
7543     if (r != NULL)
7544       return -1;
7545     free (r);
7546   }
7547   return 0;
7548 }
7549
7550 static int test_file_0 (void)
7551 {
7552   /* InitBasicFS for file (0): create ext2 on /dev/sda1 */
7553   {
7554     char device[] = "/dev/sda";
7555     device[5] = devchar;
7556     int r;
7557     suppress_error = 0;
7558     r = guestfs_blockdev_setrw (g, device);
7559     if (r == -1)
7560       return -1;
7561   }
7562   {
7563     int r;
7564     suppress_error = 0;
7565     r = guestfs_umount_all (g);
7566     if (r == -1)
7567       return -1;
7568   }
7569   {
7570     int r;
7571     suppress_error = 0;
7572     r = guestfs_lvm_remove_all (g);
7573     if (r == -1)
7574       return -1;
7575   }
7576   {
7577     char device[] = "/dev/sda";
7578     device[5] = devchar;
7579     char lines_0[] = ",";
7580     char *lines[] = {
7581       lines_0,
7582       NULL
7583     };
7584     int r;
7585     suppress_error = 0;
7586     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7587     if (r == -1)
7588       return -1;
7589   }
7590   {
7591     char fstype[] = "ext2";
7592     char device[] = "/dev/sda1";
7593     device[5] = devchar;
7594     int r;
7595     suppress_error = 0;
7596     r = guestfs_mkfs (g, fstype, device);
7597     if (r == -1)
7598       return -1;
7599   }
7600   {
7601     char device[] = "/dev/sda1";
7602     device[5] = devchar;
7603     char mountpoint[] = "/";
7604     int r;
7605     suppress_error = 0;
7606     r = guestfs_mount (g, device, mountpoint);
7607     if (r == -1)
7608       return -1;
7609   }
7610   /* TestOutput for file (0) */
7611   char expected[] = "empty";
7612   {
7613     char path[] = "/new";
7614     int r;
7615     suppress_error = 0;
7616     r = guestfs_touch (g, path);
7617     if (r == -1)
7618       return -1;
7619   }
7620   {
7621     char path[] = "/new";
7622     char *r;
7623     suppress_error = 0;
7624     r = guestfs_file (g, path);
7625     if (r == NULL)
7626       return -1;
7627     if (strcmp (r, expected) != 0) {
7628       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
7629       return -1;
7630     }
7631     free (r);
7632   }
7633   return 0;
7634 }
7635
7636 static int test_file_1 (void)
7637 {
7638   /* InitBasicFS for file (1): create ext2 on /dev/sda1 */
7639   {
7640     char device[] = "/dev/sda";
7641     device[5] = devchar;
7642     int r;
7643     suppress_error = 0;
7644     r = guestfs_blockdev_setrw (g, device);
7645     if (r == -1)
7646       return -1;
7647   }
7648   {
7649     int r;
7650     suppress_error = 0;
7651     r = guestfs_umount_all (g);
7652     if (r == -1)
7653       return -1;
7654   }
7655   {
7656     int r;
7657     suppress_error = 0;
7658     r = guestfs_lvm_remove_all (g);
7659     if (r == -1)
7660       return -1;
7661   }
7662   {
7663     char device[] = "/dev/sda";
7664     device[5] = devchar;
7665     char lines_0[] = ",";
7666     char *lines[] = {
7667       lines_0,
7668       NULL
7669     };
7670     int r;
7671     suppress_error = 0;
7672     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7673     if (r == -1)
7674       return -1;
7675   }
7676   {
7677     char fstype[] = "ext2";
7678     char device[] = "/dev/sda1";
7679     device[5] = devchar;
7680     int r;
7681     suppress_error = 0;
7682     r = guestfs_mkfs (g, fstype, device);
7683     if (r == -1)
7684       return -1;
7685   }
7686   {
7687     char device[] = "/dev/sda1";
7688     device[5] = devchar;
7689     char mountpoint[] = "/";
7690     int r;
7691     suppress_error = 0;
7692     r = guestfs_mount (g, device, mountpoint);
7693     if (r == -1)
7694       return -1;
7695   }
7696   /* TestOutput for file (1) */
7697   char expected[] = "ASCII text";
7698   {
7699     char path[] = "/new";
7700     char content[] = "some content\n";
7701     int r;
7702     suppress_error = 0;
7703     r = guestfs_write_file (g, path, content, 0);
7704     if (r == -1)
7705       return -1;
7706   }
7707   {
7708     char path[] = "/new";
7709     char *r;
7710     suppress_error = 0;
7711     r = guestfs_file (g, path);
7712     if (r == NULL)
7713       return -1;
7714     if (strcmp (r, expected) != 0) {
7715       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
7716       return -1;
7717     }
7718     free (r);
7719   }
7720   return 0;
7721 }
7722
7723 static int test_file_2 (void)
7724 {
7725   /* InitBasicFS for file (2): create ext2 on /dev/sda1 */
7726   {
7727     char device[] = "/dev/sda";
7728     device[5] = devchar;
7729     int r;
7730     suppress_error = 0;
7731     r = guestfs_blockdev_setrw (g, device);
7732     if (r == -1)
7733       return -1;
7734   }
7735   {
7736     int r;
7737     suppress_error = 0;
7738     r = guestfs_umount_all (g);
7739     if (r == -1)
7740       return -1;
7741   }
7742   {
7743     int r;
7744     suppress_error = 0;
7745     r = guestfs_lvm_remove_all (g);
7746     if (r == -1)
7747       return -1;
7748   }
7749   {
7750     char device[] = "/dev/sda";
7751     device[5] = devchar;
7752     char lines_0[] = ",";
7753     char *lines[] = {
7754       lines_0,
7755       NULL
7756     };
7757     int r;
7758     suppress_error = 0;
7759     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7760     if (r == -1)
7761       return -1;
7762   }
7763   {
7764     char fstype[] = "ext2";
7765     char device[] = "/dev/sda1";
7766     device[5] = devchar;
7767     int r;
7768     suppress_error = 0;
7769     r = guestfs_mkfs (g, fstype, device);
7770     if (r == -1)
7771       return -1;
7772   }
7773   {
7774     char device[] = "/dev/sda1";
7775     device[5] = devchar;
7776     char mountpoint[] = "/";
7777     int r;
7778     suppress_error = 0;
7779     r = guestfs_mount (g, device, mountpoint);
7780     if (r == -1)
7781       return -1;
7782   }
7783   /* TestLastFail for file (2) */
7784   {
7785     char path[] = "/nofile";
7786     char *r;
7787     suppress_error = 1;
7788     r = guestfs_file (g, path);
7789     if (r != NULL)
7790       return -1;
7791     free (r);
7792   }
7793   return 0;
7794 }
7795
7796 static int test_umount_all_0 (void)
7797 {
7798   /* InitBasicFS for umount_all (0): create ext2 on /dev/sda1 */
7799   {
7800     char device[] = "/dev/sda";
7801     device[5] = devchar;
7802     int r;
7803     suppress_error = 0;
7804     r = guestfs_blockdev_setrw (g, device);
7805     if (r == -1)
7806       return -1;
7807   }
7808   {
7809     int r;
7810     suppress_error = 0;
7811     r = guestfs_umount_all (g);
7812     if (r == -1)
7813       return -1;
7814   }
7815   {
7816     int r;
7817     suppress_error = 0;
7818     r = guestfs_lvm_remove_all (g);
7819     if (r == -1)
7820       return -1;
7821   }
7822   {
7823     char device[] = "/dev/sda";
7824     device[5] = devchar;
7825     char lines_0[] = ",";
7826     char *lines[] = {
7827       lines_0,
7828       NULL
7829     };
7830     int r;
7831     suppress_error = 0;
7832     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7833     if (r == -1)
7834       return -1;
7835   }
7836   {
7837     char fstype[] = "ext2";
7838     char device[] = "/dev/sda1";
7839     device[5] = devchar;
7840     int r;
7841     suppress_error = 0;
7842     r = guestfs_mkfs (g, fstype, device);
7843     if (r == -1)
7844       return -1;
7845   }
7846   {
7847     char device[] = "/dev/sda1";
7848     device[5] = devchar;
7849     char mountpoint[] = "/";
7850     int r;
7851     suppress_error = 0;
7852     r = guestfs_mount (g, device, mountpoint);
7853     if (r == -1)
7854       return -1;
7855   }
7856   /* TestOutputList for umount_all (0) */
7857   {
7858     int r;
7859     suppress_error = 0;
7860     r = guestfs_umount_all (g);
7861     if (r == -1)
7862       return -1;
7863   }
7864   {
7865     char **r;
7866     int i;
7867     suppress_error = 0;
7868     r = guestfs_mounts (g);
7869     if (r == NULL)
7870       return -1;
7871     if (r[0] != NULL) {
7872       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
7873       print_strings (r);
7874       return -1;
7875     }
7876     for (i = 0; r[i] != NULL; ++i)
7877       free (r[i]);
7878     free (r);
7879   }
7880   return 0;
7881 }
7882
7883 static int test_umount_all_1 (void)
7884 {
7885   /* InitEmpty for umount_all (1) */
7886   {
7887     char device[] = "/dev/sda";
7888     device[5] = devchar;
7889     int r;
7890     suppress_error = 0;
7891     r = guestfs_blockdev_setrw (g, device);
7892     if (r == -1)
7893       return -1;
7894   }
7895   {
7896     int r;
7897     suppress_error = 0;
7898     r = guestfs_umount_all (g);
7899     if (r == -1)
7900       return -1;
7901   }
7902   {
7903     int r;
7904     suppress_error = 0;
7905     r = guestfs_lvm_remove_all (g);
7906     if (r == -1)
7907       return -1;
7908   }
7909   /* TestOutputList for umount_all (1) */
7910   {
7911     char device[] = "/dev/sda";
7912     device[5] = devchar;
7913     char lines_0[] = ",10";
7914     char lines_1[] = ",20";
7915     char lines_2[] = ",";
7916     char *lines[] = {
7917       lines_0,
7918       lines_1,
7919       lines_2,
7920       NULL
7921     };
7922     int r;
7923     suppress_error = 0;
7924     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7925     if (r == -1)
7926       return -1;
7927   }
7928   {
7929     char fstype[] = "ext2";
7930     char device[] = "/dev/sda1";
7931     device[5] = devchar;
7932     int r;
7933     suppress_error = 0;
7934     r = guestfs_mkfs (g, fstype, device);
7935     if (r == -1)
7936       return -1;
7937   }
7938   {
7939     char fstype[] = "ext2";
7940     char device[] = "/dev/sda2";
7941     device[5] = devchar;
7942     int r;
7943     suppress_error = 0;
7944     r = guestfs_mkfs (g, fstype, device);
7945     if (r == -1)
7946       return -1;
7947   }
7948   {
7949     char fstype[] = "ext2";
7950     char device[] = "/dev/sda3";
7951     device[5] = devchar;
7952     int r;
7953     suppress_error = 0;
7954     r = guestfs_mkfs (g, fstype, device);
7955     if (r == -1)
7956       return -1;
7957   }
7958   {
7959     char device[] = "/dev/sda1";
7960     device[5] = devchar;
7961     char mountpoint[] = "/";
7962     int r;
7963     suppress_error = 0;
7964     r = guestfs_mount (g, device, mountpoint);
7965     if (r == -1)
7966       return -1;
7967   }
7968   {
7969     char path[] = "/mp1";
7970     int r;
7971     suppress_error = 0;
7972     r = guestfs_mkdir (g, path);
7973     if (r == -1)
7974       return -1;
7975   }
7976   {
7977     char device[] = "/dev/sda2";
7978     device[5] = devchar;
7979     char mountpoint[] = "/mp1";
7980     int r;
7981     suppress_error = 0;
7982     r = guestfs_mount (g, device, mountpoint);
7983     if (r == -1)
7984       return -1;
7985   }
7986   {
7987     char path[] = "/mp1/mp2";
7988     int r;
7989     suppress_error = 0;
7990     r = guestfs_mkdir (g, path);
7991     if (r == -1)
7992       return -1;
7993   }
7994   {
7995     char device[] = "/dev/sda3";
7996     device[5] = devchar;
7997     char mountpoint[] = "/mp1/mp2";
7998     int r;
7999     suppress_error = 0;
8000     r = guestfs_mount (g, device, mountpoint);
8001     if (r == -1)
8002       return -1;
8003   }
8004   {
8005     char path[] = "/mp1/mp2/mp3";
8006     int r;
8007     suppress_error = 0;
8008     r = guestfs_mkdir (g, path);
8009     if (r == -1)
8010       return -1;
8011   }
8012   {
8013     int r;
8014     suppress_error = 0;
8015     r = guestfs_umount_all (g);
8016     if (r == -1)
8017       return -1;
8018   }
8019   {
8020     char **r;
8021     int i;
8022     suppress_error = 0;
8023     r = guestfs_mounts (g);
8024     if (r == NULL)
8025       return -1;
8026     if (r[0] != NULL) {
8027       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8028       print_strings (r);
8029       return -1;
8030     }
8031     for (i = 0; r[i] != NULL; ++i)
8032       free (r[i]);
8033     free (r);
8034   }
8035   return 0;
8036 }
8037
8038 static int test_mounts_0 (void)
8039 {
8040   /* InitBasicFS for mounts (0): create ext2 on /dev/sda1 */
8041   {
8042     char device[] = "/dev/sda";
8043     device[5] = devchar;
8044     int r;
8045     suppress_error = 0;
8046     r = guestfs_blockdev_setrw (g, device);
8047     if (r == -1)
8048       return -1;
8049   }
8050   {
8051     int r;
8052     suppress_error = 0;
8053     r = guestfs_umount_all (g);
8054     if (r == -1)
8055       return -1;
8056   }
8057   {
8058     int r;
8059     suppress_error = 0;
8060     r = guestfs_lvm_remove_all (g);
8061     if (r == -1)
8062       return -1;
8063   }
8064   {
8065     char device[] = "/dev/sda";
8066     device[5] = devchar;
8067     char lines_0[] = ",";
8068     char *lines[] = {
8069       lines_0,
8070       NULL
8071     };
8072     int r;
8073     suppress_error = 0;
8074     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8075     if (r == -1)
8076       return -1;
8077   }
8078   {
8079     char fstype[] = "ext2";
8080     char device[] = "/dev/sda1";
8081     device[5] = devchar;
8082     int r;
8083     suppress_error = 0;
8084     r = guestfs_mkfs (g, fstype, device);
8085     if (r == -1)
8086       return -1;
8087   }
8088   {
8089     char device[] = "/dev/sda1";
8090     device[5] = devchar;
8091     char mountpoint[] = "/";
8092     int r;
8093     suppress_error = 0;
8094     r = guestfs_mount (g, device, mountpoint);
8095     if (r == -1)
8096       return -1;
8097   }
8098   /* TestOutputList for mounts (0) */
8099   {
8100     char **r;
8101     int i;
8102     suppress_error = 0;
8103     r = guestfs_mounts (g);
8104     if (r == NULL)
8105       return -1;
8106     if (!r[0]) {
8107       fprintf (stderr, "test_mounts_0: short list returned from command\n");
8108       print_strings (r);
8109       return -1;
8110     }
8111     {
8112       char expected[] = "/dev/sda1";
8113       expected[5] = devchar;
8114       if (strcmp (r[0], expected) != 0) {
8115         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8116         return -1;
8117       }
8118     }
8119     if (r[1] != NULL) {
8120       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8121       print_strings (r);
8122       return -1;
8123     }
8124     for (i = 0; r[i] != NULL; ++i)
8125       free (r[i]);
8126     free (r);
8127   }
8128   return 0;
8129 }
8130
8131 static int test_umount_0 (void)
8132 {
8133   /* InitEmpty for umount (0) */
8134   {
8135     char device[] = "/dev/sda";
8136     device[5] = devchar;
8137     int r;
8138     suppress_error = 0;
8139     r = guestfs_blockdev_setrw (g, device);
8140     if (r == -1)
8141       return -1;
8142   }
8143   {
8144     int r;
8145     suppress_error = 0;
8146     r = guestfs_umount_all (g);
8147     if (r == -1)
8148       return -1;
8149   }
8150   {
8151     int r;
8152     suppress_error = 0;
8153     r = guestfs_lvm_remove_all (g);
8154     if (r == -1)
8155       return -1;
8156   }
8157   /* TestOutputList for umount (0) */
8158   {
8159     char device[] = "/dev/sda";
8160     device[5] = devchar;
8161     char lines_0[] = ",";
8162     char *lines[] = {
8163       lines_0,
8164       NULL
8165     };
8166     int r;
8167     suppress_error = 0;
8168     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8169     if (r == -1)
8170       return -1;
8171   }
8172   {
8173     char fstype[] = "ext2";
8174     char device[] = "/dev/sda1";
8175     device[5] = devchar;
8176     int r;
8177     suppress_error = 0;
8178     r = guestfs_mkfs (g, fstype, device);
8179     if (r == -1)
8180       return -1;
8181   }
8182   {
8183     char device[] = "/dev/sda1";
8184     device[5] = devchar;
8185     char mountpoint[] = "/";
8186     int r;
8187     suppress_error = 0;
8188     r = guestfs_mount (g, device, mountpoint);
8189     if (r == -1)
8190       return -1;
8191   }
8192   {
8193     char **r;
8194     int i;
8195     suppress_error = 0;
8196     r = guestfs_mounts (g);
8197     if (r == NULL)
8198       return -1;
8199     if (!r[0]) {
8200       fprintf (stderr, "test_umount_0: short list returned from command\n");
8201       print_strings (r);
8202       return -1;
8203     }
8204     {
8205       char expected[] = "/dev/sda1";
8206       expected[5] = devchar;
8207       if (strcmp (r[0], expected) != 0) {
8208         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8209         return -1;
8210       }
8211     }
8212     if (r[1] != NULL) {
8213       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
8214       print_strings (r);
8215       return -1;
8216     }
8217     for (i = 0; r[i] != NULL; ++i)
8218       free (r[i]);
8219     free (r);
8220   }
8221   return 0;
8222 }
8223
8224 static int test_umount_1 (void)
8225 {
8226   /* InitEmpty for umount (1) */
8227   {
8228     char device[] = "/dev/sda";
8229     device[5] = devchar;
8230     int r;
8231     suppress_error = 0;
8232     r = guestfs_blockdev_setrw (g, device);
8233     if (r == -1)
8234       return -1;
8235   }
8236   {
8237     int r;
8238     suppress_error = 0;
8239     r = guestfs_umount_all (g);
8240     if (r == -1)
8241       return -1;
8242   }
8243   {
8244     int r;
8245     suppress_error = 0;
8246     r = guestfs_lvm_remove_all (g);
8247     if (r == -1)
8248       return -1;
8249   }
8250   /* TestOutputList for umount (1) */
8251   {
8252     char device[] = "/dev/sda";
8253     device[5] = devchar;
8254     char lines_0[] = ",";
8255     char *lines[] = {
8256       lines_0,
8257       NULL
8258     };
8259     int r;
8260     suppress_error = 0;
8261     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8262     if (r == -1)
8263       return -1;
8264   }
8265   {
8266     char fstype[] = "ext2";
8267     char device[] = "/dev/sda1";
8268     device[5] = devchar;
8269     int r;
8270     suppress_error = 0;
8271     r = guestfs_mkfs (g, fstype, device);
8272     if (r == -1)
8273       return -1;
8274   }
8275   {
8276     char device[] = "/dev/sda1";
8277     device[5] = devchar;
8278     char mountpoint[] = "/";
8279     int r;
8280     suppress_error = 0;
8281     r = guestfs_mount (g, device, mountpoint);
8282     if (r == -1)
8283       return -1;
8284   }
8285   {
8286     char pathordevice[] = "/";
8287     int r;
8288     suppress_error = 0;
8289     r = guestfs_umount (g, pathordevice);
8290     if (r == -1)
8291       return -1;
8292   }
8293   {
8294     char **r;
8295     int i;
8296     suppress_error = 0;
8297     r = guestfs_mounts (g);
8298     if (r == NULL)
8299       return -1;
8300     if (r[0] != NULL) {
8301       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
8302       print_strings (r);
8303       return -1;
8304     }
8305     for (i = 0; r[i] != NULL; ++i)
8306       free (r[i]);
8307     free (r);
8308   }
8309   return 0;
8310 }
8311
8312 static int test_write_file_0 (void)
8313 {
8314   /* InitBasicFS for write_file (0): create ext2 on /dev/sda1 */
8315   {
8316     char device[] = "/dev/sda";
8317     device[5] = devchar;
8318     int r;
8319     suppress_error = 0;
8320     r = guestfs_blockdev_setrw (g, device);
8321     if (r == -1)
8322       return -1;
8323   }
8324   {
8325     int r;
8326     suppress_error = 0;
8327     r = guestfs_umount_all (g);
8328     if (r == -1)
8329       return -1;
8330   }
8331   {
8332     int r;
8333     suppress_error = 0;
8334     r = guestfs_lvm_remove_all (g);
8335     if (r == -1)
8336       return -1;
8337   }
8338   {
8339     char device[] = "/dev/sda";
8340     device[5] = devchar;
8341     char lines_0[] = ",";
8342     char *lines[] = {
8343       lines_0,
8344       NULL
8345     };
8346     int r;
8347     suppress_error = 0;
8348     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8349     if (r == -1)
8350       return -1;
8351   }
8352   {
8353     char fstype[] = "ext2";
8354     char device[] = "/dev/sda1";
8355     device[5] = devchar;
8356     int r;
8357     suppress_error = 0;
8358     r = guestfs_mkfs (g, fstype, device);
8359     if (r == -1)
8360       return -1;
8361   }
8362   {
8363     char device[] = "/dev/sda1";
8364     device[5] = devchar;
8365     char mountpoint[] = "/";
8366     int r;
8367     suppress_error = 0;
8368     r = guestfs_mount (g, device, mountpoint);
8369     if (r == -1)
8370       return -1;
8371   }
8372   /* TestOutput for write_file (0) */
8373   char expected[] = "new file contents";
8374   {
8375     char path[] = "/new";
8376     char content[] = "new file contents";
8377     int r;
8378     suppress_error = 0;
8379     r = guestfs_write_file (g, path, content, 0);
8380     if (r == -1)
8381       return -1;
8382   }
8383   {
8384     char path[] = "/new";
8385     char *r;
8386     suppress_error = 0;
8387     r = guestfs_cat (g, path);
8388     if (r == NULL)
8389       return -1;
8390     if (strcmp (r, expected) != 0) {
8391       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8392       return -1;
8393     }
8394     free (r);
8395   }
8396   return 0;
8397 }
8398
8399 static int test_write_file_1 (void)
8400 {
8401   /* InitBasicFS for write_file (1): create ext2 on /dev/sda1 */
8402   {
8403     char device[] = "/dev/sda";
8404     device[5] = devchar;
8405     int r;
8406     suppress_error = 0;
8407     r = guestfs_blockdev_setrw (g, device);
8408     if (r == -1)
8409       return -1;
8410   }
8411   {
8412     int r;
8413     suppress_error = 0;
8414     r = guestfs_umount_all (g);
8415     if (r == -1)
8416       return -1;
8417   }
8418   {
8419     int r;
8420     suppress_error = 0;
8421     r = guestfs_lvm_remove_all (g);
8422     if (r == -1)
8423       return -1;
8424   }
8425   {
8426     char device[] = "/dev/sda";
8427     device[5] = devchar;
8428     char lines_0[] = ",";
8429     char *lines[] = {
8430       lines_0,
8431       NULL
8432     };
8433     int r;
8434     suppress_error = 0;
8435     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8436     if (r == -1)
8437       return -1;
8438   }
8439   {
8440     char fstype[] = "ext2";
8441     char device[] = "/dev/sda1";
8442     device[5] = devchar;
8443     int r;
8444     suppress_error = 0;
8445     r = guestfs_mkfs (g, fstype, device);
8446     if (r == -1)
8447       return -1;
8448   }
8449   {
8450     char device[] = "/dev/sda1";
8451     device[5] = devchar;
8452     char mountpoint[] = "/";
8453     int r;
8454     suppress_error = 0;
8455     r = guestfs_mount (g, device, mountpoint);
8456     if (r == -1)
8457       return -1;
8458   }
8459   /* TestOutput for write_file (1) */
8460   char expected[] = "\nnew file contents\n";
8461   {
8462     char path[] = "/new";
8463     char content[] = "\nnew file contents\n";
8464     int r;
8465     suppress_error = 0;
8466     r = guestfs_write_file (g, path, content, 0);
8467     if (r == -1)
8468       return -1;
8469   }
8470   {
8471     char path[] = "/new";
8472     char *r;
8473     suppress_error = 0;
8474     r = guestfs_cat (g, path);
8475     if (r == NULL)
8476       return -1;
8477     if (strcmp (r, expected) != 0) {
8478       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8479       return -1;
8480     }
8481     free (r);
8482   }
8483   return 0;
8484 }
8485
8486 static int test_write_file_2 (void)
8487 {
8488   /* InitBasicFS for write_file (2): create ext2 on /dev/sda1 */
8489   {
8490     char device[] = "/dev/sda";
8491     device[5] = devchar;
8492     int r;
8493     suppress_error = 0;
8494     r = guestfs_blockdev_setrw (g, device);
8495     if (r == -1)
8496       return -1;
8497   }
8498   {
8499     int r;
8500     suppress_error = 0;
8501     r = guestfs_umount_all (g);
8502     if (r == -1)
8503       return -1;
8504   }
8505   {
8506     int r;
8507     suppress_error = 0;
8508     r = guestfs_lvm_remove_all (g);
8509     if (r == -1)
8510       return -1;
8511   }
8512   {
8513     char device[] = "/dev/sda";
8514     device[5] = devchar;
8515     char lines_0[] = ",";
8516     char *lines[] = {
8517       lines_0,
8518       NULL
8519     };
8520     int r;
8521     suppress_error = 0;
8522     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8523     if (r == -1)
8524       return -1;
8525   }
8526   {
8527     char fstype[] = "ext2";
8528     char device[] = "/dev/sda1";
8529     device[5] = devchar;
8530     int r;
8531     suppress_error = 0;
8532     r = guestfs_mkfs (g, fstype, device);
8533     if (r == -1)
8534       return -1;
8535   }
8536   {
8537     char device[] = "/dev/sda1";
8538     device[5] = devchar;
8539     char mountpoint[] = "/";
8540     int r;
8541     suppress_error = 0;
8542     r = guestfs_mount (g, device, mountpoint);
8543     if (r == -1)
8544       return -1;
8545   }
8546   /* TestOutput for write_file (2) */
8547   char expected[] = "\n\n";
8548   {
8549     char path[] = "/new";
8550     char content[] = "\n\n";
8551     int r;
8552     suppress_error = 0;
8553     r = guestfs_write_file (g, path, content, 0);
8554     if (r == -1)
8555       return -1;
8556   }
8557   {
8558     char path[] = "/new";
8559     char *r;
8560     suppress_error = 0;
8561     r = guestfs_cat (g, path);
8562     if (r == NULL)
8563       return -1;
8564     if (strcmp (r, expected) != 0) {
8565       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
8566       return -1;
8567     }
8568     free (r);
8569   }
8570   return 0;
8571 }
8572
8573 static int test_write_file_3 (void)
8574 {
8575   /* InitBasicFS for write_file (3): create ext2 on /dev/sda1 */
8576   {
8577     char device[] = "/dev/sda";
8578     device[5] = devchar;
8579     int r;
8580     suppress_error = 0;
8581     r = guestfs_blockdev_setrw (g, device);
8582     if (r == -1)
8583       return -1;
8584   }
8585   {
8586     int r;
8587     suppress_error = 0;
8588     r = guestfs_umount_all (g);
8589     if (r == -1)
8590       return -1;
8591   }
8592   {
8593     int r;
8594     suppress_error = 0;
8595     r = guestfs_lvm_remove_all (g);
8596     if (r == -1)
8597       return -1;
8598   }
8599   {
8600     char device[] = "/dev/sda";
8601     device[5] = devchar;
8602     char lines_0[] = ",";
8603     char *lines[] = {
8604       lines_0,
8605       NULL
8606     };
8607     int r;
8608     suppress_error = 0;
8609     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8610     if (r == -1)
8611       return -1;
8612   }
8613   {
8614     char fstype[] = "ext2";
8615     char device[] = "/dev/sda1";
8616     device[5] = devchar;
8617     int r;
8618     suppress_error = 0;
8619     r = guestfs_mkfs (g, fstype, device);
8620     if (r == -1)
8621       return -1;
8622   }
8623   {
8624     char device[] = "/dev/sda1";
8625     device[5] = devchar;
8626     char mountpoint[] = "/";
8627     int r;
8628     suppress_error = 0;
8629     r = guestfs_mount (g, device, mountpoint);
8630     if (r == -1)
8631       return -1;
8632   }
8633   /* TestOutput for write_file (3) */
8634   char expected[] = "";
8635   {
8636     char path[] = "/new";
8637     char content[] = "";
8638     int r;
8639     suppress_error = 0;
8640     r = guestfs_write_file (g, path, content, 0);
8641     if (r == -1)
8642       return -1;
8643   }
8644   {
8645     char path[] = "/new";
8646     char *r;
8647     suppress_error = 0;
8648     r = guestfs_cat (g, path);
8649     if (r == NULL)
8650       return -1;
8651     if (strcmp (r, expected) != 0) {
8652       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
8653       return -1;
8654     }
8655     free (r);
8656   }
8657   return 0;
8658 }
8659
8660 static int test_write_file_4 (void)
8661 {
8662   /* InitBasicFS for write_file (4): create ext2 on /dev/sda1 */
8663   {
8664     char device[] = "/dev/sda";
8665     device[5] = devchar;
8666     int r;
8667     suppress_error = 0;
8668     r = guestfs_blockdev_setrw (g, device);
8669     if (r == -1)
8670       return -1;
8671   }
8672   {
8673     int r;
8674     suppress_error = 0;
8675     r = guestfs_umount_all (g);
8676     if (r == -1)
8677       return -1;
8678   }
8679   {
8680     int r;
8681     suppress_error = 0;
8682     r = guestfs_lvm_remove_all (g);
8683     if (r == -1)
8684       return -1;
8685   }
8686   {
8687     char device[] = "/dev/sda";
8688     device[5] = devchar;
8689     char lines_0[] = ",";
8690     char *lines[] = {
8691       lines_0,
8692       NULL
8693     };
8694     int r;
8695     suppress_error = 0;
8696     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8697     if (r == -1)
8698       return -1;
8699   }
8700   {
8701     char fstype[] = "ext2";
8702     char device[] = "/dev/sda1";
8703     device[5] = devchar;
8704     int r;
8705     suppress_error = 0;
8706     r = guestfs_mkfs (g, fstype, device);
8707     if (r == -1)
8708       return -1;
8709   }
8710   {
8711     char device[] = "/dev/sda1";
8712     device[5] = devchar;
8713     char mountpoint[] = "/";
8714     int r;
8715     suppress_error = 0;
8716     r = guestfs_mount (g, device, mountpoint);
8717     if (r == -1)
8718       return -1;
8719   }
8720   /* TestOutput for write_file (4) */
8721   char expected[] = "\n\n\n";
8722   {
8723     char path[] = "/new";
8724     char content[] = "\n\n\n";
8725     int r;
8726     suppress_error = 0;
8727     r = guestfs_write_file (g, path, content, 0);
8728     if (r == -1)
8729       return -1;
8730   }
8731   {
8732     char path[] = "/new";
8733     char *r;
8734     suppress_error = 0;
8735     r = guestfs_cat (g, path);
8736     if (r == NULL)
8737       return -1;
8738     if (strcmp (r, expected) != 0) {
8739       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
8740       return -1;
8741     }
8742     free (r);
8743   }
8744   return 0;
8745 }
8746
8747 static int test_write_file_5 (void)
8748 {
8749   /* InitBasicFS for write_file (5): create ext2 on /dev/sda1 */
8750   {
8751     char device[] = "/dev/sda";
8752     device[5] = devchar;
8753     int r;
8754     suppress_error = 0;
8755     r = guestfs_blockdev_setrw (g, device);
8756     if (r == -1)
8757       return -1;
8758   }
8759   {
8760     int r;
8761     suppress_error = 0;
8762     r = guestfs_umount_all (g);
8763     if (r == -1)
8764       return -1;
8765   }
8766   {
8767     int r;
8768     suppress_error = 0;
8769     r = guestfs_lvm_remove_all (g);
8770     if (r == -1)
8771       return -1;
8772   }
8773   {
8774     char device[] = "/dev/sda";
8775     device[5] = devchar;
8776     char lines_0[] = ",";
8777     char *lines[] = {
8778       lines_0,
8779       NULL
8780     };
8781     int r;
8782     suppress_error = 0;
8783     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8784     if (r == -1)
8785       return -1;
8786   }
8787   {
8788     char fstype[] = "ext2";
8789     char device[] = "/dev/sda1";
8790     device[5] = devchar;
8791     int r;
8792     suppress_error = 0;
8793     r = guestfs_mkfs (g, fstype, device);
8794     if (r == -1)
8795       return -1;
8796   }
8797   {
8798     char device[] = "/dev/sda1";
8799     device[5] = devchar;
8800     char mountpoint[] = "/";
8801     int r;
8802     suppress_error = 0;
8803     r = guestfs_mount (g, device, mountpoint);
8804     if (r == -1)
8805       return -1;
8806   }
8807   /* TestOutput for write_file (5) */
8808   char expected[] = "\n";
8809   {
8810     char path[] = "/new";
8811     char content[] = "\n";
8812     int r;
8813     suppress_error = 0;
8814     r = guestfs_write_file (g, path, content, 0);
8815     if (r == -1)
8816       return -1;
8817   }
8818   {
8819     char path[] = "/new";
8820     char *r;
8821     suppress_error = 0;
8822     r = guestfs_cat (g, path);
8823     if (r == NULL)
8824       return -1;
8825     if (strcmp (r, expected) != 0) {
8826       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
8827       return -1;
8828     }
8829     free (r);
8830   }
8831   return 0;
8832 }
8833
8834 static int test_mkfs_0 (void)
8835 {
8836   /* InitEmpty for mkfs (0) */
8837   {
8838     char device[] = "/dev/sda";
8839     device[5] = devchar;
8840     int r;
8841     suppress_error = 0;
8842     r = guestfs_blockdev_setrw (g, device);
8843     if (r == -1)
8844       return -1;
8845   }
8846   {
8847     int r;
8848     suppress_error = 0;
8849     r = guestfs_umount_all (g);
8850     if (r == -1)
8851       return -1;
8852   }
8853   {
8854     int r;
8855     suppress_error = 0;
8856     r = guestfs_lvm_remove_all (g);
8857     if (r == -1)
8858       return -1;
8859   }
8860   /* TestOutput for mkfs (0) */
8861   char expected[] = "new file contents";
8862   {
8863     char device[] = "/dev/sda";
8864     device[5] = devchar;
8865     char lines_0[] = ",";
8866     char *lines[] = {
8867       lines_0,
8868       NULL
8869     };
8870     int r;
8871     suppress_error = 0;
8872     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8873     if (r == -1)
8874       return -1;
8875   }
8876   {
8877     char fstype[] = "ext2";
8878     char device[] = "/dev/sda1";
8879     device[5] = devchar;
8880     int r;
8881     suppress_error = 0;
8882     r = guestfs_mkfs (g, fstype, device);
8883     if (r == -1)
8884       return -1;
8885   }
8886   {
8887     char device[] = "/dev/sda1";
8888     device[5] = devchar;
8889     char mountpoint[] = "/";
8890     int r;
8891     suppress_error = 0;
8892     r = guestfs_mount (g, device, mountpoint);
8893     if (r == -1)
8894       return -1;
8895   }
8896   {
8897     char path[] = "/new";
8898     char content[] = "new file contents";
8899     int r;
8900     suppress_error = 0;
8901     r = guestfs_write_file (g, path, content, 0);
8902     if (r == -1)
8903       return -1;
8904   }
8905   {
8906     char path[] = "/new";
8907     char *r;
8908     suppress_error = 0;
8909     r = guestfs_cat (g, path);
8910     if (r == NULL)
8911       return -1;
8912     if (strcmp (r, expected) != 0) {
8913       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
8914       return -1;
8915     }
8916     free (r);
8917   }
8918   return 0;
8919 }
8920
8921 static int test_lvcreate_0 (void)
8922 {
8923   /* InitEmpty for lvcreate (0) */
8924   {
8925     char device[] = "/dev/sda";
8926     device[5] = devchar;
8927     int r;
8928     suppress_error = 0;
8929     r = guestfs_blockdev_setrw (g, device);
8930     if (r == -1)
8931       return -1;
8932   }
8933   {
8934     int r;
8935     suppress_error = 0;
8936     r = guestfs_umount_all (g);
8937     if (r == -1)
8938       return -1;
8939   }
8940   {
8941     int r;
8942     suppress_error = 0;
8943     r = guestfs_lvm_remove_all (g);
8944     if (r == -1)
8945       return -1;
8946   }
8947   /* TestOutputList for lvcreate (0) */
8948   {
8949     char device[] = "/dev/sda";
8950     device[5] = devchar;
8951     char lines_0[] = ",10";
8952     char lines_1[] = ",20";
8953     char lines_2[] = ",";
8954     char *lines[] = {
8955       lines_0,
8956       lines_1,
8957       lines_2,
8958       NULL
8959     };
8960     int r;
8961     suppress_error = 0;
8962     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8963     if (r == -1)
8964       return -1;
8965   }
8966   {
8967     char device[] = "/dev/sda1";
8968     device[5] = devchar;
8969     int r;
8970     suppress_error = 0;
8971     r = guestfs_pvcreate (g, device);
8972     if (r == -1)
8973       return -1;
8974   }
8975   {
8976     char device[] = "/dev/sda2";
8977     device[5] = devchar;
8978     int r;
8979     suppress_error = 0;
8980     r = guestfs_pvcreate (g, device);
8981     if (r == -1)
8982       return -1;
8983   }
8984   {
8985     char device[] = "/dev/sda3";
8986     device[5] = devchar;
8987     int r;
8988     suppress_error = 0;
8989     r = guestfs_pvcreate (g, device);
8990     if (r == -1)
8991       return -1;
8992   }
8993   {
8994     char volgroup[] = "VG1";
8995     char physvols_0[] = "/dev/sda1";
8996     physvols_0[5] = devchar;
8997     char physvols_1[] = "/dev/sda2";
8998     physvols_1[5] = devchar;
8999     char *physvols[] = {
9000       physvols_0,
9001       physvols_1,
9002       NULL
9003     };
9004     int r;
9005     suppress_error = 0;
9006     r = guestfs_vgcreate (g, volgroup, physvols);
9007     if (r == -1)
9008       return -1;
9009   }
9010   {
9011     char volgroup[] = "VG2";
9012     char physvols_0[] = "/dev/sda3";
9013     physvols_0[5] = devchar;
9014     char *physvols[] = {
9015       physvols_0,
9016       NULL
9017     };
9018     int r;
9019     suppress_error = 0;
9020     r = guestfs_vgcreate (g, volgroup, physvols);
9021     if (r == -1)
9022       return -1;
9023   }
9024   {
9025     char logvol[] = "LV1";
9026     char volgroup[] = "VG1";
9027     int r;
9028     suppress_error = 0;
9029     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9030     if (r == -1)
9031       return -1;
9032   }
9033   {
9034     char logvol[] = "LV2";
9035     char volgroup[] = "VG1";
9036     int r;
9037     suppress_error = 0;
9038     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9039     if (r == -1)
9040       return -1;
9041   }
9042   {
9043     char logvol[] = "LV3";
9044     char volgroup[] = "VG2";
9045     int r;
9046     suppress_error = 0;
9047     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9048     if (r == -1)
9049       return -1;
9050   }
9051   {
9052     char logvol[] = "LV4";
9053     char volgroup[] = "VG2";
9054     int r;
9055     suppress_error = 0;
9056     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9057     if (r == -1)
9058       return -1;
9059   }
9060   {
9061     char logvol[] = "LV5";
9062     char volgroup[] = "VG2";
9063     int r;
9064     suppress_error = 0;
9065     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9066     if (r == -1)
9067       return -1;
9068   }
9069   {
9070     char **r;
9071     int i;
9072     suppress_error = 0;
9073     r = guestfs_lvs (g);
9074     if (r == NULL)
9075       return -1;
9076     if (!r[0]) {
9077       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9078       print_strings (r);
9079       return -1;
9080     }
9081     {
9082       char expected[] = "/dev/VG1/LV1";
9083       if (strcmp (r[0], expected) != 0) {
9084         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9085         return -1;
9086       }
9087     }
9088     if (!r[1]) {
9089       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9090       print_strings (r);
9091       return -1;
9092     }
9093     {
9094       char expected[] = "/dev/VG1/LV2";
9095       if (strcmp (r[1], expected) != 0) {
9096         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9097         return -1;
9098       }
9099     }
9100     if (!r[2]) {
9101       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9102       print_strings (r);
9103       return -1;
9104     }
9105     {
9106       char expected[] = "/dev/VG2/LV3";
9107       if (strcmp (r[2], expected) != 0) {
9108         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9109         return -1;
9110       }
9111     }
9112     if (!r[3]) {
9113       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9114       print_strings (r);
9115       return -1;
9116     }
9117     {
9118       char expected[] = "/dev/VG2/LV4";
9119       if (strcmp (r[3], expected) != 0) {
9120         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9121         return -1;
9122       }
9123     }
9124     if (!r[4]) {
9125       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9126       print_strings (r);
9127       return -1;
9128     }
9129     {
9130       char expected[] = "/dev/VG2/LV5";
9131       if (strcmp (r[4], expected) != 0) {
9132         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9133         return -1;
9134       }
9135     }
9136     if (r[5] != NULL) {
9137       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9138       print_strings (r);
9139       return -1;
9140     }
9141     for (i = 0; r[i] != NULL; ++i)
9142       free (r[i]);
9143     free (r);
9144   }
9145   return 0;
9146 }
9147
9148 static int test_vgcreate_0 (void)
9149 {
9150   /* InitEmpty for vgcreate (0) */
9151   {
9152     char device[] = "/dev/sda";
9153     device[5] = devchar;
9154     int r;
9155     suppress_error = 0;
9156     r = guestfs_blockdev_setrw (g, device);
9157     if (r == -1)
9158       return -1;
9159   }
9160   {
9161     int r;
9162     suppress_error = 0;
9163     r = guestfs_umount_all (g);
9164     if (r == -1)
9165       return -1;
9166   }
9167   {
9168     int r;
9169     suppress_error = 0;
9170     r = guestfs_lvm_remove_all (g);
9171     if (r == -1)
9172       return -1;
9173   }
9174   /* TestOutputList for vgcreate (0) */
9175   {
9176     char device[] = "/dev/sda";
9177     device[5] = devchar;
9178     char lines_0[] = ",10";
9179     char lines_1[] = ",20";
9180     char lines_2[] = ",";
9181     char *lines[] = {
9182       lines_0,
9183       lines_1,
9184       lines_2,
9185       NULL
9186     };
9187     int r;
9188     suppress_error = 0;
9189     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9190     if (r == -1)
9191       return -1;
9192   }
9193   {
9194     char device[] = "/dev/sda1";
9195     device[5] = devchar;
9196     int r;
9197     suppress_error = 0;
9198     r = guestfs_pvcreate (g, device);
9199     if (r == -1)
9200       return -1;
9201   }
9202   {
9203     char device[] = "/dev/sda2";
9204     device[5] = devchar;
9205     int r;
9206     suppress_error = 0;
9207     r = guestfs_pvcreate (g, device);
9208     if (r == -1)
9209       return -1;
9210   }
9211   {
9212     char device[] = "/dev/sda3";
9213     device[5] = devchar;
9214     int r;
9215     suppress_error = 0;
9216     r = guestfs_pvcreate (g, device);
9217     if (r == -1)
9218       return -1;
9219   }
9220   {
9221     char volgroup[] = "VG1";
9222     char physvols_0[] = "/dev/sda1";
9223     physvols_0[5] = devchar;
9224     char physvols_1[] = "/dev/sda2";
9225     physvols_1[5] = devchar;
9226     char *physvols[] = {
9227       physvols_0,
9228       physvols_1,
9229       NULL
9230     };
9231     int r;
9232     suppress_error = 0;
9233     r = guestfs_vgcreate (g, volgroup, physvols);
9234     if (r == -1)
9235       return -1;
9236   }
9237   {
9238     char volgroup[] = "VG2";
9239     char physvols_0[] = "/dev/sda3";
9240     physvols_0[5] = devchar;
9241     char *physvols[] = {
9242       physvols_0,
9243       NULL
9244     };
9245     int r;
9246     suppress_error = 0;
9247     r = guestfs_vgcreate (g, volgroup, physvols);
9248     if (r == -1)
9249       return -1;
9250   }
9251   {
9252     char **r;
9253     int i;
9254     suppress_error = 0;
9255     r = guestfs_vgs (g);
9256     if (r == NULL)
9257       return -1;
9258     if (!r[0]) {
9259       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9260       print_strings (r);
9261       return -1;
9262     }
9263     {
9264       char expected[] = "VG1";
9265       if (strcmp (r[0], expected) != 0) {
9266         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9267         return -1;
9268       }
9269     }
9270     if (!r[1]) {
9271       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9272       print_strings (r);
9273       return -1;
9274     }
9275     {
9276       char expected[] = "VG2";
9277       if (strcmp (r[1], expected) != 0) {
9278         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9279         return -1;
9280       }
9281     }
9282     if (r[2] != NULL) {
9283       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
9284       print_strings (r);
9285       return -1;
9286     }
9287     for (i = 0; r[i] != NULL; ++i)
9288       free (r[i]);
9289     free (r);
9290   }
9291   return 0;
9292 }
9293
9294 static int test_pvcreate_0 (void)
9295 {
9296   /* InitEmpty for pvcreate (0) */
9297   {
9298     char device[] = "/dev/sda";
9299     device[5] = devchar;
9300     int r;
9301     suppress_error = 0;
9302     r = guestfs_blockdev_setrw (g, device);
9303     if (r == -1)
9304       return -1;
9305   }
9306   {
9307     int r;
9308     suppress_error = 0;
9309     r = guestfs_umount_all (g);
9310     if (r == -1)
9311       return -1;
9312   }
9313   {
9314     int r;
9315     suppress_error = 0;
9316     r = guestfs_lvm_remove_all (g);
9317     if (r == -1)
9318       return -1;
9319   }
9320   /* TestOutputList for pvcreate (0) */
9321   {
9322     char device[] = "/dev/sda";
9323     device[5] = devchar;
9324     char lines_0[] = ",10";
9325     char lines_1[] = ",20";
9326     char lines_2[] = ",";
9327     char *lines[] = {
9328       lines_0,
9329       lines_1,
9330       lines_2,
9331       NULL
9332     };
9333     int r;
9334     suppress_error = 0;
9335     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9336     if (r == -1)
9337       return -1;
9338   }
9339   {
9340     char device[] = "/dev/sda1";
9341     device[5] = devchar;
9342     int r;
9343     suppress_error = 0;
9344     r = guestfs_pvcreate (g, device);
9345     if (r == -1)
9346       return -1;
9347   }
9348   {
9349     char device[] = "/dev/sda2";
9350     device[5] = devchar;
9351     int r;
9352     suppress_error = 0;
9353     r = guestfs_pvcreate (g, device);
9354     if (r == -1)
9355       return -1;
9356   }
9357   {
9358     char device[] = "/dev/sda3";
9359     device[5] = devchar;
9360     int r;
9361     suppress_error = 0;
9362     r = guestfs_pvcreate (g, device);
9363     if (r == -1)
9364       return -1;
9365   }
9366   {
9367     char **r;
9368     int i;
9369     suppress_error = 0;
9370     r = guestfs_pvs (g);
9371     if (r == NULL)
9372       return -1;
9373     if (!r[0]) {
9374       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9375       print_strings (r);
9376       return -1;
9377     }
9378     {
9379       char expected[] = "/dev/sda1";
9380       expected[5] = devchar;
9381       if (strcmp (r[0], expected) != 0) {
9382         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9383         return -1;
9384       }
9385     }
9386     if (!r[1]) {
9387       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9388       print_strings (r);
9389       return -1;
9390     }
9391     {
9392       char expected[] = "/dev/sda2";
9393       expected[5] = devchar;
9394       if (strcmp (r[1], expected) != 0) {
9395         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9396         return -1;
9397       }
9398     }
9399     if (!r[2]) {
9400       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9401       print_strings (r);
9402       return -1;
9403     }
9404     {
9405       char expected[] = "/dev/sda3";
9406       expected[5] = devchar;
9407       if (strcmp (r[2], expected) != 0) {
9408         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9409         return -1;
9410       }
9411     }
9412     if (r[3] != NULL) {
9413       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
9414       print_strings (r);
9415       return -1;
9416     }
9417     for (i = 0; r[i] != NULL; ++i)
9418       free (r[i]);
9419     free (r);
9420   }
9421   return 0;
9422 }
9423
9424 static int test_is_dir_0 (void)
9425 {
9426   /* InitBasicFS for is_dir (0): create ext2 on /dev/sda1 */
9427   {
9428     char device[] = "/dev/sda";
9429     device[5] = devchar;
9430     int r;
9431     suppress_error = 0;
9432     r = guestfs_blockdev_setrw (g, device);
9433     if (r == -1)
9434       return -1;
9435   }
9436   {
9437     int r;
9438     suppress_error = 0;
9439     r = guestfs_umount_all (g);
9440     if (r == -1)
9441       return -1;
9442   }
9443   {
9444     int r;
9445     suppress_error = 0;
9446     r = guestfs_lvm_remove_all (g);
9447     if (r == -1)
9448       return -1;
9449   }
9450   {
9451     char device[] = "/dev/sda";
9452     device[5] = devchar;
9453     char lines_0[] = ",";
9454     char *lines[] = {
9455       lines_0,
9456       NULL
9457     };
9458     int r;
9459     suppress_error = 0;
9460     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9461     if (r == -1)
9462       return -1;
9463   }
9464   {
9465     char fstype[] = "ext2";
9466     char device[] = "/dev/sda1";
9467     device[5] = devchar;
9468     int r;
9469     suppress_error = 0;
9470     r = guestfs_mkfs (g, fstype, device);
9471     if (r == -1)
9472       return -1;
9473   }
9474   {
9475     char device[] = "/dev/sda1";
9476     device[5] = devchar;
9477     char mountpoint[] = "/";
9478     int r;
9479     suppress_error = 0;
9480     r = guestfs_mount (g, device, mountpoint);
9481     if (r == -1)
9482       return -1;
9483   }
9484   /* TestOutputFalse for is_dir (0) */
9485   {
9486     char path[] = "/new";
9487     int r;
9488     suppress_error = 0;
9489     r = guestfs_touch (g, path);
9490     if (r == -1)
9491       return -1;
9492   }
9493   {
9494     char path[] = "/new";
9495     int r;
9496     suppress_error = 0;
9497     r = guestfs_is_dir (g, path);
9498     if (r == -1)
9499       return -1;
9500     if (r) {
9501       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
9502       return -1;
9503     }
9504   }
9505   return 0;
9506 }
9507
9508 static int test_is_dir_1 (void)
9509 {
9510   /* InitBasicFS for is_dir (1): create ext2 on /dev/sda1 */
9511   {
9512     char device[] = "/dev/sda";
9513     device[5] = devchar;
9514     int r;
9515     suppress_error = 0;
9516     r = guestfs_blockdev_setrw (g, device);
9517     if (r == -1)
9518       return -1;
9519   }
9520   {
9521     int r;
9522     suppress_error = 0;
9523     r = guestfs_umount_all (g);
9524     if (r == -1)
9525       return -1;
9526   }
9527   {
9528     int r;
9529     suppress_error = 0;
9530     r = guestfs_lvm_remove_all (g);
9531     if (r == -1)
9532       return -1;
9533   }
9534   {
9535     char device[] = "/dev/sda";
9536     device[5] = devchar;
9537     char lines_0[] = ",";
9538     char *lines[] = {
9539       lines_0,
9540       NULL
9541     };
9542     int r;
9543     suppress_error = 0;
9544     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9545     if (r == -1)
9546       return -1;
9547   }
9548   {
9549     char fstype[] = "ext2";
9550     char device[] = "/dev/sda1";
9551     device[5] = devchar;
9552     int r;
9553     suppress_error = 0;
9554     r = guestfs_mkfs (g, fstype, device);
9555     if (r == -1)
9556       return -1;
9557   }
9558   {
9559     char device[] = "/dev/sda1";
9560     device[5] = devchar;
9561     char mountpoint[] = "/";
9562     int r;
9563     suppress_error = 0;
9564     r = guestfs_mount (g, device, mountpoint);
9565     if (r == -1)
9566       return -1;
9567   }
9568   /* TestOutputTrue for is_dir (1) */
9569   {
9570     char path[] = "/new";
9571     int r;
9572     suppress_error = 0;
9573     r = guestfs_mkdir (g, path);
9574     if (r == -1)
9575       return -1;
9576   }
9577   {
9578     char path[] = "/new";
9579     int r;
9580     suppress_error = 0;
9581     r = guestfs_is_dir (g, path);
9582     if (r == -1)
9583       return -1;
9584     if (!r) {
9585       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
9586       return -1;
9587     }
9588   }
9589   return 0;
9590 }
9591
9592 static int test_is_file_0 (void)
9593 {
9594   /* InitBasicFS for is_file (0): create ext2 on /dev/sda1 */
9595   {
9596     char device[] = "/dev/sda";
9597     device[5] = devchar;
9598     int r;
9599     suppress_error = 0;
9600     r = guestfs_blockdev_setrw (g, device);
9601     if (r == -1)
9602       return -1;
9603   }
9604   {
9605     int r;
9606     suppress_error = 0;
9607     r = guestfs_umount_all (g);
9608     if (r == -1)
9609       return -1;
9610   }
9611   {
9612     int r;
9613     suppress_error = 0;
9614     r = guestfs_lvm_remove_all (g);
9615     if (r == -1)
9616       return -1;
9617   }
9618   {
9619     char device[] = "/dev/sda";
9620     device[5] = devchar;
9621     char lines_0[] = ",";
9622     char *lines[] = {
9623       lines_0,
9624       NULL
9625     };
9626     int r;
9627     suppress_error = 0;
9628     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9629     if (r == -1)
9630       return -1;
9631   }
9632   {
9633     char fstype[] = "ext2";
9634     char device[] = "/dev/sda1";
9635     device[5] = devchar;
9636     int r;
9637     suppress_error = 0;
9638     r = guestfs_mkfs (g, fstype, device);
9639     if (r == -1)
9640       return -1;
9641   }
9642   {
9643     char device[] = "/dev/sda1";
9644     device[5] = devchar;
9645     char mountpoint[] = "/";
9646     int r;
9647     suppress_error = 0;
9648     r = guestfs_mount (g, device, mountpoint);
9649     if (r == -1)
9650       return -1;
9651   }
9652   /* TestOutputTrue for is_file (0) */
9653   {
9654     char path[] = "/new";
9655     int r;
9656     suppress_error = 0;
9657     r = guestfs_touch (g, path);
9658     if (r == -1)
9659       return -1;
9660   }
9661   {
9662     char path[] = "/new";
9663     int r;
9664     suppress_error = 0;
9665     r = guestfs_is_file (g, path);
9666     if (r == -1)
9667       return -1;
9668     if (!r) {
9669       fprintf (stderr, "test_is_file_0: expected true, got false\n");
9670       return -1;
9671     }
9672   }
9673   return 0;
9674 }
9675
9676 static int test_is_file_1 (void)
9677 {
9678   /* InitBasicFS for is_file (1): create ext2 on /dev/sda1 */
9679   {
9680     char device[] = "/dev/sda";
9681     device[5] = devchar;
9682     int r;
9683     suppress_error = 0;
9684     r = guestfs_blockdev_setrw (g, device);
9685     if (r == -1)
9686       return -1;
9687   }
9688   {
9689     int r;
9690     suppress_error = 0;
9691     r = guestfs_umount_all (g);
9692     if (r == -1)
9693       return -1;
9694   }
9695   {
9696     int r;
9697     suppress_error = 0;
9698     r = guestfs_lvm_remove_all (g);
9699     if (r == -1)
9700       return -1;
9701   }
9702   {
9703     char device[] = "/dev/sda";
9704     device[5] = devchar;
9705     char lines_0[] = ",";
9706     char *lines[] = {
9707       lines_0,
9708       NULL
9709     };
9710     int r;
9711     suppress_error = 0;
9712     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9713     if (r == -1)
9714       return -1;
9715   }
9716   {
9717     char fstype[] = "ext2";
9718     char device[] = "/dev/sda1";
9719     device[5] = devchar;
9720     int r;
9721     suppress_error = 0;
9722     r = guestfs_mkfs (g, fstype, device);
9723     if (r == -1)
9724       return -1;
9725   }
9726   {
9727     char device[] = "/dev/sda1";
9728     device[5] = devchar;
9729     char mountpoint[] = "/";
9730     int r;
9731     suppress_error = 0;
9732     r = guestfs_mount (g, device, mountpoint);
9733     if (r == -1)
9734       return -1;
9735   }
9736   /* TestOutputFalse for is_file (1) */
9737   {
9738     char path[] = "/new";
9739     int r;
9740     suppress_error = 0;
9741     r = guestfs_mkdir (g, path);
9742     if (r == -1)
9743       return -1;
9744   }
9745   {
9746     char path[] = "/new";
9747     int r;
9748     suppress_error = 0;
9749     r = guestfs_is_file (g, path);
9750     if (r == -1)
9751       return -1;
9752     if (r) {
9753       fprintf (stderr, "test_is_file_1: expected false, got true\n");
9754       return -1;
9755     }
9756   }
9757   return 0;
9758 }
9759
9760 static int test_exists_0 (void)
9761 {
9762   /* InitBasicFS for exists (0): create ext2 on /dev/sda1 */
9763   {
9764     char device[] = "/dev/sda";
9765     device[5] = devchar;
9766     int r;
9767     suppress_error = 0;
9768     r = guestfs_blockdev_setrw (g, device);
9769     if (r == -1)
9770       return -1;
9771   }
9772   {
9773     int r;
9774     suppress_error = 0;
9775     r = guestfs_umount_all (g);
9776     if (r == -1)
9777       return -1;
9778   }
9779   {
9780     int r;
9781     suppress_error = 0;
9782     r = guestfs_lvm_remove_all (g);
9783     if (r == -1)
9784       return -1;
9785   }
9786   {
9787     char device[] = "/dev/sda";
9788     device[5] = devchar;
9789     char lines_0[] = ",";
9790     char *lines[] = {
9791       lines_0,
9792       NULL
9793     };
9794     int r;
9795     suppress_error = 0;
9796     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9797     if (r == -1)
9798       return -1;
9799   }
9800   {
9801     char fstype[] = "ext2";
9802     char device[] = "/dev/sda1";
9803     device[5] = devchar;
9804     int r;
9805     suppress_error = 0;
9806     r = guestfs_mkfs (g, fstype, device);
9807     if (r == -1)
9808       return -1;
9809   }
9810   {
9811     char device[] = "/dev/sda1";
9812     device[5] = devchar;
9813     char mountpoint[] = "/";
9814     int r;
9815     suppress_error = 0;
9816     r = guestfs_mount (g, device, mountpoint);
9817     if (r == -1)
9818       return -1;
9819   }
9820   /* TestOutputTrue for exists (0) */
9821   {
9822     char path[] = "/new";
9823     int r;
9824     suppress_error = 0;
9825     r = guestfs_touch (g, path);
9826     if (r == -1)
9827       return -1;
9828   }
9829   {
9830     char path[] = "/new";
9831     int r;
9832     suppress_error = 0;
9833     r = guestfs_exists (g, path);
9834     if (r == -1)
9835       return -1;
9836     if (!r) {
9837       fprintf (stderr, "test_exists_0: expected true, got false\n");
9838       return -1;
9839     }
9840   }
9841   return 0;
9842 }
9843
9844 static int test_exists_1 (void)
9845 {
9846   /* InitBasicFS for exists (1): create ext2 on /dev/sda1 */
9847   {
9848     char device[] = "/dev/sda";
9849     device[5] = devchar;
9850     int r;
9851     suppress_error = 0;
9852     r = guestfs_blockdev_setrw (g, device);
9853     if (r == -1)
9854       return -1;
9855   }
9856   {
9857     int r;
9858     suppress_error = 0;
9859     r = guestfs_umount_all (g);
9860     if (r == -1)
9861       return -1;
9862   }
9863   {
9864     int r;
9865     suppress_error = 0;
9866     r = guestfs_lvm_remove_all (g);
9867     if (r == -1)
9868       return -1;
9869   }
9870   {
9871     char device[] = "/dev/sda";
9872     device[5] = devchar;
9873     char lines_0[] = ",";
9874     char *lines[] = {
9875       lines_0,
9876       NULL
9877     };
9878     int r;
9879     suppress_error = 0;
9880     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9881     if (r == -1)
9882       return -1;
9883   }
9884   {
9885     char fstype[] = "ext2";
9886     char device[] = "/dev/sda1";
9887     device[5] = devchar;
9888     int r;
9889     suppress_error = 0;
9890     r = guestfs_mkfs (g, fstype, device);
9891     if (r == -1)
9892       return -1;
9893   }
9894   {
9895     char device[] = "/dev/sda1";
9896     device[5] = devchar;
9897     char mountpoint[] = "/";
9898     int r;
9899     suppress_error = 0;
9900     r = guestfs_mount (g, device, mountpoint);
9901     if (r == -1)
9902       return -1;
9903   }
9904   /* TestOutputTrue for exists (1) */
9905   {
9906     char path[] = "/new";
9907     int r;
9908     suppress_error = 0;
9909     r = guestfs_mkdir (g, path);
9910     if (r == -1)
9911       return -1;
9912   }
9913   {
9914     char path[] = "/new";
9915     int r;
9916     suppress_error = 0;
9917     r = guestfs_exists (g, path);
9918     if (r == -1)
9919       return -1;
9920     if (!r) {
9921       fprintf (stderr, "test_exists_1: expected true, got false\n");
9922       return -1;
9923     }
9924   }
9925   return 0;
9926 }
9927
9928 static int test_mkdir_p_0 (void)
9929 {
9930   /* InitBasicFS for mkdir_p (0): create ext2 on /dev/sda1 */
9931   {
9932     char device[] = "/dev/sda";
9933     device[5] = devchar;
9934     int r;
9935     suppress_error = 0;
9936     r = guestfs_blockdev_setrw (g, device);
9937     if (r == -1)
9938       return -1;
9939   }
9940   {
9941     int r;
9942     suppress_error = 0;
9943     r = guestfs_umount_all (g);
9944     if (r == -1)
9945       return -1;
9946   }
9947   {
9948     int r;
9949     suppress_error = 0;
9950     r = guestfs_lvm_remove_all (g);
9951     if (r == -1)
9952       return -1;
9953   }
9954   {
9955     char device[] = "/dev/sda";
9956     device[5] = devchar;
9957     char lines_0[] = ",";
9958     char *lines[] = {
9959       lines_0,
9960       NULL
9961     };
9962     int r;
9963     suppress_error = 0;
9964     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9965     if (r == -1)
9966       return -1;
9967   }
9968   {
9969     char fstype[] = "ext2";
9970     char device[] = "/dev/sda1";
9971     device[5] = devchar;
9972     int r;
9973     suppress_error = 0;
9974     r = guestfs_mkfs (g, fstype, device);
9975     if (r == -1)
9976       return -1;
9977   }
9978   {
9979     char device[] = "/dev/sda1";
9980     device[5] = devchar;
9981     char mountpoint[] = "/";
9982     int r;
9983     suppress_error = 0;
9984     r = guestfs_mount (g, device, mountpoint);
9985     if (r == -1)
9986       return -1;
9987   }
9988   /* TestOutputTrue for mkdir_p (0) */
9989   {
9990     char path[] = "/new/foo/bar";
9991     int r;
9992     suppress_error = 0;
9993     r = guestfs_mkdir_p (g, path);
9994     if (r == -1)
9995       return -1;
9996   }
9997   {
9998     char path[] = "/new/foo/bar";
9999     int r;
10000     suppress_error = 0;
10001     r = guestfs_is_dir (g, path);
10002     if (r == -1)
10003       return -1;
10004     if (!r) {
10005       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10006       return -1;
10007     }
10008   }
10009   return 0;
10010 }
10011
10012 static int test_mkdir_p_1 (void)
10013 {
10014   /* InitBasicFS for mkdir_p (1): create ext2 on /dev/sda1 */
10015   {
10016     char device[] = "/dev/sda";
10017     device[5] = devchar;
10018     int r;
10019     suppress_error = 0;
10020     r = guestfs_blockdev_setrw (g, device);
10021     if (r == -1)
10022       return -1;
10023   }
10024   {
10025     int r;
10026     suppress_error = 0;
10027     r = guestfs_umount_all (g);
10028     if (r == -1)
10029       return -1;
10030   }
10031   {
10032     int r;
10033     suppress_error = 0;
10034     r = guestfs_lvm_remove_all (g);
10035     if (r == -1)
10036       return -1;
10037   }
10038   {
10039     char device[] = "/dev/sda";
10040     device[5] = devchar;
10041     char lines_0[] = ",";
10042     char *lines[] = {
10043       lines_0,
10044       NULL
10045     };
10046     int r;
10047     suppress_error = 0;
10048     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10049     if (r == -1)
10050       return -1;
10051   }
10052   {
10053     char fstype[] = "ext2";
10054     char device[] = "/dev/sda1";
10055     device[5] = devchar;
10056     int r;
10057     suppress_error = 0;
10058     r = guestfs_mkfs (g, fstype, device);
10059     if (r == -1)
10060       return -1;
10061   }
10062   {
10063     char device[] = "/dev/sda1";
10064     device[5] = devchar;
10065     char mountpoint[] = "/";
10066     int r;
10067     suppress_error = 0;
10068     r = guestfs_mount (g, device, mountpoint);
10069     if (r == -1)
10070       return -1;
10071   }
10072   /* TestOutputTrue for mkdir_p (1) */
10073   {
10074     char path[] = "/new/foo/bar";
10075     int r;
10076     suppress_error = 0;
10077     r = guestfs_mkdir_p (g, path);
10078     if (r == -1)
10079       return -1;
10080   }
10081   {
10082     char path[] = "/new/foo";
10083     int r;
10084     suppress_error = 0;
10085     r = guestfs_is_dir (g, path);
10086     if (r == -1)
10087       return -1;
10088     if (!r) {
10089       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10090       return -1;
10091     }
10092   }
10093   return 0;
10094 }
10095
10096 static int test_mkdir_p_2 (void)
10097 {
10098   /* InitBasicFS for mkdir_p (2): create ext2 on /dev/sda1 */
10099   {
10100     char device[] = "/dev/sda";
10101     device[5] = devchar;
10102     int r;
10103     suppress_error = 0;
10104     r = guestfs_blockdev_setrw (g, device);
10105     if (r == -1)
10106       return -1;
10107   }
10108   {
10109     int r;
10110     suppress_error = 0;
10111     r = guestfs_umount_all (g);
10112     if (r == -1)
10113       return -1;
10114   }
10115   {
10116     int r;
10117     suppress_error = 0;
10118     r = guestfs_lvm_remove_all (g);
10119     if (r == -1)
10120       return -1;
10121   }
10122   {
10123     char device[] = "/dev/sda";
10124     device[5] = devchar;
10125     char lines_0[] = ",";
10126     char *lines[] = {
10127       lines_0,
10128       NULL
10129     };
10130     int r;
10131     suppress_error = 0;
10132     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10133     if (r == -1)
10134       return -1;
10135   }
10136   {
10137     char fstype[] = "ext2";
10138     char device[] = "/dev/sda1";
10139     device[5] = devchar;
10140     int r;
10141     suppress_error = 0;
10142     r = guestfs_mkfs (g, fstype, device);
10143     if (r == -1)
10144       return -1;
10145   }
10146   {
10147     char device[] = "/dev/sda1";
10148     device[5] = devchar;
10149     char mountpoint[] = "/";
10150     int r;
10151     suppress_error = 0;
10152     r = guestfs_mount (g, device, mountpoint);
10153     if (r == -1)
10154       return -1;
10155   }
10156   /* TestOutputTrue for mkdir_p (2) */
10157   {
10158     char path[] = "/new/foo/bar";
10159     int r;
10160     suppress_error = 0;
10161     r = guestfs_mkdir_p (g, path);
10162     if (r == -1)
10163       return -1;
10164   }
10165   {
10166     char path[] = "/new";
10167     int r;
10168     suppress_error = 0;
10169     r = guestfs_is_dir (g, path);
10170     if (r == -1)
10171       return -1;
10172     if (!r) {
10173       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
10174       return -1;
10175     }
10176   }
10177   return 0;
10178 }
10179
10180 static int test_mkdir_0 (void)
10181 {
10182   /* InitBasicFS for mkdir (0): create ext2 on /dev/sda1 */
10183   {
10184     char device[] = "/dev/sda";
10185     device[5] = devchar;
10186     int r;
10187     suppress_error = 0;
10188     r = guestfs_blockdev_setrw (g, device);
10189     if (r == -1)
10190       return -1;
10191   }
10192   {
10193     int r;
10194     suppress_error = 0;
10195     r = guestfs_umount_all (g);
10196     if (r == -1)
10197       return -1;
10198   }
10199   {
10200     int r;
10201     suppress_error = 0;
10202     r = guestfs_lvm_remove_all (g);
10203     if (r == -1)
10204       return -1;
10205   }
10206   {
10207     char device[] = "/dev/sda";
10208     device[5] = devchar;
10209     char lines_0[] = ",";
10210     char *lines[] = {
10211       lines_0,
10212       NULL
10213     };
10214     int r;
10215     suppress_error = 0;
10216     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10217     if (r == -1)
10218       return -1;
10219   }
10220   {
10221     char fstype[] = "ext2";
10222     char device[] = "/dev/sda1";
10223     device[5] = devchar;
10224     int r;
10225     suppress_error = 0;
10226     r = guestfs_mkfs (g, fstype, device);
10227     if (r == -1)
10228       return -1;
10229   }
10230   {
10231     char device[] = "/dev/sda1";
10232     device[5] = devchar;
10233     char mountpoint[] = "/";
10234     int r;
10235     suppress_error = 0;
10236     r = guestfs_mount (g, device, mountpoint);
10237     if (r == -1)
10238       return -1;
10239   }
10240   /* TestOutputTrue for mkdir (0) */
10241   {
10242     char path[] = "/new";
10243     int r;
10244     suppress_error = 0;
10245     r = guestfs_mkdir (g, path);
10246     if (r == -1)
10247       return -1;
10248   }
10249   {
10250     char path[] = "/new";
10251     int r;
10252     suppress_error = 0;
10253     r = guestfs_is_dir (g, path);
10254     if (r == -1)
10255       return -1;
10256     if (!r) {
10257       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
10258       return -1;
10259     }
10260   }
10261   return 0;
10262 }
10263
10264 static int test_mkdir_1 (void)
10265 {
10266   /* InitBasicFS for mkdir (1): create ext2 on /dev/sda1 */
10267   {
10268     char device[] = "/dev/sda";
10269     device[5] = devchar;
10270     int r;
10271     suppress_error = 0;
10272     r = guestfs_blockdev_setrw (g, device);
10273     if (r == -1)
10274       return -1;
10275   }
10276   {
10277     int r;
10278     suppress_error = 0;
10279     r = guestfs_umount_all (g);
10280     if (r == -1)
10281       return -1;
10282   }
10283   {
10284     int r;
10285     suppress_error = 0;
10286     r = guestfs_lvm_remove_all (g);
10287     if (r == -1)
10288       return -1;
10289   }
10290   {
10291     char device[] = "/dev/sda";
10292     device[5] = devchar;
10293     char lines_0[] = ",";
10294     char *lines[] = {
10295       lines_0,
10296       NULL
10297     };
10298     int r;
10299     suppress_error = 0;
10300     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10301     if (r == -1)
10302       return -1;
10303   }
10304   {
10305     char fstype[] = "ext2";
10306     char device[] = "/dev/sda1";
10307     device[5] = devchar;
10308     int r;
10309     suppress_error = 0;
10310     r = guestfs_mkfs (g, fstype, device);
10311     if (r == -1)
10312       return -1;
10313   }
10314   {
10315     char device[] = "/dev/sda1";
10316     device[5] = devchar;
10317     char mountpoint[] = "/";
10318     int r;
10319     suppress_error = 0;
10320     r = guestfs_mount (g, device, mountpoint);
10321     if (r == -1)
10322       return -1;
10323   }
10324   /* TestLastFail for mkdir (1) */
10325   {
10326     char path[] = "/new/foo/bar";
10327     int r;
10328     suppress_error = 1;
10329     r = guestfs_mkdir (g, path);
10330     if (r != -1)
10331       return -1;
10332   }
10333   return 0;
10334 }
10335
10336 static int test_rm_rf_0 (void)
10337 {
10338   /* InitBasicFS for rm_rf (0): create ext2 on /dev/sda1 */
10339   {
10340     char device[] = "/dev/sda";
10341     device[5] = devchar;
10342     int r;
10343     suppress_error = 0;
10344     r = guestfs_blockdev_setrw (g, device);
10345     if (r == -1)
10346       return -1;
10347   }
10348   {
10349     int r;
10350     suppress_error = 0;
10351     r = guestfs_umount_all (g);
10352     if (r == -1)
10353       return -1;
10354   }
10355   {
10356     int r;
10357     suppress_error = 0;
10358     r = guestfs_lvm_remove_all (g);
10359     if (r == -1)
10360       return -1;
10361   }
10362   {
10363     char device[] = "/dev/sda";
10364     device[5] = devchar;
10365     char lines_0[] = ",";
10366     char *lines[] = {
10367       lines_0,
10368       NULL
10369     };
10370     int r;
10371     suppress_error = 0;
10372     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10373     if (r == -1)
10374       return -1;
10375   }
10376   {
10377     char fstype[] = "ext2";
10378     char device[] = "/dev/sda1";
10379     device[5] = devchar;
10380     int r;
10381     suppress_error = 0;
10382     r = guestfs_mkfs (g, fstype, device);
10383     if (r == -1)
10384       return -1;
10385   }
10386   {
10387     char device[] = "/dev/sda1";
10388     device[5] = devchar;
10389     char mountpoint[] = "/";
10390     int r;
10391     suppress_error = 0;
10392     r = guestfs_mount (g, device, mountpoint);
10393     if (r == -1)
10394       return -1;
10395   }
10396   /* TestOutputFalse for rm_rf (0) */
10397   {
10398     char path[] = "/new";
10399     int r;
10400     suppress_error = 0;
10401     r = guestfs_mkdir (g, path);
10402     if (r == -1)
10403       return -1;
10404   }
10405   {
10406     char path[] = "/new/foo";
10407     int r;
10408     suppress_error = 0;
10409     r = guestfs_mkdir (g, path);
10410     if (r == -1)
10411       return -1;
10412   }
10413   {
10414     char path[] = "/new/foo/bar";
10415     int r;
10416     suppress_error = 0;
10417     r = guestfs_touch (g, path);
10418     if (r == -1)
10419       return -1;
10420   }
10421   {
10422     char path[] = "/new";
10423     int r;
10424     suppress_error = 0;
10425     r = guestfs_rm_rf (g, path);
10426     if (r == -1)
10427       return -1;
10428   }
10429   {
10430     char path[] = "/new";
10431     int r;
10432     suppress_error = 0;
10433     r = guestfs_exists (g, path);
10434     if (r == -1)
10435       return -1;
10436     if (r) {
10437       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
10438       return -1;
10439     }
10440   }
10441   return 0;
10442 }
10443
10444 static int test_rmdir_0 (void)
10445 {
10446   /* InitBasicFS for rmdir (0): create ext2 on /dev/sda1 */
10447   {
10448     char device[] = "/dev/sda";
10449     device[5] = devchar;
10450     int r;
10451     suppress_error = 0;
10452     r = guestfs_blockdev_setrw (g, device);
10453     if (r == -1)
10454       return -1;
10455   }
10456   {
10457     int r;
10458     suppress_error = 0;
10459     r = guestfs_umount_all (g);
10460     if (r == -1)
10461       return -1;
10462   }
10463   {
10464     int r;
10465     suppress_error = 0;
10466     r = guestfs_lvm_remove_all (g);
10467     if (r == -1)
10468       return -1;
10469   }
10470   {
10471     char device[] = "/dev/sda";
10472     device[5] = devchar;
10473     char lines_0[] = ",";
10474     char *lines[] = {
10475       lines_0,
10476       NULL
10477     };
10478     int r;
10479     suppress_error = 0;
10480     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10481     if (r == -1)
10482       return -1;
10483   }
10484   {
10485     char fstype[] = "ext2";
10486     char device[] = "/dev/sda1";
10487     device[5] = devchar;
10488     int r;
10489     suppress_error = 0;
10490     r = guestfs_mkfs (g, fstype, device);
10491     if (r == -1)
10492       return -1;
10493   }
10494   {
10495     char device[] = "/dev/sda1";
10496     device[5] = devchar;
10497     char mountpoint[] = "/";
10498     int r;
10499     suppress_error = 0;
10500     r = guestfs_mount (g, device, mountpoint);
10501     if (r == -1)
10502       return -1;
10503   }
10504   /* TestRun for rmdir (0) */
10505   {
10506     char path[] = "/new";
10507     int r;
10508     suppress_error = 0;
10509     r = guestfs_mkdir (g, path);
10510     if (r == -1)
10511       return -1;
10512   }
10513   {
10514     char path[] = "/new";
10515     int r;
10516     suppress_error = 0;
10517     r = guestfs_rmdir (g, path);
10518     if (r == -1)
10519       return -1;
10520   }
10521   return 0;
10522 }
10523
10524 static int test_rmdir_1 (void)
10525 {
10526   /* InitBasicFS for rmdir (1): create ext2 on /dev/sda1 */
10527   {
10528     char device[] = "/dev/sda";
10529     device[5] = devchar;
10530     int r;
10531     suppress_error = 0;
10532     r = guestfs_blockdev_setrw (g, device);
10533     if (r == -1)
10534       return -1;
10535   }
10536   {
10537     int r;
10538     suppress_error = 0;
10539     r = guestfs_umount_all (g);
10540     if (r == -1)
10541       return -1;
10542   }
10543   {
10544     int r;
10545     suppress_error = 0;
10546     r = guestfs_lvm_remove_all (g);
10547     if (r == -1)
10548       return -1;
10549   }
10550   {
10551     char device[] = "/dev/sda";
10552     device[5] = devchar;
10553     char lines_0[] = ",";
10554     char *lines[] = {
10555       lines_0,
10556       NULL
10557     };
10558     int r;
10559     suppress_error = 0;
10560     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10561     if (r == -1)
10562       return -1;
10563   }
10564   {
10565     char fstype[] = "ext2";
10566     char device[] = "/dev/sda1";
10567     device[5] = devchar;
10568     int r;
10569     suppress_error = 0;
10570     r = guestfs_mkfs (g, fstype, device);
10571     if (r == -1)
10572       return -1;
10573   }
10574   {
10575     char device[] = "/dev/sda1";
10576     device[5] = devchar;
10577     char mountpoint[] = "/";
10578     int r;
10579     suppress_error = 0;
10580     r = guestfs_mount (g, device, mountpoint);
10581     if (r == -1)
10582       return -1;
10583   }
10584   /* TestLastFail for rmdir (1) */
10585   {
10586     char path[] = "/new";
10587     int r;
10588     suppress_error = 1;
10589     r = guestfs_rmdir (g, path);
10590     if (r != -1)
10591       return -1;
10592   }
10593   return 0;
10594 }
10595
10596 static int test_rmdir_2 (void)
10597 {
10598   /* InitBasicFS for rmdir (2): create ext2 on /dev/sda1 */
10599   {
10600     char device[] = "/dev/sda";
10601     device[5] = devchar;
10602     int r;
10603     suppress_error = 0;
10604     r = guestfs_blockdev_setrw (g, device);
10605     if (r == -1)
10606       return -1;
10607   }
10608   {
10609     int r;
10610     suppress_error = 0;
10611     r = guestfs_umount_all (g);
10612     if (r == -1)
10613       return -1;
10614   }
10615   {
10616     int r;
10617     suppress_error = 0;
10618     r = guestfs_lvm_remove_all (g);
10619     if (r == -1)
10620       return -1;
10621   }
10622   {
10623     char device[] = "/dev/sda";
10624     device[5] = devchar;
10625     char lines_0[] = ",";
10626     char *lines[] = {
10627       lines_0,
10628       NULL
10629     };
10630     int r;
10631     suppress_error = 0;
10632     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10633     if (r == -1)
10634       return -1;
10635   }
10636   {
10637     char fstype[] = "ext2";
10638     char device[] = "/dev/sda1";
10639     device[5] = devchar;
10640     int r;
10641     suppress_error = 0;
10642     r = guestfs_mkfs (g, fstype, device);
10643     if (r == -1)
10644       return -1;
10645   }
10646   {
10647     char device[] = "/dev/sda1";
10648     device[5] = devchar;
10649     char mountpoint[] = "/";
10650     int r;
10651     suppress_error = 0;
10652     r = guestfs_mount (g, device, mountpoint);
10653     if (r == -1)
10654       return -1;
10655   }
10656   /* TestLastFail for rmdir (2) */
10657   {
10658     char path[] = "/new";
10659     int r;
10660     suppress_error = 0;
10661     r = guestfs_touch (g, path);
10662     if (r == -1)
10663       return -1;
10664   }
10665   {
10666     char path[] = "/new";
10667     int r;
10668     suppress_error = 1;
10669     r = guestfs_rmdir (g, path);
10670     if (r != -1)
10671       return -1;
10672   }
10673   return 0;
10674 }
10675
10676 static int test_rm_0 (void)
10677 {
10678   /* InitBasicFS for rm (0): create ext2 on /dev/sda1 */
10679   {
10680     char device[] = "/dev/sda";
10681     device[5] = devchar;
10682     int r;
10683     suppress_error = 0;
10684     r = guestfs_blockdev_setrw (g, device);
10685     if (r == -1)
10686       return -1;
10687   }
10688   {
10689     int r;
10690     suppress_error = 0;
10691     r = guestfs_umount_all (g);
10692     if (r == -1)
10693       return -1;
10694   }
10695   {
10696     int r;
10697     suppress_error = 0;
10698     r = guestfs_lvm_remove_all (g);
10699     if (r == -1)
10700       return -1;
10701   }
10702   {
10703     char device[] = "/dev/sda";
10704     device[5] = devchar;
10705     char lines_0[] = ",";
10706     char *lines[] = {
10707       lines_0,
10708       NULL
10709     };
10710     int r;
10711     suppress_error = 0;
10712     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10713     if (r == -1)
10714       return -1;
10715   }
10716   {
10717     char fstype[] = "ext2";
10718     char device[] = "/dev/sda1";
10719     device[5] = devchar;
10720     int r;
10721     suppress_error = 0;
10722     r = guestfs_mkfs (g, fstype, device);
10723     if (r == -1)
10724       return -1;
10725   }
10726   {
10727     char device[] = "/dev/sda1";
10728     device[5] = devchar;
10729     char mountpoint[] = "/";
10730     int r;
10731     suppress_error = 0;
10732     r = guestfs_mount (g, device, mountpoint);
10733     if (r == -1)
10734       return -1;
10735   }
10736   /* TestRun for rm (0) */
10737   {
10738     char path[] = "/new";
10739     int r;
10740     suppress_error = 0;
10741     r = guestfs_touch (g, path);
10742     if (r == -1)
10743       return -1;
10744   }
10745   {
10746     char path[] = "/new";
10747     int r;
10748     suppress_error = 0;
10749     r = guestfs_rm (g, path);
10750     if (r == -1)
10751       return -1;
10752   }
10753   return 0;
10754 }
10755
10756 static int test_rm_1 (void)
10757 {
10758   /* InitBasicFS for rm (1): create ext2 on /dev/sda1 */
10759   {
10760     char device[] = "/dev/sda";
10761     device[5] = devchar;
10762     int r;
10763     suppress_error = 0;
10764     r = guestfs_blockdev_setrw (g, device);
10765     if (r == -1)
10766       return -1;
10767   }
10768   {
10769     int r;
10770     suppress_error = 0;
10771     r = guestfs_umount_all (g);
10772     if (r == -1)
10773       return -1;
10774   }
10775   {
10776     int r;
10777     suppress_error = 0;
10778     r = guestfs_lvm_remove_all (g);
10779     if (r == -1)
10780       return -1;
10781   }
10782   {
10783     char device[] = "/dev/sda";
10784     device[5] = devchar;
10785     char lines_0[] = ",";
10786     char *lines[] = {
10787       lines_0,
10788       NULL
10789     };
10790     int r;
10791     suppress_error = 0;
10792     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10793     if (r == -1)
10794       return -1;
10795   }
10796   {
10797     char fstype[] = "ext2";
10798     char device[] = "/dev/sda1";
10799     device[5] = devchar;
10800     int r;
10801     suppress_error = 0;
10802     r = guestfs_mkfs (g, fstype, device);
10803     if (r == -1)
10804       return -1;
10805   }
10806   {
10807     char device[] = "/dev/sda1";
10808     device[5] = devchar;
10809     char mountpoint[] = "/";
10810     int r;
10811     suppress_error = 0;
10812     r = guestfs_mount (g, device, mountpoint);
10813     if (r == -1)
10814       return -1;
10815   }
10816   /* TestLastFail for rm (1) */
10817   {
10818     char path[] = "/new";
10819     int r;
10820     suppress_error = 1;
10821     r = guestfs_rm (g, path);
10822     if (r != -1)
10823       return -1;
10824   }
10825   return 0;
10826 }
10827
10828 static int test_rm_2 (void)
10829 {
10830   /* InitBasicFS for rm (2): create ext2 on /dev/sda1 */
10831   {
10832     char device[] = "/dev/sda";
10833     device[5] = devchar;
10834     int r;
10835     suppress_error = 0;
10836     r = guestfs_blockdev_setrw (g, device);
10837     if (r == -1)
10838       return -1;
10839   }
10840   {
10841     int r;
10842     suppress_error = 0;
10843     r = guestfs_umount_all (g);
10844     if (r == -1)
10845       return -1;
10846   }
10847   {
10848     int r;
10849     suppress_error = 0;
10850     r = guestfs_lvm_remove_all (g);
10851     if (r == -1)
10852       return -1;
10853   }
10854   {
10855     char device[] = "/dev/sda";
10856     device[5] = devchar;
10857     char lines_0[] = ",";
10858     char *lines[] = {
10859       lines_0,
10860       NULL
10861     };
10862     int r;
10863     suppress_error = 0;
10864     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10865     if (r == -1)
10866       return -1;
10867   }
10868   {
10869     char fstype[] = "ext2";
10870     char device[] = "/dev/sda1";
10871     device[5] = devchar;
10872     int r;
10873     suppress_error = 0;
10874     r = guestfs_mkfs (g, fstype, device);
10875     if (r == -1)
10876       return -1;
10877   }
10878   {
10879     char device[] = "/dev/sda1";
10880     device[5] = devchar;
10881     char mountpoint[] = "/";
10882     int r;
10883     suppress_error = 0;
10884     r = guestfs_mount (g, device, mountpoint);
10885     if (r == -1)
10886       return -1;
10887   }
10888   /* TestLastFail for rm (2) */
10889   {
10890     char path[] = "/new";
10891     int r;
10892     suppress_error = 0;
10893     r = guestfs_mkdir (g, path);
10894     if (r == -1)
10895       return -1;
10896   }
10897   {
10898     char path[] = "/new";
10899     int r;
10900     suppress_error = 1;
10901     r = guestfs_rm (g, path);
10902     if (r != -1)
10903       return -1;
10904   }
10905   return 0;
10906 }
10907
10908 static int test_read_lines_0 (void)
10909 {
10910   /* InitBasicFS for read_lines (0): create ext2 on /dev/sda1 */
10911   {
10912     char device[] = "/dev/sda";
10913     device[5] = devchar;
10914     int r;
10915     suppress_error = 0;
10916     r = guestfs_blockdev_setrw (g, device);
10917     if (r == -1)
10918       return -1;
10919   }
10920   {
10921     int r;
10922     suppress_error = 0;
10923     r = guestfs_umount_all (g);
10924     if (r == -1)
10925       return -1;
10926   }
10927   {
10928     int r;
10929     suppress_error = 0;
10930     r = guestfs_lvm_remove_all (g);
10931     if (r == -1)
10932       return -1;
10933   }
10934   {
10935     char device[] = "/dev/sda";
10936     device[5] = devchar;
10937     char lines_0[] = ",";
10938     char *lines[] = {
10939       lines_0,
10940       NULL
10941     };
10942     int r;
10943     suppress_error = 0;
10944     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10945     if (r == -1)
10946       return -1;
10947   }
10948   {
10949     char fstype[] = "ext2";
10950     char device[] = "/dev/sda1";
10951     device[5] = devchar;
10952     int r;
10953     suppress_error = 0;
10954     r = guestfs_mkfs (g, fstype, device);
10955     if (r == -1)
10956       return -1;
10957   }
10958   {
10959     char device[] = "/dev/sda1";
10960     device[5] = devchar;
10961     char mountpoint[] = "/";
10962     int r;
10963     suppress_error = 0;
10964     r = guestfs_mount (g, device, mountpoint);
10965     if (r == -1)
10966       return -1;
10967   }
10968   /* TestOutputList for read_lines (0) */
10969   {
10970     char path[] = "/new";
10971     char content[] = "line1\r\nline2\nline3";
10972     int r;
10973     suppress_error = 0;
10974     r = guestfs_write_file (g, path, content, 0);
10975     if (r == -1)
10976       return -1;
10977   }
10978   {
10979     char path[] = "/new";
10980     char **r;
10981     int i;
10982     suppress_error = 0;
10983     r = guestfs_read_lines (g, path);
10984     if (r == NULL)
10985       return -1;
10986     if (!r[0]) {
10987       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
10988       print_strings (r);
10989       return -1;
10990     }
10991     {
10992       char expected[] = "line1";
10993       if (strcmp (r[0], expected) != 0) {
10994         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10995         return -1;
10996       }
10997     }
10998     if (!r[1]) {
10999       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11000       print_strings (r);
11001       return -1;
11002     }
11003     {
11004       char expected[] = "line2";
11005       if (strcmp (r[1], expected) != 0) {
11006         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11007         return -1;
11008       }
11009     }
11010     if (!r[2]) {
11011       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11012       print_strings (r);
11013       return -1;
11014     }
11015     {
11016       char expected[] = "line3";
11017       if (strcmp (r[2], expected) != 0) {
11018         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11019         return -1;
11020       }
11021     }
11022     if (r[3] != NULL) {
11023       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11024       print_strings (r);
11025       return -1;
11026     }
11027     for (i = 0; r[i] != NULL; ++i)
11028       free (r[i]);
11029     free (r);
11030   }
11031   return 0;
11032 }
11033
11034 static int test_read_lines_1 (void)
11035 {
11036   /* InitBasicFS for read_lines (1): create ext2 on /dev/sda1 */
11037   {
11038     char device[] = "/dev/sda";
11039     device[5] = devchar;
11040     int r;
11041     suppress_error = 0;
11042     r = guestfs_blockdev_setrw (g, device);
11043     if (r == -1)
11044       return -1;
11045   }
11046   {
11047     int r;
11048     suppress_error = 0;
11049     r = guestfs_umount_all (g);
11050     if (r == -1)
11051       return -1;
11052   }
11053   {
11054     int r;
11055     suppress_error = 0;
11056     r = guestfs_lvm_remove_all (g);
11057     if (r == -1)
11058       return -1;
11059   }
11060   {
11061     char device[] = "/dev/sda";
11062     device[5] = devchar;
11063     char lines_0[] = ",";
11064     char *lines[] = {
11065       lines_0,
11066       NULL
11067     };
11068     int r;
11069     suppress_error = 0;
11070     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11071     if (r == -1)
11072       return -1;
11073   }
11074   {
11075     char fstype[] = "ext2";
11076     char device[] = "/dev/sda1";
11077     device[5] = devchar;
11078     int r;
11079     suppress_error = 0;
11080     r = guestfs_mkfs (g, fstype, device);
11081     if (r == -1)
11082       return -1;
11083   }
11084   {
11085     char device[] = "/dev/sda1";
11086     device[5] = devchar;
11087     char mountpoint[] = "/";
11088     int r;
11089     suppress_error = 0;
11090     r = guestfs_mount (g, device, mountpoint);
11091     if (r == -1)
11092       return -1;
11093   }
11094   /* TestOutputList for read_lines (1) */
11095   {
11096     char path[] = "/new";
11097     char content[] = "";
11098     int r;
11099     suppress_error = 0;
11100     r = guestfs_write_file (g, path, content, 0);
11101     if (r == -1)
11102       return -1;
11103   }
11104   {
11105     char path[] = "/new";
11106     char **r;
11107     int i;
11108     suppress_error = 0;
11109     r = guestfs_read_lines (g, path);
11110     if (r == NULL)
11111       return -1;
11112     if (r[0] != NULL) {
11113       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11114       print_strings (r);
11115       return -1;
11116     }
11117     for (i = 0; r[i] != NULL; ++i)
11118       free (r[i]);
11119     free (r);
11120   }
11121   return 0;
11122 }
11123
11124 static int test_lvs_0 (void)
11125 {
11126   /* InitBasicFSonLVM for lvs (0): create ext2 on /dev/VG/LV */
11127   {
11128     char device[] = "/dev/sda";
11129     device[5] = devchar;
11130     int r;
11131     suppress_error = 0;
11132     r = guestfs_blockdev_setrw (g, device);
11133     if (r == -1)
11134       return -1;
11135   }
11136   {
11137     int r;
11138     suppress_error = 0;
11139     r = guestfs_umount_all (g);
11140     if (r == -1)
11141       return -1;
11142   }
11143   {
11144     int r;
11145     suppress_error = 0;
11146     r = guestfs_lvm_remove_all (g);
11147     if (r == -1)
11148       return -1;
11149   }
11150   {
11151     char device[] = "/dev/sda";
11152     device[5] = devchar;
11153     char lines_0[] = ",";
11154     char *lines[] = {
11155       lines_0,
11156       NULL
11157     };
11158     int r;
11159     suppress_error = 0;
11160     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11161     if (r == -1)
11162       return -1;
11163   }
11164   {
11165     char device[] = "/dev/sda1";
11166     device[5] = devchar;
11167     int r;
11168     suppress_error = 0;
11169     r = guestfs_pvcreate (g, device);
11170     if (r == -1)
11171       return -1;
11172   }
11173   {
11174     char volgroup[] = "VG";
11175     char physvols_0[] = "/dev/sda1";
11176     physvols_0[5] = devchar;
11177     char *physvols[] = {
11178       physvols_0,
11179       NULL
11180     };
11181     int r;
11182     suppress_error = 0;
11183     r = guestfs_vgcreate (g, volgroup, physvols);
11184     if (r == -1)
11185       return -1;
11186   }
11187   {
11188     char logvol[] = "LV";
11189     char volgroup[] = "VG";
11190     int r;
11191     suppress_error = 0;
11192     r = guestfs_lvcreate (g, logvol, volgroup, 8);
11193     if (r == -1)
11194       return -1;
11195   }
11196   {
11197     char fstype[] = "ext2";
11198     char device[] = "/dev/VG/LV";
11199     int r;
11200     suppress_error = 0;
11201     r = guestfs_mkfs (g, fstype, device);
11202     if (r == -1)
11203       return -1;
11204   }
11205   {
11206     char device[] = "/dev/VG/LV";
11207     char mountpoint[] = "/";
11208     int r;
11209     suppress_error = 0;
11210     r = guestfs_mount (g, device, mountpoint);
11211     if (r == -1)
11212       return -1;
11213   }
11214   /* TestOutputList for lvs (0) */
11215   {
11216     char **r;
11217     int i;
11218     suppress_error = 0;
11219     r = guestfs_lvs (g);
11220     if (r == NULL)
11221       return -1;
11222     if (!r[0]) {
11223       fprintf (stderr, "test_lvs_0: short list returned from command\n");
11224       print_strings (r);
11225       return -1;
11226     }
11227     {
11228       char expected[] = "/dev/VG/LV";
11229       if (strcmp (r[0], expected) != 0) {
11230         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11231         return -1;
11232       }
11233     }
11234     if (r[1] != NULL) {
11235       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
11236       print_strings (r);
11237       return -1;
11238     }
11239     for (i = 0; r[i] != NULL; ++i)
11240       free (r[i]);
11241     free (r);
11242   }
11243   return 0;
11244 }
11245
11246 static int test_lvs_1 (void)
11247 {
11248   /* InitEmpty for lvs (1) */
11249   {
11250     char device[] = "/dev/sda";
11251     device[5] = devchar;
11252     int r;
11253     suppress_error = 0;
11254     r = guestfs_blockdev_setrw (g, device);
11255     if (r == -1)
11256       return -1;
11257   }
11258   {
11259     int r;
11260     suppress_error = 0;
11261     r = guestfs_umount_all (g);
11262     if (r == -1)
11263       return -1;
11264   }
11265   {
11266     int r;
11267     suppress_error = 0;
11268     r = guestfs_lvm_remove_all (g);
11269     if (r == -1)
11270       return -1;
11271   }
11272   /* TestOutputList for lvs (1) */
11273   {
11274     char device[] = "/dev/sda";
11275     device[5] = devchar;
11276     char lines_0[] = ",10";
11277     char lines_1[] = ",20";
11278     char lines_2[] = ",";
11279     char *lines[] = {
11280       lines_0,
11281       lines_1,
11282       lines_2,
11283       NULL
11284     };
11285     int r;
11286     suppress_error = 0;
11287     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11288     if (r == -1)
11289       return -1;
11290   }
11291   {
11292     char device[] = "/dev/sda1";
11293     device[5] = devchar;
11294     int r;
11295     suppress_error = 0;
11296     r = guestfs_pvcreate (g, device);
11297     if (r == -1)
11298       return -1;
11299   }
11300   {
11301     char device[] = "/dev/sda2";
11302     device[5] = devchar;
11303     int r;
11304     suppress_error = 0;
11305     r = guestfs_pvcreate (g, device);
11306     if (r == -1)
11307       return -1;
11308   }
11309   {
11310     char device[] = "/dev/sda3";
11311     device[5] = devchar;
11312     int r;
11313     suppress_error = 0;
11314     r = guestfs_pvcreate (g, device);
11315     if (r == -1)
11316       return -1;
11317   }
11318   {
11319     char volgroup[] = "VG1";
11320     char physvols_0[] = "/dev/sda1";
11321     physvols_0[5] = devchar;
11322     char physvols_1[] = "/dev/sda2";
11323     physvols_1[5] = devchar;
11324     char *physvols[] = {
11325       physvols_0,
11326       physvols_1,
11327       NULL
11328     };
11329     int r;
11330     suppress_error = 0;
11331     r = guestfs_vgcreate (g, volgroup, physvols);
11332     if (r == -1)
11333       return -1;
11334   }
11335   {
11336     char volgroup[] = "VG2";
11337     char physvols_0[] = "/dev/sda3";
11338     physvols_0[5] = devchar;
11339     char *physvols[] = {
11340       physvols_0,
11341       NULL
11342     };
11343     int r;
11344     suppress_error = 0;
11345     r = guestfs_vgcreate (g, volgroup, physvols);
11346     if (r == -1)
11347       return -1;
11348   }
11349   {
11350     char logvol[] = "LV1";
11351     char volgroup[] = "VG1";
11352     int r;
11353     suppress_error = 0;
11354     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11355     if (r == -1)
11356       return -1;
11357   }
11358   {
11359     char logvol[] = "LV2";
11360     char volgroup[] = "VG1";
11361     int r;
11362     suppress_error = 0;
11363     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11364     if (r == -1)
11365       return -1;
11366   }
11367   {
11368     char logvol[] = "LV3";
11369     char volgroup[] = "VG2";
11370     int r;
11371     suppress_error = 0;
11372     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11373     if (r == -1)
11374       return -1;
11375   }
11376   {
11377     char **r;
11378     int i;
11379     suppress_error = 0;
11380     r = guestfs_lvs (g);
11381     if (r == NULL)
11382       return -1;
11383     if (!r[0]) {
11384       fprintf (stderr, "test_lvs_1: short list returned from command\n");
11385       print_strings (r);
11386       return -1;
11387     }
11388     {
11389       char expected[] = "/dev/VG1/LV1";
11390       if (strcmp (r[0], expected) != 0) {
11391         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11392         return -1;
11393       }
11394     }
11395     if (!r[1]) {
11396       fprintf (stderr, "test_lvs_1: short list returned from command\n");
11397       print_strings (r);
11398       return -1;
11399     }
11400     {
11401       char expected[] = "/dev/VG1/LV2";
11402       if (strcmp (r[1], expected) != 0) {
11403         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11404         return -1;
11405       }
11406     }
11407     if (!r[2]) {
11408       fprintf (stderr, "test_lvs_1: short list returned from command\n");
11409       print_strings (r);
11410       return -1;
11411     }
11412     {
11413       char expected[] = "/dev/VG2/LV3";
11414       if (strcmp (r[2], expected) != 0) {
11415         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11416         return -1;
11417       }
11418     }
11419     if (r[3] != NULL) {
11420       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
11421       print_strings (r);
11422       return -1;
11423     }
11424     for (i = 0; r[i] != NULL; ++i)
11425       free (r[i]);
11426     free (r);
11427   }
11428   return 0;
11429 }
11430
11431 static int test_vgs_0 (void)
11432 {
11433   /* InitBasicFSonLVM for vgs (0): create ext2 on /dev/VG/LV */
11434   {
11435     char device[] = "/dev/sda";
11436     device[5] = devchar;
11437     int r;
11438     suppress_error = 0;
11439     r = guestfs_blockdev_setrw (g, device);
11440     if (r == -1)
11441       return -1;
11442   }
11443   {
11444     int r;
11445     suppress_error = 0;
11446     r = guestfs_umount_all (g);
11447     if (r == -1)
11448       return -1;
11449   }
11450   {
11451     int r;
11452     suppress_error = 0;
11453     r = guestfs_lvm_remove_all (g);
11454     if (r == -1)
11455       return -1;
11456   }
11457   {
11458     char device[] = "/dev/sda";
11459     device[5] = devchar;
11460     char lines_0[] = ",";
11461     char *lines[] = {
11462       lines_0,
11463       NULL
11464     };
11465     int r;
11466     suppress_error = 0;
11467     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11468     if (r == -1)
11469       return -1;
11470   }
11471   {
11472     char device[] = "/dev/sda1";
11473     device[5] = devchar;
11474     int r;
11475     suppress_error = 0;
11476     r = guestfs_pvcreate (g, device);
11477     if (r == -1)
11478       return -1;
11479   }
11480   {
11481     char volgroup[] = "VG";
11482     char physvols_0[] = "/dev/sda1";
11483     physvols_0[5] = devchar;
11484     char *physvols[] = {
11485       physvols_0,
11486       NULL
11487     };
11488     int r;
11489     suppress_error = 0;
11490     r = guestfs_vgcreate (g, volgroup, physvols);
11491     if (r == -1)
11492       return -1;
11493   }
11494   {
11495     char logvol[] = "LV";
11496     char volgroup[] = "VG";
11497     int r;
11498     suppress_error = 0;
11499     r = guestfs_lvcreate (g, logvol, volgroup, 8);
11500     if (r == -1)
11501       return -1;
11502   }
11503   {
11504     char fstype[] = "ext2";
11505     char device[] = "/dev/VG/LV";
11506     int r;
11507     suppress_error = 0;
11508     r = guestfs_mkfs (g, fstype, device);
11509     if (r == -1)
11510       return -1;
11511   }
11512   {
11513     char device[] = "/dev/VG/LV";
11514     char mountpoint[] = "/";
11515     int r;
11516     suppress_error = 0;
11517     r = guestfs_mount (g, device, mountpoint);
11518     if (r == -1)
11519       return -1;
11520   }
11521   /* TestOutputList for vgs (0) */
11522   {
11523     char **r;
11524     int i;
11525     suppress_error = 0;
11526     r = guestfs_vgs (g);
11527     if (r == NULL)
11528       return -1;
11529     if (!r[0]) {
11530       fprintf (stderr, "test_vgs_0: short list returned from command\n");
11531       print_strings (r);
11532       return -1;
11533     }
11534     {
11535       char expected[] = "VG";
11536       if (strcmp (r[0], expected) != 0) {
11537         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11538         return -1;
11539       }
11540     }
11541     if (r[1] != NULL) {
11542       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
11543       print_strings (r);
11544       return -1;
11545     }
11546     for (i = 0; r[i] != NULL; ++i)
11547       free (r[i]);
11548     free (r);
11549   }
11550   return 0;
11551 }
11552
11553 static int test_vgs_1 (void)
11554 {
11555   /* InitEmpty for vgs (1) */
11556   {
11557     char device[] = "/dev/sda";
11558     device[5] = devchar;
11559     int r;
11560     suppress_error = 0;
11561     r = guestfs_blockdev_setrw (g, device);
11562     if (r == -1)
11563       return -1;
11564   }
11565   {
11566     int r;
11567     suppress_error = 0;
11568     r = guestfs_umount_all (g);
11569     if (r == -1)
11570       return -1;
11571   }
11572   {
11573     int r;
11574     suppress_error = 0;
11575     r = guestfs_lvm_remove_all (g);
11576     if (r == -1)
11577       return -1;
11578   }
11579   /* TestOutputList for vgs (1) */
11580   {
11581     char device[] = "/dev/sda";
11582     device[5] = devchar;
11583     char lines_0[] = ",10";
11584     char lines_1[] = ",20";
11585     char lines_2[] = ",";
11586     char *lines[] = {
11587       lines_0,
11588       lines_1,
11589       lines_2,
11590       NULL
11591     };
11592     int r;
11593     suppress_error = 0;
11594     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11595     if (r == -1)
11596       return -1;
11597   }
11598   {
11599     char device[] = "/dev/sda1";
11600     device[5] = devchar;
11601     int r;
11602     suppress_error = 0;
11603     r = guestfs_pvcreate (g, device);
11604     if (r == -1)
11605       return -1;
11606   }
11607   {
11608     char device[] = "/dev/sda2";
11609     device[5] = devchar;
11610     int r;
11611     suppress_error = 0;
11612     r = guestfs_pvcreate (g, device);
11613     if (r == -1)
11614       return -1;
11615   }
11616   {
11617     char device[] = "/dev/sda3";
11618     device[5] = devchar;
11619     int r;
11620     suppress_error = 0;
11621     r = guestfs_pvcreate (g, device);
11622     if (r == -1)
11623       return -1;
11624   }
11625   {
11626     char volgroup[] = "VG1";
11627     char physvols_0[] = "/dev/sda1";
11628     physvols_0[5] = devchar;
11629     char physvols_1[] = "/dev/sda2";
11630     physvols_1[5] = devchar;
11631     char *physvols[] = {
11632       physvols_0,
11633       physvols_1,
11634       NULL
11635     };
11636     int r;
11637     suppress_error = 0;
11638     r = guestfs_vgcreate (g, volgroup, physvols);
11639     if (r == -1)
11640       return -1;
11641   }
11642   {
11643     char volgroup[] = "VG2";
11644     char physvols_0[] = "/dev/sda3";
11645     physvols_0[5] = devchar;
11646     char *physvols[] = {
11647       physvols_0,
11648       NULL
11649     };
11650     int r;
11651     suppress_error = 0;
11652     r = guestfs_vgcreate (g, volgroup, physvols);
11653     if (r == -1)
11654       return -1;
11655   }
11656   {
11657     char **r;
11658     int i;
11659     suppress_error = 0;
11660     r = guestfs_vgs (g);
11661     if (r == NULL)
11662       return -1;
11663     if (!r[0]) {
11664       fprintf (stderr, "test_vgs_1: short list returned from command\n");
11665       print_strings (r);
11666       return -1;
11667     }
11668     {
11669       char expected[] = "VG1";
11670       if (strcmp (r[0], expected) != 0) {
11671         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11672         return -1;
11673       }
11674     }
11675     if (!r[1]) {
11676       fprintf (stderr, "test_vgs_1: short list returned from command\n");
11677       print_strings (r);
11678       return -1;
11679     }
11680     {
11681       char expected[] = "VG2";
11682       if (strcmp (r[1], expected) != 0) {
11683         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11684         return -1;
11685       }
11686     }
11687     if (r[2] != NULL) {
11688       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
11689       print_strings (r);
11690       return -1;
11691     }
11692     for (i = 0; r[i] != NULL; ++i)
11693       free (r[i]);
11694     free (r);
11695   }
11696   return 0;
11697 }
11698
11699 static int test_pvs_0 (void)
11700 {
11701   /* InitBasicFSonLVM for pvs (0): create ext2 on /dev/VG/LV */
11702   {
11703     char device[] = "/dev/sda";
11704     device[5] = devchar;
11705     int r;
11706     suppress_error = 0;
11707     r = guestfs_blockdev_setrw (g, device);
11708     if (r == -1)
11709       return -1;
11710   }
11711   {
11712     int r;
11713     suppress_error = 0;
11714     r = guestfs_umount_all (g);
11715     if (r == -1)
11716       return -1;
11717   }
11718   {
11719     int r;
11720     suppress_error = 0;
11721     r = guestfs_lvm_remove_all (g);
11722     if (r == -1)
11723       return -1;
11724   }
11725   {
11726     char device[] = "/dev/sda";
11727     device[5] = devchar;
11728     char lines_0[] = ",";
11729     char *lines[] = {
11730       lines_0,
11731       NULL
11732     };
11733     int r;
11734     suppress_error = 0;
11735     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11736     if (r == -1)
11737       return -1;
11738   }
11739   {
11740     char device[] = "/dev/sda1";
11741     device[5] = devchar;
11742     int r;
11743     suppress_error = 0;
11744     r = guestfs_pvcreate (g, device);
11745     if (r == -1)
11746       return -1;
11747   }
11748   {
11749     char volgroup[] = "VG";
11750     char physvols_0[] = "/dev/sda1";
11751     physvols_0[5] = devchar;
11752     char *physvols[] = {
11753       physvols_0,
11754       NULL
11755     };
11756     int r;
11757     suppress_error = 0;
11758     r = guestfs_vgcreate (g, volgroup, physvols);
11759     if (r == -1)
11760       return -1;
11761   }
11762   {
11763     char logvol[] = "LV";
11764     char volgroup[] = "VG";
11765     int r;
11766     suppress_error = 0;
11767     r = guestfs_lvcreate (g, logvol, volgroup, 8);
11768     if (r == -1)
11769       return -1;
11770   }
11771   {
11772     char fstype[] = "ext2";
11773     char device[] = "/dev/VG/LV";
11774     int r;
11775     suppress_error = 0;
11776     r = guestfs_mkfs (g, fstype, device);
11777     if (r == -1)
11778       return -1;
11779   }
11780   {
11781     char device[] = "/dev/VG/LV";
11782     char mountpoint[] = "/";
11783     int r;
11784     suppress_error = 0;
11785     r = guestfs_mount (g, device, mountpoint);
11786     if (r == -1)
11787       return -1;
11788   }
11789   /* TestOutputList for pvs (0) */
11790   {
11791     char **r;
11792     int i;
11793     suppress_error = 0;
11794     r = guestfs_pvs (g);
11795     if (r == NULL)
11796       return -1;
11797     if (!r[0]) {
11798       fprintf (stderr, "test_pvs_0: short list returned from command\n");
11799       print_strings (r);
11800       return -1;
11801     }
11802     {
11803       char expected[] = "/dev/sda1";
11804       expected[5] = devchar;
11805       if (strcmp (r[0], expected) != 0) {
11806         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11807         return -1;
11808       }
11809     }
11810     if (r[1] != NULL) {
11811       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
11812       print_strings (r);
11813       return -1;
11814     }
11815     for (i = 0; r[i] != NULL; ++i)
11816       free (r[i]);
11817     free (r);
11818   }
11819   return 0;
11820 }
11821
11822 static int test_pvs_1 (void)
11823 {
11824   /* InitEmpty for pvs (1) */
11825   {
11826     char device[] = "/dev/sda";
11827     device[5] = devchar;
11828     int r;
11829     suppress_error = 0;
11830     r = guestfs_blockdev_setrw (g, device);
11831     if (r == -1)
11832       return -1;
11833   }
11834   {
11835     int r;
11836     suppress_error = 0;
11837     r = guestfs_umount_all (g);
11838     if (r == -1)
11839       return -1;
11840   }
11841   {
11842     int r;
11843     suppress_error = 0;
11844     r = guestfs_lvm_remove_all (g);
11845     if (r == -1)
11846       return -1;
11847   }
11848   /* TestOutputList for pvs (1) */
11849   {
11850     char device[] = "/dev/sda";
11851     device[5] = devchar;
11852     char lines_0[] = ",10";
11853     char lines_1[] = ",20";
11854     char lines_2[] = ",";
11855     char *lines[] = {
11856       lines_0,
11857       lines_1,
11858       lines_2,
11859       NULL
11860     };
11861     int r;
11862     suppress_error = 0;
11863     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11864     if (r == -1)
11865       return -1;
11866   }
11867   {
11868     char device[] = "/dev/sda1";
11869     device[5] = devchar;
11870     int r;
11871     suppress_error = 0;
11872     r = guestfs_pvcreate (g, device);
11873     if (r == -1)
11874       return -1;
11875   }
11876   {
11877     char device[] = "/dev/sda2";
11878     device[5] = devchar;
11879     int r;
11880     suppress_error = 0;
11881     r = guestfs_pvcreate (g, device);
11882     if (r == -1)
11883       return -1;
11884   }
11885   {
11886     char device[] = "/dev/sda3";
11887     device[5] = devchar;
11888     int r;
11889     suppress_error = 0;
11890     r = guestfs_pvcreate (g, device);
11891     if (r == -1)
11892       return -1;
11893   }
11894   {
11895     char **r;
11896     int i;
11897     suppress_error = 0;
11898     r = guestfs_pvs (g);
11899     if (r == NULL)
11900       return -1;
11901     if (!r[0]) {
11902       fprintf (stderr, "test_pvs_1: short list returned from command\n");
11903       print_strings (r);
11904       return -1;
11905     }
11906     {
11907       char expected[] = "/dev/sda1";
11908       expected[5] = devchar;
11909       if (strcmp (r[0], expected) != 0) {
11910         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11911         return -1;
11912       }
11913     }
11914     if (!r[1]) {
11915       fprintf (stderr, "test_pvs_1: short list returned from command\n");
11916       print_strings (r);
11917       return -1;
11918     }
11919     {
11920       char expected[] = "/dev/sda2";
11921       expected[5] = devchar;
11922       if (strcmp (r[1], expected) != 0) {
11923         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11924         return -1;
11925       }
11926     }
11927     if (!r[2]) {
11928       fprintf (stderr, "test_pvs_1: short list returned from command\n");
11929       print_strings (r);
11930       return -1;
11931     }
11932     {
11933       char expected[] = "/dev/sda3";
11934       expected[5] = devchar;
11935       if (strcmp (r[2], expected) != 0) {
11936         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11937         return -1;
11938       }
11939     }
11940     if (r[3] != NULL) {
11941       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
11942       print_strings (r);
11943       return -1;
11944     }
11945     for (i = 0; r[i] != NULL; ++i)
11946       free (r[i]);
11947     free (r);
11948   }
11949   return 0;
11950 }
11951
11952 static int test_list_partitions_0 (void)
11953 {
11954   /* InitBasicFS for list_partitions (0): create ext2 on /dev/sda1 */
11955   {
11956     char device[] = "/dev/sda";
11957     device[5] = devchar;
11958     int r;
11959     suppress_error = 0;
11960     r = guestfs_blockdev_setrw (g, device);
11961     if (r == -1)
11962       return -1;
11963   }
11964   {
11965     int r;
11966     suppress_error = 0;
11967     r = guestfs_umount_all (g);
11968     if (r == -1)
11969       return -1;
11970   }
11971   {
11972     int r;
11973     suppress_error = 0;
11974     r = guestfs_lvm_remove_all (g);
11975     if (r == -1)
11976       return -1;
11977   }
11978   {
11979     char device[] = "/dev/sda";
11980     device[5] = devchar;
11981     char lines_0[] = ",";
11982     char *lines[] = {
11983       lines_0,
11984       NULL
11985     };
11986     int r;
11987     suppress_error = 0;
11988     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11989     if (r == -1)
11990       return -1;
11991   }
11992   {
11993     char fstype[] = "ext2";
11994     char device[] = "/dev/sda1";
11995     device[5] = devchar;
11996     int r;
11997     suppress_error = 0;
11998     r = guestfs_mkfs (g, fstype, device);
11999     if (r == -1)
12000       return -1;
12001   }
12002   {
12003     char device[] = "/dev/sda1";
12004     device[5] = devchar;
12005     char mountpoint[] = "/";
12006     int r;
12007     suppress_error = 0;
12008     r = guestfs_mount (g, device, mountpoint);
12009     if (r == -1)
12010       return -1;
12011   }
12012   /* TestOutputList for list_partitions (0) */
12013   {
12014     char **r;
12015     int i;
12016     suppress_error = 0;
12017     r = guestfs_list_partitions (g);
12018     if (r == NULL)
12019       return -1;
12020     if (!r[0]) {
12021       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12022       print_strings (r);
12023       return -1;
12024     }
12025     {
12026       char expected[] = "/dev/sda1";
12027       expected[5] = devchar;
12028       if (strcmp (r[0], expected) != 0) {
12029         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12030         return -1;
12031       }
12032     }
12033     if (r[1] != NULL) {
12034       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12035       print_strings (r);
12036       return -1;
12037     }
12038     for (i = 0; r[i] != NULL; ++i)
12039       free (r[i]);
12040     free (r);
12041   }
12042   return 0;
12043 }
12044
12045 static int test_list_partitions_1 (void)
12046 {
12047   /* InitEmpty for list_partitions (1) */
12048   {
12049     char device[] = "/dev/sda";
12050     device[5] = devchar;
12051     int r;
12052     suppress_error = 0;
12053     r = guestfs_blockdev_setrw (g, device);
12054     if (r == -1)
12055       return -1;
12056   }
12057   {
12058     int r;
12059     suppress_error = 0;
12060     r = guestfs_umount_all (g);
12061     if (r == -1)
12062       return -1;
12063   }
12064   {
12065     int r;
12066     suppress_error = 0;
12067     r = guestfs_lvm_remove_all (g);
12068     if (r == -1)
12069       return -1;
12070   }
12071   /* TestOutputList for list_partitions (1) */
12072   {
12073     char device[] = "/dev/sda";
12074     device[5] = devchar;
12075     char lines_0[] = ",10";
12076     char lines_1[] = ",20";
12077     char lines_2[] = ",";
12078     char *lines[] = {
12079       lines_0,
12080       lines_1,
12081       lines_2,
12082       NULL
12083     };
12084     int r;
12085     suppress_error = 0;
12086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12087     if (r == -1)
12088       return -1;
12089   }
12090   {
12091     char **r;
12092     int i;
12093     suppress_error = 0;
12094     r = guestfs_list_partitions (g);
12095     if (r == NULL)
12096       return -1;
12097     if (!r[0]) {
12098       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12099       print_strings (r);
12100       return -1;
12101     }
12102     {
12103       char expected[] = "/dev/sda1";
12104       expected[5] = devchar;
12105       if (strcmp (r[0], expected) != 0) {
12106         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12107         return -1;
12108       }
12109     }
12110     if (!r[1]) {
12111       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12112       print_strings (r);
12113       return -1;
12114     }
12115     {
12116       char expected[] = "/dev/sda2";
12117       expected[5] = devchar;
12118       if (strcmp (r[1], expected) != 0) {
12119         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12120         return -1;
12121       }
12122     }
12123     if (!r[2]) {
12124       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12125       print_strings (r);
12126       return -1;
12127     }
12128     {
12129       char expected[] = "/dev/sda3";
12130       expected[5] = devchar;
12131       if (strcmp (r[2], expected) != 0) {
12132         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12133         return -1;
12134       }
12135     }
12136     if (r[3] != NULL) {
12137       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12138       print_strings (r);
12139       return -1;
12140     }
12141     for (i = 0; r[i] != NULL; ++i)
12142       free (r[i]);
12143     free (r);
12144   }
12145   return 0;
12146 }
12147
12148 static int test_list_devices_0 (void)
12149 {
12150   /* InitEmpty for list_devices (0) */
12151   {
12152     char device[] = "/dev/sda";
12153     device[5] = devchar;
12154     int r;
12155     suppress_error = 0;
12156     r = guestfs_blockdev_setrw (g, device);
12157     if (r == -1)
12158       return -1;
12159   }
12160   {
12161     int r;
12162     suppress_error = 0;
12163     r = guestfs_umount_all (g);
12164     if (r == -1)
12165       return -1;
12166   }
12167   {
12168     int r;
12169     suppress_error = 0;
12170     r = guestfs_lvm_remove_all (g);
12171     if (r == -1)
12172       return -1;
12173   }
12174   /* TestOutputList for list_devices (0) */
12175   {
12176     char **r;
12177     int i;
12178     suppress_error = 0;
12179     r = guestfs_list_devices (g);
12180     if (r == NULL)
12181       return -1;
12182     if (!r[0]) {
12183       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12184       print_strings (r);
12185       return -1;
12186     }
12187     {
12188       char expected[] = "/dev/sda";
12189       expected[5] = devchar;
12190       if (strcmp (r[0], expected) != 0) {
12191         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12192         return -1;
12193       }
12194     }
12195     if (!r[1]) {
12196       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12197       print_strings (r);
12198       return -1;
12199     }
12200     {
12201       char expected[] = "/dev/sdb";
12202       expected[5] = devchar;
12203       if (strcmp (r[1], expected) != 0) {
12204         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12205         return -1;
12206       }
12207     }
12208     if (!r[2]) {
12209       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12210       print_strings (r);
12211       return -1;
12212     }
12213     {
12214       char expected[] = "/dev/sdc";
12215       expected[5] = devchar;
12216       if (strcmp (r[2], expected) != 0) {
12217         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12218         return -1;
12219       }
12220     }
12221     if (r[3] != NULL) {
12222       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
12223       print_strings (r);
12224       return -1;
12225     }
12226     for (i = 0; r[i] != NULL; ++i)
12227       free (r[i]);
12228     free (r);
12229   }
12230   return 0;
12231 }
12232
12233 static int test_ls_0 (void)
12234 {
12235   /* InitBasicFS for ls (0): create ext2 on /dev/sda1 */
12236   {
12237     char device[] = "/dev/sda";
12238     device[5] = devchar;
12239     int r;
12240     suppress_error = 0;
12241     r = guestfs_blockdev_setrw (g, device);
12242     if (r == -1)
12243       return -1;
12244   }
12245   {
12246     int r;
12247     suppress_error = 0;
12248     r = guestfs_umount_all (g);
12249     if (r == -1)
12250       return -1;
12251   }
12252   {
12253     int r;
12254     suppress_error = 0;
12255     r = guestfs_lvm_remove_all (g);
12256     if (r == -1)
12257       return -1;
12258   }
12259   {
12260     char device[] = "/dev/sda";
12261     device[5] = devchar;
12262     char lines_0[] = ",";
12263     char *lines[] = {
12264       lines_0,
12265       NULL
12266     };
12267     int r;
12268     suppress_error = 0;
12269     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12270     if (r == -1)
12271       return -1;
12272   }
12273   {
12274     char fstype[] = "ext2";
12275     char device[] = "/dev/sda1";
12276     device[5] = devchar;
12277     int r;
12278     suppress_error = 0;
12279     r = guestfs_mkfs (g, fstype, device);
12280     if (r == -1)
12281       return -1;
12282   }
12283   {
12284     char device[] = "/dev/sda1";
12285     device[5] = devchar;
12286     char mountpoint[] = "/";
12287     int r;
12288     suppress_error = 0;
12289     r = guestfs_mount (g, device, mountpoint);
12290     if (r == -1)
12291       return -1;
12292   }
12293   /* TestOutputList for ls (0) */
12294   {
12295     char path[] = "/new";
12296     int r;
12297     suppress_error = 0;
12298     r = guestfs_touch (g, path);
12299     if (r == -1)
12300       return -1;
12301   }
12302   {
12303     char path[] = "/newer";
12304     int r;
12305     suppress_error = 0;
12306     r = guestfs_touch (g, path);
12307     if (r == -1)
12308       return -1;
12309   }
12310   {
12311     char path[] = "/newest";
12312     int r;
12313     suppress_error = 0;
12314     r = guestfs_touch (g, path);
12315     if (r == -1)
12316       return -1;
12317   }
12318   {
12319     char directory[] = "/";
12320     char **r;
12321     int i;
12322     suppress_error = 0;
12323     r = guestfs_ls (g, directory);
12324     if (r == NULL)
12325       return -1;
12326     if (!r[0]) {
12327       fprintf (stderr, "test_ls_0: short list returned from command\n");
12328       print_strings (r);
12329       return -1;
12330     }
12331     {
12332       char expected[] = "lost+found";
12333       if (strcmp (r[0], expected) != 0) {
12334         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12335         return -1;
12336       }
12337     }
12338     if (!r[1]) {
12339       fprintf (stderr, "test_ls_0: short list returned from command\n");
12340       print_strings (r);
12341       return -1;
12342     }
12343     {
12344       char expected[] = "new";
12345       if (strcmp (r[1], expected) != 0) {
12346         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12347         return -1;
12348       }
12349     }
12350     if (!r[2]) {
12351       fprintf (stderr, "test_ls_0: short list returned from command\n");
12352       print_strings (r);
12353       return -1;
12354     }
12355     {
12356       char expected[] = "newer";
12357       if (strcmp (r[2], expected) != 0) {
12358         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12359         return -1;
12360       }
12361     }
12362     if (!r[3]) {
12363       fprintf (stderr, "test_ls_0: short list returned from command\n");
12364       print_strings (r);
12365       return -1;
12366     }
12367     {
12368       char expected[] = "newest";
12369       if (strcmp (r[3], expected) != 0) {
12370         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12371         return -1;
12372       }
12373     }
12374     if (r[4] != NULL) {
12375       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
12376       print_strings (r);
12377       return -1;
12378     }
12379     for (i = 0; r[i] != NULL; ++i)
12380       free (r[i]);
12381     free (r);
12382   }
12383   return 0;
12384 }
12385
12386 static int test_cat_0 (void)
12387 {
12388   /* InitBasicFS for cat (0): create ext2 on /dev/sda1 */
12389   {
12390     char device[] = "/dev/sda";
12391     device[5] = devchar;
12392     int r;
12393     suppress_error = 0;
12394     r = guestfs_blockdev_setrw (g, device);
12395     if (r == -1)
12396       return -1;
12397   }
12398   {
12399     int r;
12400     suppress_error = 0;
12401     r = guestfs_umount_all (g);
12402     if (r == -1)
12403       return -1;
12404   }
12405   {
12406     int r;
12407     suppress_error = 0;
12408     r = guestfs_lvm_remove_all (g);
12409     if (r == -1)
12410       return -1;
12411   }
12412   {
12413     char device[] = "/dev/sda";
12414     device[5] = devchar;
12415     char lines_0[] = ",";
12416     char *lines[] = {
12417       lines_0,
12418       NULL
12419     };
12420     int r;
12421     suppress_error = 0;
12422     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12423     if (r == -1)
12424       return -1;
12425   }
12426   {
12427     char fstype[] = "ext2";
12428     char device[] = "/dev/sda1";
12429     device[5] = devchar;
12430     int r;
12431     suppress_error = 0;
12432     r = guestfs_mkfs (g, fstype, device);
12433     if (r == -1)
12434       return -1;
12435   }
12436   {
12437     char device[] = "/dev/sda1";
12438     device[5] = devchar;
12439     char mountpoint[] = "/";
12440     int r;
12441     suppress_error = 0;
12442     r = guestfs_mount (g, device, mountpoint);
12443     if (r == -1)
12444       return -1;
12445   }
12446   /* TestOutput for cat (0) */
12447   char expected[] = "new file contents";
12448   {
12449     char path[] = "/new";
12450     char content[] = "new file contents";
12451     int r;
12452     suppress_error = 0;
12453     r = guestfs_write_file (g, path, content, 0);
12454     if (r == -1)
12455       return -1;
12456   }
12457   {
12458     char path[] = "/new";
12459     char *r;
12460     suppress_error = 0;
12461     r = guestfs_cat (g, path);
12462     if (r == NULL)
12463       return -1;
12464     if (strcmp (r, expected) != 0) {
12465       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
12466       return -1;
12467     }
12468     free (r);
12469   }
12470   return 0;
12471 }
12472
12473 static int test_touch_0 (void)
12474 {
12475   /* InitBasicFS for touch (0): create ext2 on /dev/sda1 */
12476   {
12477     char device[] = "/dev/sda";
12478     device[5] = devchar;
12479     int r;
12480     suppress_error = 0;
12481     r = guestfs_blockdev_setrw (g, device);
12482     if (r == -1)
12483       return -1;
12484   }
12485   {
12486     int r;
12487     suppress_error = 0;
12488     r = guestfs_umount_all (g);
12489     if (r == -1)
12490       return -1;
12491   }
12492   {
12493     int r;
12494     suppress_error = 0;
12495     r = guestfs_lvm_remove_all (g);
12496     if (r == -1)
12497       return -1;
12498   }
12499   {
12500     char device[] = "/dev/sda";
12501     device[5] = devchar;
12502     char lines_0[] = ",";
12503     char *lines[] = {
12504       lines_0,
12505       NULL
12506     };
12507     int r;
12508     suppress_error = 0;
12509     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12510     if (r == -1)
12511       return -1;
12512   }
12513   {
12514     char fstype[] = "ext2";
12515     char device[] = "/dev/sda1";
12516     device[5] = devchar;
12517     int r;
12518     suppress_error = 0;
12519     r = guestfs_mkfs (g, fstype, device);
12520     if (r == -1)
12521       return -1;
12522   }
12523   {
12524     char device[] = "/dev/sda1";
12525     device[5] = devchar;
12526     char mountpoint[] = "/";
12527     int r;
12528     suppress_error = 0;
12529     r = guestfs_mount (g, device, mountpoint);
12530     if (r == -1)
12531       return -1;
12532   }
12533   /* TestOutputTrue for touch (0) */
12534   {
12535     char path[] = "/new";
12536     int r;
12537     suppress_error = 0;
12538     r = guestfs_touch (g, path);
12539     if (r == -1)
12540       return -1;
12541   }
12542   {
12543     char path[] = "/new";
12544     int r;
12545     suppress_error = 0;
12546     r = guestfs_exists (g, path);
12547     if (r == -1)
12548       return -1;
12549     if (!r) {
12550       fprintf (stderr, "test_touch_0: expected true, got false\n");
12551       return -1;
12552     }
12553   }
12554   return 0;
12555 }
12556
12557 static int test_sync_0 (void)
12558 {
12559   /* InitEmpty for sync (0) */
12560   {
12561     char device[] = "/dev/sda";
12562     device[5] = devchar;
12563     int r;
12564     suppress_error = 0;
12565     r = guestfs_blockdev_setrw (g, device);
12566     if (r == -1)
12567       return -1;
12568   }
12569   {
12570     int r;
12571     suppress_error = 0;
12572     r = guestfs_umount_all (g);
12573     if (r == -1)
12574       return -1;
12575   }
12576   {
12577     int r;
12578     suppress_error = 0;
12579     r = guestfs_lvm_remove_all (g);
12580     if (r == -1)
12581       return -1;
12582   }
12583   /* TestRun for sync (0) */
12584   {
12585     int r;
12586     suppress_error = 0;
12587     r = guestfs_sync (g);
12588     if (r == -1)
12589       return -1;
12590   }
12591   return 0;
12592 }
12593
12594 static int test_mount_0 (void)
12595 {
12596   /* InitEmpty for mount (0) */
12597   {
12598     char device[] = "/dev/sda";
12599     device[5] = devchar;
12600     int r;
12601     suppress_error = 0;
12602     r = guestfs_blockdev_setrw (g, device);
12603     if (r == -1)
12604       return -1;
12605   }
12606   {
12607     int r;
12608     suppress_error = 0;
12609     r = guestfs_umount_all (g);
12610     if (r == -1)
12611       return -1;
12612   }
12613   {
12614     int r;
12615     suppress_error = 0;
12616     r = guestfs_lvm_remove_all (g);
12617     if (r == -1)
12618       return -1;
12619   }
12620   /* TestOutput for mount (0) */
12621   char expected[] = "new file contents";
12622   {
12623     char device[] = "/dev/sda";
12624     device[5] = devchar;
12625     char lines_0[] = ",";
12626     char *lines[] = {
12627       lines_0,
12628       NULL
12629     };
12630     int r;
12631     suppress_error = 0;
12632     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12633     if (r == -1)
12634       return -1;
12635   }
12636   {
12637     char fstype[] = "ext2";
12638     char device[] = "/dev/sda1";
12639     device[5] = devchar;
12640     int r;
12641     suppress_error = 0;
12642     r = guestfs_mkfs (g, fstype, device);
12643     if (r == -1)
12644       return -1;
12645   }
12646   {
12647     char device[] = "/dev/sda1";
12648     device[5] = devchar;
12649     char mountpoint[] = "/";
12650     int r;
12651     suppress_error = 0;
12652     r = guestfs_mount (g, device, mountpoint);
12653     if (r == -1)
12654       return -1;
12655   }
12656   {
12657     char path[] = "/new";
12658     char content[] = "new file contents";
12659     int r;
12660     suppress_error = 0;
12661     r = guestfs_write_file (g, path, content, 0);
12662     if (r == -1)
12663       return -1;
12664   }
12665   {
12666     char path[] = "/new";
12667     char *r;
12668     suppress_error = 0;
12669     r = guestfs_cat (g, path);
12670     if (r == NULL)
12671       return -1;
12672     if (strcmp (r, expected) != 0) {
12673       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
12674       return -1;
12675     }
12676     free (r);
12677   }
12678   return 0;
12679 }
12680
12681 int main (int argc, char *argv[])
12682 {
12683   char c = 0;
12684   int failed = 0;
12685   const char *srcdir;
12686   const char *filename;
12687   int fd, i;
12688   int nr_tests, test_num = 0;
12689   char **devs;
12690
12691   no_test_warnings ();
12692
12693   g = guestfs_create ();
12694   if (g == NULL) {
12695     printf ("guestfs_create FAILED\n");
12696     exit (1);
12697   }
12698
12699   guestfs_set_error_handler (g, print_error, NULL);
12700
12701   srcdir = getenv ("srcdir");
12702   if (!srcdir) srcdir = ".";
12703   chdir (srcdir);
12704   guestfs_set_path (g, ".");
12705
12706   filename = "test1.img";
12707   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
12708   if (fd == -1) {
12709     perror (filename);
12710     exit (1);
12711   }
12712   if (lseek (fd, 524288000, SEEK_SET) == -1) {
12713     perror ("lseek");
12714     close (fd);
12715     unlink (filename);
12716     exit (1);
12717   }
12718   if (write (fd, &c, 1) == -1) {
12719     perror ("write");
12720     close (fd);
12721     unlink (filename);
12722     exit (1);
12723   }
12724   if (close (fd) == -1) {
12725     perror (filename);
12726     unlink (filename);
12727     exit (1);
12728   }
12729   if (guestfs_add_drive (g, filename) == -1) {
12730     printf ("guestfs_add_drive %s FAILED\n", filename);
12731     exit (1);
12732   }
12733
12734   filename = "test2.img";
12735   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
12736   if (fd == -1) {
12737     perror (filename);
12738     exit (1);
12739   }
12740   if (lseek (fd, 52428800, SEEK_SET) == -1) {
12741     perror ("lseek");
12742     close (fd);
12743     unlink (filename);
12744     exit (1);
12745   }
12746   if (write (fd, &c, 1) == -1) {
12747     perror ("write");
12748     close (fd);
12749     unlink (filename);
12750     exit (1);
12751   }
12752   if (close (fd) == -1) {
12753     perror (filename);
12754     unlink (filename);
12755     exit (1);
12756   }
12757   if (guestfs_add_drive (g, filename) == -1) {
12758     printf ("guestfs_add_drive %s FAILED\n", filename);
12759     exit (1);
12760   }
12761
12762   filename = "test3.img";
12763   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
12764   if (fd == -1) {
12765     perror (filename);
12766     exit (1);
12767   }
12768   if (lseek (fd, 10485760, SEEK_SET) == -1) {
12769     perror ("lseek");
12770     close (fd);
12771     unlink (filename);
12772     exit (1);
12773   }
12774   if (write (fd, &c, 1) == -1) {
12775     perror ("write");
12776     close (fd);
12777     unlink (filename);
12778     exit (1);
12779   }
12780   if (close (fd) == -1) {
12781     perror (filename);
12782     unlink (filename);
12783     exit (1);
12784   }
12785   if (guestfs_add_drive (g, filename) == -1) {
12786     printf ("guestfs_add_drive %s FAILED\n", filename);
12787     exit (1);
12788   }
12789
12790   if (guestfs_launch (g) == -1) {
12791     printf ("guestfs_launch FAILED\n");
12792     exit (1);
12793   }
12794   if (guestfs_wait_ready (g) == -1) {
12795     printf ("guestfs_wait_ready FAILED\n");
12796     exit (1);
12797   }
12798
12799   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
12800    * names.  This changed between RHEL 5 and RHEL 6 so we have to
12801    * support both.
12802    */
12803   devs = guestfs_list_devices (g);
12804   if (devs == NULL || devs[0] == NULL) {
12805     printf ("guestfs_list_devices FAILED\n");
12806     exit (1);
12807   }
12808   if (strncmp (devs[0], "/dev/sd", 7) == 0)
12809     devchar = 's';
12810   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
12811     devchar = 'h';
12812   else {
12813     printf ("guestfs_list_devices returned unexpected string '%s'\n",
12814             devs[0]);
12815     exit (1);
12816   }
12817   for (i = 0; devs[i] != NULL; ++i)
12818     free (devs[i]);
12819   free (devs);
12820
12821   nr_tests = 135;
12822
12823   test_num++;
12824   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
12825   if (test_hexdump_0 () == -1) {
12826     printf ("test_hexdump_0 FAILED\n");
12827     failed++;
12828   }
12829   test_num++;
12830   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
12831   if (test_strings_e_0 () == -1) {
12832     printf ("test_strings_e_0 FAILED\n");
12833     failed++;
12834   }
12835   test_num++;
12836   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
12837   if (test_strings_e_1 () == -1) {
12838     printf ("test_strings_e_1 FAILED\n");
12839     failed++;
12840   }
12841   test_num++;
12842   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
12843   if (test_strings_0 () == -1) {
12844     printf ("test_strings_0 FAILED\n");
12845     failed++;
12846   }
12847   test_num++;
12848   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
12849   if (test_strings_1 () == -1) {
12850     printf ("test_strings_1 FAILED\n");
12851     failed++;
12852   }
12853   test_num++;
12854   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
12855   if (test_equal_0 () == -1) {
12856     printf ("test_equal_0 FAILED\n");
12857     failed++;
12858   }
12859   test_num++;
12860   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
12861   if (test_equal_1 () == -1) {
12862     printf ("test_equal_1 FAILED\n");
12863     failed++;
12864   }
12865   test_num++;
12866   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
12867   if (test_equal_2 () == -1) {
12868     printf ("test_equal_2 FAILED\n");
12869     failed++;
12870   }
12871   test_num++;
12872   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
12873   if (test_ping_daemon_0 () == -1) {
12874     printf ("test_ping_daemon_0 FAILED\n");
12875     failed++;
12876   }
12877   test_num++;
12878   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
12879   if (test_dmesg_0 () == -1) {
12880     printf ("test_dmesg_0 FAILED\n");
12881     failed++;
12882   }
12883   test_num++;
12884   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
12885   if (test_drop_caches_0 () == -1) {
12886     printf ("test_drop_caches_0 FAILED\n");
12887     failed++;
12888   }
12889   test_num++;
12890   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
12891   if (test_mv_0 () == -1) {
12892     printf ("test_mv_0 FAILED\n");
12893     failed++;
12894   }
12895   test_num++;
12896   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
12897   if (test_mv_1 () == -1) {
12898     printf ("test_mv_1 FAILED\n");
12899     failed++;
12900   }
12901   test_num++;
12902   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
12903   if (test_cp_a_0 () == -1) {
12904     printf ("test_cp_a_0 FAILED\n");
12905     failed++;
12906   }
12907   test_num++;
12908   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
12909   if (test_cp_0 () == -1) {
12910     printf ("test_cp_0 FAILED\n");
12911     failed++;
12912   }
12913   test_num++;
12914   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
12915   if (test_cp_1 () == -1) {
12916     printf ("test_cp_1 FAILED\n");
12917     failed++;
12918   }
12919   test_num++;
12920   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
12921   if (test_cp_2 () == -1) {
12922     printf ("test_cp_2 FAILED\n");
12923     failed++;
12924   }
12925   test_num++;
12926   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
12927   if (test_grub_install_0 () == -1) {
12928     printf ("test_grub_install_0 FAILED\n");
12929     failed++;
12930   }
12931   test_num++;
12932   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
12933   if (test_zero_0 () == -1) {
12934     printf ("test_zero_0 FAILED\n");
12935     failed++;
12936   }
12937   test_num++;
12938   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
12939   if (test_fsck_0 () == -1) {
12940     printf ("test_fsck_0 FAILED\n");
12941     failed++;
12942   }
12943   test_num++;
12944   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
12945   if (test_fsck_1 () == -1) {
12946     printf ("test_fsck_1 FAILED\n");
12947     failed++;
12948   }
12949   test_num++;
12950   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
12951   if (test_set_e2uuid_0 () == -1) {
12952     printf ("test_set_e2uuid_0 FAILED\n");
12953     failed++;
12954   }
12955   test_num++;
12956   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
12957   if (test_set_e2uuid_1 () == -1) {
12958     printf ("test_set_e2uuid_1 FAILED\n");
12959     failed++;
12960   }
12961   test_num++;
12962   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
12963   if (test_set_e2uuid_2 () == -1) {
12964     printf ("test_set_e2uuid_2 FAILED\n");
12965     failed++;
12966   }
12967   test_num++;
12968   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
12969   if (test_set_e2uuid_3 () == -1) {
12970     printf ("test_set_e2uuid_3 FAILED\n");
12971     failed++;
12972   }
12973   test_num++;
12974   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
12975   if (test_set_e2label_0 () == -1) {
12976     printf ("test_set_e2label_0 FAILED\n");
12977     failed++;
12978   }
12979   test_num++;
12980   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
12981   if (test_pvremove_0 () == -1) {
12982     printf ("test_pvremove_0 FAILED\n");
12983     failed++;
12984   }
12985   test_num++;
12986   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
12987   if (test_pvremove_1 () == -1) {
12988     printf ("test_pvremove_1 FAILED\n");
12989     failed++;
12990   }
12991   test_num++;
12992   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
12993   if (test_pvremove_2 () == -1) {
12994     printf ("test_pvremove_2 FAILED\n");
12995     failed++;
12996   }
12997   test_num++;
12998   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
12999   if (test_vgremove_0 () == -1) {
13000     printf ("test_vgremove_0 FAILED\n");
13001     failed++;
13002   }
13003   test_num++;
13004   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13005   if (test_vgremove_1 () == -1) {
13006     printf ("test_vgremove_1 FAILED\n");
13007     failed++;
13008   }
13009   test_num++;
13010   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13011   if (test_lvremove_0 () == -1) {
13012     printf ("test_lvremove_0 FAILED\n");
13013     failed++;
13014   }
13015   test_num++;
13016   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13017   if (test_lvremove_1 () == -1) {
13018     printf ("test_lvremove_1 FAILED\n");
13019     failed++;
13020   }
13021   test_num++;
13022   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13023   if (test_lvremove_2 () == -1) {
13024     printf ("test_lvremove_2 FAILED\n");
13025     failed++;
13026   }
13027   test_num++;
13028   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13029   if (test_mount_ro_0 () == -1) {
13030     printf ("test_mount_ro_0 FAILED\n");
13031     failed++;
13032   }
13033   test_num++;
13034   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13035   if (test_mount_ro_1 () == -1) {
13036     printf ("test_mount_ro_1 FAILED\n");
13037     failed++;
13038   }
13039   test_num++;
13040   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13041   if (test_tgz_in_0 () == -1) {
13042     printf ("test_tgz_in_0 FAILED\n");
13043     failed++;
13044   }
13045   test_num++;
13046   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13047   if (test_tar_in_0 () == -1) {
13048     printf ("test_tar_in_0 FAILED\n");
13049     failed++;
13050   }
13051   test_num++;
13052   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13053   if (test_checksum_0 () == -1) {
13054     printf ("test_checksum_0 FAILED\n");
13055     failed++;
13056   }
13057   test_num++;
13058   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13059   if (test_checksum_1 () == -1) {
13060     printf ("test_checksum_1 FAILED\n");
13061     failed++;
13062   }
13063   test_num++;
13064   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13065   if (test_checksum_2 () == -1) {
13066     printf ("test_checksum_2 FAILED\n");
13067     failed++;
13068   }
13069   test_num++;
13070   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13071   if (test_checksum_3 () == -1) {
13072     printf ("test_checksum_3 FAILED\n");
13073     failed++;
13074   }
13075   test_num++;
13076   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13077   if (test_checksum_4 () == -1) {
13078     printf ("test_checksum_4 FAILED\n");
13079     failed++;
13080   }
13081   test_num++;
13082   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13083   if (test_checksum_5 () == -1) {
13084     printf ("test_checksum_5 FAILED\n");
13085     failed++;
13086   }
13087   test_num++;
13088   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13089   if (test_checksum_6 () == -1) {
13090     printf ("test_checksum_6 FAILED\n");
13091     failed++;
13092   }
13093   test_num++;
13094   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13095   if (test_checksum_7 () == -1) {
13096     printf ("test_checksum_7 FAILED\n");
13097     failed++;
13098   }
13099   test_num++;
13100   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13101   if (test_download_0 () == -1) {
13102     printf ("test_download_0 FAILED\n");
13103     failed++;
13104   }
13105   test_num++;
13106   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13107   if (test_upload_0 () == -1) {
13108     printf ("test_upload_0 FAILED\n");
13109     failed++;
13110   }
13111   test_num++;
13112   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13113   if (test_blockdev_rereadpt_0 () == -1) {
13114     printf ("test_blockdev_rereadpt_0 FAILED\n");
13115     failed++;
13116   }
13117   test_num++;
13118   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
13119   if (test_blockdev_flushbufs_0 () == -1) {
13120     printf ("test_blockdev_flushbufs_0 FAILED\n");
13121     failed++;
13122   }
13123   test_num++;
13124   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
13125   if (test_blockdev_getsize64_0 () == -1) {
13126     printf ("test_blockdev_getsize64_0 FAILED\n");
13127     failed++;
13128   }
13129   test_num++;
13130   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
13131   if (test_blockdev_getsz_0 () == -1) {
13132     printf ("test_blockdev_getsz_0 FAILED\n");
13133     failed++;
13134   }
13135   test_num++;
13136   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
13137   if (test_blockdev_getbsz_0 () == -1) {
13138     printf ("test_blockdev_getbsz_0 FAILED\n");
13139     failed++;
13140   }
13141   test_num++;
13142   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
13143   if (test_blockdev_getss_0 () == -1) {
13144     printf ("test_blockdev_getss_0 FAILED\n");
13145     failed++;
13146   }
13147   test_num++;
13148   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
13149   if (test_blockdev_getro_0 () == -1) {
13150     printf ("test_blockdev_getro_0 FAILED\n");
13151     failed++;
13152   }
13153   test_num++;
13154   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
13155   if (test_blockdev_setrw_0 () == -1) {
13156     printf ("test_blockdev_setrw_0 FAILED\n");
13157     failed++;
13158   }
13159   test_num++;
13160   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
13161   if (test_blockdev_setro_0 () == -1) {
13162     printf ("test_blockdev_setro_0 FAILED\n");
13163     failed++;
13164   }
13165   test_num++;
13166   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
13167   if (test_statvfs_0 () == -1) {
13168     printf ("test_statvfs_0 FAILED\n");
13169     failed++;
13170   }
13171   test_num++;
13172   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
13173   if (test_lstat_0 () == -1) {
13174     printf ("test_lstat_0 FAILED\n");
13175     failed++;
13176   }
13177   test_num++;
13178   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
13179   if (test_stat_0 () == -1) {
13180     printf ("test_stat_0 FAILED\n");
13181     failed++;
13182   }
13183   test_num++;
13184   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
13185   if (test_command_lines_0 () == -1) {
13186     printf ("test_command_lines_0 FAILED\n");
13187     failed++;
13188   }
13189   test_num++;
13190   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
13191   if (test_command_lines_1 () == -1) {
13192     printf ("test_command_lines_1 FAILED\n");
13193     failed++;
13194   }
13195   test_num++;
13196   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
13197   if (test_command_lines_2 () == -1) {
13198     printf ("test_command_lines_2 FAILED\n");
13199     failed++;
13200   }
13201   test_num++;
13202   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
13203   if (test_command_lines_3 () == -1) {
13204     printf ("test_command_lines_3 FAILED\n");
13205     failed++;
13206   }
13207   test_num++;
13208   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
13209   if (test_command_lines_4 () == -1) {
13210     printf ("test_command_lines_4 FAILED\n");
13211     failed++;
13212   }
13213   test_num++;
13214   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
13215   if (test_command_lines_5 () == -1) {
13216     printf ("test_command_lines_5 FAILED\n");
13217     failed++;
13218   }
13219   test_num++;
13220   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
13221   if (test_command_lines_6 () == -1) {
13222     printf ("test_command_lines_6 FAILED\n");
13223     failed++;
13224   }
13225   test_num++;
13226   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
13227   if (test_command_lines_7 () == -1) {
13228     printf ("test_command_lines_7 FAILED\n");
13229     failed++;
13230   }
13231   test_num++;
13232   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
13233   if (test_command_lines_8 () == -1) {
13234     printf ("test_command_lines_8 FAILED\n");
13235     failed++;
13236   }
13237   test_num++;
13238   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
13239   if (test_command_lines_9 () == -1) {
13240     printf ("test_command_lines_9 FAILED\n");
13241     failed++;
13242   }
13243   test_num++;
13244   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
13245   if (test_command_lines_10 () == -1) {
13246     printf ("test_command_lines_10 FAILED\n");
13247     failed++;
13248   }
13249   test_num++;
13250   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
13251   if (test_command_0 () == -1) {
13252     printf ("test_command_0 FAILED\n");
13253     failed++;
13254   }
13255   test_num++;
13256   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
13257   if (test_command_1 () == -1) {
13258     printf ("test_command_1 FAILED\n");
13259     failed++;
13260   }
13261   test_num++;
13262   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
13263   if (test_command_2 () == -1) {
13264     printf ("test_command_2 FAILED\n");
13265     failed++;
13266   }
13267   test_num++;
13268   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
13269   if (test_command_3 () == -1) {
13270     printf ("test_command_3 FAILED\n");
13271     failed++;
13272   }
13273   test_num++;
13274   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
13275   if (test_command_4 () == -1) {
13276     printf ("test_command_4 FAILED\n");
13277     failed++;
13278   }
13279   test_num++;
13280   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
13281   if (test_command_5 () == -1) {
13282     printf ("test_command_5 FAILED\n");
13283     failed++;
13284   }
13285   test_num++;
13286   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
13287   if (test_command_6 () == -1) {
13288     printf ("test_command_6 FAILED\n");
13289     failed++;
13290   }
13291   test_num++;
13292   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
13293   if (test_command_7 () == -1) {
13294     printf ("test_command_7 FAILED\n");
13295     failed++;
13296   }
13297   test_num++;
13298   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
13299   if (test_command_8 () == -1) {
13300     printf ("test_command_8 FAILED\n");
13301     failed++;
13302   }
13303   test_num++;
13304   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
13305   if (test_command_9 () == -1) {
13306     printf ("test_command_9 FAILED\n");
13307     failed++;
13308   }
13309   test_num++;
13310   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
13311   if (test_command_10 () == -1) {
13312     printf ("test_command_10 FAILED\n");
13313     failed++;
13314   }
13315   test_num++;
13316   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
13317   if (test_command_11 () == -1) {
13318     printf ("test_command_11 FAILED\n");
13319     failed++;
13320   }
13321   test_num++;
13322   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
13323   if (test_file_0 () == -1) {
13324     printf ("test_file_0 FAILED\n");
13325     failed++;
13326   }
13327   test_num++;
13328   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
13329   if (test_file_1 () == -1) {
13330     printf ("test_file_1 FAILED\n");
13331     failed++;
13332   }
13333   test_num++;
13334   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
13335   if (test_file_2 () == -1) {
13336     printf ("test_file_2 FAILED\n");
13337     failed++;
13338   }
13339   test_num++;
13340   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
13341   if (test_umount_all_0 () == -1) {
13342     printf ("test_umount_all_0 FAILED\n");
13343     failed++;
13344   }
13345   test_num++;
13346   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
13347   if (test_umount_all_1 () == -1) {
13348     printf ("test_umount_all_1 FAILED\n");
13349     failed++;
13350   }
13351   test_num++;
13352   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
13353   if (test_mounts_0 () == -1) {
13354     printf ("test_mounts_0 FAILED\n");
13355     failed++;
13356   }
13357   test_num++;
13358   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
13359   if (test_umount_0 () == -1) {
13360     printf ("test_umount_0 FAILED\n");
13361     failed++;
13362   }
13363   test_num++;
13364   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
13365   if (test_umount_1 () == -1) {
13366     printf ("test_umount_1 FAILED\n");
13367     failed++;
13368   }
13369   test_num++;
13370   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
13371   if (test_write_file_0 () == -1) {
13372     printf ("test_write_file_0 FAILED\n");
13373     failed++;
13374   }
13375   test_num++;
13376   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
13377   if (test_write_file_1 () == -1) {
13378     printf ("test_write_file_1 FAILED\n");
13379     failed++;
13380   }
13381   test_num++;
13382   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
13383   if (test_write_file_2 () == -1) {
13384     printf ("test_write_file_2 FAILED\n");
13385     failed++;
13386   }
13387   test_num++;
13388   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
13389   if (test_write_file_3 () == -1) {
13390     printf ("test_write_file_3 FAILED\n");
13391     failed++;
13392   }
13393   test_num++;
13394   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
13395   if (test_write_file_4 () == -1) {
13396     printf ("test_write_file_4 FAILED\n");
13397     failed++;
13398   }
13399   test_num++;
13400   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
13401   if (test_write_file_5 () == -1) {
13402     printf ("test_write_file_5 FAILED\n");
13403     failed++;
13404   }
13405   test_num++;
13406   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
13407   if (test_mkfs_0 () == -1) {
13408     printf ("test_mkfs_0 FAILED\n");
13409     failed++;
13410   }
13411   test_num++;
13412   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
13413   if (test_lvcreate_0 () == -1) {
13414     printf ("test_lvcreate_0 FAILED\n");
13415     failed++;
13416   }
13417   test_num++;
13418   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
13419   if (test_vgcreate_0 () == -1) {
13420     printf ("test_vgcreate_0 FAILED\n");
13421     failed++;
13422   }
13423   test_num++;
13424   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
13425   if (test_pvcreate_0 () == -1) {
13426     printf ("test_pvcreate_0 FAILED\n");
13427     failed++;
13428   }
13429   test_num++;
13430   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
13431   if (test_is_dir_0 () == -1) {
13432     printf ("test_is_dir_0 FAILED\n");
13433     failed++;
13434   }
13435   test_num++;
13436   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
13437   if (test_is_dir_1 () == -1) {
13438     printf ("test_is_dir_1 FAILED\n");
13439     failed++;
13440   }
13441   test_num++;
13442   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
13443   if (test_is_file_0 () == -1) {
13444     printf ("test_is_file_0 FAILED\n");
13445     failed++;
13446   }
13447   test_num++;
13448   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
13449   if (test_is_file_1 () == -1) {
13450     printf ("test_is_file_1 FAILED\n");
13451     failed++;
13452   }
13453   test_num++;
13454   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
13455   if (test_exists_0 () == -1) {
13456     printf ("test_exists_0 FAILED\n");
13457     failed++;
13458   }
13459   test_num++;
13460   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
13461   if (test_exists_1 () == -1) {
13462     printf ("test_exists_1 FAILED\n");
13463     failed++;
13464   }
13465   test_num++;
13466   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
13467   if (test_mkdir_p_0 () == -1) {
13468     printf ("test_mkdir_p_0 FAILED\n");
13469     failed++;
13470   }
13471   test_num++;
13472   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
13473   if (test_mkdir_p_1 () == -1) {
13474     printf ("test_mkdir_p_1 FAILED\n");
13475     failed++;
13476   }
13477   test_num++;
13478   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
13479   if (test_mkdir_p_2 () == -1) {
13480     printf ("test_mkdir_p_2 FAILED\n");
13481     failed++;
13482   }
13483   test_num++;
13484   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
13485   if (test_mkdir_0 () == -1) {
13486     printf ("test_mkdir_0 FAILED\n");
13487     failed++;
13488   }
13489   test_num++;
13490   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
13491   if (test_mkdir_1 () == -1) {
13492     printf ("test_mkdir_1 FAILED\n");
13493     failed++;
13494   }
13495   test_num++;
13496   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
13497   if (test_rm_rf_0 () == -1) {
13498     printf ("test_rm_rf_0 FAILED\n");
13499     failed++;
13500   }
13501   test_num++;
13502   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
13503   if (test_rmdir_0 () == -1) {
13504     printf ("test_rmdir_0 FAILED\n");
13505     failed++;
13506   }
13507   test_num++;
13508   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
13509   if (test_rmdir_1 () == -1) {
13510     printf ("test_rmdir_1 FAILED\n");
13511     failed++;
13512   }
13513   test_num++;
13514   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
13515   if (test_rmdir_2 () == -1) {
13516     printf ("test_rmdir_2 FAILED\n");
13517     failed++;
13518   }
13519   test_num++;
13520   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
13521   if (test_rm_0 () == -1) {
13522     printf ("test_rm_0 FAILED\n");
13523     failed++;
13524   }
13525   test_num++;
13526   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
13527   if (test_rm_1 () == -1) {
13528     printf ("test_rm_1 FAILED\n");
13529     failed++;
13530   }
13531   test_num++;
13532   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
13533   if (test_rm_2 () == -1) {
13534     printf ("test_rm_2 FAILED\n");
13535     failed++;
13536   }
13537   test_num++;
13538   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
13539   if (test_read_lines_0 () == -1) {
13540     printf ("test_read_lines_0 FAILED\n");
13541     failed++;
13542   }
13543   test_num++;
13544   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
13545   if (test_read_lines_1 () == -1) {
13546     printf ("test_read_lines_1 FAILED\n");
13547     failed++;
13548   }
13549   test_num++;
13550   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
13551   if (test_lvs_0 () == -1) {
13552     printf ("test_lvs_0 FAILED\n");
13553     failed++;
13554   }
13555   test_num++;
13556   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
13557   if (test_lvs_1 () == -1) {
13558     printf ("test_lvs_1 FAILED\n");
13559     failed++;
13560   }
13561   test_num++;
13562   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
13563   if (test_vgs_0 () == -1) {
13564     printf ("test_vgs_0 FAILED\n");
13565     failed++;
13566   }
13567   test_num++;
13568   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
13569   if (test_vgs_1 () == -1) {
13570     printf ("test_vgs_1 FAILED\n");
13571     failed++;
13572   }
13573   test_num++;
13574   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
13575   if (test_pvs_0 () == -1) {
13576     printf ("test_pvs_0 FAILED\n");
13577     failed++;
13578   }
13579   test_num++;
13580   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
13581   if (test_pvs_1 () == -1) {
13582     printf ("test_pvs_1 FAILED\n");
13583     failed++;
13584   }
13585   test_num++;
13586   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
13587   if (test_list_partitions_0 () == -1) {
13588     printf ("test_list_partitions_0 FAILED\n");
13589     failed++;
13590   }
13591   test_num++;
13592   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
13593   if (test_list_partitions_1 () == -1) {
13594     printf ("test_list_partitions_1 FAILED\n");
13595     failed++;
13596   }
13597   test_num++;
13598   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
13599   if (test_list_devices_0 () == -1) {
13600     printf ("test_list_devices_0 FAILED\n");
13601     failed++;
13602   }
13603   test_num++;
13604   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
13605   if (test_ls_0 () == -1) {
13606     printf ("test_ls_0 FAILED\n");
13607     failed++;
13608   }
13609   test_num++;
13610   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
13611   if (test_cat_0 () == -1) {
13612     printf ("test_cat_0 FAILED\n");
13613     failed++;
13614   }
13615   test_num++;
13616   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
13617   if (test_touch_0 () == -1) {
13618     printf ("test_touch_0 FAILED\n");
13619     failed++;
13620   }
13621   test_num++;
13622   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
13623   if (test_sync_0 () == -1) {
13624     printf ("test_sync_0 FAILED\n");
13625     failed++;
13626   }
13627   test_num++;
13628   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
13629   if (test_mount_0 () == -1) {
13630     printf ("test_mount_0 FAILED\n");
13631     failed++;
13632   }
13633
13634   guestfs_close (g);
13635   unlink ("test1.img");
13636   unlink ("test2.img");
13637   unlink ("test3.img");
13638
13639   if (failed > 0) {
13640     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
13641     exit (1);
13642   }
13643
13644   exit (0);
13645 }