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