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