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