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 static void print_error (guestfs_h *g, void *data, const char *msg)
  35 {
  36   if (!suppress_error)
  37     fprintf (stderr, "%s\n", msg);
  38 }
  39
  40 static void print_strings (char * const * const argv)
  41 {
  42   int argc;
  43
  44   for (argc = 0; argv[argc] != NULL; ++argc)
  45     printf ("\t%s\n", argv[argc]);
  46 }
  47
  48 /*
  49 static void print_table (char * const * const argv)
  50 {
  51   int i;
  52
  53   for (i = 0; argv[i] != NULL; i += 2)
  54     printf ("%s: %s\n", argv[i], argv[i+1]);
  55 }
  56 */
  57
  58 static void no_test_warnings (void)
  59 {
  60   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  61   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  62   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  63   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  64   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  65   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_command\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_command_lines\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 113 }
 114
 115 static int test_mv_0 (void)
 116 {
 117   /* InitBasicFS for mv (0): create ext2 on /dev/sda1 */
 118   {
 119     int r;
 120     suppress_error = 0;
 121     r = guestfs_umount_all (g);
 122     if (r == -1)
 123       return -1;
 124   }
 125   {
 126     int r;
 127     suppress_error = 0;
 128     r = guestfs_lvm_remove_all (g);
 129     if (r == -1)
 130       return -1;
 131   }
 132   {
 133     char *lines[] = {
 134       ",",
 135       NULL
 136     };
 137     int r;
 138     suppress_error = 0;
 139     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 140     if (r == -1)
 141       return -1;
 142   }
 143   {
 144     int r;
 145     suppress_error = 0;
 146     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 147     if (r == -1)
 148       return -1;
 149   }
 150   {
 151     int r;
 152     suppress_error = 0;
 153     r = guestfs_mount (g, "/dev/sda1", "/");
 154     if (r == -1)
 155       return -1;
 156   }
 157   /* TestOutput for mv (0) */
 158   {
 159     int r;
 160     suppress_error = 0;
 161     r = guestfs_write_file (g, "/old", "file content", 0);
 162     if (r == -1)
 163       return -1;
 164   }
 165   {
 166     int r;
 167     suppress_error = 0;
 168     r = guestfs_mv (g, "/old", "/new");
 169     if (r == -1)
 170       return -1;
 171   }
 172   {
 173     char *r;
 174     suppress_error = 0;
 175     r = guestfs_cat (g, "/new");
 176     if (r == NULL)
 177       return -1;
 178     if (strcmp (r, "file content") != 0) {
 179       fprintf (stderr, "test_mv_0: expected \"file content\" but got \"%s\"\n", r);
 180       return -1;
 181     }
 182     free (r);
 183   }
 184   return 0;
 185 }
 186
 187 static int test_mv_1 (void)
 188 {
 189   /* InitBasicFS for mv (1): create ext2 on /dev/sda1 */
 190   {
 191     int r;
 192     suppress_error = 0;
 193     r = guestfs_umount_all (g);
 194     if (r == -1)
 195       return -1;
 196   }
 197   {
 198     int r;
 199     suppress_error = 0;
 200     r = guestfs_lvm_remove_all (g);
 201     if (r == -1)
 202       return -1;
 203   }
 204   {
 205     char *lines[] = {
 206       ",",
 207       NULL
 208     };
 209     int r;
 210     suppress_error = 0;
 211     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 212     if (r == -1)
 213       return -1;
 214   }
 215   {
 216     int r;
 217     suppress_error = 0;
 218     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 219     if (r == -1)
 220       return -1;
 221   }
 222   {
 223     int r;
 224     suppress_error = 0;
 225     r = guestfs_mount (g, "/dev/sda1", "/");
 226     if (r == -1)
 227       return -1;
 228   }
 229   /* TestOutputFalse for mv (1) */
 230   {
 231     int r;
 232     suppress_error = 0;
 233     r = guestfs_write_file (g, "/old", "file content", 0);
 234     if (r == -1)
 235       return -1;
 236   }
 237   {
 238     int r;
 239     suppress_error = 0;
 240     r = guestfs_mv (g, "/old", "/new");
 241     if (r == -1)
 242       return -1;
 243   }
 244   {
 245     int r;
 246     suppress_error = 0;
 247     r = guestfs_is_file (g, "/old");
 248     if (r == -1)
 249       return -1;
 250     if (r) {
 251       fprintf (stderr, "test_mv_1: expected false, got true\n");
 252       return -1;
 253     }
 254   }
 255   return 0;
 256 }
 257
 258 static int test_cp_a_0 (void)
 259 {
 260   /* InitBasicFS for cp_a (0): create ext2 on /dev/sda1 */
 261   {
 262     int r;
 263     suppress_error = 0;
 264     r = guestfs_umount_all (g);
 265     if (r == -1)
 266       return -1;
 267   }
 268   {
 269     int r;
 270     suppress_error = 0;
 271     r = guestfs_lvm_remove_all (g);
 272     if (r == -1)
 273       return -1;
 274   }
 275   {
 276     char *lines[] = {
 277       ",",
 278       NULL
 279     };
 280     int r;
 281     suppress_error = 0;
 282     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 283     if (r == -1)
 284       return -1;
 285   }
 286   {
 287     int r;
 288     suppress_error = 0;
 289     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 290     if (r == -1)
 291       return -1;
 292   }
 293   {
 294     int r;
 295     suppress_error = 0;
 296     r = guestfs_mount (g, "/dev/sda1", "/");
 297     if (r == -1)
 298       return -1;
 299   }
 300   /* TestOutput for cp_a (0) */
 301   {
 302     int r;
 303     suppress_error = 0;
 304     r = guestfs_mkdir (g, "/olddir");
 305     if (r == -1)
 306       return -1;
 307   }
 308   {
 309     int r;
 310     suppress_error = 0;
 311     r = guestfs_mkdir (g, "/newdir");
 312     if (r == -1)
 313       return -1;
 314   }
 315   {
 316     int r;
 317     suppress_error = 0;
 318     r = guestfs_write_file (g, "/olddir/file", "file content", 0);
 319     if (r == -1)
 320       return -1;
 321   }
 322   {
 323     int r;
 324     suppress_error = 0;
 325     r = guestfs_cp_a (g, "/olddir", "/newdir");
 326     if (r == -1)
 327       return -1;
 328   }
 329   {
 330     char *r;
 331     suppress_error = 0;
 332     r = guestfs_cat (g, "/newdir/olddir/file");
 333     if (r == NULL)
 334       return -1;
 335     if (strcmp (r, "file content") != 0) {
 336       fprintf (stderr, "test_cp_a_0: expected \"file content\" but got \"%s\"\n", r);
 337       return -1;
 338     }
 339     free (r);
 340   }
 341   return 0;
 342 }
 343
 344 static int test_cp_0 (void)
 345 {
 346   /* InitBasicFS for cp (0): create ext2 on /dev/sda1 */
 347   {
 348     int r;
 349     suppress_error = 0;
 350     r = guestfs_umount_all (g);
 351     if (r == -1)
 352       return -1;
 353   }
 354   {
 355     int r;
 356     suppress_error = 0;
 357     r = guestfs_lvm_remove_all (g);
 358     if (r == -1)
 359       return -1;
 360   }
 361   {
 362     char *lines[] = {
 363       ",",
 364       NULL
 365     };
 366     int r;
 367     suppress_error = 0;
 368     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 369     if (r == -1)
 370       return -1;
 371   }
 372   {
 373     int r;
 374     suppress_error = 0;
 375     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 376     if (r == -1)
 377       return -1;
 378   }
 379   {
 380     int r;
 381     suppress_error = 0;
 382     r = guestfs_mount (g, "/dev/sda1", "/");
 383     if (r == -1)
 384       return -1;
 385   }
 386   /* TestOutput for cp (0) */
 387   {
 388     int r;
 389     suppress_error = 0;
 390     r = guestfs_write_file (g, "/old", "file content", 0);
 391     if (r == -1)
 392       return -1;
 393   }
 394   {
 395     int r;
 396     suppress_error = 0;
 397     r = guestfs_cp (g, "/old", "/new");
 398     if (r == -1)
 399       return -1;
 400   }
 401   {
 402     char *r;
 403     suppress_error = 0;
 404     r = guestfs_cat (g, "/new");
 405     if (r == NULL)
 406       return -1;
 407     if (strcmp (r, "file content") != 0) {
 408       fprintf (stderr, "test_cp_0: expected \"file content\" but got \"%s\"\n", r);
 409       return -1;
 410     }
 411     free (r);
 412   }
 413   return 0;
 414 }
 415
 416 static int test_cp_1 (void)
 417 {
 418   /* InitBasicFS for cp (1): create ext2 on /dev/sda1 */
 419   {
 420     int r;
 421     suppress_error = 0;
 422     r = guestfs_umount_all (g);
 423     if (r == -1)
 424       return -1;
 425   }
 426   {
 427     int r;
 428     suppress_error = 0;
 429     r = guestfs_lvm_remove_all (g);
 430     if (r == -1)
 431       return -1;
 432   }
 433   {
 434     char *lines[] = {
 435       ",",
 436       NULL
 437     };
 438     int r;
 439     suppress_error = 0;
 440     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 441     if (r == -1)
 442       return -1;
 443   }
 444   {
 445     int r;
 446     suppress_error = 0;
 447     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 448     if (r == -1)
 449       return -1;
 450   }
 451   {
 452     int r;
 453     suppress_error = 0;
 454     r = guestfs_mount (g, "/dev/sda1", "/");
 455     if (r == -1)
 456       return -1;
 457   }
 458   /* TestOutputTrue for cp (1) */
 459   {
 460     int r;
 461     suppress_error = 0;
 462     r = guestfs_write_file (g, "/old", "file content", 0);
 463     if (r == -1)
 464       return -1;
 465   }
 466   {
 467     int r;
 468     suppress_error = 0;
 469     r = guestfs_cp (g, "/old", "/new");
 470     if (r == -1)
 471       return -1;
 472   }
 473   {
 474     int r;
 475     suppress_error = 0;
 476     r = guestfs_is_file (g, "/old");
 477     if (r == -1)
 478       return -1;
 479     if (!r) {
 480       fprintf (stderr, "test_cp_1: expected true, got false\n");
 481       return -1;
 482     }
 483   }
 484   return 0;
 485 }
 486
 487 static int test_cp_2 (void)
 488 {
 489   /* InitBasicFS for cp (2): create ext2 on /dev/sda1 */
 490   {
 491     int r;
 492     suppress_error = 0;
 493     r = guestfs_umount_all (g);
 494     if (r == -1)
 495       return -1;
 496   }
 497   {
 498     int r;
 499     suppress_error = 0;
 500     r = guestfs_lvm_remove_all (g);
 501     if (r == -1)
 502       return -1;
 503   }
 504   {
 505     char *lines[] = {
 506       ",",
 507       NULL
 508     };
 509     int r;
 510     suppress_error = 0;
 511     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 512     if (r == -1)
 513       return -1;
 514   }
 515   {
 516     int r;
 517     suppress_error = 0;
 518     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 519     if (r == -1)
 520       return -1;
 521   }
 522   {
 523     int r;
 524     suppress_error = 0;
 525     r = guestfs_mount (g, "/dev/sda1", "/");
 526     if (r == -1)
 527       return -1;
 528   }
 529   /* TestOutput for cp (2) */
 530   {
 531     int r;
 532     suppress_error = 0;
 533     r = guestfs_write_file (g, "/old", "file content", 0);
 534     if (r == -1)
 535       return -1;
 536   }
 537   {
 538     int r;
 539     suppress_error = 0;
 540     r = guestfs_mkdir (g, "/dir");
 541     if (r == -1)
 542       return -1;
 543   }
 544   {
 545     int r;
 546     suppress_error = 0;
 547     r = guestfs_cp (g, "/old", "/dir/new");
 548     if (r == -1)
 549       return -1;
 550   }
 551   {
 552     char *r;
 553     suppress_error = 0;
 554     r = guestfs_cat (g, "/dir/new");
 555     if (r == NULL)
 556       return -1;
 557     if (strcmp (r, "file content") != 0) {
 558       fprintf (stderr, "test_cp_2: expected \"file content\" but got \"%s\"\n", r);
 559       return -1;
 560     }
 561     free (r);
 562   }
 563   return 0;
 564 }
 565
 566 static int test_grub_install_0 (void)
 567 {
 568   /* InitBasicFS for grub_install (0): create ext2 on /dev/sda1 */
 569   {
 570     int r;
 571     suppress_error = 0;
 572     r = guestfs_umount_all (g);
 573     if (r == -1)
 574       return -1;
 575   }
 576   {
 577     int r;
 578     suppress_error = 0;
 579     r = guestfs_lvm_remove_all (g);
 580     if (r == -1)
 581       return -1;
 582   }
 583   {
 584     char *lines[] = {
 585       ",",
 586       NULL
 587     };
 588     int r;
 589     suppress_error = 0;
 590     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 591     if (r == -1)
 592       return -1;
 593   }
 594   {
 595     int r;
 596     suppress_error = 0;
 597     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 598     if (r == -1)
 599       return -1;
 600   }
 601   {
 602     int r;
 603     suppress_error = 0;
 604     r = guestfs_mount (g, "/dev/sda1", "/");
 605     if (r == -1)
 606       return -1;
 607   }
 608   /* TestOutputTrue for grub_install (0) */
 609   {
 610     int r;
 611     suppress_error = 0;
 612     r = guestfs_grub_install (g, "/", "/dev/sda1");
 613     if (r == -1)
 614       return -1;
 615   }
 616   {
 617     int r;
 618     suppress_error = 0;
 619     r = guestfs_is_dir (g, "/boot");
 620     if (r == -1)
 621       return -1;
 622     if (!r) {
 623       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
 624       return -1;
 625     }
 626   }
 627   return 0;
 628 }
 629
 630 static int test_zero_0 (void)
 631 {
 632   /* InitBasicFS for zero (0): create ext2 on /dev/sda1 */
 633   {
 634     int r;
 635     suppress_error = 0;
 636     r = guestfs_umount_all (g);
 637     if (r == -1)
 638       return -1;
 639   }
 640   {
 641     int r;
 642     suppress_error = 0;
 643     r = guestfs_lvm_remove_all (g);
 644     if (r == -1)
 645       return -1;
 646   }
 647   {
 648     char *lines[] = {
 649       ",",
 650       NULL
 651     };
 652     int r;
 653     suppress_error = 0;
 654     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 655     if (r == -1)
 656       return -1;
 657   }
 658   {
 659     int r;
 660     suppress_error = 0;
 661     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 662     if (r == -1)
 663       return -1;
 664   }
 665   {
 666     int r;
 667     suppress_error = 0;
 668     r = guestfs_mount (g, "/dev/sda1", "/");
 669     if (r == -1)
 670       return -1;
 671   }
 672   /* TestOutput for zero (0) */
 673   {
 674     int r;
 675     suppress_error = 0;
 676     r = guestfs_umount (g, "/dev/sda1");
 677     if (r == -1)
 678       return -1;
 679   }
 680   {
 681     int r;
 682     suppress_error = 0;
 683     r = guestfs_zero (g, "/dev/sda1");
 684     if (r == -1)
 685       return -1;
 686   }
 687   {
 688     char *r;
 689     suppress_error = 0;
 690     r = guestfs_file (g, "/dev/sda1");
 691     if (r == NULL)
 692       return -1;
 693     if (strcmp (r, "data") != 0) {
 694       fprintf (stderr, "test_zero_0: expected \"data\" but got \"%s\"\n", r);
 695       return -1;
 696     }
 697     free (r);
 698   }
 699   return 0;
 700 }
 701
 702 static int test_fsck_0 (void)
 703 {
 704   /* InitBasicFS for fsck (0): create ext2 on /dev/sda1 */
 705   {
 706     int r;
 707     suppress_error = 0;
 708     r = guestfs_umount_all (g);
 709     if (r == -1)
 710       return -1;
 711   }
 712   {
 713     int r;
 714     suppress_error = 0;
 715     r = guestfs_lvm_remove_all (g);
 716     if (r == -1)
 717       return -1;
 718   }
 719   {
 720     char *lines[] = {
 721       ",",
 722       NULL
 723     };
 724     int r;
 725     suppress_error = 0;
 726     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 727     if (r == -1)
 728       return -1;
 729   }
 730   {
 731     int r;
 732     suppress_error = 0;
 733     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 734     if (r == -1)
 735       return -1;
 736   }
 737   {
 738     int r;
 739     suppress_error = 0;
 740     r = guestfs_mount (g, "/dev/sda1", "/");
 741     if (r == -1)
 742       return -1;
 743   }
 744   /* TestOutputInt for fsck (0) */
 745   {
 746     int r;
 747     suppress_error = 0;
 748     r = guestfs_umount (g, "/dev/sda1");
 749     if (r == -1)
 750       return -1;
 751   }
 752   {
 753     int r;
 754     suppress_error = 0;
 755     r = guestfs_fsck (g, "ext2", "/dev/sda1");
 756     if (r == -1)
 757       return -1;
 758     if (r != 0) {
 759       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
 760       return -1;
 761     }
 762   }
 763   return 0;
 764 }
 765
 766 static int test_fsck_1 (void)
 767 {
 768   /* InitBasicFS for fsck (1): create ext2 on /dev/sda1 */
 769   {
 770     int r;
 771     suppress_error = 0;
 772     r = guestfs_umount_all (g);
 773     if (r == -1)
 774       return -1;
 775   }
 776   {
 777     int r;
 778     suppress_error = 0;
 779     r = guestfs_lvm_remove_all (g);
 780     if (r == -1)
 781       return -1;
 782   }
 783   {
 784     char *lines[] = {
 785       ",",
 786       NULL
 787     };
 788     int r;
 789     suppress_error = 0;
 790     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 791     if (r == -1)
 792       return -1;
 793   }
 794   {
 795     int r;
 796     suppress_error = 0;
 797     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 798     if (r == -1)
 799       return -1;
 800   }
 801   {
 802     int r;
 803     suppress_error = 0;
 804     r = guestfs_mount (g, "/dev/sda1", "/");
 805     if (r == -1)
 806       return -1;
 807   }
 808   /* TestOutputInt for fsck (1) */
 809   {
 810     int r;
 811     suppress_error = 0;
 812     r = guestfs_umount (g, "/dev/sda1");
 813     if (r == -1)
 814       return -1;
 815   }
 816   {
 817     int r;
 818     suppress_error = 0;
 819     r = guestfs_zero (g, "/dev/sda1");
 820     if (r == -1)
 821       return -1;
 822   }
 823   {
 824     int r;
 825     suppress_error = 0;
 826     r = guestfs_fsck (g, "ext2", "/dev/sda1");
 827     if (r == -1)
 828       return -1;
 829     if (r != 8) {
 830       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
 831       return -1;
 832     }
 833   }
 834   return 0;
 835 }
 836
 837 static int test_set_e2uuid_0 (void)
 838 {
 839   /* InitBasicFS for set_e2uuid (0): create ext2 on /dev/sda1 */
 840   {
 841     int r;
 842     suppress_error = 0;
 843     r = guestfs_umount_all (g);
 844     if (r == -1)
 845       return -1;
 846   }
 847   {
 848     int r;
 849     suppress_error = 0;
 850     r = guestfs_lvm_remove_all (g);
 851     if (r == -1)
 852       return -1;
 853   }
 854   {
 855     char *lines[] = {
 856       ",",
 857       NULL
 858     };
 859     int r;
 860     suppress_error = 0;
 861     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 862     if (r == -1)
 863       return -1;
 864   }
 865   {
 866     int r;
 867     suppress_error = 0;
 868     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 869     if (r == -1)
 870       return -1;
 871   }
 872   {
 873     int r;
 874     suppress_error = 0;
 875     r = guestfs_mount (g, "/dev/sda1", "/");
 876     if (r == -1)
 877       return -1;
 878   }
 879   /* TestOutput for set_e2uuid (0) */
 880   {
 881     int r;
 882     suppress_error = 0;
 883     r = guestfs_set_e2uuid (g, "/dev/sda1", "a3a61220-882b-4f61-89f4-cf24dcc7297d");
 884     if (r == -1)
 885       return -1;
 886   }
 887   {
 888     char *r;
 889     suppress_error = 0;
 890     r = guestfs_get_e2uuid (g, "/dev/sda1");
 891     if (r == NULL)
 892       return -1;
 893     if (strcmp (r, "a3a61220-882b-4f61-89f4-cf24dcc7297d") != 0) {
 894       fprintf (stderr, "test_set_e2uuid_0: expected \"a3a61220-882b-4f61-89f4-cf24dcc7297d\" but got \"%s\"\n", r);
 895       return -1;
 896     }
 897     free (r);
 898   }
 899   return 0;
 900 }
 901
 902 static int test_set_e2uuid_1 (void)
 903 {
 904   /* InitBasicFS for set_e2uuid (1): create ext2 on /dev/sda1 */
 905   {
 906     int r;
 907     suppress_error = 0;
 908     r = guestfs_umount_all (g);
 909     if (r == -1)
 910       return -1;
 911   }
 912   {
 913     int r;
 914     suppress_error = 0;
 915     r = guestfs_lvm_remove_all (g);
 916     if (r == -1)
 917       return -1;
 918   }
 919   {
 920     char *lines[] = {
 921       ",",
 922       NULL
 923     };
 924     int r;
 925     suppress_error = 0;
 926     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 927     if (r == -1)
 928       return -1;
 929   }
 930   {
 931     int r;
 932     suppress_error = 0;
 933     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 934     if (r == -1)
 935       return -1;
 936   }
 937   {
 938     int r;
 939     suppress_error = 0;
 940     r = guestfs_mount (g, "/dev/sda1", "/");
 941     if (r == -1)
 942       return -1;
 943   }
 944   /* TestOutput for set_e2uuid (1) */
 945   {
 946     int r;
 947     suppress_error = 0;
 948     r = guestfs_set_e2uuid (g, "/dev/sda1", "clear");
 949     if (r == -1)
 950       return -1;
 951   }
 952   {
 953     char *r;
 954     suppress_error = 0;
 955     r = guestfs_get_e2uuid (g, "/dev/sda1");
 956     if (r == NULL)
 957       return -1;
 958     if (strcmp (r, "") != 0) {
 959       fprintf (stderr, "test_set_e2uuid_1: expected \"\" but got \"%s\"\n", r);
 960       return -1;
 961     }
 962     free (r);
 963   }
 964   return 0;
 965 }
 966
 967 static int test_set_e2uuid_2 (void)
 968 {
 969   /* InitBasicFS for set_e2uuid (2): create ext2 on /dev/sda1 */
 970   {
 971     int r;
 972     suppress_error = 0;
 973     r = guestfs_umount_all (g);
 974     if (r == -1)
 975       return -1;
 976   }
 977   {
 978     int r;
 979     suppress_error = 0;
 980     r = guestfs_lvm_remove_all (g);
 981     if (r == -1)
 982       return -1;
 983   }
 984   {
 985     char *lines[] = {
 986       ",",
 987       NULL
 988     };
 989     int r;
 990     suppress_error = 0;
 991     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 992     if (r == -1)
 993       return -1;
 994   }
 995   {
 996     int r;
 997     suppress_error = 0;
 998     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 999     if (r == -1)
1000       return -1;
1001   }
1002   {
1003     int r;
1004     suppress_error = 0;
1005     r = guestfs_mount (g, "/dev/sda1", "/");
1006     if (r == -1)
1007       return -1;
1008   }
1009   /* TestRun for set_e2uuid (2) */
1010   {
1011     int r;
1012     suppress_error = 0;
1013     r = guestfs_set_e2uuid (g, "/dev/sda1", "random");
1014     if (r == -1)
1015       return -1;
1016   }
1017   return 0;
1018 }
1019
1020 static int test_set_e2uuid_3 (void)
1021 {
1022   /* InitBasicFS for set_e2uuid (3): create ext2 on /dev/sda1 */
1023   {
1024     int r;
1025     suppress_error = 0;
1026     r = guestfs_umount_all (g);
1027     if (r == -1)
1028       return -1;
1029   }
1030   {
1031     int r;
1032     suppress_error = 0;
1033     r = guestfs_lvm_remove_all (g);
1034     if (r == -1)
1035       return -1;
1036   }
1037   {
1038     char *lines[] = {
1039       ",",
1040       NULL
1041     };
1042     int r;
1043     suppress_error = 0;
1044     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1045     if (r == -1)
1046       return -1;
1047   }
1048   {
1049     int r;
1050     suppress_error = 0;
1051     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1052     if (r == -1)
1053       return -1;
1054   }
1055   {
1056     int r;
1057     suppress_error = 0;
1058     r = guestfs_mount (g, "/dev/sda1", "/");
1059     if (r == -1)
1060       return -1;
1061   }
1062   /* TestRun for set_e2uuid (3) */
1063   {
1064     int r;
1065     suppress_error = 0;
1066     r = guestfs_set_e2uuid (g, "/dev/sda1", "time");
1067     if (r == -1)
1068       return -1;
1069   }
1070   return 0;
1071 }
1072
1073 static int test_set_e2label_0 (void)
1074 {
1075   /* InitBasicFS for set_e2label (0): create ext2 on /dev/sda1 */
1076   {
1077     int r;
1078     suppress_error = 0;
1079     r = guestfs_umount_all (g);
1080     if (r == -1)
1081       return -1;
1082   }
1083   {
1084     int r;
1085     suppress_error = 0;
1086     r = guestfs_lvm_remove_all (g);
1087     if (r == -1)
1088       return -1;
1089   }
1090   {
1091     char *lines[] = {
1092       ",",
1093       NULL
1094     };
1095     int r;
1096     suppress_error = 0;
1097     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1098     if (r == -1)
1099       return -1;
1100   }
1101   {
1102     int r;
1103     suppress_error = 0;
1104     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1105     if (r == -1)
1106       return -1;
1107   }
1108   {
1109     int r;
1110     suppress_error = 0;
1111     r = guestfs_mount (g, "/dev/sda1", "/");
1112     if (r == -1)
1113       return -1;
1114   }
1115   /* TestOutput for set_e2label (0) */
1116   {
1117     int r;
1118     suppress_error = 0;
1119     r = guestfs_set_e2label (g, "/dev/sda1", "testlabel");
1120     if (r == -1)
1121       return -1;
1122   }
1123   {
1124     char *r;
1125     suppress_error = 0;
1126     r = guestfs_get_e2label (g, "/dev/sda1");
1127     if (r == NULL)
1128       return -1;
1129     if (strcmp (r, "testlabel") != 0) {
1130       fprintf (stderr, "test_set_e2label_0: expected \"testlabel\" but got \"%s\"\n", r);
1131       return -1;
1132     }
1133     free (r);
1134   }
1135   return 0;
1136 }
1137
1138 static int test_pvremove_0 (void)
1139 {
1140   /* InitEmpty for pvremove (0) */
1141   {
1142     int r;
1143     suppress_error = 0;
1144     r = guestfs_umount_all (g);
1145     if (r == -1)
1146       return -1;
1147   }
1148   {
1149     int r;
1150     suppress_error = 0;
1151     r = guestfs_lvm_remove_all (g);
1152     if (r == -1)
1153       return -1;
1154   }
1155   /* TestOutputList for pvremove (0) */
1156   {
1157     int r;
1158     suppress_error = 0;
1159     r = guestfs_pvcreate (g, "/dev/sda");
1160     if (r == -1)
1161       return -1;
1162   }
1163   {
1164     char *physvols[] = {
1165       "/dev/sda",
1166       NULL
1167     };
1168     int r;
1169     suppress_error = 0;
1170     r = guestfs_vgcreate (g, "VG", physvols);
1171     if (r == -1)
1172       return -1;
1173   }
1174   {
1175     int r;
1176     suppress_error = 0;
1177     r = guestfs_lvcreate (g, "LV1", "VG", 50);
1178     if (r == -1)
1179       return -1;
1180   }
1181   {
1182     int r;
1183     suppress_error = 0;
1184     r = guestfs_lvcreate (g, "LV2", "VG", 50);
1185     if (r == -1)
1186       return -1;
1187   }
1188   {
1189     int r;
1190     suppress_error = 0;
1191     r = guestfs_vgremove (g, "VG");
1192     if (r == -1)
1193       return -1;
1194   }
1195   {
1196     int r;
1197     suppress_error = 0;
1198     r = guestfs_pvremove (g, "/dev/sda");
1199     if (r == -1)
1200       return -1;
1201   }
1202   {
1203     char **r;
1204     int i;
1205     suppress_error = 0;
1206     r = guestfs_lvs (g);
1207     if (r == NULL)
1208       return -1;
1209     if (r[0] != NULL) {
1210       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
1211       print_strings (r);
1212       return -1;
1213     }
1214     for (i = 0; r[i] != NULL; ++i)
1215       free (r[i]);
1216     free (r);
1217   }
1218   return 0;
1219 }
1220
1221 static int test_pvremove_1 (void)
1222 {
1223   /* InitEmpty for pvremove (1) */
1224   {
1225     int r;
1226     suppress_error = 0;
1227     r = guestfs_umount_all (g);
1228     if (r == -1)
1229       return -1;
1230   }
1231   {
1232     int r;
1233     suppress_error = 0;
1234     r = guestfs_lvm_remove_all (g);
1235     if (r == -1)
1236       return -1;
1237   }
1238   /* TestOutputList for pvremove (1) */
1239   {
1240     int r;
1241     suppress_error = 0;
1242     r = guestfs_pvcreate (g, "/dev/sda");
1243     if (r == -1)
1244       return -1;
1245   }
1246   {
1247     char *physvols[] = {
1248       "/dev/sda",
1249       NULL
1250     };
1251     int r;
1252     suppress_error = 0;
1253     r = guestfs_vgcreate (g, "VG", physvols);
1254     if (r == -1)
1255       return -1;
1256   }
1257   {
1258     int r;
1259     suppress_error = 0;
1260     r = guestfs_lvcreate (g, "LV1", "VG", 50);
1261     if (r == -1)
1262       return -1;
1263   }
1264   {
1265     int r;
1266     suppress_error = 0;
1267     r = guestfs_lvcreate (g, "LV2", "VG", 50);
1268     if (r == -1)
1269       return -1;
1270   }
1271   {
1272     int r;
1273     suppress_error = 0;
1274     r = guestfs_vgremove (g, "VG");
1275     if (r == -1)
1276       return -1;
1277   }
1278   {
1279     int r;
1280     suppress_error = 0;
1281     r = guestfs_pvremove (g, "/dev/sda");
1282     if (r == -1)
1283       return -1;
1284   }
1285   {
1286     char **r;
1287     int i;
1288     suppress_error = 0;
1289     r = guestfs_vgs (g);
1290     if (r == NULL)
1291       return -1;
1292     if (r[0] != NULL) {
1293       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
1294       print_strings (r);
1295       return -1;
1296     }
1297     for (i = 0; r[i] != NULL; ++i)
1298       free (r[i]);
1299     free (r);
1300   }
1301   return 0;
1302 }
1303
1304 static int test_pvremove_2 (void)
1305 {
1306   /* InitEmpty for pvremove (2) */
1307   {
1308     int r;
1309     suppress_error = 0;
1310     r = guestfs_umount_all (g);
1311     if (r == -1)
1312       return -1;
1313   }
1314   {
1315     int r;
1316     suppress_error = 0;
1317     r = guestfs_lvm_remove_all (g);
1318     if (r == -1)
1319       return -1;
1320   }
1321   /* TestOutputList for pvremove (2) */
1322   {
1323     int r;
1324     suppress_error = 0;
1325     r = guestfs_pvcreate (g, "/dev/sda");
1326     if (r == -1)
1327       return -1;
1328   }
1329   {
1330     char *physvols[] = {
1331       "/dev/sda",
1332       NULL
1333     };
1334     int r;
1335     suppress_error = 0;
1336     r = guestfs_vgcreate (g, "VG", physvols);
1337     if (r == -1)
1338       return -1;
1339   }
1340   {
1341     int r;
1342     suppress_error = 0;
1343     r = guestfs_lvcreate (g, "LV1", "VG", 50);
1344     if (r == -1)
1345       return -1;
1346   }
1347   {
1348     int r;
1349     suppress_error = 0;
1350     r = guestfs_lvcreate (g, "LV2", "VG", 50);
1351     if (r == -1)
1352       return -1;
1353   }
1354   {
1355     int r;
1356     suppress_error = 0;
1357     r = guestfs_vgremove (g, "VG");
1358     if (r == -1)
1359       return -1;
1360   }
1361   {
1362     int r;
1363     suppress_error = 0;
1364     r = guestfs_pvremove (g, "/dev/sda");
1365     if (r == -1)
1366       return -1;
1367   }
1368   {
1369     char **r;
1370     int i;
1371     suppress_error = 0;
1372     r = guestfs_pvs (g);
1373     if (r == NULL)
1374       return -1;
1375     if (r[0] != NULL) {
1376       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
1377       print_strings (r);
1378       return -1;
1379     }
1380     for (i = 0; r[i] != NULL; ++i)
1381       free (r[i]);
1382     free (r);
1383   }
1384   return 0;
1385 }
1386
1387 static int test_vgremove_0 (void)
1388 {
1389   /* InitEmpty for vgremove (0) */
1390   {
1391     int r;
1392     suppress_error = 0;
1393     r = guestfs_umount_all (g);
1394     if (r == -1)
1395       return -1;
1396   }
1397   {
1398     int r;
1399     suppress_error = 0;
1400     r = guestfs_lvm_remove_all (g);
1401     if (r == -1)
1402       return -1;
1403   }
1404   /* TestOutputList for vgremove (0) */
1405   {
1406     int r;
1407     suppress_error = 0;
1408     r = guestfs_pvcreate (g, "/dev/sda");
1409     if (r == -1)
1410       return -1;
1411   }
1412   {
1413     char *physvols[] = {
1414       "/dev/sda",
1415       NULL
1416     };
1417     int r;
1418     suppress_error = 0;
1419     r = guestfs_vgcreate (g, "VG", physvols);
1420     if (r == -1)
1421       return -1;
1422   }
1423   {
1424     int r;
1425     suppress_error = 0;
1426     r = guestfs_lvcreate (g, "LV1", "VG", 50);
1427     if (r == -1)
1428       return -1;
1429   }
1430   {
1431     int r;
1432     suppress_error = 0;
1433     r = guestfs_lvcreate (g, "LV2", "VG", 50);
1434     if (r == -1)
1435       return -1;
1436   }
1437   {
1438     int r;
1439     suppress_error = 0;
1440     r = guestfs_vgremove (g, "VG");
1441     if (r == -1)
1442       return -1;
1443   }
1444   {
1445     char **r;
1446     int i;
1447     suppress_error = 0;
1448     r = guestfs_lvs (g);
1449     if (r == NULL)
1450       return -1;
1451     if (r[0] != NULL) {
1452       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
1453       print_strings (r);
1454       return -1;
1455     }
1456     for (i = 0; r[i] != NULL; ++i)
1457       free (r[i]);
1458     free (r);
1459   }
1460   return 0;
1461 }
1462
1463 static int test_vgremove_1 (void)
1464 {
1465   /* InitEmpty for vgremove (1) */
1466   {
1467     int r;
1468     suppress_error = 0;
1469     r = guestfs_umount_all (g);
1470     if (r == -1)
1471       return -1;
1472   }
1473   {
1474     int r;
1475     suppress_error = 0;
1476     r = guestfs_lvm_remove_all (g);
1477     if (r == -1)
1478       return -1;
1479   }
1480   /* TestOutputList for vgremove (1) */
1481   {
1482     int r;
1483     suppress_error = 0;
1484     r = guestfs_pvcreate (g, "/dev/sda");
1485     if (r == -1)
1486       return -1;
1487   }
1488   {
1489     char *physvols[] = {
1490       "/dev/sda",
1491       NULL
1492     };
1493     int r;
1494     suppress_error = 0;
1495     r = guestfs_vgcreate (g, "VG", physvols);
1496     if (r == -1)
1497       return -1;
1498   }
1499   {
1500     int r;
1501     suppress_error = 0;
1502     r = guestfs_lvcreate (g, "LV1", "VG", 50);
1503     if (r == -1)
1504       return -1;
1505   }
1506   {
1507     int r;
1508     suppress_error = 0;
1509     r = guestfs_lvcreate (g, "LV2", "VG", 50);
1510     if (r == -1)
1511       return -1;
1512   }
1513   {
1514     int r;
1515     suppress_error = 0;
1516     r = guestfs_vgremove (g, "VG");
1517     if (r == -1)
1518       return -1;
1519   }
1520   {
1521     char **r;
1522     int i;
1523     suppress_error = 0;
1524     r = guestfs_vgs (g);
1525     if (r == NULL)
1526       return -1;
1527     if (r[0] != NULL) {
1528       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
1529       print_strings (r);
1530       return -1;
1531     }
1532     for (i = 0; r[i] != NULL; ++i)
1533       free (r[i]);
1534     free (r);
1535   }
1536   return 0;
1537 }
1538
1539 static int test_lvremove_0 (void)
1540 {
1541   /* InitEmpty for lvremove (0) */
1542   {
1543     int r;
1544     suppress_error = 0;
1545     r = guestfs_umount_all (g);
1546     if (r == -1)
1547       return -1;
1548   }
1549   {
1550     int r;
1551     suppress_error = 0;
1552     r = guestfs_lvm_remove_all (g);
1553     if (r == -1)
1554       return -1;
1555   }
1556   /* TestOutputList for lvremove (0) */
1557   {
1558     int r;
1559     suppress_error = 0;
1560     r = guestfs_pvcreate (g, "/dev/sda");
1561     if (r == -1)
1562       return -1;
1563   }
1564   {
1565     char *physvols[] = {
1566       "/dev/sda",
1567       NULL
1568     };
1569     int r;
1570     suppress_error = 0;
1571     r = guestfs_vgcreate (g, "VG", physvols);
1572     if (r == -1)
1573       return -1;
1574   }
1575   {
1576     int r;
1577     suppress_error = 0;
1578     r = guestfs_lvcreate (g, "LV1", "VG", 50);
1579     if (r == -1)
1580       return -1;
1581   }
1582   {
1583     int r;
1584     suppress_error = 0;
1585     r = guestfs_lvcreate (g, "LV2", "VG", 50);
1586     if (r == -1)
1587       return -1;
1588   }
1589   {
1590     int r;
1591     suppress_error = 0;
1592     r = guestfs_lvremove (g, "/dev/VG/LV1");
1593     if (r == -1)
1594       return -1;
1595   }
1596   {
1597     char **r;
1598     int i;
1599     suppress_error = 0;
1600     r = guestfs_lvs (g);
1601     if (r == NULL)
1602       return -1;
1603     if (!r[0]) {
1604       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
1605       print_strings (r);
1606       return -1;
1607     }
1608     if (strcmp (r[0], "/dev/VG/LV2") != 0) {
1609       fprintf (stderr, "test_lvremove_0: expected \"/dev/VG/LV2\" but got \"%s\"\n", r[0]);
1610       return -1;
1611     }
1612     if (r[1] != NULL) {
1613       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
1614       print_strings (r);
1615       return -1;
1616     }
1617     for (i = 0; r[i] != NULL; ++i)
1618       free (r[i]);
1619     free (r);
1620   }
1621   return 0;
1622 }
1623
1624 static int test_lvremove_1 (void)
1625 {
1626   /* InitEmpty for lvremove (1) */
1627   {
1628     int r;
1629     suppress_error = 0;
1630     r = guestfs_umount_all (g);
1631     if (r == -1)
1632       return -1;
1633   }
1634   {
1635     int r;
1636     suppress_error = 0;
1637     r = guestfs_lvm_remove_all (g);
1638     if (r == -1)
1639       return -1;
1640   }
1641   /* TestOutputList for lvremove (1) */
1642   {
1643     int r;
1644     suppress_error = 0;
1645     r = guestfs_pvcreate (g, "/dev/sda");
1646     if (r == -1)
1647       return -1;
1648   }
1649   {
1650     char *physvols[] = {
1651       "/dev/sda",
1652       NULL
1653     };
1654     int r;
1655     suppress_error = 0;
1656     r = guestfs_vgcreate (g, "VG", physvols);
1657     if (r == -1)
1658       return -1;
1659   }
1660   {
1661     int r;
1662     suppress_error = 0;
1663     r = guestfs_lvcreate (g, "LV1", "VG", 50);
1664     if (r == -1)
1665       return -1;
1666   }
1667   {
1668     int r;
1669     suppress_error = 0;
1670     r = guestfs_lvcreate (g, "LV2", "VG", 50);
1671     if (r == -1)
1672       return -1;
1673   }
1674   {
1675     int r;
1676     suppress_error = 0;
1677     r = guestfs_lvremove (g, "/dev/VG");
1678     if (r == -1)
1679       return -1;
1680   }
1681   {
1682     char **r;
1683     int i;
1684     suppress_error = 0;
1685     r = guestfs_lvs (g);
1686     if (r == NULL)
1687       return -1;
1688     if (r[0] != NULL) {
1689       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
1690       print_strings (r);
1691       return -1;
1692     }
1693     for (i = 0; r[i] != NULL; ++i)
1694       free (r[i]);
1695     free (r);
1696   }
1697   return 0;
1698 }
1699
1700 static int test_lvremove_2 (void)
1701 {
1702   /* InitEmpty for lvremove (2) */
1703   {
1704     int r;
1705     suppress_error = 0;
1706     r = guestfs_umount_all (g);
1707     if (r == -1)
1708       return -1;
1709   }
1710   {
1711     int r;
1712     suppress_error = 0;
1713     r = guestfs_lvm_remove_all (g);
1714     if (r == -1)
1715       return -1;
1716   }
1717   /* TestOutputList for lvremove (2) */
1718   {
1719     int r;
1720     suppress_error = 0;
1721     r = guestfs_pvcreate (g, "/dev/sda");
1722     if (r == -1)
1723       return -1;
1724   }
1725   {
1726     char *physvols[] = {
1727       "/dev/sda",
1728       NULL
1729     };
1730     int r;
1731     suppress_error = 0;
1732     r = guestfs_vgcreate (g, "VG", physvols);
1733     if (r == -1)
1734       return -1;
1735   }
1736   {
1737     int r;
1738     suppress_error = 0;
1739     r = guestfs_lvcreate (g, "LV1", "VG", 50);
1740     if (r == -1)
1741       return -1;
1742   }
1743   {
1744     int r;
1745     suppress_error = 0;
1746     r = guestfs_lvcreate (g, "LV2", "VG", 50);
1747     if (r == -1)
1748       return -1;
1749   }
1750   {
1751     int r;
1752     suppress_error = 0;
1753     r = guestfs_lvremove (g, "/dev/VG");
1754     if (r == -1)
1755       return -1;
1756   }
1757   {
1758     char **r;
1759     int i;
1760     suppress_error = 0;
1761     r = guestfs_vgs (g);
1762     if (r == NULL)
1763       return -1;
1764     if (!r[0]) {
1765       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
1766       print_strings (r);
1767       return -1;
1768     }
1769     if (strcmp (r[0], "VG") != 0) {
1770       fprintf (stderr, "test_lvremove_2: expected \"VG\" but got \"%s\"\n", r[0]);
1771       return -1;
1772     }
1773     if (r[1] != NULL) {
1774       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
1775       print_strings (r);
1776       return -1;
1777     }
1778     for (i = 0; r[i] != NULL; ++i)
1779       free (r[i]);
1780     free (r);
1781   }
1782   return 0;
1783 }
1784
1785 static int test_mount_ro_0 (void)
1786 {
1787   /* InitBasicFS for mount_ro (0): create ext2 on /dev/sda1 */
1788   {
1789     int r;
1790     suppress_error = 0;
1791     r = guestfs_umount_all (g);
1792     if (r == -1)
1793       return -1;
1794   }
1795   {
1796     int r;
1797     suppress_error = 0;
1798     r = guestfs_lvm_remove_all (g);
1799     if (r == -1)
1800       return -1;
1801   }
1802   {
1803     char *lines[] = {
1804       ",",
1805       NULL
1806     };
1807     int r;
1808     suppress_error = 0;
1809     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1810     if (r == -1)
1811       return -1;
1812   }
1813   {
1814     int r;
1815     suppress_error = 0;
1816     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1817     if (r == -1)
1818       return -1;
1819   }
1820   {
1821     int r;
1822     suppress_error = 0;
1823     r = guestfs_mount (g, "/dev/sda1", "/");
1824     if (r == -1)
1825       return -1;
1826   }
1827   /* TestLastFail for mount_ro (0) */
1828   {
1829     int r;
1830     suppress_error = 0;
1831     r = guestfs_umount (g, "/");
1832     if (r == -1)
1833       return -1;
1834   }
1835   {
1836     int r;
1837     suppress_error = 0;
1838     r = guestfs_mount_ro (g, "/dev/sda1", "/");
1839     if (r == -1)
1840       return -1;
1841   }
1842   {
1843     int r;
1844     suppress_error = 1;
1845     r = guestfs_touch (g, "/new");
1846     if (r != -1)
1847       return -1;
1848   }
1849   return 0;
1850 }
1851
1852 static int test_mount_ro_1 (void)
1853 {
1854   /* InitBasicFS for mount_ro (1): create ext2 on /dev/sda1 */
1855   {
1856     int r;
1857     suppress_error = 0;
1858     r = guestfs_umount_all (g);
1859     if (r == -1)
1860       return -1;
1861   }
1862   {
1863     int r;
1864     suppress_error = 0;
1865     r = guestfs_lvm_remove_all (g);
1866     if (r == -1)
1867       return -1;
1868   }
1869   {
1870     char *lines[] = {
1871       ",",
1872       NULL
1873     };
1874     int r;
1875     suppress_error = 0;
1876     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1877     if (r == -1)
1878       return -1;
1879   }
1880   {
1881     int r;
1882     suppress_error = 0;
1883     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1884     if (r == -1)
1885       return -1;
1886   }
1887   {
1888     int r;
1889     suppress_error = 0;
1890     r = guestfs_mount (g, "/dev/sda1", "/");
1891     if (r == -1)
1892       return -1;
1893   }
1894   /* TestOutput for mount_ro (1) */
1895   {
1896     int r;
1897     suppress_error = 0;
1898     r = guestfs_write_file (g, "/new", "data", 0);
1899     if (r == -1)
1900       return -1;
1901   }
1902   {
1903     int r;
1904     suppress_error = 0;
1905     r = guestfs_umount (g, "/");
1906     if (r == -1)
1907       return -1;
1908   }
1909   {
1910     int r;
1911     suppress_error = 0;
1912     r = guestfs_mount_ro (g, "/dev/sda1", "/");
1913     if (r == -1)
1914       return -1;
1915   }
1916   {
1917     char *r;
1918     suppress_error = 0;
1919     r = guestfs_cat (g, "/new");
1920     if (r == NULL)
1921       return -1;
1922     if (strcmp (r, "data") != 0) {
1923       fprintf (stderr, "test_mount_ro_1: expected \"data\" but got \"%s\"\n", r);
1924       return -1;
1925     }
1926     free (r);
1927   }
1928   return 0;
1929 }
1930
1931 static int test_tgz_in_0 (void)
1932 {
1933   /* InitBasicFS for tgz_in (0): create ext2 on /dev/sda1 */
1934   {
1935     int r;
1936     suppress_error = 0;
1937     r = guestfs_umount_all (g);
1938     if (r == -1)
1939       return -1;
1940   }
1941   {
1942     int r;
1943     suppress_error = 0;
1944     r = guestfs_lvm_remove_all (g);
1945     if (r == -1)
1946       return -1;
1947   }
1948   {
1949     char *lines[] = {
1950       ",",
1951       NULL
1952     };
1953     int r;
1954     suppress_error = 0;
1955     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1956     if (r == -1)
1957       return -1;
1958   }
1959   {
1960     int r;
1961     suppress_error = 0;
1962     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1963     if (r == -1)
1964       return -1;
1965   }
1966   {
1967     int r;
1968     suppress_error = 0;
1969     r = guestfs_mount (g, "/dev/sda1", "/");
1970     if (r == -1)
1971       return -1;
1972   }
1973   /* TestOutput for tgz_in (0) */
1974   {
1975     int r;
1976     suppress_error = 0;
1977     r = guestfs_tgz_in (g, "images/helloworld.tar.gz", "/");
1978     if (r == -1)
1979       return -1;
1980   }
1981   {
1982     char *r;
1983     suppress_error = 0;
1984     r = guestfs_cat (g, "/hello");
1985     if (r == NULL)
1986       return -1;
1987     if (strcmp (r, "hello\n") != 0) {
1988       fprintf (stderr, "test_tgz_in_0: expected \"hello\n\" but got \"%s\"\n", r);
1989       return -1;
1990     }
1991     free (r);
1992   }
1993   return 0;
1994 }
1995
1996 static int test_tar_in_0 (void)
1997 {
1998   /* InitBasicFS for tar_in (0): create ext2 on /dev/sda1 */
1999   {
2000     int r;
2001     suppress_error = 0;
2002     r = guestfs_umount_all (g);
2003     if (r == -1)
2004       return -1;
2005   }
2006   {
2007     int r;
2008     suppress_error = 0;
2009     r = guestfs_lvm_remove_all (g);
2010     if (r == -1)
2011       return -1;
2012   }
2013   {
2014     char *lines[] = {
2015       ",",
2016       NULL
2017     };
2018     int r;
2019     suppress_error = 0;
2020     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2021     if (r == -1)
2022       return -1;
2023   }
2024   {
2025     int r;
2026     suppress_error = 0;
2027     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2028     if (r == -1)
2029       return -1;
2030   }
2031   {
2032     int r;
2033     suppress_error = 0;
2034     r = guestfs_mount (g, "/dev/sda1", "/");
2035     if (r == -1)
2036       return -1;
2037   }
2038   /* TestOutput for tar_in (0) */
2039   {
2040     int r;
2041     suppress_error = 0;
2042     r = guestfs_tar_in (g, "images/helloworld.tar", "/");
2043     if (r == -1)
2044       return -1;
2045   }
2046   {
2047     char *r;
2048     suppress_error = 0;
2049     r = guestfs_cat (g, "/hello");
2050     if (r == NULL)
2051       return -1;
2052     if (strcmp (r, "hello\n") != 0) {
2053       fprintf (stderr, "test_tar_in_0: expected \"hello\n\" but got \"%s\"\n", r);
2054       return -1;
2055     }
2056     free (r);
2057   }
2058   return 0;
2059 }
2060
2061 static int test_checksum_0 (void)
2062 {
2063   /* InitBasicFS for checksum (0): create ext2 on /dev/sda1 */
2064   {
2065     int r;
2066     suppress_error = 0;
2067     r = guestfs_umount_all (g);
2068     if (r == -1)
2069       return -1;
2070   }
2071   {
2072     int r;
2073     suppress_error = 0;
2074     r = guestfs_lvm_remove_all (g);
2075     if (r == -1)
2076       return -1;
2077   }
2078   {
2079     char *lines[] = {
2080       ",",
2081       NULL
2082     };
2083     int r;
2084     suppress_error = 0;
2085     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2086     if (r == -1)
2087       return -1;
2088   }
2089   {
2090     int r;
2091     suppress_error = 0;
2092     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2093     if (r == -1)
2094       return -1;
2095   }
2096   {
2097     int r;
2098     suppress_error = 0;
2099     r = guestfs_mount (g, "/dev/sda1", "/");
2100     if (r == -1)
2101       return -1;
2102   }
2103   /* TestOutput for checksum (0) */
2104   {
2105     int r;
2106     suppress_error = 0;
2107     r = guestfs_write_file (g, "/new", "test\n", 0);
2108     if (r == -1)
2109       return -1;
2110   }
2111   {
2112     char *r;
2113     suppress_error = 0;
2114     r = guestfs_checksum (g, "crc", "/new");
2115     if (r == NULL)
2116       return -1;
2117     if (strcmp (r, "935282863") != 0) {
2118       fprintf (stderr, "test_checksum_0: expected \"935282863\" but got \"%s\"\n", r);
2119       return -1;
2120     }
2121     free (r);
2122   }
2123   return 0;
2124 }
2125
2126 static int test_checksum_1 (void)
2127 {
2128   /* InitBasicFS for checksum (1): create ext2 on /dev/sda1 */
2129   {
2130     int r;
2131     suppress_error = 0;
2132     r = guestfs_umount_all (g);
2133     if (r == -1)
2134       return -1;
2135   }
2136   {
2137     int r;
2138     suppress_error = 0;
2139     r = guestfs_lvm_remove_all (g);
2140     if (r == -1)
2141       return -1;
2142   }
2143   {
2144     char *lines[] = {
2145       ",",
2146       NULL
2147     };
2148     int r;
2149     suppress_error = 0;
2150     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2151     if (r == -1)
2152       return -1;
2153   }
2154   {
2155     int r;
2156     suppress_error = 0;
2157     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2158     if (r == -1)
2159       return -1;
2160   }
2161   {
2162     int r;
2163     suppress_error = 0;
2164     r = guestfs_mount (g, "/dev/sda1", "/");
2165     if (r == -1)
2166       return -1;
2167   }
2168   /* TestLastFail for checksum (1) */
2169   {
2170     char *r;
2171     suppress_error = 1;
2172     r = guestfs_checksum (g, "crc", "/new");
2173     if (r != NULL)
2174       return -1;
2175     free (r);
2176   }
2177   return 0;
2178 }
2179
2180 static int test_checksum_2 (void)
2181 {
2182   /* InitBasicFS for checksum (2): create ext2 on /dev/sda1 */
2183   {
2184     int r;
2185     suppress_error = 0;
2186     r = guestfs_umount_all (g);
2187     if (r == -1)
2188       return -1;
2189   }
2190   {
2191     int r;
2192     suppress_error = 0;
2193     r = guestfs_lvm_remove_all (g);
2194     if (r == -1)
2195       return -1;
2196   }
2197   {
2198     char *lines[] = {
2199       ",",
2200       NULL
2201     };
2202     int r;
2203     suppress_error = 0;
2204     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2205     if (r == -1)
2206       return -1;
2207   }
2208   {
2209     int r;
2210     suppress_error = 0;
2211     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2212     if (r == -1)
2213       return -1;
2214   }
2215   {
2216     int r;
2217     suppress_error = 0;
2218     r = guestfs_mount (g, "/dev/sda1", "/");
2219     if (r == -1)
2220       return -1;
2221   }
2222   /* TestOutput for checksum (2) */
2223   {
2224     int r;
2225     suppress_error = 0;
2226     r = guestfs_write_file (g, "/new", "test\n", 0);
2227     if (r == -1)
2228       return -1;
2229   }
2230   {
2231     char *r;
2232     suppress_error = 0;
2233     r = guestfs_checksum (g, "md5", "/new");
2234     if (r == NULL)
2235       return -1;
2236     if (strcmp (r, "d8e8fca2dc0f896fd7cb4cb0031ba249") != 0) {
2237       fprintf (stderr, "test_checksum_2: expected \"d8e8fca2dc0f896fd7cb4cb0031ba249\" but got \"%s\"\n", r);
2238       return -1;
2239     }
2240     free (r);
2241   }
2242   return 0;
2243 }
2244
2245 static int test_checksum_3 (void)
2246 {
2247   /* InitBasicFS for checksum (3): create ext2 on /dev/sda1 */
2248   {
2249     int r;
2250     suppress_error = 0;
2251     r = guestfs_umount_all (g);
2252     if (r == -1)
2253       return -1;
2254   }
2255   {
2256     int r;
2257     suppress_error = 0;
2258     r = guestfs_lvm_remove_all (g);
2259     if (r == -1)
2260       return -1;
2261   }
2262   {
2263     char *lines[] = {
2264       ",",
2265       NULL
2266     };
2267     int r;
2268     suppress_error = 0;
2269     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2270     if (r == -1)
2271       return -1;
2272   }
2273   {
2274     int r;
2275     suppress_error = 0;
2276     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2277     if (r == -1)
2278       return -1;
2279   }
2280   {
2281     int r;
2282     suppress_error = 0;
2283     r = guestfs_mount (g, "/dev/sda1", "/");
2284     if (r == -1)
2285       return -1;
2286   }
2287   /* TestOutput for checksum (3) */
2288   {
2289     int r;
2290     suppress_error = 0;
2291     r = guestfs_write_file (g, "/new", "test\n", 0);
2292     if (r == -1)
2293       return -1;
2294   }
2295   {
2296     char *r;
2297     suppress_error = 0;
2298     r = guestfs_checksum (g, "sha1", "/new");
2299     if (r == NULL)
2300       return -1;
2301     if (strcmp (r, "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83") != 0) {
2302       fprintf (stderr, "test_checksum_3: expected \"4e1243bd22c66e76c2ba9eddc1f91394e57f9f83\" but got \"%s\"\n", r);
2303       return -1;
2304     }
2305     free (r);
2306   }
2307   return 0;
2308 }
2309
2310 static int test_checksum_4 (void)
2311 {
2312   /* InitBasicFS for checksum (4): create ext2 on /dev/sda1 */
2313   {
2314     int r;
2315     suppress_error = 0;
2316     r = guestfs_umount_all (g);
2317     if (r == -1)
2318       return -1;
2319   }
2320   {
2321     int r;
2322     suppress_error = 0;
2323     r = guestfs_lvm_remove_all (g);
2324     if (r == -1)
2325       return -1;
2326   }
2327   {
2328     char *lines[] = {
2329       ",",
2330       NULL
2331     };
2332     int r;
2333     suppress_error = 0;
2334     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2335     if (r == -1)
2336       return -1;
2337   }
2338   {
2339     int r;
2340     suppress_error = 0;
2341     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2342     if (r == -1)
2343       return -1;
2344   }
2345   {
2346     int r;
2347     suppress_error = 0;
2348     r = guestfs_mount (g, "/dev/sda1", "/");
2349     if (r == -1)
2350       return -1;
2351   }
2352   /* TestOutput for checksum (4) */
2353   {
2354     int r;
2355     suppress_error = 0;
2356     r = guestfs_write_file (g, "/new", "test\n", 0);
2357     if (r == -1)
2358       return -1;
2359   }
2360   {
2361     char *r;
2362     suppress_error = 0;
2363     r = guestfs_checksum (g, "sha224", "/new");
2364     if (r == NULL)
2365       return -1;
2366     if (strcmp (r, "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec") != 0) {
2367       fprintf (stderr, "test_checksum_4: expected \"52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec\" but got \"%s\"\n", r);
2368       return -1;
2369     }
2370     free (r);
2371   }
2372   return 0;
2373 }
2374
2375 static int test_checksum_5 (void)
2376 {
2377   /* InitBasicFS for checksum (5): create ext2 on /dev/sda1 */
2378   {
2379     int r;
2380     suppress_error = 0;
2381     r = guestfs_umount_all (g);
2382     if (r == -1)
2383       return -1;
2384   }
2385   {
2386     int r;
2387     suppress_error = 0;
2388     r = guestfs_lvm_remove_all (g);
2389     if (r == -1)
2390       return -1;
2391   }
2392   {
2393     char *lines[] = {
2394       ",",
2395       NULL
2396     };
2397     int r;
2398     suppress_error = 0;
2399     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2400     if (r == -1)
2401       return -1;
2402   }
2403   {
2404     int r;
2405     suppress_error = 0;
2406     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2407     if (r == -1)
2408       return -1;
2409   }
2410   {
2411     int r;
2412     suppress_error = 0;
2413     r = guestfs_mount (g, "/dev/sda1", "/");
2414     if (r == -1)
2415       return -1;
2416   }
2417   /* TestOutput for checksum (5) */
2418   {
2419     int r;
2420     suppress_error = 0;
2421     r = guestfs_write_file (g, "/new", "test\n", 0);
2422     if (r == -1)
2423       return -1;
2424   }
2425   {
2426     char *r;
2427     suppress_error = 0;
2428     r = guestfs_checksum (g, "sha256", "/new");
2429     if (r == NULL)
2430       return -1;
2431     if (strcmp (r, "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2") != 0) {
2432       fprintf (stderr, "test_checksum_5: expected \"f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2\" but got \"%s\"\n", r);
2433       return -1;
2434     }
2435     free (r);
2436   }
2437   return 0;
2438 }
2439
2440 static int test_checksum_6 (void)
2441 {
2442   /* InitBasicFS for checksum (6): create ext2 on /dev/sda1 */
2443   {
2444     int r;
2445     suppress_error = 0;
2446     r = guestfs_umount_all (g);
2447     if (r == -1)
2448       return -1;
2449   }
2450   {
2451     int r;
2452     suppress_error = 0;
2453     r = guestfs_lvm_remove_all (g);
2454     if (r == -1)
2455       return -1;
2456   }
2457   {
2458     char *lines[] = {
2459       ",",
2460       NULL
2461     };
2462     int r;
2463     suppress_error = 0;
2464     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2465     if (r == -1)
2466       return -1;
2467   }
2468   {
2469     int r;
2470     suppress_error = 0;
2471     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2472     if (r == -1)
2473       return -1;
2474   }
2475   {
2476     int r;
2477     suppress_error = 0;
2478     r = guestfs_mount (g, "/dev/sda1", "/");
2479     if (r == -1)
2480       return -1;
2481   }
2482   /* TestOutput for checksum (6) */
2483   {
2484     int r;
2485     suppress_error = 0;
2486     r = guestfs_write_file (g, "/new", "test\n", 0);
2487     if (r == -1)
2488       return -1;
2489   }
2490   {
2491     char *r;
2492     suppress_error = 0;
2493     r = guestfs_checksum (g, "sha384", "/new");
2494     if (r == NULL)
2495       return -1;
2496     if (strcmp (r, "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d") != 0) {
2497       fprintf (stderr, "test_checksum_6: expected \"109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d\" but got \"%s\"\n", r);
2498       return -1;
2499     }
2500     free (r);
2501   }
2502   return 0;
2503 }
2504
2505 static int test_checksum_7 (void)
2506 {
2507   /* InitBasicFS for checksum (7): create ext2 on /dev/sda1 */
2508   {
2509     int r;
2510     suppress_error = 0;
2511     r = guestfs_umount_all (g);
2512     if (r == -1)
2513       return -1;
2514   }
2515   {
2516     int r;
2517     suppress_error = 0;
2518     r = guestfs_lvm_remove_all (g);
2519     if (r == -1)
2520       return -1;
2521   }
2522   {
2523     char *lines[] = {
2524       ",",
2525       NULL
2526     };
2527     int r;
2528     suppress_error = 0;
2529     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2530     if (r == -1)
2531       return -1;
2532   }
2533   {
2534     int r;
2535     suppress_error = 0;
2536     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2537     if (r == -1)
2538       return -1;
2539   }
2540   {
2541     int r;
2542     suppress_error = 0;
2543     r = guestfs_mount (g, "/dev/sda1", "/");
2544     if (r == -1)
2545       return -1;
2546   }
2547   /* TestOutput for checksum (7) */
2548   {
2549     int r;
2550     suppress_error = 0;
2551     r = guestfs_write_file (g, "/new", "test\n", 0);
2552     if (r == -1)
2553       return -1;
2554   }
2555   {
2556     char *r;
2557     suppress_error = 0;
2558     r = guestfs_checksum (g, "sha512", "/new");
2559     if (r == NULL)
2560       return -1;
2561     if (strcmp (r, "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123") != 0) {
2562       fprintf (stderr, "test_checksum_7: expected \"0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123\" but got \"%s\"\n", r);
2563       return -1;
2564     }
2565     free (r);
2566   }
2567   return 0;
2568 }
2569
2570 static int test_download_0 (void)
2571 {
2572   /* InitBasicFS for download (0): create ext2 on /dev/sda1 */
2573   {
2574     int r;
2575     suppress_error = 0;
2576     r = guestfs_umount_all (g);
2577     if (r == -1)
2578       return -1;
2579   }
2580   {
2581     int r;
2582     suppress_error = 0;
2583     r = guestfs_lvm_remove_all (g);
2584     if (r == -1)
2585       return -1;
2586   }
2587   {
2588     char *lines[] = {
2589       ",",
2590       NULL
2591     };
2592     int r;
2593     suppress_error = 0;
2594     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2595     if (r == -1)
2596       return -1;
2597   }
2598   {
2599     int r;
2600     suppress_error = 0;
2601     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2602     if (r == -1)
2603       return -1;
2604   }
2605   {
2606     int r;
2607     suppress_error = 0;
2608     r = guestfs_mount (g, "/dev/sda1", "/");
2609     if (r == -1)
2610       return -1;
2611   }
2612   /* TestOutput for download (0) */
2613   {
2614     int r;
2615     suppress_error = 0;
2616     r = guestfs_upload (g, "COPYING.LIB", "/COPYING.LIB");
2617     if (r == -1)
2618       return -1;
2619   }
2620   {
2621     int r;
2622     suppress_error = 0;
2623     r = guestfs_download (g, "/COPYING.LIB", "testdownload.tmp");
2624     if (r == -1)
2625       return -1;
2626   }
2627   {
2628     int r;
2629     suppress_error = 0;
2630     r = guestfs_upload (g, "testdownload.tmp", "/upload");
2631     if (r == -1)
2632       return -1;
2633   }
2634   {
2635     char *r;
2636     suppress_error = 0;
2637     r = guestfs_checksum (g, "md5", "/upload");
2638     if (r == NULL)
2639       return -1;
2640     if (strcmp (r, "e3eda01d9815f8d24aae2dbd89b68b06") != 0) {
2641       fprintf (stderr, "test_download_0: expected \"e3eda01d9815f8d24aae2dbd89b68b06\" but got \"%s\"\n", r);
2642       return -1;
2643     }
2644     free (r);
2645   }
2646   return 0;
2647 }
2648
2649 static int test_upload_0 (void)
2650 {
2651   /* InitBasicFS for upload (0): create ext2 on /dev/sda1 */
2652   {
2653     int r;
2654     suppress_error = 0;
2655     r = guestfs_umount_all (g);
2656     if (r == -1)
2657       return -1;
2658   }
2659   {
2660     int r;
2661     suppress_error = 0;
2662     r = guestfs_lvm_remove_all (g);
2663     if (r == -1)
2664       return -1;
2665   }
2666   {
2667     char *lines[] = {
2668       ",",
2669       NULL
2670     };
2671     int r;
2672     suppress_error = 0;
2673     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2674     if (r == -1)
2675       return -1;
2676   }
2677   {
2678     int r;
2679     suppress_error = 0;
2680     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2681     if (r == -1)
2682       return -1;
2683   }
2684   {
2685     int r;
2686     suppress_error = 0;
2687     r = guestfs_mount (g, "/dev/sda1", "/");
2688     if (r == -1)
2689       return -1;
2690   }
2691   /* TestOutput for upload (0) */
2692   {
2693     int r;
2694     suppress_error = 0;
2695     r = guestfs_upload (g, "COPYING.LIB", "/COPYING.LIB");
2696     if (r == -1)
2697       return -1;
2698   }
2699   {
2700     char *r;
2701     suppress_error = 0;
2702     r = guestfs_checksum (g, "md5", "/COPYING.LIB");
2703     if (r == NULL)
2704       return -1;
2705     if (strcmp (r, "e3eda01d9815f8d24aae2dbd89b68b06") != 0) {
2706       fprintf (stderr, "test_upload_0: expected \"e3eda01d9815f8d24aae2dbd89b68b06\" but got \"%s\"\n", r);
2707       return -1;
2708     }
2709     free (r);
2710   }
2711   return 0;
2712 }
2713
2714 static int test_blockdev_rereadpt_0 (void)
2715 {
2716   /* InitEmpty for blockdev_rereadpt (0) */
2717   {
2718     int r;
2719     suppress_error = 0;
2720     r = guestfs_umount_all (g);
2721     if (r == -1)
2722       return -1;
2723   }
2724   {
2725     int r;
2726     suppress_error = 0;
2727     r = guestfs_lvm_remove_all (g);
2728     if (r == -1)
2729       return -1;
2730   }
2731   /* TestRun for blockdev_rereadpt (0) */
2732   {
2733     int r;
2734     suppress_error = 0;
2735     r = guestfs_blockdev_rereadpt (g, "/dev/sda");
2736     if (r == -1)
2737       return -1;
2738   }
2739   return 0;
2740 }
2741
2742 static int test_blockdev_flushbufs_0 (void)
2743 {
2744   /* InitEmpty for blockdev_flushbufs (0) */
2745   {
2746     int r;
2747     suppress_error = 0;
2748     r = guestfs_umount_all (g);
2749     if (r == -1)
2750       return -1;
2751   }
2752   {
2753     int r;
2754     suppress_error = 0;
2755     r = guestfs_lvm_remove_all (g);
2756     if (r == -1)
2757       return -1;
2758   }
2759   /* TestRun for blockdev_flushbufs (0) */
2760   {
2761     int r;
2762     suppress_error = 0;
2763     r = guestfs_blockdev_flushbufs (g, "/dev/sda");
2764     if (r == -1)
2765       return -1;
2766   }
2767   return 0;
2768 }
2769
2770 static int test_blockdev_getsize64_0 (void)
2771 {
2772   /* InitEmpty for blockdev_getsize64 (0) */
2773   {
2774     int r;
2775     suppress_error = 0;
2776     r = guestfs_umount_all (g);
2777     if (r == -1)
2778       return -1;
2779   }
2780   {
2781     int r;
2782     suppress_error = 0;
2783     r = guestfs_lvm_remove_all (g);
2784     if (r == -1)
2785       return -1;
2786   }
2787   /* TestOutputInt for blockdev_getsize64 (0) */
2788   {
2789     int64_t r;
2790     suppress_error = 0;
2791     r = guestfs_blockdev_getsize64 (g, "/dev/sda");
2792     if (r == -1)
2793       return -1;
2794     if (r != 524288000) {
2795       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
2796       return -1;
2797     }
2798   }
2799   return 0;
2800 }
2801
2802 static int test_blockdev_getsz_0 (void)
2803 {
2804   /* InitEmpty for blockdev_getsz (0) */
2805   {
2806     int r;
2807     suppress_error = 0;
2808     r = guestfs_umount_all (g);
2809     if (r == -1)
2810       return -1;
2811   }
2812   {
2813     int r;
2814     suppress_error = 0;
2815     r = guestfs_lvm_remove_all (g);
2816     if (r == -1)
2817       return -1;
2818   }
2819   /* TestOutputInt for blockdev_getsz (0) */
2820   {
2821     int64_t r;
2822     suppress_error = 0;
2823     r = guestfs_blockdev_getsz (g, "/dev/sda");
2824     if (r == -1)
2825       return -1;
2826     if (r != 1024000) {
2827       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
2828       return -1;
2829     }
2830   }
2831   return 0;
2832 }
2833
2834 static int test_blockdev_getbsz_0 (void)
2835 {
2836   /* InitEmpty for blockdev_getbsz (0) */
2837   {
2838     int r;
2839     suppress_error = 0;
2840     r = guestfs_umount_all (g);
2841     if (r == -1)
2842       return -1;
2843   }
2844   {
2845     int r;
2846     suppress_error = 0;
2847     r = guestfs_lvm_remove_all (g);
2848     if (r == -1)
2849       return -1;
2850   }
2851   /* TestOutputInt for blockdev_getbsz (0) */
2852   {
2853     int r;
2854     suppress_error = 0;
2855     r = guestfs_blockdev_getbsz (g, "/dev/sda");
2856     if (r == -1)
2857       return -1;
2858     if (r != 4096) {
2859       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
2860       return -1;
2861     }
2862   }
2863   return 0;
2864 }
2865
2866 static int test_blockdev_getss_0 (void)
2867 {
2868   /* InitEmpty for blockdev_getss (0) */
2869   {
2870     int r;
2871     suppress_error = 0;
2872     r = guestfs_umount_all (g);
2873     if (r == -1)
2874       return -1;
2875   }
2876   {
2877     int r;
2878     suppress_error = 0;
2879     r = guestfs_lvm_remove_all (g);
2880     if (r == -1)
2881       return -1;
2882   }
2883   /* TestOutputInt for blockdev_getss (0) */
2884   {
2885     int r;
2886     suppress_error = 0;
2887     r = guestfs_blockdev_getss (g, "/dev/sda");
2888     if (r == -1)
2889       return -1;
2890     if (r != 512) {
2891       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
2892       return -1;
2893     }
2894   }
2895   return 0;
2896 }
2897
2898 static int test_blockdev_getro_0 (void)
2899 {
2900   /* InitEmpty for blockdev_getro (0) */
2901   {
2902     int r;
2903     suppress_error = 0;
2904     r = guestfs_umount_all (g);
2905     if (r == -1)
2906       return -1;
2907   }
2908   {
2909     int r;
2910     suppress_error = 0;
2911     r = guestfs_lvm_remove_all (g);
2912     if (r == -1)
2913       return -1;
2914   }
2915   /* TestOutputTrue for blockdev_getro (0) */
2916   {
2917     int r;
2918     suppress_error = 0;
2919     r = guestfs_blockdev_setro (g, "/dev/sda");
2920     if (r == -1)
2921       return -1;
2922   }
2923   {
2924     int r;
2925     suppress_error = 0;
2926     r = guestfs_blockdev_getro (g, "/dev/sda");
2927     if (r == -1)
2928       return -1;
2929     if (!r) {
2930       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
2931       return -1;
2932     }
2933   }
2934   return 0;
2935 }
2936
2937 static int test_blockdev_setrw_0 (void)
2938 {
2939   /* InitEmpty for blockdev_setrw (0) */
2940   {
2941     int r;
2942     suppress_error = 0;
2943     r = guestfs_umount_all (g);
2944     if (r == -1)
2945       return -1;
2946   }
2947   {
2948     int r;
2949     suppress_error = 0;
2950     r = guestfs_lvm_remove_all (g);
2951     if (r == -1)
2952       return -1;
2953   }
2954   /* TestOutputFalse for blockdev_setrw (0) */
2955   {
2956     int r;
2957     suppress_error = 0;
2958     r = guestfs_blockdev_setrw (g, "/dev/sda");
2959     if (r == -1)
2960       return -1;
2961   }
2962   {
2963     int r;
2964     suppress_error = 0;
2965     r = guestfs_blockdev_getro (g, "/dev/sda");
2966     if (r == -1)
2967       return -1;
2968     if (r) {
2969       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
2970       return -1;
2971     }
2972   }
2973   return 0;
2974 }
2975
2976 static int test_blockdev_setro_0 (void)
2977 {
2978   /* InitEmpty for blockdev_setro (0) */
2979   {
2980     int r;
2981     suppress_error = 0;
2982     r = guestfs_umount_all (g);
2983     if (r == -1)
2984       return -1;
2985   }
2986   {
2987     int r;
2988     suppress_error = 0;
2989     r = guestfs_lvm_remove_all (g);
2990     if (r == -1)
2991       return -1;
2992   }
2993   /* TestOutputTrue for blockdev_setro (0) */
2994   {
2995     int r;
2996     suppress_error = 0;
2997     r = guestfs_blockdev_setro (g, "/dev/sda");
2998     if (r == -1)
2999       return -1;
3000   }
3001   {
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_blockdev_getro (g, "/dev/sda");
3005     if (r == -1)
3006       return -1;
3007     if (!r) {
3008       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
3009       return -1;
3010     }
3011   }
3012   return 0;
3013 }
3014
3015 static int test_statvfs_0 (void)
3016 {
3017   /* InitBasicFS for statvfs (0): create ext2 on /dev/sda1 */
3018   {
3019     int r;
3020     suppress_error = 0;
3021     r = guestfs_umount_all (g);
3022     if (r == -1)
3023       return -1;
3024   }
3025   {
3026     int r;
3027     suppress_error = 0;
3028     r = guestfs_lvm_remove_all (g);
3029     if (r == -1)
3030       return -1;
3031   }
3032   {
3033     char *lines[] = {
3034       ",",
3035       NULL
3036     };
3037     int r;
3038     suppress_error = 0;
3039     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3040     if (r == -1)
3041       return -1;
3042   }
3043   {
3044     int r;
3045     suppress_error = 0;
3046     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3047     if (r == -1)
3048       return -1;
3049   }
3050   {
3051     int r;
3052     suppress_error = 0;
3053     r = guestfs_mount (g, "/dev/sda1", "/");
3054     if (r == -1)
3055       return -1;
3056   }
3057   /* TestOutputStruct for statvfs (0) */
3058   {
3059     struct guestfs_statvfs *r;
3060     suppress_error = 0;
3061     r = guestfs_statvfs (g, "/");
3062     if (r == NULL)
3063       return -1;
3064     if (r->bfree != 487702) {
3065       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
3066                (int) r->bfree);
3067       return -1;
3068     }
3069     if (r->blocks != 490020) {
3070       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
3071                (int) r->blocks);
3072       return -1;
3073     }
3074     if (r->bsize != 1024) {
3075       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
3076                (int) r->bsize);
3077       return -1;
3078     }
3079     free (r);
3080   }
3081   return 0;
3082 }
3083
3084 static int test_lstat_0 (void)
3085 {
3086   /* InitBasicFS for lstat (0): create ext2 on /dev/sda1 */
3087   {
3088     int r;
3089     suppress_error = 0;
3090     r = guestfs_umount_all (g);
3091     if (r == -1)
3092       return -1;
3093   }
3094   {
3095     int r;
3096     suppress_error = 0;
3097     r = guestfs_lvm_remove_all (g);
3098     if (r == -1)
3099       return -1;
3100   }
3101   {
3102     char *lines[] = {
3103       ",",
3104       NULL
3105     };
3106     int r;
3107     suppress_error = 0;
3108     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3109     if (r == -1)
3110       return -1;
3111   }
3112   {
3113     int r;
3114     suppress_error = 0;
3115     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3116     if (r == -1)
3117       return -1;
3118   }
3119   {
3120     int r;
3121     suppress_error = 0;
3122     r = guestfs_mount (g, "/dev/sda1", "/");
3123     if (r == -1)
3124       return -1;
3125   }
3126   /* TestOutputStruct for lstat (0) */
3127   {
3128     int r;
3129     suppress_error = 0;
3130     r = guestfs_touch (g, "/new");
3131     if (r == -1)
3132       return -1;
3133   }
3134   {
3135     struct guestfs_stat *r;
3136     suppress_error = 0;
3137     r = guestfs_lstat (g, "/new");
3138     if (r == NULL)
3139       return -1;
3140     if (r->size != 0) {
3141       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
3142                (int) r->size);
3143       return -1;
3144     }
3145     free (r);
3146   }
3147   return 0;
3148 }
3149
3150 static int test_stat_0 (void)
3151 {
3152   /* InitBasicFS for stat (0): create ext2 on /dev/sda1 */
3153   {
3154     int r;
3155     suppress_error = 0;
3156     r = guestfs_umount_all (g);
3157     if (r == -1)
3158       return -1;
3159   }
3160   {
3161     int r;
3162     suppress_error = 0;
3163     r = guestfs_lvm_remove_all (g);
3164     if (r == -1)
3165       return -1;
3166   }
3167   {
3168     char *lines[] = {
3169       ",",
3170       NULL
3171     };
3172     int r;
3173     suppress_error = 0;
3174     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3175     if (r == -1)
3176       return -1;
3177   }
3178   {
3179     int r;
3180     suppress_error = 0;
3181     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3182     if (r == -1)
3183       return -1;
3184   }
3185   {
3186     int r;
3187     suppress_error = 0;
3188     r = guestfs_mount (g, "/dev/sda1", "/");
3189     if (r == -1)
3190       return -1;
3191   }
3192   /* TestOutputStruct for stat (0) */
3193   {
3194     int r;
3195     suppress_error = 0;
3196     r = guestfs_touch (g, "/new");
3197     if (r == -1)
3198       return -1;
3199   }
3200   {
3201     struct guestfs_stat *r;
3202     suppress_error = 0;
3203     r = guestfs_stat (g, "/new");
3204     if (r == NULL)
3205       return -1;
3206     if (r->size != 0) {
3207       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
3208                (int) r->size);
3209       return -1;
3210     }
3211     free (r);
3212   }
3213   return 0;
3214 }
3215
3216 static int test_file_0 (void)
3217 {
3218   /* InitBasicFS for file (0): create ext2 on /dev/sda1 */
3219   {
3220     int r;
3221     suppress_error = 0;
3222     r = guestfs_umount_all (g);
3223     if (r == -1)
3224       return -1;
3225   }
3226   {
3227     int r;
3228     suppress_error = 0;
3229     r = guestfs_lvm_remove_all (g);
3230     if (r == -1)
3231       return -1;
3232   }
3233   {
3234     char *lines[] = {
3235       ",",
3236       NULL
3237     };
3238     int r;
3239     suppress_error = 0;
3240     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3241     if (r == -1)
3242       return -1;
3243   }
3244   {
3245     int r;
3246     suppress_error = 0;
3247     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3248     if (r == -1)
3249       return -1;
3250   }
3251   {
3252     int r;
3253     suppress_error = 0;
3254     r = guestfs_mount (g, "/dev/sda1", "/");
3255     if (r == -1)
3256       return -1;
3257   }
3258   /* TestOutput for file (0) */
3259   {
3260     int r;
3261     suppress_error = 0;
3262     r = guestfs_touch (g, "/new");
3263     if (r == -1)
3264       return -1;
3265   }
3266   {
3267     char *r;
3268     suppress_error = 0;
3269     r = guestfs_file (g, "/new");
3270     if (r == NULL)
3271       return -1;
3272     if (strcmp (r, "empty") != 0) {
3273       fprintf (stderr, "test_file_0: expected \"empty\" but got \"%s\"\n", r);
3274       return -1;
3275     }
3276     free (r);
3277   }
3278   return 0;
3279 }
3280
3281 static int test_file_1 (void)
3282 {
3283   /* InitBasicFS for file (1): create ext2 on /dev/sda1 */
3284   {
3285     int r;
3286     suppress_error = 0;
3287     r = guestfs_umount_all (g);
3288     if (r == -1)
3289       return -1;
3290   }
3291   {
3292     int r;
3293     suppress_error = 0;
3294     r = guestfs_lvm_remove_all (g);
3295     if (r == -1)
3296       return -1;
3297   }
3298   {
3299     char *lines[] = {
3300       ",",
3301       NULL
3302     };
3303     int r;
3304     suppress_error = 0;
3305     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3306     if (r == -1)
3307       return -1;
3308   }
3309   {
3310     int r;
3311     suppress_error = 0;
3312     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3313     if (r == -1)
3314       return -1;
3315   }
3316   {
3317     int r;
3318     suppress_error = 0;
3319     r = guestfs_mount (g, "/dev/sda1", "/");
3320     if (r == -1)
3321       return -1;
3322   }
3323   /* TestOutput for file (1) */
3324   {
3325     int r;
3326     suppress_error = 0;
3327     r = guestfs_write_file (g, "/new", "some content\n", 0);
3328     if (r == -1)
3329       return -1;
3330   }
3331   {
3332     char *r;
3333     suppress_error = 0;
3334     r = guestfs_file (g, "/new");
3335     if (r == NULL)
3336       return -1;
3337     if (strcmp (r, "ASCII text") != 0) {
3338       fprintf (stderr, "test_file_1: expected \"ASCII text\" but got \"%s\"\n", r);
3339       return -1;
3340     }
3341     free (r);
3342   }
3343   return 0;
3344 }
3345
3346 static int test_file_2 (void)
3347 {
3348   /* InitBasicFS for file (2): create ext2 on /dev/sda1 */
3349   {
3350     int r;
3351     suppress_error = 0;
3352     r = guestfs_umount_all (g);
3353     if (r == -1)
3354       return -1;
3355   }
3356   {
3357     int r;
3358     suppress_error = 0;
3359     r = guestfs_lvm_remove_all (g);
3360     if (r == -1)
3361       return -1;
3362   }
3363   {
3364     char *lines[] = {
3365       ",",
3366       NULL
3367     };
3368     int r;
3369     suppress_error = 0;
3370     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3371     if (r == -1)
3372       return -1;
3373   }
3374   {
3375     int r;
3376     suppress_error = 0;
3377     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3378     if (r == -1)
3379       return -1;
3380   }
3381   {
3382     int r;
3383     suppress_error = 0;
3384     r = guestfs_mount (g, "/dev/sda1", "/");
3385     if (r == -1)
3386       return -1;
3387   }
3388   /* TestLastFail for file (2) */
3389   {
3390     char *r;
3391     suppress_error = 1;
3392     r = guestfs_file (g, "/nofile");
3393     if (r != NULL)
3394       return -1;
3395     free (r);
3396   }
3397   return 0;
3398 }
3399
3400 static int test_umount_all_0 (void)
3401 {
3402   /* InitBasicFS for umount_all (0): create ext2 on /dev/sda1 */
3403   {
3404     int r;
3405     suppress_error = 0;
3406     r = guestfs_umount_all (g);
3407     if (r == -1)
3408       return -1;
3409   }
3410   {
3411     int r;
3412     suppress_error = 0;
3413     r = guestfs_lvm_remove_all (g);
3414     if (r == -1)
3415       return -1;
3416   }
3417   {
3418     char *lines[] = {
3419       ",",
3420       NULL
3421     };
3422     int r;
3423     suppress_error = 0;
3424     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3425     if (r == -1)
3426       return -1;
3427   }
3428   {
3429     int r;
3430     suppress_error = 0;
3431     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3432     if (r == -1)
3433       return -1;
3434   }
3435   {
3436     int r;
3437     suppress_error = 0;
3438     r = guestfs_mount (g, "/dev/sda1", "/");
3439     if (r == -1)
3440       return -1;
3441   }
3442   /* TestOutputList for umount_all (0) */
3443   {
3444     int r;
3445     suppress_error = 0;
3446     r = guestfs_umount_all (g);
3447     if (r == -1)
3448       return -1;
3449   }
3450   {
3451     char **r;
3452     int i;
3453     suppress_error = 0;
3454     r = guestfs_mounts (g);
3455     if (r == NULL)
3456       return -1;
3457     if (r[0] != NULL) {
3458       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
3459       print_strings (r);
3460       return -1;
3461     }
3462     for (i = 0; r[i] != NULL; ++i)
3463       free (r[i]);
3464     free (r);
3465   }
3466   return 0;
3467 }
3468
3469 static int test_umount_all_1 (void)
3470 {
3471   /* InitEmpty for umount_all (1) */
3472   {
3473     int r;
3474     suppress_error = 0;
3475     r = guestfs_umount_all (g);
3476     if (r == -1)
3477       return -1;
3478   }
3479   {
3480     int r;
3481     suppress_error = 0;
3482     r = guestfs_lvm_remove_all (g);
3483     if (r == -1)
3484       return -1;
3485   }
3486   /* TestOutputList for umount_all (1) */
3487   {
3488     char *lines[] = {
3489       ",10",
3490       ",20",
3491       ",",
3492       NULL
3493     };
3494     int r;
3495     suppress_error = 0;
3496     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3497     if (r == -1)
3498       return -1;
3499   }
3500   {
3501     int r;
3502     suppress_error = 0;
3503     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3504     if (r == -1)
3505       return -1;
3506   }
3507   {
3508     int r;
3509     suppress_error = 0;
3510     r = guestfs_mkfs (g, "ext2", "/dev/sda2");
3511     if (r == -1)
3512       return -1;
3513   }
3514   {
3515     int r;
3516     suppress_error = 0;
3517     r = guestfs_mkfs (g, "ext2", "/dev/sda3");
3518     if (r == -1)
3519       return -1;
3520   }
3521   {
3522     int r;
3523     suppress_error = 0;
3524     r = guestfs_mount (g, "/dev/sda1", "/");
3525     if (r == -1)
3526       return -1;
3527   }
3528   {
3529     int r;
3530     suppress_error = 0;
3531     r = guestfs_mkdir (g, "/mp1");
3532     if (r == -1)
3533       return -1;
3534   }
3535   {
3536     int r;
3537     suppress_error = 0;
3538     r = guestfs_mount (g, "/dev/sda2", "/mp1");
3539     if (r == -1)
3540       return -1;
3541   }
3542   {
3543     int r;
3544     suppress_error = 0;
3545     r = guestfs_mkdir (g, "/mp1/mp2");
3546     if (r == -1)
3547       return -1;
3548   }
3549   {
3550     int r;
3551     suppress_error = 0;
3552     r = guestfs_mount (g, "/dev/sda3", "/mp1/mp2");
3553     if (r == -1)
3554       return -1;
3555   }
3556   {
3557     int r;
3558     suppress_error = 0;
3559     r = guestfs_mkdir (g, "/mp1/mp2/mp3");
3560     if (r == -1)
3561       return -1;
3562   }
3563   {
3564     int r;
3565     suppress_error = 0;
3566     r = guestfs_umount_all (g);
3567     if (r == -1)
3568       return -1;
3569   }
3570   {
3571     char **r;
3572     int i;
3573     suppress_error = 0;
3574     r = guestfs_mounts (g);
3575     if (r == NULL)
3576       return -1;
3577     if (r[0] != NULL) {
3578       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
3579       print_strings (r);
3580       return -1;
3581     }
3582     for (i = 0; r[i] != NULL; ++i)
3583       free (r[i]);
3584     free (r);
3585   }
3586   return 0;
3587 }
3588
3589 static int test_mounts_0 (void)
3590 {
3591   /* InitBasicFS for mounts (0): create ext2 on /dev/sda1 */
3592   {
3593     int r;
3594     suppress_error = 0;
3595     r = guestfs_umount_all (g);
3596     if (r == -1)
3597       return -1;
3598   }
3599   {
3600     int r;
3601     suppress_error = 0;
3602     r = guestfs_lvm_remove_all (g);
3603     if (r == -1)
3604       return -1;
3605   }
3606   {
3607     char *lines[] = {
3608       ",",
3609       NULL
3610     };
3611     int r;
3612     suppress_error = 0;
3613     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3614     if (r == -1)
3615       return -1;
3616   }
3617   {
3618     int r;
3619     suppress_error = 0;
3620     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3621     if (r == -1)
3622       return -1;
3623   }
3624   {
3625     int r;
3626     suppress_error = 0;
3627     r = guestfs_mount (g, "/dev/sda1", "/");
3628     if (r == -1)
3629       return -1;
3630   }
3631   /* TestOutputList for mounts (0) */
3632   {
3633     char **r;
3634     int i;
3635     suppress_error = 0;
3636     r = guestfs_mounts (g);
3637     if (r == NULL)
3638       return -1;
3639     if (!r[0]) {
3640       fprintf (stderr, "test_mounts_0: short list returned from command\n");
3641       print_strings (r);
3642       return -1;
3643     }
3644     if (strcmp (r[0], "/dev/sda1") != 0) {
3645       fprintf (stderr, "test_mounts_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
3646       return -1;
3647     }
3648     if (r[1] != NULL) {
3649       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
3650       print_strings (r);
3651       return -1;
3652     }
3653     for (i = 0; r[i] != NULL; ++i)
3654       free (r[i]);
3655     free (r);
3656   }
3657   return 0;
3658 }
3659
3660 static int test_umount_0 (void)
3661 {
3662   /* InitEmpty for umount (0) */
3663   {
3664     int r;
3665     suppress_error = 0;
3666     r = guestfs_umount_all (g);
3667     if (r == -1)
3668       return -1;
3669   }
3670   {
3671     int r;
3672     suppress_error = 0;
3673     r = guestfs_lvm_remove_all (g);
3674     if (r == -1)
3675       return -1;
3676   }
3677   /* TestOutputList for umount (0) */
3678   {
3679     char *lines[] = {
3680       ",",
3681       NULL
3682     };
3683     int r;
3684     suppress_error = 0;
3685     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3686     if (r == -1)
3687       return -1;
3688   }
3689   {
3690     int r;
3691     suppress_error = 0;
3692     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3693     if (r == -1)
3694       return -1;
3695   }
3696   {
3697     int r;
3698     suppress_error = 0;
3699     r = guestfs_mount (g, "/dev/sda1", "/");
3700     if (r == -1)
3701       return -1;
3702   }
3703   {
3704     char **r;
3705     int i;
3706     suppress_error = 0;
3707     r = guestfs_mounts (g);
3708     if (r == NULL)
3709       return -1;
3710     if (!r[0]) {
3711       fprintf (stderr, "test_umount_0: short list returned from command\n");
3712       print_strings (r);
3713       return -1;
3714     }
3715     if (strcmp (r[0], "/dev/sda1") != 0) {
3716       fprintf (stderr, "test_umount_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
3717       return -1;
3718     }
3719     if (r[1] != NULL) {
3720       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
3721       print_strings (r);
3722       return -1;
3723     }
3724     for (i = 0; r[i] != NULL; ++i)
3725       free (r[i]);
3726     free (r);
3727   }
3728   return 0;
3729 }
3730
3731 static int test_umount_1 (void)
3732 {
3733   /* InitEmpty for umount (1) */
3734   {
3735     int r;
3736     suppress_error = 0;
3737     r = guestfs_umount_all (g);
3738     if (r == -1)
3739       return -1;
3740   }
3741   {
3742     int r;
3743     suppress_error = 0;
3744     r = guestfs_lvm_remove_all (g);
3745     if (r == -1)
3746       return -1;
3747   }
3748   /* TestOutputList for umount (1) */
3749   {
3750     char *lines[] = {
3751       ",",
3752       NULL
3753     };
3754     int r;
3755     suppress_error = 0;
3756     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3757     if (r == -1)
3758       return -1;
3759   }
3760   {
3761     int r;
3762     suppress_error = 0;
3763     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3764     if (r == -1)
3765       return -1;
3766   }
3767   {
3768     int r;
3769     suppress_error = 0;
3770     r = guestfs_mount (g, "/dev/sda1", "/");
3771     if (r == -1)
3772       return -1;
3773   }
3774   {
3775     int r;
3776     suppress_error = 0;
3777     r = guestfs_umount (g, "/");
3778     if (r == -1)
3779       return -1;
3780   }
3781   {
3782     char **r;
3783     int i;
3784     suppress_error = 0;
3785     r = guestfs_mounts (g);
3786     if (r == NULL)
3787       return -1;
3788     if (r[0] != NULL) {
3789       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
3790       print_strings (r);
3791       return -1;
3792     }
3793     for (i = 0; r[i] != NULL; ++i)
3794       free (r[i]);
3795     free (r);
3796   }
3797   return 0;
3798 }
3799
3800 static int test_write_file_0 (void)
3801 {
3802   /* InitBasicFS for write_file (0): create ext2 on /dev/sda1 */
3803   {
3804     int r;
3805     suppress_error = 0;
3806     r = guestfs_umount_all (g);
3807     if (r == -1)
3808       return -1;
3809   }
3810   {
3811     int r;
3812     suppress_error = 0;
3813     r = guestfs_lvm_remove_all (g);
3814     if (r == -1)
3815       return -1;
3816   }
3817   {
3818     char *lines[] = {
3819       ",",
3820       NULL
3821     };
3822     int r;
3823     suppress_error = 0;
3824     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3825     if (r == -1)
3826       return -1;
3827   }
3828   {
3829     int r;
3830     suppress_error = 0;
3831     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3832     if (r == -1)
3833       return -1;
3834   }
3835   {
3836     int r;
3837     suppress_error = 0;
3838     r = guestfs_mount (g, "/dev/sda1", "/");
3839     if (r == -1)
3840       return -1;
3841   }
3842   /* TestOutput for write_file (0) */
3843   {
3844     int r;
3845     suppress_error = 0;
3846     r = guestfs_write_file (g, "/new", "new file contents", 0);
3847     if (r == -1)
3848       return -1;
3849   }
3850   {
3851     char *r;
3852     suppress_error = 0;
3853     r = guestfs_cat (g, "/new");
3854     if (r == NULL)
3855       return -1;
3856     if (strcmp (r, "new file contents") != 0) {
3857       fprintf (stderr, "test_write_file_0: expected \"new file contents\" but got \"%s\"\n", r);
3858       return -1;
3859     }
3860     free (r);
3861   }
3862   return 0;
3863 }
3864
3865 static int test_write_file_1 (void)
3866 {
3867   /* InitBasicFS for write_file (1): create ext2 on /dev/sda1 */
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 *lines[] = {
3884       ",",
3885       NULL
3886     };
3887     int r;
3888     suppress_error = 0;
3889     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3890     if (r == -1)
3891       return -1;
3892   }
3893   {
3894     int r;
3895     suppress_error = 0;
3896     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3897     if (r == -1)
3898       return -1;
3899   }
3900   {
3901     int r;
3902     suppress_error = 0;
3903     r = guestfs_mount (g, "/dev/sda1", "/");
3904     if (r == -1)
3905       return -1;
3906   }
3907   /* TestOutput for write_file (1) */
3908   {
3909     int r;
3910     suppress_error = 0;
3911     r = guestfs_write_file (g, "/new", "\nnew file contents\n", 0);
3912     if (r == -1)
3913       return -1;
3914   }
3915   {
3916     char *r;
3917     suppress_error = 0;
3918     r = guestfs_cat (g, "/new");
3919     if (r == NULL)
3920       return -1;
3921     if (strcmp (r, "\nnew file contents\n") != 0) {
3922       fprintf (stderr, "test_write_file_1: expected \"\nnew file contents\n\" but got \"%s\"\n", r);
3923       return -1;
3924     }
3925     free (r);
3926   }
3927   return 0;
3928 }
3929
3930 static int test_write_file_2 (void)
3931 {
3932   /* InitBasicFS for write_file (2): create ext2 on /dev/sda1 */
3933   {
3934     int r;
3935     suppress_error = 0;
3936     r = guestfs_umount_all (g);
3937     if (r == -1)
3938       return -1;
3939   }
3940   {
3941     int r;
3942     suppress_error = 0;
3943     r = guestfs_lvm_remove_all (g);
3944     if (r == -1)
3945       return -1;
3946   }
3947   {
3948     char *lines[] = {
3949       ",",
3950       NULL
3951     };
3952     int r;
3953     suppress_error = 0;
3954     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3955     if (r == -1)
3956       return -1;
3957   }
3958   {
3959     int r;
3960     suppress_error = 0;
3961     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3962     if (r == -1)
3963       return -1;
3964   }
3965   {
3966     int r;
3967     suppress_error = 0;
3968     r = guestfs_mount (g, "/dev/sda1", "/");
3969     if (r == -1)
3970       return -1;
3971   }
3972   /* TestOutput for write_file (2) */
3973   {
3974     int r;
3975     suppress_error = 0;
3976     r = guestfs_write_file (g, "/new", "\n\n", 0);
3977     if (r == -1)
3978       return -1;
3979   }
3980   {
3981     char *r;
3982     suppress_error = 0;
3983     r = guestfs_cat (g, "/new");
3984     if (r == NULL)
3985       return -1;
3986     if (strcmp (r, "\n\n") != 0) {
3987       fprintf (stderr, "test_write_file_2: expected \"\n\n\" but got \"%s\"\n", r);
3988       return -1;
3989     }
3990     free (r);
3991   }
3992   return 0;
3993 }
3994
3995 static int test_write_file_3 (void)
3996 {
3997   /* InitBasicFS for write_file (3): create ext2 on /dev/sda1 */
3998   {
3999     int r;
4000     suppress_error = 0;
4001     r = guestfs_umount_all (g);
4002     if (r == -1)
4003       return -1;
4004   }
4005   {
4006     int r;
4007     suppress_error = 0;
4008     r = guestfs_lvm_remove_all (g);
4009     if (r == -1)
4010       return -1;
4011   }
4012   {
4013     char *lines[] = {
4014       ",",
4015       NULL
4016     };
4017     int r;
4018     suppress_error = 0;
4019     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4020     if (r == -1)
4021       return -1;
4022   }
4023   {
4024     int r;
4025     suppress_error = 0;
4026     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4027     if (r == -1)
4028       return -1;
4029   }
4030   {
4031     int r;
4032     suppress_error = 0;
4033     r = guestfs_mount (g, "/dev/sda1", "/");
4034     if (r == -1)
4035       return -1;
4036   }
4037   /* TestOutput for write_file (3) */
4038   {
4039     int r;
4040     suppress_error = 0;
4041     r = guestfs_write_file (g, "/new", "", 0);
4042     if (r == -1)
4043       return -1;
4044   }
4045   {
4046     char *r;
4047     suppress_error = 0;
4048     r = guestfs_cat (g, "/new");
4049     if (r == NULL)
4050       return -1;
4051     if (strcmp (r, "") != 0) {
4052       fprintf (stderr, "test_write_file_3: expected \"\" but got \"%s\"\n", r);
4053       return -1;
4054     }
4055     free (r);
4056   }
4057   return 0;
4058 }
4059
4060 static int test_write_file_4 (void)
4061 {
4062   /* InitBasicFS for write_file (4): create ext2 on /dev/sda1 */
4063   {
4064     int r;
4065     suppress_error = 0;
4066     r = guestfs_umount_all (g);
4067     if (r == -1)
4068       return -1;
4069   }
4070   {
4071     int r;
4072     suppress_error = 0;
4073     r = guestfs_lvm_remove_all (g);
4074     if (r == -1)
4075       return -1;
4076   }
4077   {
4078     char *lines[] = {
4079       ",",
4080       NULL
4081     };
4082     int r;
4083     suppress_error = 0;
4084     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4085     if (r == -1)
4086       return -1;
4087   }
4088   {
4089     int r;
4090     suppress_error = 0;
4091     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4092     if (r == -1)
4093       return -1;
4094   }
4095   {
4096     int r;
4097     suppress_error = 0;
4098     r = guestfs_mount (g, "/dev/sda1", "/");
4099     if (r == -1)
4100       return -1;
4101   }
4102   /* TestOutput for write_file (4) */
4103   {
4104     int r;
4105     suppress_error = 0;
4106     r = guestfs_write_file (g, "/new", "\n\n\n", 0);
4107     if (r == -1)
4108       return -1;
4109   }
4110   {
4111     char *r;
4112     suppress_error = 0;
4113     r = guestfs_cat (g, "/new");
4114     if (r == NULL)
4115       return -1;
4116     if (strcmp (r, "\n\n\n") != 0) {
4117       fprintf (stderr, "test_write_file_4: expected \"\n\n\n\" but got \"%s\"\n", r);
4118       return -1;
4119     }
4120     free (r);
4121   }
4122   return 0;
4123 }
4124
4125 static int test_write_file_5 (void)
4126 {
4127   /* InitBasicFS for write_file (5): create ext2 on /dev/sda1 */
4128   {
4129     int r;
4130     suppress_error = 0;
4131     r = guestfs_umount_all (g);
4132     if (r == -1)
4133       return -1;
4134   }
4135   {
4136     int r;
4137     suppress_error = 0;
4138     r = guestfs_lvm_remove_all (g);
4139     if (r == -1)
4140       return -1;
4141   }
4142   {
4143     char *lines[] = {
4144       ",",
4145       NULL
4146     };
4147     int r;
4148     suppress_error = 0;
4149     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4150     if (r == -1)
4151       return -1;
4152   }
4153   {
4154     int r;
4155     suppress_error = 0;
4156     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4157     if (r == -1)
4158       return -1;
4159   }
4160   {
4161     int r;
4162     suppress_error = 0;
4163     r = guestfs_mount (g, "/dev/sda1", "/");
4164     if (r == -1)
4165       return -1;
4166   }
4167   /* TestOutput for write_file (5) */
4168   {
4169     int r;
4170     suppress_error = 0;
4171     r = guestfs_write_file (g, "/new", "\n", 0);
4172     if (r == -1)
4173       return -1;
4174   }
4175   {
4176     char *r;
4177     suppress_error = 0;
4178     r = guestfs_cat (g, "/new");
4179     if (r == NULL)
4180       return -1;
4181     if (strcmp (r, "\n") != 0) {
4182       fprintf (stderr, "test_write_file_5: expected \"\n\" but got \"%s\"\n", r);
4183       return -1;
4184     }
4185     free (r);
4186   }
4187   return 0;
4188 }
4189
4190 static int test_mkfs_0 (void)
4191 {
4192   /* InitEmpty for mkfs (0) */
4193   {
4194     int r;
4195     suppress_error = 0;
4196     r = guestfs_umount_all (g);
4197     if (r == -1)
4198       return -1;
4199   }
4200   {
4201     int r;
4202     suppress_error = 0;
4203     r = guestfs_lvm_remove_all (g);
4204     if (r == -1)
4205       return -1;
4206   }
4207   /* TestOutput for mkfs (0) */
4208   {
4209     char *lines[] = {
4210       ",",
4211       NULL
4212     };
4213     int r;
4214     suppress_error = 0;
4215     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4216     if (r == -1)
4217       return -1;
4218   }
4219   {
4220     int r;
4221     suppress_error = 0;
4222     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4223     if (r == -1)
4224       return -1;
4225   }
4226   {
4227     int r;
4228     suppress_error = 0;
4229     r = guestfs_mount (g, "/dev/sda1", "/");
4230     if (r == -1)
4231       return -1;
4232   }
4233   {
4234     int r;
4235     suppress_error = 0;
4236     r = guestfs_write_file (g, "/new", "new file contents", 0);
4237     if (r == -1)
4238       return -1;
4239   }
4240   {
4241     char *r;
4242     suppress_error = 0;
4243     r = guestfs_cat (g, "/new");
4244     if (r == NULL)
4245       return -1;
4246     if (strcmp (r, "new file contents") != 0) {
4247       fprintf (stderr, "test_mkfs_0: expected \"new file contents\" but got \"%s\"\n", r);
4248       return -1;
4249     }
4250     free (r);
4251   }
4252   return 0;
4253 }
4254
4255 static int test_lvcreate_0 (void)
4256 {
4257   /* InitEmpty for lvcreate (0) */
4258   {
4259     int r;
4260     suppress_error = 0;
4261     r = guestfs_umount_all (g);
4262     if (r == -1)
4263       return -1;
4264   }
4265   {
4266     int r;
4267     suppress_error = 0;
4268     r = guestfs_lvm_remove_all (g);
4269     if (r == -1)
4270       return -1;
4271   }
4272   /* TestOutputList for lvcreate (0) */
4273   {
4274     char *lines[] = {
4275       ",10",
4276       ",20",
4277       ",",
4278       NULL
4279     };
4280     int r;
4281     suppress_error = 0;
4282     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4283     if (r == -1)
4284       return -1;
4285   }
4286   {
4287     int r;
4288     suppress_error = 0;
4289     r = guestfs_pvcreate (g, "/dev/sda1");
4290     if (r == -1)
4291       return -1;
4292   }
4293   {
4294     int r;
4295     suppress_error = 0;
4296     r = guestfs_pvcreate (g, "/dev/sda2");
4297     if (r == -1)
4298       return -1;
4299   }
4300   {
4301     int r;
4302     suppress_error = 0;
4303     r = guestfs_pvcreate (g, "/dev/sda3");
4304     if (r == -1)
4305       return -1;
4306   }
4307   {
4308     char *physvols[] = {
4309       "/dev/sda1",
4310       "/dev/sda2",
4311       NULL
4312     };
4313     int r;
4314     suppress_error = 0;
4315     r = guestfs_vgcreate (g, "VG1", physvols);
4316     if (r == -1)
4317       return -1;
4318   }
4319   {
4320     char *physvols[] = {
4321       "/dev/sda3",
4322       NULL
4323     };
4324     int r;
4325     suppress_error = 0;
4326     r = guestfs_vgcreate (g, "VG2", physvols);
4327     if (r == -1)
4328       return -1;
4329   }
4330   {
4331     int r;
4332     suppress_error = 0;
4333     r = guestfs_lvcreate (g, "LV1", "VG1", 50);
4334     if (r == -1)
4335       return -1;
4336   }
4337   {
4338     int r;
4339     suppress_error = 0;
4340     r = guestfs_lvcreate (g, "LV2", "VG1", 50);
4341     if (r == -1)
4342       return -1;
4343   }
4344   {
4345     int r;
4346     suppress_error = 0;
4347     r = guestfs_lvcreate (g, "LV3", "VG2", 50);
4348     if (r == -1)
4349       return -1;
4350   }
4351   {
4352     int r;
4353     suppress_error = 0;
4354     r = guestfs_lvcreate (g, "LV4", "VG2", 50);
4355     if (r == -1)
4356       return -1;
4357   }
4358   {
4359     int r;
4360     suppress_error = 0;
4361     r = guestfs_lvcreate (g, "LV5", "VG2", 50);
4362     if (r == -1)
4363       return -1;
4364   }
4365   {
4366     char **r;
4367     int i;
4368     suppress_error = 0;
4369     r = guestfs_lvs (g);
4370     if (r == NULL)
4371       return -1;
4372     if (!r[0]) {
4373       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
4374       print_strings (r);
4375       return -1;
4376     }
4377     if (strcmp (r[0], "/dev/VG1/LV1") != 0) {
4378       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG1/LV1\" but got \"%s\"\n", r[0]);
4379       return -1;
4380     }
4381     if (!r[1]) {
4382       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
4383       print_strings (r);
4384       return -1;
4385     }
4386     if (strcmp (r[1], "/dev/VG1/LV2") != 0) {
4387       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG1/LV2\" but got \"%s\"\n", r[1]);
4388       return -1;
4389     }
4390     if (!r[2]) {
4391       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
4392       print_strings (r);
4393       return -1;
4394     }
4395     if (strcmp (r[2], "/dev/VG2/LV3") != 0) {
4396       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG2/LV3\" but got \"%s\"\n", r[2]);
4397       return -1;
4398     }
4399     if (!r[3]) {
4400       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
4401       print_strings (r);
4402       return -1;
4403     }
4404     if (strcmp (r[3], "/dev/VG2/LV4") != 0) {
4405       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG2/LV4\" but got \"%s\"\n", r[3]);
4406       return -1;
4407     }
4408     if (!r[4]) {
4409       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
4410       print_strings (r);
4411       return -1;
4412     }
4413     if (strcmp (r[4], "/dev/VG2/LV5") != 0) {
4414       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG2/LV5\" but got \"%s\"\n", r[4]);
4415       return -1;
4416     }
4417     if (r[5] != NULL) {
4418       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
4419       print_strings (r);
4420       return -1;
4421     }
4422     for (i = 0; r[i] != NULL; ++i)
4423       free (r[i]);
4424     free (r);
4425   }
4426   return 0;
4427 }
4428
4429 static int test_vgcreate_0 (void)
4430 {
4431   /* InitEmpty for vgcreate (0) */
4432   {
4433     int r;
4434     suppress_error = 0;
4435     r = guestfs_umount_all (g);
4436     if (r == -1)
4437       return -1;
4438   }
4439   {
4440     int r;
4441     suppress_error = 0;
4442     r = guestfs_lvm_remove_all (g);
4443     if (r == -1)
4444       return -1;
4445   }
4446   /* TestOutputList for vgcreate (0) */
4447   {
4448     char *lines[] = {
4449       ",10",
4450       ",20",
4451       ",",
4452       NULL
4453     };
4454     int r;
4455     suppress_error = 0;
4456     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4457     if (r == -1)
4458       return -1;
4459   }
4460   {
4461     int r;
4462     suppress_error = 0;
4463     r = guestfs_pvcreate (g, "/dev/sda1");
4464     if (r == -1)
4465       return -1;
4466   }
4467   {
4468     int r;
4469     suppress_error = 0;
4470     r = guestfs_pvcreate (g, "/dev/sda2");
4471     if (r == -1)
4472       return -1;
4473   }
4474   {
4475     int r;
4476     suppress_error = 0;
4477     r = guestfs_pvcreate (g, "/dev/sda3");
4478     if (r == -1)
4479       return -1;
4480   }
4481   {
4482     char *physvols[] = {
4483       "/dev/sda1",
4484       "/dev/sda2",
4485       NULL
4486     };
4487     int r;
4488     suppress_error = 0;
4489     r = guestfs_vgcreate (g, "VG1", physvols);
4490     if (r == -1)
4491       return -1;
4492   }
4493   {
4494     char *physvols[] = {
4495       "/dev/sda3",
4496       NULL
4497     };
4498     int r;
4499     suppress_error = 0;
4500     r = guestfs_vgcreate (g, "VG2", physvols);
4501     if (r == -1)
4502       return -1;
4503   }
4504   {
4505     char **r;
4506     int i;
4507     suppress_error = 0;
4508     r = guestfs_vgs (g);
4509     if (r == NULL)
4510       return -1;
4511     if (!r[0]) {
4512       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
4513       print_strings (r);
4514       return -1;
4515     }
4516     if (strcmp (r[0], "VG1") != 0) {
4517       fprintf (stderr, "test_vgcreate_0: expected \"VG1\" but got \"%s\"\n", r[0]);
4518       return -1;
4519     }
4520     if (!r[1]) {
4521       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
4522       print_strings (r);
4523       return -1;
4524     }
4525     if (strcmp (r[1], "VG2") != 0) {
4526       fprintf (stderr, "test_vgcreate_0: expected \"VG2\" but got \"%s\"\n", r[1]);
4527       return -1;
4528     }
4529     if (r[2] != NULL) {
4530       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
4531       print_strings (r);
4532       return -1;
4533     }
4534     for (i = 0; r[i] != NULL; ++i)
4535       free (r[i]);
4536     free (r);
4537   }
4538   return 0;
4539 }
4540
4541 static int test_pvcreate_0 (void)
4542 {
4543   /* InitEmpty for pvcreate (0) */
4544   {
4545     int r;
4546     suppress_error = 0;
4547     r = guestfs_umount_all (g);
4548     if (r == -1)
4549       return -1;
4550   }
4551   {
4552     int r;
4553     suppress_error = 0;
4554     r = guestfs_lvm_remove_all (g);
4555     if (r == -1)
4556       return -1;
4557   }
4558   /* TestOutputList for pvcreate (0) */
4559   {
4560     char *lines[] = {
4561       ",10",
4562       ",20",
4563       ",",
4564       NULL
4565     };
4566     int r;
4567     suppress_error = 0;
4568     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4569     if (r == -1)
4570       return -1;
4571   }
4572   {
4573     int r;
4574     suppress_error = 0;
4575     r = guestfs_pvcreate (g, "/dev/sda1");
4576     if (r == -1)
4577       return -1;
4578   }
4579   {
4580     int r;
4581     suppress_error = 0;
4582     r = guestfs_pvcreate (g, "/dev/sda2");
4583     if (r == -1)
4584       return -1;
4585   }
4586   {
4587     int r;
4588     suppress_error = 0;
4589     r = guestfs_pvcreate (g, "/dev/sda3");
4590     if (r == -1)
4591       return -1;
4592   }
4593   {
4594     char **r;
4595     int i;
4596     suppress_error = 0;
4597     r = guestfs_pvs (g);
4598     if (r == NULL)
4599       return -1;
4600     if (!r[0]) {
4601       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
4602       print_strings (r);
4603       return -1;
4604     }
4605     if (strcmp (r[0], "/dev/sda1") != 0) {
4606       fprintf (stderr, "test_pvcreate_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
4607       return -1;
4608     }
4609     if (!r[1]) {
4610       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
4611       print_strings (r);
4612       return -1;
4613     }
4614     if (strcmp (r[1], "/dev/sda2") != 0) {
4615       fprintf (stderr, "test_pvcreate_0: expected \"/dev/sda2\" but got \"%s\"\n", r[1]);
4616       return -1;
4617     }
4618     if (!r[2]) {
4619       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
4620       print_strings (r);
4621       return -1;
4622     }
4623     if (strcmp (r[2], "/dev/sda3") != 0) {
4624       fprintf (stderr, "test_pvcreate_0: expected \"/dev/sda3\" but got \"%s\"\n", r[2]);
4625       return -1;
4626     }
4627     if (r[3] != NULL) {
4628       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
4629       print_strings (r);
4630       return -1;
4631     }
4632     for (i = 0; r[i] != NULL; ++i)
4633       free (r[i]);
4634     free (r);
4635   }
4636   return 0;
4637 }
4638
4639 static int test_is_dir_0 (void)
4640 {
4641   /* InitBasicFS for is_dir (0): create ext2 on /dev/sda1 */
4642   {
4643     int r;
4644     suppress_error = 0;
4645     r = guestfs_umount_all (g);
4646     if (r == -1)
4647       return -1;
4648   }
4649   {
4650     int r;
4651     suppress_error = 0;
4652     r = guestfs_lvm_remove_all (g);
4653     if (r == -1)
4654       return -1;
4655   }
4656   {
4657     char *lines[] = {
4658       ",",
4659       NULL
4660     };
4661     int r;
4662     suppress_error = 0;
4663     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4664     if (r == -1)
4665       return -1;
4666   }
4667   {
4668     int r;
4669     suppress_error = 0;
4670     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4671     if (r == -1)
4672       return -1;
4673   }
4674   {
4675     int r;
4676     suppress_error = 0;
4677     r = guestfs_mount (g, "/dev/sda1", "/");
4678     if (r == -1)
4679       return -1;
4680   }
4681   /* TestOutputFalse for is_dir (0) */
4682   {
4683     int r;
4684     suppress_error = 0;
4685     r = guestfs_touch (g, "/new");
4686     if (r == -1)
4687       return -1;
4688   }
4689   {
4690     int r;
4691     suppress_error = 0;
4692     r = guestfs_is_dir (g, "/new");
4693     if (r == -1)
4694       return -1;
4695     if (r) {
4696       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
4697       return -1;
4698     }
4699   }
4700   return 0;
4701 }
4702
4703 static int test_is_dir_1 (void)
4704 {
4705   /* InitBasicFS for is_dir (1): create ext2 on /dev/sda1 */
4706   {
4707     int r;
4708     suppress_error = 0;
4709     r = guestfs_umount_all (g);
4710     if (r == -1)
4711       return -1;
4712   }
4713   {
4714     int r;
4715     suppress_error = 0;
4716     r = guestfs_lvm_remove_all (g);
4717     if (r == -1)
4718       return -1;
4719   }
4720   {
4721     char *lines[] = {
4722       ",",
4723       NULL
4724     };
4725     int r;
4726     suppress_error = 0;
4727     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4728     if (r == -1)
4729       return -1;
4730   }
4731   {
4732     int r;
4733     suppress_error = 0;
4734     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4735     if (r == -1)
4736       return -1;
4737   }
4738   {
4739     int r;
4740     suppress_error = 0;
4741     r = guestfs_mount (g, "/dev/sda1", "/");
4742     if (r == -1)
4743       return -1;
4744   }
4745   /* TestOutputTrue for is_dir (1) */
4746   {
4747     int r;
4748     suppress_error = 0;
4749     r = guestfs_mkdir (g, "/new");
4750     if (r == -1)
4751       return -1;
4752   }
4753   {
4754     int r;
4755     suppress_error = 0;
4756     r = guestfs_is_dir (g, "/new");
4757     if (r == -1)
4758       return -1;
4759     if (!r) {
4760       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
4761       return -1;
4762     }
4763   }
4764   return 0;
4765 }
4766
4767 static int test_is_file_0 (void)
4768 {
4769   /* InitBasicFS for is_file (0): create ext2 on /dev/sda1 */
4770   {
4771     int r;
4772     suppress_error = 0;
4773     r = guestfs_umount_all (g);
4774     if (r == -1)
4775       return -1;
4776   }
4777   {
4778     int r;
4779     suppress_error = 0;
4780     r = guestfs_lvm_remove_all (g);
4781     if (r == -1)
4782       return -1;
4783   }
4784   {
4785     char *lines[] = {
4786       ",",
4787       NULL
4788     };
4789     int r;
4790     suppress_error = 0;
4791     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4792     if (r == -1)
4793       return -1;
4794   }
4795   {
4796     int r;
4797     suppress_error = 0;
4798     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4799     if (r == -1)
4800       return -1;
4801   }
4802   {
4803     int r;
4804     suppress_error = 0;
4805     r = guestfs_mount (g, "/dev/sda1", "/");
4806     if (r == -1)
4807       return -1;
4808   }
4809   /* TestOutputTrue for is_file (0) */
4810   {
4811     int r;
4812     suppress_error = 0;
4813     r = guestfs_touch (g, "/new");
4814     if (r == -1)
4815       return -1;
4816   }
4817   {
4818     int r;
4819     suppress_error = 0;
4820     r = guestfs_is_file (g, "/new");
4821     if (r == -1)
4822       return -1;
4823     if (!r) {
4824       fprintf (stderr, "test_is_file_0: expected true, got false\n");
4825       return -1;
4826     }
4827   }
4828   return 0;
4829 }
4830
4831 static int test_is_file_1 (void)
4832 {
4833   /* InitBasicFS for is_file (1): create ext2 on /dev/sda1 */
4834   {
4835     int r;
4836     suppress_error = 0;
4837     r = guestfs_umount_all (g);
4838     if (r == -1)
4839       return -1;
4840   }
4841   {
4842     int r;
4843     suppress_error = 0;
4844     r = guestfs_lvm_remove_all (g);
4845     if (r == -1)
4846       return -1;
4847   }
4848   {
4849     char *lines[] = {
4850       ",",
4851       NULL
4852     };
4853     int r;
4854     suppress_error = 0;
4855     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4856     if (r == -1)
4857       return -1;
4858   }
4859   {
4860     int r;
4861     suppress_error = 0;
4862     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4863     if (r == -1)
4864       return -1;
4865   }
4866   {
4867     int r;
4868     suppress_error = 0;
4869     r = guestfs_mount (g, "/dev/sda1", "/");
4870     if (r == -1)
4871       return -1;
4872   }
4873   /* TestOutputFalse for is_file (1) */
4874   {
4875     int r;
4876     suppress_error = 0;
4877     r = guestfs_mkdir (g, "/new");
4878     if (r == -1)
4879       return -1;
4880   }
4881   {
4882     int r;
4883     suppress_error = 0;
4884     r = guestfs_is_file (g, "/new");
4885     if (r == -1)
4886       return -1;
4887     if (r) {
4888       fprintf (stderr, "test_is_file_1: expected false, got true\n");
4889       return -1;
4890     }
4891   }
4892   return 0;
4893 }
4894
4895 static int test_exists_0 (void)
4896 {
4897   /* InitBasicFS for exists (0): create ext2 on /dev/sda1 */
4898   {
4899     int r;
4900     suppress_error = 0;
4901     r = guestfs_umount_all (g);
4902     if (r == -1)
4903       return -1;
4904   }
4905   {
4906     int r;
4907     suppress_error = 0;
4908     r = guestfs_lvm_remove_all (g);
4909     if (r == -1)
4910       return -1;
4911   }
4912   {
4913     char *lines[] = {
4914       ",",
4915       NULL
4916     };
4917     int r;
4918     suppress_error = 0;
4919     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4920     if (r == -1)
4921       return -1;
4922   }
4923   {
4924     int r;
4925     suppress_error = 0;
4926     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4927     if (r == -1)
4928       return -1;
4929   }
4930   {
4931     int r;
4932     suppress_error = 0;
4933     r = guestfs_mount (g, "/dev/sda1", "/");
4934     if (r == -1)
4935       return -1;
4936   }
4937   /* TestOutputTrue for exists (0) */
4938   {
4939     int r;
4940     suppress_error = 0;
4941     r = guestfs_touch (g, "/new");
4942     if (r == -1)
4943       return -1;
4944   }
4945   {
4946     int r;
4947     suppress_error = 0;
4948     r = guestfs_exists (g, "/new");
4949     if (r == -1)
4950       return -1;
4951     if (!r) {
4952       fprintf (stderr, "test_exists_0: expected true, got false\n");
4953       return -1;
4954     }
4955   }
4956   return 0;
4957 }
4958
4959 static int test_exists_1 (void)
4960 {
4961   /* InitBasicFS for exists (1): create ext2 on /dev/sda1 */
4962   {
4963     int r;
4964     suppress_error = 0;
4965     r = guestfs_umount_all (g);
4966     if (r == -1)
4967       return -1;
4968   }
4969   {
4970     int r;
4971     suppress_error = 0;
4972     r = guestfs_lvm_remove_all (g);
4973     if (r == -1)
4974       return -1;
4975   }
4976   {
4977     char *lines[] = {
4978       ",",
4979       NULL
4980     };
4981     int r;
4982     suppress_error = 0;
4983     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
4984     if (r == -1)
4985       return -1;
4986   }
4987   {
4988     int r;
4989     suppress_error = 0;
4990     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
4991     if (r == -1)
4992       return -1;
4993   }
4994   {
4995     int r;
4996     suppress_error = 0;
4997     r = guestfs_mount (g, "/dev/sda1", "/");
4998     if (r == -1)
4999       return -1;
5000   }
5001   /* TestOutputTrue for exists (1) */
5002   {
5003     int r;
5004     suppress_error = 0;
5005     r = guestfs_mkdir (g, "/new");
5006     if (r == -1)
5007       return -1;
5008   }
5009   {
5010     int r;
5011     suppress_error = 0;
5012     r = guestfs_exists (g, "/new");
5013     if (r == -1)
5014       return -1;
5015     if (!r) {
5016       fprintf (stderr, "test_exists_1: expected true, got false\n");
5017       return -1;
5018     }
5019   }
5020   return 0;
5021 }
5022
5023 static int test_mkdir_p_0 (void)
5024 {
5025   /* InitBasicFS for mkdir_p (0): create ext2 on /dev/sda1 */
5026   {
5027     int r;
5028     suppress_error = 0;
5029     r = guestfs_umount_all (g);
5030     if (r == -1)
5031       return -1;
5032   }
5033   {
5034     int r;
5035     suppress_error = 0;
5036     r = guestfs_lvm_remove_all (g);
5037     if (r == -1)
5038       return -1;
5039   }
5040   {
5041     char *lines[] = {
5042       ",",
5043       NULL
5044     };
5045     int r;
5046     suppress_error = 0;
5047     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5048     if (r == -1)
5049       return -1;
5050   }
5051   {
5052     int r;
5053     suppress_error = 0;
5054     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5055     if (r == -1)
5056       return -1;
5057   }
5058   {
5059     int r;
5060     suppress_error = 0;
5061     r = guestfs_mount (g, "/dev/sda1", "/");
5062     if (r == -1)
5063       return -1;
5064   }
5065   /* TestOutputTrue for mkdir_p (0) */
5066   {
5067     int r;
5068     suppress_error = 0;
5069     r = guestfs_mkdir_p (g, "/new/foo/bar");
5070     if (r == -1)
5071       return -1;
5072   }
5073   {
5074     int r;
5075     suppress_error = 0;
5076     r = guestfs_is_dir (g, "/new/foo/bar");
5077     if (r == -1)
5078       return -1;
5079     if (!r) {
5080       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
5081       return -1;
5082     }
5083   }
5084   return 0;
5085 }
5086
5087 static int test_mkdir_p_1 (void)
5088 {
5089   /* InitBasicFS for mkdir_p (1): create ext2 on /dev/sda1 */
5090   {
5091     int r;
5092     suppress_error = 0;
5093     r = guestfs_umount_all (g);
5094     if (r == -1)
5095       return -1;
5096   }
5097   {
5098     int r;
5099     suppress_error = 0;
5100     r = guestfs_lvm_remove_all (g);
5101     if (r == -1)
5102       return -1;
5103   }
5104   {
5105     char *lines[] = {
5106       ",",
5107       NULL
5108     };
5109     int r;
5110     suppress_error = 0;
5111     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5112     if (r == -1)
5113       return -1;
5114   }
5115   {
5116     int r;
5117     suppress_error = 0;
5118     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5119     if (r == -1)
5120       return -1;
5121   }
5122   {
5123     int r;
5124     suppress_error = 0;
5125     r = guestfs_mount (g, "/dev/sda1", "/");
5126     if (r == -1)
5127       return -1;
5128   }
5129   /* TestOutputTrue for mkdir_p (1) */
5130   {
5131     int r;
5132     suppress_error = 0;
5133     r = guestfs_mkdir_p (g, "/new/foo/bar");
5134     if (r == -1)
5135       return -1;
5136   }
5137   {
5138     int r;
5139     suppress_error = 0;
5140     r = guestfs_is_dir (g, "/new/foo");
5141     if (r == -1)
5142       return -1;
5143     if (!r) {
5144       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
5145       return -1;
5146     }
5147   }
5148   return 0;
5149 }
5150
5151 static int test_mkdir_p_2 (void)
5152 {
5153   /* InitBasicFS for mkdir_p (2): create ext2 on /dev/sda1 */
5154   {
5155     int r;
5156     suppress_error = 0;
5157     r = guestfs_umount_all (g);
5158     if (r == -1)
5159       return -1;
5160   }
5161   {
5162     int r;
5163     suppress_error = 0;
5164     r = guestfs_lvm_remove_all (g);
5165     if (r == -1)
5166       return -1;
5167   }
5168   {
5169     char *lines[] = {
5170       ",",
5171       NULL
5172     };
5173     int r;
5174     suppress_error = 0;
5175     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5176     if (r == -1)
5177       return -1;
5178   }
5179   {
5180     int r;
5181     suppress_error = 0;
5182     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5183     if (r == -1)
5184       return -1;
5185   }
5186   {
5187     int r;
5188     suppress_error = 0;
5189     r = guestfs_mount (g, "/dev/sda1", "/");
5190     if (r == -1)
5191       return -1;
5192   }
5193   /* TestOutputTrue for mkdir_p (2) */
5194   {
5195     int r;
5196     suppress_error = 0;
5197     r = guestfs_mkdir_p (g, "/new/foo/bar");
5198     if (r == -1)
5199       return -1;
5200   }
5201   {
5202     int r;
5203     suppress_error = 0;
5204     r = guestfs_is_dir (g, "/new");
5205     if (r == -1)
5206       return -1;
5207     if (!r) {
5208       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
5209       return -1;
5210     }
5211   }
5212   return 0;
5213 }
5214
5215 static int test_mkdir_0 (void)
5216 {
5217   /* InitBasicFS for mkdir (0): create ext2 on /dev/sda1 */
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 *lines[] = {
5234       ",",
5235       NULL
5236     };
5237     int r;
5238     suppress_error = 0;
5239     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5240     if (r == -1)
5241       return -1;
5242   }
5243   {
5244     int r;
5245     suppress_error = 0;
5246     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5247     if (r == -1)
5248       return -1;
5249   }
5250   {
5251     int r;
5252     suppress_error = 0;
5253     r = guestfs_mount (g, "/dev/sda1", "/");
5254     if (r == -1)
5255       return -1;
5256   }
5257   /* TestOutputTrue for mkdir (0) */
5258   {
5259     int r;
5260     suppress_error = 0;
5261     r = guestfs_mkdir (g, "/new");
5262     if (r == -1)
5263       return -1;
5264   }
5265   {
5266     int r;
5267     suppress_error = 0;
5268     r = guestfs_is_dir (g, "/new");
5269     if (r == -1)
5270       return -1;
5271     if (!r) {
5272       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
5273       return -1;
5274     }
5275   }
5276   return 0;
5277 }
5278
5279 static int test_mkdir_1 (void)
5280 {
5281   /* InitBasicFS for mkdir (1): create ext2 on /dev/sda1 */
5282   {
5283     int r;
5284     suppress_error = 0;
5285     r = guestfs_umount_all (g);
5286     if (r == -1)
5287       return -1;
5288   }
5289   {
5290     int r;
5291     suppress_error = 0;
5292     r = guestfs_lvm_remove_all (g);
5293     if (r == -1)
5294       return -1;
5295   }
5296   {
5297     char *lines[] = {
5298       ",",
5299       NULL
5300     };
5301     int r;
5302     suppress_error = 0;
5303     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5304     if (r == -1)
5305       return -1;
5306   }
5307   {
5308     int r;
5309     suppress_error = 0;
5310     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5311     if (r == -1)
5312       return -1;
5313   }
5314   {
5315     int r;
5316     suppress_error = 0;
5317     r = guestfs_mount (g, "/dev/sda1", "/");
5318     if (r == -1)
5319       return -1;
5320   }
5321   /* TestLastFail for mkdir (1) */
5322   {
5323     int r;
5324     suppress_error = 1;
5325     r = guestfs_mkdir (g, "/new/foo/bar");
5326     if (r != -1)
5327       return -1;
5328   }
5329   return 0;
5330 }
5331
5332 static int test_rm_rf_0 (void)
5333 {
5334   /* InitBasicFS for rm_rf (0): create ext2 on /dev/sda1 */
5335   {
5336     int r;
5337     suppress_error = 0;
5338     r = guestfs_umount_all (g);
5339     if (r == -1)
5340       return -1;
5341   }
5342   {
5343     int r;
5344     suppress_error = 0;
5345     r = guestfs_lvm_remove_all (g);
5346     if (r == -1)
5347       return -1;
5348   }
5349   {
5350     char *lines[] = {
5351       ",",
5352       NULL
5353     };
5354     int r;
5355     suppress_error = 0;
5356     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5357     if (r == -1)
5358       return -1;
5359   }
5360   {
5361     int r;
5362     suppress_error = 0;
5363     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5364     if (r == -1)
5365       return -1;
5366   }
5367   {
5368     int r;
5369     suppress_error = 0;
5370     r = guestfs_mount (g, "/dev/sda1", "/");
5371     if (r == -1)
5372       return -1;
5373   }
5374   /* TestOutputFalse for rm_rf (0) */
5375   {
5376     int r;
5377     suppress_error = 0;
5378     r = guestfs_mkdir (g, "/new");
5379     if (r == -1)
5380       return -1;
5381   }
5382   {
5383     int r;
5384     suppress_error = 0;
5385     r = guestfs_mkdir (g, "/new/foo");
5386     if (r == -1)
5387       return -1;
5388   }
5389   {
5390     int r;
5391     suppress_error = 0;
5392     r = guestfs_touch (g, "/new/foo/bar");
5393     if (r == -1)
5394       return -1;
5395   }
5396   {
5397     int r;
5398     suppress_error = 0;
5399     r = guestfs_rm_rf (g, "/new");
5400     if (r == -1)
5401       return -1;
5402   }
5403   {
5404     int r;
5405     suppress_error = 0;
5406     r = guestfs_exists (g, "/new");
5407     if (r == -1)
5408       return -1;
5409     if (r) {
5410       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
5411       return -1;
5412     }
5413   }
5414   return 0;
5415 }
5416
5417 static int test_rmdir_0 (void)
5418 {
5419   /* InitBasicFS for rmdir (0): create ext2 on /dev/sda1 */
5420   {
5421     int r;
5422     suppress_error = 0;
5423     r = guestfs_umount_all (g);
5424     if (r == -1)
5425       return -1;
5426   }
5427   {
5428     int r;
5429     suppress_error = 0;
5430     r = guestfs_lvm_remove_all (g);
5431     if (r == -1)
5432       return -1;
5433   }
5434   {
5435     char *lines[] = {
5436       ",",
5437       NULL
5438     };
5439     int r;
5440     suppress_error = 0;
5441     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5442     if (r == -1)
5443       return -1;
5444   }
5445   {
5446     int r;
5447     suppress_error = 0;
5448     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5449     if (r == -1)
5450       return -1;
5451   }
5452   {
5453     int r;
5454     suppress_error = 0;
5455     r = guestfs_mount (g, "/dev/sda1", "/");
5456     if (r == -1)
5457       return -1;
5458   }
5459   /* TestRun for rmdir (0) */
5460   {
5461     int r;
5462     suppress_error = 0;
5463     r = guestfs_mkdir (g, "/new");
5464     if (r == -1)
5465       return -1;
5466   }
5467   {
5468     int r;
5469     suppress_error = 0;
5470     r = guestfs_rmdir (g, "/new");
5471     if (r == -1)
5472       return -1;
5473   }
5474   return 0;
5475 }
5476
5477 static int test_rmdir_1 (void)
5478 {
5479   /* InitBasicFS for rmdir (1): create ext2 on /dev/sda1 */
5480   {
5481     int r;
5482     suppress_error = 0;
5483     r = guestfs_umount_all (g);
5484     if (r == -1)
5485       return -1;
5486   }
5487   {
5488     int r;
5489     suppress_error = 0;
5490     r = guestfs_lvm_remove_all (g);
5491     if (r == -1)
5492       return -1;
5493   }
5494   {
5495     char *lines[] = {
5496       ",",
5497       NULL
5498     };
5499     int r;
5500     suppress_error = 0;
5501     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5502     if (r == -1)
5503       return -1;
5504   }
5505   {
5506     int r;
5507     suppress_error = 0;
5508     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5509     if (r == -1)
5510       return -1;
5511   }
5512   {
5513     int r;
5514     suppress_error = 0;
5515     r = guestfs_mount (g, "/dev/sda1", "/");
5516     if (r == -1)
5517       return -1;
5518   }
5519   /* TestLastFail for rmdir (1) */
5520   {
5521     int r;
5522     suppress_error = 1;
5523     r = guestfs_rmdir (g, "/new");
5524     if (r != -1)
5525       return -1;
5526   }
5527   return 0;
5528 }
5529
5530 static int test_rmdir_2 (void)
5531 {
5532   /* InitBasicFS for rmdir (2): create ext2 on /dev/sda1 */
5533   {
5534     int r;
5535     suppress_error = 0;
5536     r = guestfs_umount_all (g);
5537     if (r == -1)
5538       return -1;
5539   }
5540   {
5541     int r;
5542     suppress_error = 0;
5543     r = guestfs_lvm_remove_all (g);
5544     if (r == -1)
5545       return -1;
5546   }
5547   {
5548     char *lines[] = {
5549       ",",
5550       NULL
5551     };
5552     int r;
5553     suppress_error = 0;
5554     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5555     if (r == -1)
5556       return -1;
5557   }
5558   {
5559     int r;
5560     suppress_error = 0;
5561     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5562     if (r == -1)
5563       return -1;
5564   }
5565   {
5566     int r;
5567     suppress_error = 0;
5568     r = guestfs_mount (g, "/dev/sda1", "/");
5569     if (r == -1)
5570       return -1;
5571   }
5572   /* TestLastFail for rmdir (2) */
5573   {
5574     int r;
5575     suppress_error = 0;
5576     r = guestfs_touch (g, "/new");
5577     if (r == -1)
5578       return -1;
5579   }
5580   {
5581     int r;
5582     suppress_error = 1;
5583     r = guestfs_rmdir (g, "/new");
5584     if (r != -1)
5585       return -1;
5586   }
5587   return 0;
5588 }
5589
5590 static int test_rm_0 (void)
5591 {
5592   /* InitBasicFS for rm (0): create ext2 on /dev/sda1 */
5593   {
5594     int r;
5595     suppress_error = 0;
5596     r = guestfs_umount_all (g);
5597     if (r == -1)
5598       return -1;
5599   }
5600   {
5601     int r;
5602     suppress_error = 0;
5603     r = guestfs_lvm_remove_all (g);
5604     if (r == -1)
5605       return -1;
5606   }
5607   {
5608     char *lines[] = {
5609       ",",
5610       NULL
5611     };
5612     int r;
5613     suppress_error = 0;
5614     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5615     if (r == -1)
5616       return -1;
5617   }
5618   {
5619     int r;
5620     suppress_error = 0;
5621     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5622     if (r == -1)
5623       return -1;
5624   }
5625   {
5626     int r;
5627     suppress_error = 0;
5628     r = guestfs_mount (g, "/dev/sda1", "/");
5629     if (r == -1)
5630       return -1;
5631   }
5632   /* TestRun for rm (0) */
5633   {
5634     int r;
5635     suppress_error = 0;
5636     r = guestfs_touch (g, "/new");
5637     if (r == -1)
5638       return -1;
5639   }
5640   {
5641     int r;
5642     suppress_error = 0;
5643     r = guestfs_rm (g, "/new");
5644     if (r == -1)
5645       return -1;
5646   }
5647   return 0;
5648 }
5649
5650 static int test_rm_1 (void)
5651 {
5652   /* InitBasicFS for rm (1): create ext2 on /dev/sda1 */
5653   {
5654     int r;
5655     suppress_error = 0;
5656     r = guestfs_umount_all (g);
5657     if (r == -1)
5658       return -1;
5659   }
5660   {
5661     int r;
5662     suppress_error = 0;
5663     r = guestfs_lvm_remove_all (g);
5664     if (r == -1)
5665       return -1;
5666   }
5667   {
5668     char *lines[] = {
5669       ",",
5670       NULL
5671     };
5672     int r;
5673     suppress_error = 0;
5674     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5675     if (r == -1)
5676       return -1;
5677   }
5678   {
5679     int r;
5680     suppress_error = 0;
5681     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5682     if (r == -1)
5683       return -1;
5684   }
5685   {
5686     int r;
5687     suppress_error = 0;
5688     r = guestfs_mount (g, "/dev/sda1", "/");
5689     if (r == -1)
5690       return -1;
5691   }
5692   /* TestLastFail for rm (1) */
5693   {
5694     int r;
5695     suppress_error = 1;
5696     r = guestfs_rm (g, "/new");
5697     if (r != -1)
5698       return -1;
5699   }
5700   return 0;
5701 }
5702
5703 static int test_rm_2 (void)
5704 {
5705   /* InitBasicFS for rm (2): create ext2 on /dev/sda1 */
5706   {
5707     int r;
5708     suppress_error = 0;
5709     r = guestfs_umount_all (g);
5710     if (r == -1)
5711       return -1;
5712   }
5713   {
5714     int r;
5715     suppress_error = 0;
5716     r = guestfs_lvm_remove_all (g);
5717     if (r == -1)
5718       return -1;
5719   }
5720   {
5721     char *lines[] = {
5722       ",",
5723       NULL
5724     };
5725     int r;
5726     suppress_error = 0;
5727     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5728     if (r == -1)
5729       return -1;
5730   }
5731   {
5732     int r;
5733     suppress_error = 0;
5734     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5735     if (r == -1)
5736       return -1;
5737   }
5738   {
5739     int r;
5740     suppress_error = 0;
5741     r = guestfs_mount (g, "/dev/sda1", "/");
5742     if (r == -1)
5743       return -1;
5744   }
5745   /* TestLastFail for rm (2) */
5746   {
5747     int r;
5748     suppress_error = 0;
5749     r = guestfs_mkdir (g, "/new");
5750     if (r == -1)
5751       return -1;
5752   }
5753   {
5754     int r;
5755     suppress_error = 1;
5756     r = guestfs_rm (g, "/new");
5757     if (r != -1)
5758       return -1;
5759   }
5760   return 0;
5761 }
5762
5763 static int test_read_lines_0 (void)
5764 {
5765   /* InitBasicFS for read_lines (0): create ext2 on /dev/sda1 */
5766   {
5767     int r;
5768     suppress_error = 0;
5769     r = guestfs_umount_all (g);
5770     if (r == -1)
5771       return -1;
5772   }
5773   {
5774     int r;
5775     suppress_error = 0;
5776     r = guestfs_lvm_remove_all (g);
5777     if (r == -1)
5778       return -1;
5779   }
5780   {
5781     char *lines[] = {
5782       ",",
5783       NULL
5784     };
5785     int r;
5786     suppress_error = 0;
5787     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5788     if (r == -1)
5789       return -1;
5790   }
5791   {
5792     int r;
5793     suppress_error = 0;
5794     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5795     if (r == -1)
5796       return -1;
5797   }
5798   {
5799     int r;
5800     suppress_error = 0;
5801     r = guestfs_mount (g, "/dev/sda1", "/");
5802     if (r == -1)
5803       return -1;
5804   }
5805   /* TestOutputList for read_lines (0) */
5806   {
5807     int r;
5808     suppress_error = 0;
5809     r = guestfs_write_file (g, "/new", "line1\r\nline2\nline3", 0);
5810     if (r == -1)
5811       return -1;
5812   }
5813   {
5814     char **r;
5815     int i;
5816     suppress_error = 0;
5817     r = guestfs_read_lines (g, "/new");
5818     if (r == NULL)
5819       return -1;
5820     if (!r[0]) {
5821       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
5822       print_strings (r);
5823       return -1;
5824     }
5825     if (strcmp (r[0], "line1") != 0) {
5826       fprintf (stderr, "test_read_lines_0: expected \"line1\" but got \"%s\"\n", r[0]);
5827       return -1;
5828     }
5829     if (!r[1]) {
5830       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
5831       print_strings (r);
5832       return -1;
5833     }
5834     if (strcmp (r[1], "line2") != 0) {
5835       fprintf (stderr, "test_read_lines_0: expected \"line2\" but got \"%s\"\n", r[1]);
5836       return -1;
5837     }
5838     if (!r[2]) {
5839       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
5840       print_strings (r);
5841       return -1;
5842     }
5843     if (strcmp (r[2], "line3") != 0) {
5844       fprintf (stderr, "test_read_lines_0: expected \"line3\" but got \"%s\"\n", r[2]);
5845       return -1;
5846     }
5847     if (r[3] != NULL) {
5848       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
5849       print_strings (r);
5850       return -1;
5851     }
5852     for (i = 0; r[i] != NULL; ++i)
5853       free (r[i]);
5854     free (r);
5855   }
5856   return 0;
5857 }
5858
5859 static int test_read_lines_1 (void)
5860 {
5861   /* InitBasicFS for read_lines (1): create ext2 on /dev/sda1 */
5862   {
5863     int r;
5864     suppress_error = 0;
5865     r = guestfs_umount_all (g);
5866     if (r == -1)
5867       return -1;
5868   }
5869   {
5870     int r;
5871     suppress_error = 0;
5872     r = guestfs_lvm_remove_all (g);
5873     if (r == -1)
5874       return -1;
5875   }
5876   {
5877     char *lines[] = {
5878       ",",
5879       NULL
5880     };
5881     int r;
5882     suppress_error = 0;
5883     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5884     if (r == -1)
5885       return -1;
5886   }
5887   {
5888     int r;
5889     suppress_error = 0;
5890     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
5891     if (r == -1)
5892       return -1;
5893   }
5894   {
5895     int r;
5896     suppress_error = 0;
5897     r = guestfs_mount (g, "/dev/sda1", "/");
5898     if (r == -1)
5899       return -1;
5900   }
5901   /* TestOutputList for read_lines (1) */
5902   {
5903     int r;
5904     suppress_error = 0;
5905     r = guestfs_write_file (g, "/new", "", 0);
5906     if (r == -1)
5907       return -1;
5908   }
5909   {
5910     char **r;
5911     int i;
5912     suppress_error = 0;
5913     r = guestfs_read_lines (g, "/new");
5914     if (r == NULL)
5915       return -1;
5916     if (r[0] != NULL) {
5917       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
5918       print_strings (r);
5919       return -1;
5920     }
5921     for (i = 0; r[i] != NULL; ++i)
5922       free (r[i]);
5923     free (r);
5924   }
5925   return 0;
5926 }
5927
5928 static int test_lvs_0 (void)
5929 {
5930   /* InitBasicFSonLVM for lvs (0): create ext2 on /dev/VG/LV */
5931   {
5932     int r;
5933     suppress_error = 0;
5934     r = guestfs_umount_all (g);
5935     if (r == -1)
5936       return -1;
5937   }
5938   {
5939     int r;
5940     suppress_error = 0;
5941     r = guestfs_lvm_remove_all (g);
5942     if (r == -1)
5943       return -1;
5944   }
5945   {
5946     char *lines[] = {
5947       ",",
5948       NULL
5949     };
5950     int r;
5951     suppress_error = 0;
5952     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
5953     if (r == -1)
5954       return -1;
5955   }
5956   {
5957     int r;
5958     suppress_error = 0;
5959     r = guestfs_pvcreate (g, "/dev/sda1");
5960     if (r == -1)
5961       return -1;
5962   }
5963   {
5964     char *physvols[] = {
5965       "/dev/sda1",
5966       NULL
5967     };
5968     int r;
5969     suppress_error = 0;
5970     r = guestfs_vgcreate (g, "VG", physvols);
5971     if (r == -1)
5972       return -1;
5973   }
5974   {
5975     int r;
5976     suppress_error = 0;
5977     r = guestfs_lvcreate (g, "LV", "VG", 8);
5978     if (r == -1)
5979       return -1;
5980   }
5981   {
5982     int r;
5983     suppress_error = 0;
5984     r = guestfs_mkfs (g, "ext2", "/dev/VG/LV");
5985     if (r == -1)
5986       return -1;
5987   }
5988   {
5989     int r;
5990     suppress_error = 0;
5991     r = guestfs_mount (g, "/dev/VG/LV", "/");
5992     if (r == -1)
5993       return -1;
5994   }
5995   /* TestOutputList for lvs (0) */
5996   {
5997     char **r;
5998     int i;
5999     suppress_error = 0;
6000     r = guestfs_lvs (g);
6001     if (r == NULL)
6002       return -1;
6003     if (!r[0]) {
6004       fprintf (stderr, "test_lvs_0: short list returned from command\n");
6005       print_strings (r);
6006       return -1;
6007     }
6008     if (strcmp (r[0], "/dev/VG/LV") != 0) {
6009       fprintf (stderr, "test_lvs_0: expected \"/dev/VG/LV\" but got \"%s\"\n", r[0]);
6010       return -1;
6011     }
6012     if (r[1] != NULL) {
6013       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
6014       print_strings (r);
6015       return -1;
6016     }
6017     for (i = 0; r[i] != NULL; ++i)
6018       free (r[i]);
6019     free (r);
6020   }
6021   return 0;
6022 }
6023
6024 static int test_lvs_1 (void)
6025 {
6026   /* InitEmpty for lvs (1) */
6027   {
6028     int r;
6029     suppress_error = 0;
6030     r = guestfs_umount_all (g);
6031     if (r == -1)
6032       return -1;
6033   }
6034   {
6035     int r;
6036     suppress_error = 0;
6037     r = guestfs_lvm_remove_all (g);
6038     if (r == -1)
6039       return -1;
6040   }
6041   /* TestOutputList for lvs (1) */
6042   {
6043     char *lines[] = {
6044       ",10",
6045       ",20",
6046       ",",
6047       NULL
6048     };
6049     int r;
6050     suppress_error = 0;
6051     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6052     if (r == -1)
6053       return -1;
6054   }
6055   {
6056     int r;
6057     suppress_error = 0;
6058     r = guestfs_pvcreate (g, "/dev/sda1");
6059     if (r == -1)
6060       return -1;
6061   }
6062   {
6063     int r;
6064     suppress_error = 0;
6065     r = guestfs_pvcreate (g, "/dev/sda2");
6066     if (r == -1)
6067       return -1;
6068   }
6069   {
6070     int r;
6071     suppress_error = 0;
6072     r = guestfs_pvcreate (g, "/dev/sda3");
6073     if (r == -1)
6074       return -1;
6075   }
6076   {
6077     char *physvols[] = {
6078       "/dev/sda1",
6079       "/dev/sda2",
6080       NULL
6081     };
6082     int r;
6083     suppress_error = 0;
6084     r = guestfs_vgcreate (g, "VG1", physvols);
6085     if (r == -1)
6086       return -1;
6087   }
6088   {
6089     char *physvols[] = {
6090       "/dev/sda3",
6091       NULL
6092     };
6093     int r;
6094     suppress_error = 0;
6095     r = guestfs_vgcreate (g, "VG2", physvols);
6096     if (r == -1)
6097       return -1;
6098   }
6099   {
6100     int r;
6101     suppress_error = 0;
6102     r = guestfs_lvcreate (g, "LV1", "VG1", 50);
6103     if (r == -1)
6104       return -1;
6105   }
6106   {
6107     int r;
6108     suppress_error = 0;
6109     r = guestfs_lvcreate (g, "LV2", "VG1", 50);
6110     if (r == -1)
6111       return -1;
6112   }
6113   {
6114     int r;
6115     suppress_error = 0;
6116     r = guestfs_lvcreate (g, "LV3", "VG2", 50);
6117     if (r == -1)
6118       return -1;
6119   }
6120   {
6121     char **r;
6122     int i;
6123     suppress_error = 0;
6124     r = guestfs_lvs (g);
6125     if (r == NULL)
6126       return -1;
6127     if (!r[0]) {
6128       fprintf (stderr, "test_lvs_1: short list returned from command\n");
6129       print_strings (r);
6130       return -1;
6131     }
6132     if (strcmp (r[0], "/dev/VG1/LV1") != 0) {
6133       fprintf (stderr, "test_lvs_1: expected \"/dev/VG1/LV1\" but got \"%s\"\n", r[0]);
6134       return -1;
6135     }
6136     if (!r[1]) {
6137       fprintf (stderr, "test_lvs_1: short list returned from command\n");
6138       print_strings (r);
6139       return -1;
6140     }
6141     if (strcmp (r[1], "/dev/VG1/LV2") != 0) {
6142       fprintf (stderr, "test_lvs_1: expected \"/dev/VG1/LV2\" but got \"%s\"\n", r[1]);
6143       return -1;
6144     }
6145     if (!r[2]) {
6146       fprintf (stderr, "test_lvs_1: short list returned from command\n");
6147       print_strings (r);
6148       return -1;
6149     }
6150     if (strcmp (r[2], "/dev/VG2/LV3") != 0) {
6151       fprintf (stderr, "test_lvs_1: expected \"/dev/VG2/LV3\" but got \"%s\"\n", r[2]);
6152       return -1;
6153     }
6154     if (r[3] != NULL) {
6155       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
6156       print_strings (r);
6157       return -1;
6158     }
6159     for (i = 0; r[i] != NULL; ++i)
6160       free (r[i]);
6161     free (r);
6162   }
6163   return 0;
6164 }
6165
6166 static int test_vgs_0 (void)
6167 {
6168   /* InitBasicFSonLVM for vgs (0): create ext2 on /dev/VG/LV */
6169   {
6170     int r;
6171     suppress_error = 0;
6172     r = guestfs_umount_all (g);
6173     if (r == -1)
6174       return -1;
6175   }
6176   {
6177     int r;
6178     suppress_error = 0;
6179     r = guestfs_lvm_remove_all (g);
6180     if (r == -1)
6181       return -1;
6182   }
6183   {
6184     char *lines[] = {
6185       ",",
6186       NULL
6187     };
6188     int r;
6189     suppress_error = 0;
6190     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6191     if (r == -1)
6192       return -1;
6193   }
6194   {
6195     int r;
6196     suppress_error = 0;
6197     r = guestfs_pvcreate (g, "/dev/sda1");
6198     if (r == -1)
6199       return -1;
6200   }
6201   {
6202     char *physvols[] = {
6203       "/dev/sda1",
6204       NULL
6205     };
6206     int r;
6207     suppress_error = 0;
6208     r = guestfs_vgcreate (g, "VG", physvols);
6209     if (r == -1)
6210       return -1;
6211   }
6212   {
6213     int r;
6214     suppress_error = 0;
6215     r = guestfs_lvcreate (g, "LV", "VG", 8);
6216     if (r == -1)
6217       return -1;
6218   }
6219   {
6220     int r;
6221     suppress_error = 0;
6222     r = guestfs_mkfs (g, "ext2", "/dev/VG/LV");
6223     if (r == -1)
6224       return -1;
6225   }
6226   {
6227     int r;
6228     suppress_error = 0;
6229     r = guestfs_mount (g, "/dev/VG/LV", "/");
6230     if (r == -1)
6231       return -1;
6232   }
6233   /* TestOutputList for vgs (0) */
6234   {
6235     char **r;
6236     int i;
6237     suppress_error = 0;
6238     r = guestfs_vgs (g);
6239     if (r == NULL)
6240       return -1;
6241     if (!r[0]) {
6242       fprintf (stderr, "test_vgs_0: short list returned from command\n");
6243       print_strings (r);
6244       return -1;
6245     }
6246     if (strcmp (r[0], "VG") != 0) {
6247       fprintf (stderr, "test_vgs_0: expected \"VG\" but got \"%s\"\n", r[0]);
6248       return -1;
6249     }
6250     if (r[1] != NULL) {
6251       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
6252       print_strings (r);
6253       return -1;
6254     }
6255     for (i = 0; r[i] != NULL; ++i)
6256       free (r[i]);
6257     free (r);
6258   }
6259   return 0;
6260 }
6261
6262 static int test_vgs_1 (void)
6263 {
6264   /* InitEmpty for vgs (1) */
6265   {
6266     int r;
6267     suppress_error = 0;
6268     r = guestfs_umount_all (g);
6269     if (r == -1)
6270       return -1;
6271   }
6272   {
6273     int r;
6274     suppress_error = 0;
6275     r = guestfs_lvm_remove_all (g);
6276     if (r == -1)
6277       return -1;
6278   }
6279   /* TestOutputList for vgs (1) */
6280   {
6281     char *lines[] = {
6282       ",10",
6283       ",20",
6284       ",",
6285       NULL
6286     };
6287     int r;
6288     suppress_error = 0;
6289     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6290     if (r == -1)
6291       return -1;
6292   }
6293   {
6294     int r;
6295     suppress_error = 0;
6296     r = guestfs_pvcreate (g, "/dev/sda1");
6297     if (r == -1)
6298       return -1;
6299   }
6300   {
6301     int r;
6302     suppress_error = 0;
6303     r = guestfs_pvcreate (g, "/dev/sda2");
6304     if (r == -1)
6305       return -1;
6306   }
6307   {
6308     int r;
6309     suppress_error = 0;
6310     r = guestfs_pvcreate (g, "/dev/sda3");
6311     if (r == -1)
6312       return -1;
6313   }
6314   {
6315     char *physvols[] = {
6316       "/dev/sda1",
6317       "/dev/sda2",
6318       NULL
6319     };
6320     int r;
6321     suppress_error = 0;
6322     r = guestfs_vgcreate (g, "VG1", physvols);
6323     if (r == -1)
6324       return -1;
6325   }
6326   {
6327     char *physvols[] = {
6328       "/dev/sda3",
6329       NULL
6330     };
6331     int r;
6332     suppress_error = 0;
6333     r = guestfs_vgcreate (g, "VG2", physvols);
6334     if (r == -1)
6335       return -1;
6336   }
6337   {
6338     char **r;
6339     int i;
6340     suppress_error = 0;
6341     r = guestfs_vgs (g);
6342     if (r == NULL)
6343       return -1;
6344     if (!r[0]) {
6345       fprintf (stderr, "test_vgs_1: short list returned from command\n");
6346       print_strings (r);
6347       return -1;
6348     }
6349     if (strcmp (r[0], "VG1") != 0) {
6350       fprintf (stderr, "test_vgs_1: expected \"VG1\" but got \"%s\"\n", r[0]);
6351       return -1;
6352     }
6353     if (!r[1]) {
6354       fprintf (stderr, "test_vgs_1: short list returned from command\n");
6355       print_strings (r);
6356       return -1;
6357     }
6358     if (strcmp (r[1], "VG2") != 0) {
6359       fprintf (stderr, "test_vgs_1: expected \"VG2\" but got \"%s\"\n", r[1]);
6360       return -1;
6361     }
6362     if (r[2] != NULL) {
6363       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
6364       print_strings (r);
6365       return -1;
6366     }
6367     for (i = 0; r[i] != NULL; ++i)
6368       free (r[i]);
6369     free (r);
6370   }
6371   return 0;
6372 }
6373
6374 static int test_pvs_0 (void)
6375 {
6376   /* InitBasicFSonLVM for pvs (0): create ext2 on /dev/VG/LV */
6377   {
6378     int r;
6379     suppress_error = 0;
6380     r = guestfs_umount_all (g);
6381     if (r == -1)
6382       return -1;
6383   }
6384   {
6385     int r;
6386     suppress_error = 0;
6387     r = guestfs_lvm_remove_all (g);
6388     if (r == -1)
6389       return -1;
6390   }
6391   {
6392     char *lines[] = {
6393       ",",
6394       NULL
6395     };
6396     int r;
6397     suppress_error = 0;
6398     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6399     if (r == -1)
6400       return -1;
6401   }
6402   {
6403     int r;
6404     suppress_error = 0;
6405     r = guestfs_pvcreate (g, "/dev/sda1");
6406     if (r == -1)
6407       return -1;
6408   }
6409   {
6410     char *physvols[] = {
6411       "/dev/sda1",
6412       NULL
6413     };
6414     int r;
6415     suppress_error = 0;
6416     r = guestfs_vgcreate (g, "VG", physvols);
6417     if (r == -1)
6418       return -1;
6419   }
6420   {
6421     int r;
6422     suppress_error = 0;
6423     r = guestfs_lvcreate (g, "LV", "VG", 8);
6424     if (r == -1)
6425       return -1;
6426   }
6427   {
6428     int r;
6429     suppress_error = 0;
6430     r = guestfs_mkfs (g, "ext2", "/dev/VG/LV");
6431     if (r == -1)
6432       return -1;
6433   }
6434   {
6435     int r;
6436     suppress_error = 0;
6437     r = guestfs_mount (g, "/dev/VG/LV", "/");
6438     if (r == -1)
6439       return -1;
6440   }
6441   /* TestOutputList for pvs (0) */
6442   {
6443     char **r;
6444     int i;
6445     suppress_error = 0;
6446     r = guestfs_pvs (g);
6447     if (r == NULL)
6448       return -1;
6449     if (!r[0]) {
6450       fprintf (stderr, "test_pvs_0: short list returned from command\n");
6451       print_strings (r);
6452       return -1;
6453     }
6454     if (strcmp (r[0], "/dev/sda1") != 0) {
6455       fprintf (stderr, "test_pvs_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
6456       return -1;
6457     }
6458     if (r[1] != NULL) {
6459       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
6460       print_strings (r);
6461       return -1;
6462     }
6463     for (i = 0; r[i] != NULL; ++i)
6464       free (r[i]);
6465     free (r);
6466   }
6467   return 0;
6468 }
6469
6470 static int test_pvs_1 (void)
6471 {
6472   /* InitEmpty for pvs (1) */
6473   {
6474     int r;
6475     suppress_error = 0;
6476     r = guestfs_umount_all (g);
6477     if (r == -1)
6478       return -1;
6479   }
6480   {
6481     int r;
6482     suppress_error = 0;
6483     r = guestfs_lvm_remove_all (g);
6484     if (r == -1)
6485       return -1;
6486   }
6487   /* TestOutputList for pvs (1) */
6488   {
6489     char *lines[] = {
6490       ",10",
6491       ",20",
6492       ",",
6493       NULL
6494     };
6495     int r;
6496     suppress_error = 0;
6497     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6498     if (r == -1)
6499       return -1;
6500   }
6501   {
6502     int r;
6503     suppress_error = 0;
6504     r = guestfs_pvcreate (g, "/dev/sda1");
6505     if (r == -1)
6506       return -1;
6507   }
6508   {
6509     int r;
6510     suppress_error = 0;
6511     r = guestfs_pvcreate (g, "/dev/sda2");
6512     if (r == -1)
6513       return -1;
6514   }
6515   {
6516     int r;
6517     suppress_error = 0;
6518     r = guestfs_pvcreate (g, "/dev/sda3");
6519     if (r == -1)
6520       return -1;
6521   }
6522   {
6523     char **r;
6524     int i;
6525     suppress_error = 0;
6526     r = guestfs_pvs (g);
6527     if (r == NULL)
6528       return -1;
6529     if (!r[0]) {
6530       fprintf (stderr, "test_pvs_1: short list returned from command\n");
6531       print_strings (r);
6532       return -1;
6533     }
6534     if (strcmp (r[0], "/dev/sda1") != 0) {
6535       fprintf (stderr, "test_pvs_1: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
6536       return -1;
6537     }
6538     if (!r[1]) {
6539       fprintf (stderr, "test_pvs_1: short list returned from command\n");
6540       print_strings (r);
6541       return -1;
6542     }
6543     if (strcmp (r[1], "/dev/sda2") != 0) {
6544       fprintf (stderr, "test_pvs_1: expected \"/dev/sda2\" but got \"%s\"\n", r[1]);
6545       return -1;
6546     }
6547     if (!r[2]) {
6548       fprintf (stderr, "test_pvs_1: short list returned from command\n");
6549       print_strings (r);
6550       return -1;
6551     }
6552     if (strcmp (r[2], "/dev/sda3") != 0) {
6553       fprintf (stderr, "test_pvs_1: expected \"/dev/sda3\" but got \"%s\"\n", r[2]);
6554       return -1;
6555     }
6556     if (r[3] != NULL) {
6557       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
6558       print_strings (r);
6559       return -1;
6560     }
6561     for (i = 0; r[i] != NULL; ++i)
6562       free (r[i]);
6563     free (r);
6564   }
6565   return 0;
6566 }
6567
6568 static int test_list_partitions_0 (void)
6569 {
6570   /* InitBasicFS for list_partitions (0): create ext2 on /dev/sda1 */
6571   {
6572     int r;
6573     suppress_error = 0;
6574     r = guestfs_umount_all (g);
6575     if (r == -1)
6576       return -1;
6577   }
6578   {
6579     int r;
6580     suppress_error = 0;
6581     r = guestfs_lvm_remove_all (g);
6582     if (r == -1)
6583       return -1;
6584   }
6585   {
6586     char *lines[] = {
6587       ",",
6588       NULL
6589     };
6590     int r;
6591     suppress_error = 0;
6592     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6593     if (r == -1)
6594       return -1;
6595   }
6596   {
6597     int r;
6598     suppress_error = 0;
6599     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
6600     if (r == -1)
6601       return -1;
6602   }
6603   {
6604     int r;
6605     suppress_error = 0;
6606     r = guestfs_mount (g, "/dev/sda1", "/");
6607     if (r == -1)
6608       return -1;
6609   }
6610   /* TestOutputList for list_partitions (0) */
6611   {
6612     char **r;
6613     int i;
6614     suppress_error = 0;
6615     r = guestfs_list_partitions (g);
6616     if (r == NULL)
6617       return -1;
6618     if (!r[0]) {
6619       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
6620       print_strings (r);
6621       return -1;
6622     }
6623     if (strcmp (r[0], "/dev/sda1") != 0) {
6624       fprintf (stderr, "test_list_partitions_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
6625       return -1;
6626     }
6627     if (r[1] != NULL) {
6628       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
6629       print_strings (r);
6630       return -1;
6631     }
6632     for (i = 0; r[i] != NULL; ++i)
6633       free (r[i]);
6634     free (r);
6635   }
6636   return 0;
6637 }
6638
6639 static int test_list_partitions_1 (void)
6640 {
6641   /* InitEmpty for list_partitions (1) */
6642   {
6643     int r;
6644     suppress_error = 0;
6645     r = guestfs_umount_all (g);
6646     if (r == -1)
6647       return -1;
6648   }
6649   {
6650     int r;
6651     suppress_error = 0;
6652     r = guestfs_lvm_remove_all (g);
6653     if (r == -1)
6654       return -1;
6655   }
6656   /* TestOutputList for list_partitions (1) */
6657   {
6658     char *lines[] = {
6659       ",10",
6660       ",20",
6661       ",",
6662       NULL
6663     };
6664     int r;
6665     suppress_error = 0;
6666     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6667     if (r == -1)
6668       return -1;
6669   }
6670   {
6671     char **r;
6672     int i;
6673     suppress_error = 0;
6674     r = guestfs_list_partitions (g);
6675     if (r == NULL)
6676       return -1;
6677     if (!r[0]) {
6678       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
6679       print_strings (r);
6680       return -1;
6681     }
6682     if (strcmp (r[0], "/dev/sda1") != 0) {
6683       fprintf (stderr, "test_list_partitions_1: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
6684       return -1;
6685     }
6686     if (!r[1]) {
6687       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
6688       print_strings (r);
6689       return -1;
6690     }
6691     if (strcmp (r[1], "/dev/sda2") != 0) {
6692       fprintf (stderr, "test_list_partitions_1: expected \"/dev/sda2\" but got \"%s\"\n", r[1]);
6693       return -1;
6694     }
6695     if (!r[2]) {
6696       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
6697       print_strings (r);
6698       return -1;
6699     }
6700     if (strcmp (r[2], "/dev/sda3") != 0) {
6701       fprintf (stderr, "test_list_partitions_1: expected \"/dev/sda3\" but got \"%s\"\n", r[2]);
6702       return -1;
6703     }
6704     if (r[3] != NULL) {
6705       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
6706       print_strings (r);
6707       return -1;
6708     }
6709     for (i = 0; r[i] != NULL; ++i)
6710       free (r[i]);
6711     free (r);
6712   }
6713   return 0;
6714 }
6715
6716 static int test_list_devices_0 (void)
6717 {
6718   /* InitEmpty for list_devices (0) */
6719   {
6720     int r;
6721     suppress_error = 0;
6722     r = guestfs_umount_all (g);
6723     if (r == -1)
6724       return -1;
6725   }
6726   {
6727     int r;
6728     suppress_error = 0;
6729     r = guestfs_lvm_remove_all (g);
6730     if (r == -1)
6731       return -1;
6732   }
6733   /* TestOutputList for list_devices (0) */
6734   {
6735     char **r;
6736     int i;
6737     suppress_error = 0;
6738     r = guestfs_list_devices (g);
6739     if (r == NULL)
6740       return -1;
6741     if (!r[0]) {
6742       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
6743       print_strings (r);
6744       return -1;
6745     }
6746     if (strcmp (r[0], "/dev/sda") != 0) {
6747       fprintf (stderr, "test_list_devices_0: expected \"/dev/sda\" but got \"%s\"\n", r[0]);
6748       return -1;
6749     }
6750     if (!r[1]) {
6751       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
6752       print_strings (r);
6753       return -1;
6754     }
6755     if (strcmp (r[1], "/dev/sdb") != 0) {
6756       fprintf (stderr, "test_list_devices_0: expected \"/dev/sdb\" but got \"%s\"\n", r[1]);
6757       return -1;
6758     }
6759     if (!r[2]) {
6760       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
6761       print_strings (r);
6762       return -1;
6763     }
6764     if (strcmp (r[2], "/dev/sdc") != 0) {
6765       fprintf (stderr, "test_list_devices_0: expected \"/dev/sdc\" but got \"%s\"\n", r[2]);
6766       return -1;
6767     }
6768     if (r[3] != NULL) {
6769       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
6770       print_strings (r);
6771       return -1;
6772     }
6773     for (i = 0; r[i] != NULL; ++i)
6774       free (r[i]);
6775     free (r);
6776   }
6777   return 0;
6778 }
6779
6780 static int test_ls_0 (void)
6781 {
6782   /* InitBasicFS for ls (0): create ext2 on /dev/sda1 */
6783   {
6784     int r;
6785     suppress_error = 0;
6786     r = guestfs_umount_all (g);
6787     if (r == -1)
6788       return -1;
6789   }
6790   {
6791     int r;
6792     suppress_error = 0;
6793     r = guestfs_lvm_remove_all (g);
6794     if (r == -1)
6795       return -1;
6796   }
6797   {
6798     char *lines[] = {
6799       ",",
6800       NULL
6801     };
6802     int r;
6803     suppress_error = 0;
6804     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6805     if (r == -1)
6806       return -1;
6807   }
6808   {
6809     int r;
6810     suppress_error = 0;
6811     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
6812     if (r == -1)
6813       return -1;
6814   }
6815   {
6816     int r;
6817     suppress_error = 0;
6818     r = guestfs_mount (g, "/dev/sda1", "/");
6819     if (r == -1)
6820       return -1;
6821   }
6822   /* TestOutputList for ls (0) */
6823   {
6824     int r;
6825     suppress_error = 0;
6826     r = guestfs_touch (g, "/new");
6827     if (r == -1)
6828       return -1;
6829   }
6830   {
6831     int r;
6832     suppress_error = 0;
6833     r = guestfs_touch (g, "/newer");
6834     if (r == -1)
6835       return -1;
6836   }
6837   {
6838     int r;
6839     suppress_error = 0;
6840     r = guestfs_touch (g, "/newest");
6841     if (r == -1)
6842       return -1;
6843   }
6844   {
6845     char **r;
6846     int i;
6847     suppress_error = 0;
6848     r = guestfs_ls (g, "/");
6849     if (r == NULL)
6850       return -1;
6851     if (!r[0]) {
6852       fprintf (stderr, "test_ls_0: short list returned from command\n");
6853       print_strings (r);
6854       return -1;
6855     }
6856     if (strcmp (r[0], "lost+found") != 0) {
6857       fprintf (stderr, "test_ls_0: expected \"lost+found\" but got \"%s\"\n", r[0]);
6858       return -1;
6859     }
6860     if (!r[1]) {
6861       fprintf (stderr, "test_ls_0: short list returned from command\n");
6862       print_strings (r);
6863       return -1;
6864     }
6865     if (strcmp (r[1], "new") != 0) {
6866       fprintf (stderr, "test_ls_0: expected \"new\" but got \"%s\"\n", r[1]);
6867       return -1;
6868     }
6869     if (!r[2]) {
6870       fprintf (stderr, "test_ls_0: short list returned from command\n");
6871       print_strings (r);
6872       return -1;
6873     }
6874     if (strcmp (r[2], "newer") != 0) {
6875       fprintf (stderr, "test_ls_0: expected \"newer\" but got \"%s\"\n", r[2]);
6876       return -1;
6877     }
6878     if (!r[3]) {
6879       fprintf (stderr, "test_ls_0: short list returned from command\n");
6880       print_strings (r);
6881       return -1;
6882     }
6883     if (strcmp (r[3], "newest") != 0) {
6884       fprintf (stderr, "test_ls_0: expected \"newest\" but got \"%s\"\n", r[3]);
6885       return -1;
6886     }
6887     if (r[4] != NULL) {
6888       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
6889       print_strings (r);
6890       return -1;
6891     }
6892     for (i = 0; r[i] != NULL; ++i)
6893       free (r[i]);
6894     free (r);
6895   }
6896   return 0;
6897 }
6898
6899 static int test_cat_0 (void)
6900 {
6901   /* InitBasicFS for cat (0): create ext2 on /dev/sda1 */
6902   {
6903     int r;
6904     suppress_error = 0;
6905     r = guestfs_umount_all (g);
6906     if (r == -1)
6907       return -1;
6908   }
6909   {
6910     int r;
6911     suppress_error = 0;
6912     r = guestfs_lvm_remove_all (g);
6913     if (r == -1)
6914       return -1;
6915   }
6916   {
6917     char *lines[] = {
6918       ",",
6919       NULL
6920     };
6921     int r;
6922     suppress_error = 0;
6923     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6924     if (r == -1)
6925       return -1;
6926   }
6927   {
6928     int r;
6929     suppress_error = 0;
6930     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
6931     if (r == -1)
6932       return -1;
6933   }
6934   {
6935     int r;
6936     suppress_error = 0;
6937     r = guestfs_mount (g, "/dev/sda1", "/");
6938     if (r == -1)
6939       return -1;
6940   }
6941   /* TestOutput for cat (0) */
6942   {
6943     int r;
6944     suppress_error = 0;
6945     r = guestfs_write_file (g, "/new", "new file contents", 0);
6946     if (r == -1)
6947       return -1;
6948   }
6949   {
6950     char *r;
6951     suppress_error = 0;
6952     r = guestfs_cat (g, "/new");
6953     if (r == NULL)
6954       return -1;
6955     if (strcmp (r, "new file contents") != 0) {
6956       fprintf (stderr, "test_cat_0: expected \"new file contents\" but got \"%s\"\n", r);
6957       return -1;
6958     }
6959     free (r);
6960   }
6961   return 0;
6962 }
6963
6964 static int test_touch_0 (void)
6965 {
6966   /* InitBasicFS for touch (0): create ext2 on /dev/sda1 */
6967   {
6968     int r;
6969     suppress_error = 0;
6970     r = guestfs_umount_all (g);
6971     if (r == -1)
6972       return -1;
6973   }
6974   {
6975     int r;
6976     suppress_error = 0;
6977     r = guestfs_lvm_remove_all (g);
6978     if (r == -1)
6979       return -1;
6980   }
6981   {
6982     char *lines[] = {
6983       ",",
6984       NULL
6985     };
6986     int r;
6987     suppress_error = 0;
6988     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
6989     if (r == -1)
6990       return -1;
6991   }
6992   {
6993     int r;
6994     suppress_error = 0;
6995     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
6996     if (r == -1)
6997       return -1;
6998   }
6999   {
7000     int r;
7001     suppress_error = 0;
7002     r = guestfs_mount (g, "/dev/sda1", "/");
7003     if (r == -1)
7004       return -1;
7005   }
7006   /* TestOutputTrue for touch (0) */
7007   {
7008     int r;
7009     suppress_error = 0;
7010     r = guestfs_touch (g, "/new");
7011     if (r == -1)
7012       return -1;
7013   }
7014   {
7015     int r;
7016     suppress_error = 0;
7017     r = guestfs_exists (g, "/new");
7018     if (r == -1)
7019       return -1;
7020     if (!r) {
7021       fprintf (stderr, "test_touch_0: expected true, got false\n");
7022       return -1;
7023     }
7024   }
7025   return 0;
7026 }
7027
7028 static int test_sync_0 (void)
7029 {
7030   /* InitEmpty for sync (0) */
7031   {
7032     int r;
7033     suppress_error = 0;
7034     r = guestfs_umount_all (g);
7035     if (r == -1)
7036       return -1;
7037   }
7038   {
7039     int r;
7040     suppress_error = 0;
7041     r = guestfs_lvm_remove_all (g);
7042     if (r == -1)
7043       return -1;
7044   }
7045   /* TestRun for sync (0) */
7046   {
7047     int r;
7048     suppress_error = 0;
7049     r = guestfs_sync (g);
7050     if (r == -1)
7051       return -1;
7052   }
7053   return 0;
7054 }
7055
7056 static int test_mount_0 (void)
7057 {
7058   /* InitEmpty for mount (0) */
7059   {
7060     int r;
7061     suppress_error = 0;
7062     r = guestfs_umount_all (g);
7063     if (r == -1)
7064       return -1;
7065   }
7066   {
7067     int r;
7068     suppress_error = 0;
7069     r = guestfs_lvm_remove_all (g);
7070     if (r == -1)
7071       return -1;
7072   }
7073   /* TestOutput for mount (0) */
7074   {
7075     char *lines[] = {
7076       ",",
7077       NULL
7078     };
7079     int r;
7080     suppress_error = 0;
7081     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
7082     if (r == -1)
7083       return -1;
7084   }
7085   {
7086     int r;
7087     suppress_error = 0;
7088     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
7089     if (r == -1)
7090       return -1;
7091   }
7092   {
7093     int r;
7094     suppress_error = 0;
7095     r = guestfs_mount (g, "/dev/sda1", "/");
7096     if (r == -1)
7097       return -1;
7098   }
7099   {
7100     int r;
7101     suppress_error = 0;
7102     r = guestfs_write_file (g, "/new", "new file contents", 0);
7103     if (r == -1)
7104       return -1;
7105   }
7106   {
7107     char *r;
7108     suppress_error = 0;
7109     r = guestfs_cat (g, "/new");
7110     if (r == NULL)
7111       return -1;
7112     if (strcmp (r, "new file contents") != 0) {
7113       fprintf (stderr, "test_mount_0: expected \"new file contents\" but got \"%s\"\n", r);
7114       return -1;
7115     }
7116     free (r);
7117   }
7118   return 0;
7119 }
7120
7121 int main (int argc, char *argv[])
7122 {
7123   char c = 0;
7124   int failed = 0;
7125   const char *srcdir;
7126   const char *filename;
7127   int fd;
7128   int nr_tests, test_num = 0;
7129
7130   no_test_warnings ();
7131
7132   g = guestfs_create ();
7133   if (g == NULL) {
7134     printf ("guestfs_create FAILED\n");
7135     exit (1);
7136   }
7137
7138   guestfs_set_error_handler (g, print_error, NULL);
7139
7140   srcdir = getenv ("srcdir");
7141   if (!srcdir) srcdir = ".";
7142   chdir (srcdir);
7143   guestfs_set_path (g, ".");
7144
7145   filename = "test1.img";
7146   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
7147   if (fd == -1) {
7148     perror (filename);
7149     exit (1);
7150   }
7151   if (lseek (fd, 524288000, SEEK_SET) == -1) {
7152     perror ("lseek");
7153     close (fd);
7154     unlink (filename);
7155     exit (1);
7156   }
7157   if (write (fd, &c, 1) == -1) {
7158     perror ("write");
7159     close (fd);
7160     unlink (filename);
7161     exit (1);
7162   }
7163   if (close (fd) == -1) {
7164     perror (filename);
7165     unlink (filename);
7166     exit (1);
7167   }
7168   if (guestfs_add_drive (g, filename) == -1) {
7169     printf ("guestfs_add_drive %s FAILED\n", filename);
7170     exit (1);
7171   }
7172
7173   filename = "test2.img";
7174   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
7175   if (fd == -1) {
7176     perror (filename);
7177     exit (1);
7178   }
7179   if (lseek (fd, 52428800, SEEK_SET) == -1) {
7180     perror ("lseek");
7181     close (fd);
7182     unlink (filename);
7183     exit (1);
7184   }
7185   if (write (fd, &c, 1) == -1) {
7186     perror ("write");
7187     close (fd);
7188     unlink (filename);
7189     exit (1);
7190   }
7191   if (close (fd) == -1) {
7192     perror (filename);
7193     unlink (filename);
7194     exit (1);
7195   }
7196   if (guestfs_add_drive (g, filename) == -1) {
7197     printf ("guestfs_add_drive %s FAILED\n", filename);
7198     exit (1);
7199   }
7200
7201   filename = "test3.img";
7202   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
7203   if (fd == -1) {
7204     perror (filename);
7205     exit (1);
7206   }
7207   if (lseek (fd, 10485760, SEEK_SET) == -1) {
7208     perror ("lseek");
7209     close (fd);
7210     unlink (filename);
7211     exit (1);
7212   }
7213   if (write (fd, &c, 1) == -1) {
7214     perror ("write");
7215     close (fd);
7216     unlink (filename);
7217     exit (1);
7218   }
7219   if (close (fd) == -1) {
7220     perror (filename);
7221     unlink (filename);
7222     exit (1);
7223   }
7224   if (guestfs_add_drive (g, filename) == -1) {
7225     printf ("guestfs_add_drive %s FAILED\n", filename);
7226     exit (1);
7227   }
7228
7229   if (guestfs_launch (g) == -1) {
7230     printf ("guestfs_launch FAILED\n");
7231     exit (1);
7232   }
7233   if (guestfs_wait_ready (g) == -1) {
7234     printf ("guestfs_wait_ready FAILED\n");
7235     exit (1);
7236   }
7237
7238   nr_tests = 101;
7239
7240   test_num++;
7241   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
7242   if (test_mv_0 () == -1) {
7243     printf ("test_mv_0 FAILED\n");
7244     failed++;
7245   }
7246   test_num++;
7247   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
7248   if (test_mv_1 () == -1) {
7249     printf ("test_mv_1 FAILED\n");
7250     failed++;
7251   }
7252   test_num++;
7253   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
7254   if (test_cp_a_0 () == -1) {
7255     printf ("test_cp_a_0 FAILED\n");
7256     failed++;
7257   }
7258   test_num++;
7259   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
7260   if (test_cp_0 () == -1) {
7261     printf ("test_cp_0 FAILED\n");
7262     failed++;
7263   }
7264   test_num++;
7265   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
7266   if (test_cp_1 () == -1) {
7267     printf ("test_cp_1 FAILED\n");
7268     failed++;
7269   }
7270   test_num++;
7271   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
7272   if (test_cp_2 () == -1) {
7273     printf ("test_cp_2 FAILED\n");
7274     failed++;
7275   }
7276   test_num++;
7277   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
7278   if (test_grub_install_0 () == -1) {
7279     printf ("test_grub_install_0 FAILED\n");
7280     failed++;
7281   }
7282   test_num++;
7283   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
7284   if (test_zero_0 () == -1) {
7285     printf ("test_zero_0 FAILED\n");
7286     failed++;
7287   }
7288   test_num++;
7289   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
7290   if (test_fsck_0 () == -1) {
7291     printf ("test_fsck_0 FAILED\n");
7292     failed++;
7293   }
7294   test_num++;
7295   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
7296   if (test_fsck_1 () == -1) {
7297     printf ("test_fsck_1 FAILED\n");
7298     failed++;
7299   }
7300   test_num++;
7301   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
7302   if (test_set_e2uuid_0 () == -1) {
7303     printf ("test_set_e2uuid_0 FAILED\n");
7304     failed++;
7305   }
7306   test_num++;
7307   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
7308   if (test_set_e2uuid_1 () == -1) {
7309     printf ("test_set_e2uuid_1 FAILED\n");
7310     failed++;
7311   }
7312   test_num++;
7313   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
7314   if (test_set_e2uuid_2 () == -1) {
7315     printf ("test_set_e2uuid_2 FAILED\n");
7316     failed++;
7317   }
7318   test_num++;
7319   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
7320   if (test_set_e2uuid_3 () == -1) {
7321     printf ("test_set_e2uuid_3 FAILED\n");
7322     failed++;
7323   }
7324   test_num++;
7325   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
7326   if (test_set_e2label_0 () == -1) {
7327     printf ("test_set_e2label_0 FAILED\n");
7328     failed++;
7329   }
7330   test_num++;
7331   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
7332   if (test_pvremove_0 () == -1) {
7333     printf ("test_pvremove_0 FAILED\n");
7334     failed++;
7335   }
7336   test_num++;
7337   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
7338   if (test_pvremove_1 () == -1) {
7339     printf ("test_pvremove_1 FAILED\n");
7340     failed++;
7341   }
7342   test_num++;
7343   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
7344   if (test_pvremove_2 () == -1) {
7345     printf ("test_pvremove_2 FAILED\n");
7346     failed++;
7347   }
7348   test_num++;
7349   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
7350   if (test_vgremove_0 () == -1) {
7351     printf ("test_vgremove_0 FAILED\n");
7352     failed++;
7353   }
7354   test_num++;
7355   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
7356   if (test_vgremove_1 () == -1) {
7357     printf ("test_vgremove_1 FAILED\n");
7358     failed++;
7359   }
7360   test_num++;
7361   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
7362   if (test_lvremove_0 () == -1) {
7363     printf ("test_lvremove_0 FAILED\n");
7364     failed++;
7365   }
7366   test_num++;
7367   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
7368   if (test_lvremove_1 () == -1) {
7369     printf ("test_lvremove_1 FAILED\n");
7370     failed++;
7371   }
7372   test_num++;
7373   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
7374   if (test_lvremove_2 () == -1) {
7375     printf ("test_lvremove_2 FAILED\n");
7376     failed++;
7377   }
7378   test_num++;
7379   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
7380   if (test_mount_ro_0 () == -1) {
7381     printf ("test_mount_ro_0 FAILED\n");
7382     failed++;
7383   }
7384   test_num++;
7385   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
7386   if (test_mount_ro_1 () == -1) {
7387     printf ("test_mount_ro_1 FAILED\n");
7388     failed++;
7389   }
7390   test_num++;
7391   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
7392   if (test_tgz_in_0 () == -1) {
7393     printf ("test_tgz_in_0 FAILED\n");
7394     failed++;
7395   }
7396   test_num++;
7397   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
7398   if (test_tar_in_0 () == -1) {
7399     printf ("test_tar_in_0 FAILED\n");
7400     failed++;
7401   }
7402   test_num++;
7403   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
7404   if (test_checksum_0 () == -1) {
7405     printf ("test_checksum_0 FAILED\n");
7406     failed++;
7407   }
7408   test_num++;
7409   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
7410   if (test_checksum_1 () == -1) {
7411     printf ("test_checksum_1 FAILED\n");
7412     failed++;
7413   }
7414   test_num++;
7415   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
7416   if (test_checksum_2 () == -1) {
7417     printf ("test_checksum_2 FAILED\n");
7418     failed++;
7419   }
7420   test_num++;
7421   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
7422   if (test_checksum_3 () == -1) {
7423     printf ("test_checksum_3 FAILED\n");
7424     failed++;
7425   }
7426   test_num++;
7427   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
7428   if (test_checksum_4 () == -1) {
7429     printf ("test_checksum_4 FAILED\n");
7430     failed++;
7431   }
7432   test_num++;
7433   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
7434   if (test_checksum_5 () == -1) {
7435     printf ("test_checksum_5 FAILED\n");
7436     failed++;
7437   }
7438   test_num++;
7439   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
7440   if (test_checksum_6 () == -1) {
7441     printf ("test_checksum_6 FAILED\n");
7442     failed++;
7443   }
7444   test_num++;
7445   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
7446   if (test_checksum_7 () == -1) {
7447     printf ("test_checksum_7 FAILED\n");
7448     failed++;
7449   }
7450   test_num++;
7451   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
7452   if (test_download_0 () == -1) {
7453     printf ("test_download_0 FAILED\n");
7454     failed++;
7455   }
7456   test_num++;
7457   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
7458   if (test_upload_0 () == -1) {
7459     printf ("test_upload_0 FAILED\n");
7460     failed++;
7461   }
7462   test_num++;
7463   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
7464   if (test_blockdev_rereadpt_0 () == -1) {
7465     printf ("test_blockdev_rereadpt_0 FAILED\n");
7466     failed++;
7467   }
7468   test_num++;
7469   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
7470   if (test_blockdev_flushbufs_0 () == -1) {
7471     printf ("test_blockdev_flushbufs_0 FAILED\n");
7472     failed++;
7473   }
7474   test_num++;
7475   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
7476   if (test_blockdev_getsize64_0 () == -1) {
7477     printf ("test_blockdev_getsize64_0 FAILED\n");
7478     failed++;
7479   }
7480   test_num++;
7481   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
7482   if (test_blockdev_getsz_0 () == -1) {
7483     printf ("test_blockdev_getsz_0 FAILED\n");
7484     failed++;
7485   }
7486   test_num++;
7487   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
7488   if (test_blockdev_getbsz_0 () == -1) {
7489     printf ("test_blockdev_getbsz_0 FAILED\n");
7490     failed++;
7491   }
7492   test_num++;
7493   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
7494   if (test_blockdev_getss_0 () == -1) {
7495     printf ("test_blockdev_getss_0 FAILED\n");
7496     failed++;
7497   }
7498   test_num++;
7499   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
7500   if (test_blockdev_getro_0 () == -1) {
7501     printf ("test_blockdev_getro_0 FAILED\n");
7502     failed++;
7503   }
7504   test_num++;
7505   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
7506   if (test_blockdev_setrw_0 () == -1) {
7507     printf ("test_blockdev_setrw_0 FAILED\n");
7508     failed++;
7509   }
7510   test_num++;
7511   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
7512   if (test_blockdev_setro_0 () == -1) {
7513     printf ("test_blockdev_setro_0 FAILED\n");
7514     failed++;
7515   }
7516   test_num++;
7517   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
7518   if (test_statvfs_0 () == -1) {
7519     printf ("test_statvfs_0 FAILED\n");
7520     failed++;
7521   }
7522   test_num++;
7523   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
7524   if (test_lstat_0 () == -1) {
7525     printf ("test_lstat_0 FAILED\n");
7526     failed++;
7527   }
7528   test_num++;
7529   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
7530   if (test_stat_0 () == -1) {
7531     printf ("test_stat_0 FAILED\n");
7532     failed++;
7533   }
7534   test_num++;
7535   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
7536   if (test_file_0 () == -1) {
7537     printf ("test_file_0 FAILED\n");
7538     failed++;
7539   }
7540   test_num++;
7541   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
7542   if (test_file_1 () == -1) {
7543     printf ("test_file_1 FAILED\n");
7544     failed++;
7545   }
7546   test_num++;
7547   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
7548   if (test_file_2 () == -1) {
7549     printf ("test_file_2 FAILED\n");
7550     failed++;
7551   }
7552   test_num++;
7553   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
7554   if (test_umount_all_0 () == -1) {
7555     printf ("test_umount_all_0 FAILED\n");
7556     failed++;
7557   }
7558   test_num++;
7559   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
7560   if (test_umount_all_1 () == -1) {
7561     printf ("test_umount_all_1 FAILED\n");
7562     failed++;
7563   }
7564   test_num++;
7565   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
7566   if (test_mounts_0 () == -1) {
7567     printf ("test_mounts_0 FAILED\n");
7568     failed++;
7569   }
7570   test_num++;
7571   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
7572   if (test_umount_0 () == -1) {
7573     printf ("test_umount_0 FAILED\n");
7574     failed++;
7575   }
7576   test_num++;
7577   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
7578   if (test_umount_1 () == -1) {
7579     printf ("test_umount_1 FAILED\n");
7580     failed++;
7581   }
7582   test_num++;
7583   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
7584   if (test_write_file_0 () == -1) {
7585     printf ("test_write_file_0 FAILED\n");
7586     failed++;
7587   }
7588   test_num++;
7589   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
7590   if (test_write_file_1 () == -1) {
7591     printf ("test_write_file_1 FAILED\n");
7592     failed++;
7593   }
7594   test_num++;
7595   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
7596   if (test_write_file_2 () == -1) {
7597     printf ("test_write_file_2 FAILED\n");
7598     failed++;
7599   }
7600   test_num++;
7601   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
7602   if (test_write_file_3 () == -1) {
7603     printf ("test_write_file_3 FAILED\n");
7604     failed++;
7605   }
7606   test_num++;
7607   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
7608   if (test_write_file_4 () == -1) {
7609     printf ("test_write_file_4 FAILED\n");
7610     failed++;
7611   }
7612   test_num++;
7613   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
7614   if (test_write_file_5 () == -1) {
7615     printf ("test_write_file_5 FAILED\n");
7616     failed++;
7617   }
7618   test_num++;
7619   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
7620   if (test_mkfs_0 () == -1) {
7621     printf ("test_mkfs_0 FAILED\n");
7622     failed++;
7623   }
7624   test_num++;
7625   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
7626   if (test_lvcreate_0 () == -1) {
7627     printf ("test_lvcreate_0 FAILED\n");
7628     failed++;
7629   }
7630   test_num++;
7631   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
7632   if (test_vgcreate_0 () == -1) {
7633     printf ("test_vgcreate_0 FAILED\n");
7634     failed++;
7635   }
7636   test_num++;
7637   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
7638   if (test_pvcreate_0 () == -1) {
7639     printf ("test_pvcreate_0 FAILED\n");
7640     failed++;
7641   }
7642   test_num++;
7643   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
7644   if (test_is_dir_0 () == -1) {
7645     printf ("test_is_dir_0 FAILED\n");
7646     failed++;
7647   }
7648   test_num++;
7649   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
7650   if (test_is_dir_1 () == -1) {
7651     printf ("test_is_dir_1 FAILED\n");
7652     failed++;
7653   }
7654   test_num++;
7655   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
7656   if (test_is_file_0 () == -1) {
7657     printf ("test_is_file_0 FAILED\n");
7658     failed++;
7659   }
7660   test_num++;
7661   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
7662   if (test_is_file_1 () == -1) {
7663     printf ("test_is_file_1 FAILED\n");
7664     failed++;
7665   }
7666   test_num++;
7667   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
7668   if (test_exists_0 () == -1) {
7669     printf ("test_exists_0 FAILED\n");
7670     failed++;
7671   }
7672   test_num++;
7673   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
7674   if (test_exists_1 () == -1) {
7675     printf ("test_exists_1 FAILED\n");
7676     failed++;
7677   }
7678   test_num++;
7679   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
7680   if (test_mkdir_p_0 () == -1) {
7681     printf ("test_mkdir_p_0 FAILED\n");
7682     failed++;
7683   }
7684   test_num++;
7685   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
7686   if (test_mkdir_p_1 () == -1) {
7687     printf ("test_mkdir_p_1 FAILED\n");
7688     failed++;
7689   }
7690   test_num++;
7691   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
7692   if (test_mkdir_p_2 () == -1) {
7693     printf ("test_mkdir_p_2 FAILED\n");
7694     failed++;
7695   }
7696   test_num++;
7697   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
7698   if (test_mkdir_0 () == -1) {
7699     printf ("test_mkdir_0 FAILED\n");
7700     failed++;
7701   }
7702   test_num++;
7703   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
7704   if (test_mkdir_1 () == -1) {
7705     printf ("test_mkdir_1 FAILED\n");
7706     failed++;
7707   }
7708   test_num++;
7709   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
7710   if (test_rm_rf_0 () == -1) {
7711     printf ("test_rm_rf_0 FAILED\n");
7712     failed++;
7713   }
7714   test_num++;
7715   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
7716   if (test_rmdir_0 () == -1) {
7717     printf ("test_rmdir_0 FAILED\n");
7718     failed++;
7719   }
7720   test_num++;
7721   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
7722   if (test_rmdir_1 () == -1) {
7723     printf ("test_rmdir_1 FAILED\n");
7724     failed++;
7725   }
7726   test_num++;
7727   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
7728   if (test_rmdir_2 () == -1) {
7729     printf ("test_rmdir_2 FAILED\n");
7730     failed++;
7731   }
7732   test_num++;
7733   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
7734   if (test_rm_0 () == -1) {
7735     printf ("test_rm_0 FAILED\n");
7736     failed++;
7737   }
7738   test_num++;
7739   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
7740   if (test_rm_1 () == -1) {
7741     printf ("test_rm_1 FAILED\n");
7742     failed++;
7743   }
7744   test_num++;
7745   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
7746   if (test_rm_2 () == -1) {
7747     printf ("test_rm_2 FAILED\n");
7748     failed++;
7749   }
7750   test_num++;
7751   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
7752   if (test_read_lines_0 () == -1) {
7753     printf ("test_read_lines_0 FAILED\n");
7754     failed++;
7755   }
7756   test_num++;
7757   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
7758   if (test_read_lines_1 () == -1) {
7759     printf ("test_read_lines_1 FAILED\n");
7760     failed++;
7761   }
7762   test_num++;
7763   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
7764   if (test_lvs_0 () == -1) {
7765     printf ("test_lvs_0 FAILED\n");
7766     failed++;
7767   }
7768   test_num++;
7769   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
7770   if (test_lvs_1 () == -1) {
7771     printf ("test_lvs_1 FAILED\n");
7772     failed++;
7773   }
7774   test_num++;
7775   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
7776   if (test_vgs_0 () == -1) {
7777     printf ("test_vgs_0 FAILED\n");
7778     failed++;
7779   }
7780   test_num++;
7781   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
7782   if (test_vgs_1 () == -1) {
7783     printf ("test_vgs_1 FAILED\n");
7784     failed++;
7785   }
7786   test_num++;
7787   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
7788   if (test_pvs_0 () == -1) {
7789     printf ("test_pvs_0 FAILED\n");
7790     failed++;
7791   }
7792   test_num++;
7793   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
7794   if (test_pvs_1 () == -1) {
7795     printf ("test_pvs_1 FAILED\n");
7796     failed++;
7797   }
7798   test_num++;
7799   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
7800   if (test_list_partitions_0 () == -1) {
7801     printf ("test_list_partitions_0 FAILED\n");
7802     failed++;
7803   }
7804   test_num++;
7805   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
7806   if (test_list_partitions_1 () == -1) {
7807     printf ("test_list_partitions_1 FAILED\n");
7808     failed++;
7809   }
7810   test_num++;
7811   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
7812   if (test_list_devices_0 () == -1) {
7813     printf ("test_list_devices_0 FAILED\n");
7814     failed++;
7815   }
7816   test_num++;
7817   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
7818   if (test_ls_0 () == -1) {
7819     printf ("test_ls_0 FAILED\n");
7820     failed++;
7821   }
7822   test_num++;
7823   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
7824   if (test_cat_0 () == -1) {
7825     printf ("test_cat_0 FAILED\n");
7826     failed++;
7827   }
7828   test_num++;
7829   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
7830   if (test_touch_0 () == -1) {
7831     printf ("test_touch_0 FAILED\n");
7832     failed++;
7833   }
7834   test_num++;
7835   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
7836   if (test_sync_0 () == -1) {
7837     printf ("test_sync_0 FAILED\n");
7838     failed++;
7839   }
7840   test_num++;
7841   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
7842   if (test_mount_0 () == -1) {
7843     printf ("test_mount_0 FAILED\n");
7844     failed++;
7845   }
7846
7847   guestfs_close (g);
7848   unlink ("test1.img");
7849   unlink ("test2.img");
7850   unlink ("test3.img");
7851
7852   if (failed > 0) {
7853     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
7854     exit (1);
7855   }
7856
7857   exit (0);
7858 }