tests.c

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