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