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 static int test_mount_0 (void)
  49 {
  50   /* InitEmpty for mount (0) */
  51   {
  52     int r;
  53     suppress_error = 0;
  54     r = guestfs_umount_all (g);
  55     if (r == -1)
  56       return -1;
  57   }
  58   {
  59     int r;
  60     suppress_error = 0;
  61     r = guestfs_lvm_remove_all (g);
  62     if (r == -1)
  63       return -1;
  64   }
  65   /* TestOutput for mount (0) */
  66   {
  67     char *lines[] = {
  68       ",",
  69       NULL
  70     };
  71     int r;
  72     suppress_error = 0;
  73     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
  74     if (r == -1)
  75       return -1;
  76   }
  77   {
  78     int r;
  79     suppress_error = 0;
  80     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
  81     if (r == -1)
  82       return -1;
  83   }
  84   {
  85     int r;
  86     suppress_error = 0;
  87     r = guestfs_mount (g, "/dev/sda1", "/");
  88     if (r == -1)
  89       return -1;
  90   }
  91   {
  92     int r;
  93     suppress_error = 0;
  94     r = guestfs_write_file (g, "/new", "new file contents", 0);
  95     if (r == -1)
  96       return -1;
  97   }
  98   {
  99     char *r;
 100     suppress_error = 0;
 101     r = guestfs_cat (g, "/new");
 102     if (r == NULL)
 103       return -1;
 104     if (strcmp (r, "new file contents") != 0) {
 105       fprintf (stderr, "test_mount_0: expected \"new file contents\" but got \"%s\"\n", r);
 106       return -1;
 107     }
 108     free (r);
 109   }
 110   return 0;
 111 }
 112
 113 static int test_sync_0 (void)
 114 {
 115   /* InitEmpty for sync (0) */
 116   {
 117     int r;
 118     suppress_error = 0;
 119     r = guestfs_umount_all (g);
 120     if (r == -1)
 121       return -1;
 122   }
 123   {
 124     int r;
 125     suppress_error = 0;
 126     r = guestfs_lvm_remove_all (g);
 127     if (r == -1)
 128       return -1;
 129   }
 130   /* TestRun for sync (0) */
 131   {
 132     int r;
 133     suppress_error = 0;
 134     r = guestfs_sync (g);
 135     if (r == -1)
 136       return -1;
 137   }
 138   return 0;
 139 }
 140
 141 static int test_touch_0 (void)
 142 {
 143   /* InitBasicFS for touch (0): create ext2 on /dev/sda1 */
 144   {
 145     int r;
 146     suppress_error = 0;
 147     r = guestfs_umount_all (g);
 148     if (r == -1)
 149       return -1;
 150   }
 151   {
 152     int r;
 153     suppress_error = 0;
 154     r = guestfs_lvm_remove_all (g);
 155     if (r == -1)
 156       return -1;
 157   }
 158   {
 159     char *lines[] = {
 160       ",",
 161       NULL
 162     };
 163     int r;
 164     suppress_error = 0;
 165     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 166     if (r == -1)
 167       return -1;
 168   }
 169   {
 170     int r;
 171     suppress_error = 0;
 172     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 173     if (r == -1)
 174       return -1;
 175   }
 176   {
 177     int r;
 178     suppress_error = 0;
 179     r = guestfs_mount (g, "/dev/sda1", "/");
 180     if (r == -1)
 181       return -1;
 182   }
 183   /* TestOutputTrue for touch (0) */
 184   {
 185     int r;
 186     suppress_error = 0;
 187     r = guestfs_touch (g, "/new");
 188     if (r == -1)
 189       return -1;
 190   }
 191   {
 192     int r;
 193     suppress_error = 0;
 194     r = guestfs_exists (g, "/new");
 195     if (r == -1)
 196       return -1;
 197     if (!r) {
 198       fprintf (stderr, "test_touch_0: expected true, got false\n");
 199       return -1;
 200     }
 201   }
 202   return 0;
 203 }
 204
 205 static int test_cat_0 (void)
 206 {
 207   /* InitBasicFS for cat (0): create ext2 on /dev/sda1 */
 208   {
 209     int r;
 210     suppress_error = 0;
 211     r = guestfs_umount_all (g);
 212     if (r == -1)
 213       return -1;
 214   }
 215   {
 216     int r;
 217     suppress_error = 0;
 218     r = guestfs_lvm_remove_all (g);
 219     if (r == -1)
 220       return -1;
 221   }
 222   {
 223     char *lines[] = {
 224       ",",
 225       NULL
 226     };
 227     int r;
 228     suppress_error = 0;
 229     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 230     if (r == -1)
 231       return -1;
 232   }
 233   {
 234     int r;
 235     suppress_error = 0;
 236     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 237     if (r == -1)
 238       return -1;
 239   }
 240   {
 241     int r;
 242     suppress_error = 0;
 243     r = guestfs_mount (g, "/dev/sda1", "/");
 244     if (r == -1)
 245       return -1;
 246   }
 247   /* TestOutput for cat (0) */
 248   {
 249     int r;
 250     suppress_error = 0;
 251     r = guestfs_write_file (g, "/new", "new file contents", 0);
 252     if (r == -1)
 253       return -1;
 254   }
 255   {
 256     char *r;
 257     suppress_error = 0;
 258     r = guestfs_cat (g, "/new");
 259     if (r == NULL)
 260       return -1;
 261     if (strcmp (r, "new file contents") != 0) {
 262       fprintf (stderr, "test_cat_0: expected \"new file contents\" but got \"%s\"\n", r);
 263       return -1;
 264     }
 265     free (r);
 266   }
 267   return 0;
 268 }
 269
 270 static int test_ls_0 (void)
 271 {
 272   /* InitBasicFS for ls (0): create ext2 on /dev/sda1 */
 273   {
 274     int r;
 275     suppress_error = 0;
 276     r = guestfs_umount_all (g);
 277     if (r == -1)
 278       return -1;
 279   }
 280   {
 281     int r;
 282     suppress_error = 0;
 283     r = guestfs_lvm_remove_all (g);
 284     if (r == -1)
 285       return -1;
 286   }
 287   {
 288     char *lines[] = {
 289       ",",
 290       NULL
 291     };
 292     int r;
 293     suppress_error = 0;
 294     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 295     if (r == -1)
 296       return -1;
 297   }
 298   {
 299     int r;
 300     suppress_error = 0;
 301     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 302     if (r == -1)
 303       return -1;
 304   }
 305   {
 306     int r;
 307     suppress_error = 0;
 308     r = guestfs_mount (g, "/dev/sda1", "/");
 309     if (r == -1)
 310       return -1;
 311   }
 312   /* TestOutputList for ls (0) */
 313   {
 314     int r;
 315     suppress_error = 0;
 316     r = guestfs_touch (g, "/new");
 317     if (r == -1)
 318       return -1;
 319   }
 320   {
 321     int r;
 322     suppress_error = 0;
 323     r = guestfs_touch (g, "/newer");
 324     if (r == -1)
 325       return -1;
 326   }
 327   {
 328     int r;
 329     suppress_error = 0;
 330     r = guestfs_touch (g, "/newest");
 331     if (r == -1)
 332       return -1;
 333   }
 334   {
 335     char **r;
 336     int i;
 337     suppress_error = 0;
 338     r = guestfs_ls (g, "/");
 339     if (r == NULL)
 340       return -1;
 341     if (!r[0]) {
 342       fprintf (stderr, "test_ls_0: short list returned from command\n");
 343       print_strings (r);
 344       return -1;
 345     }
 346     if (strcmp (r[0], "lost+found") != 0) {
 347       fprintf (stderr, "test_ls_0: expected \"lost+found\" but got \"%s\"\n", r[0]);
 348       return -1;
 349     }
 350     if (!r[1]) {
 351       fprintf (stderr, "test_ls_0: short list returned from command\n");
 352       print_strings (r);
 353       return -1;
 354     }
 355     if (strcmp (r[1], "new") != 0) {
 356       fprintf (stderr, "test_ls_0: expected \"new\" but got \"%s\"\n", r[1]);
 357       return -1;
 358     }
 359     if (!r[2]) {
 360       fprintf (stderr, "test_ls_0: short list returned from command\n");
 361       print_strings (r);
 362       return -1;
 363     }
 364     if (strcmp (r[2], "newer") != 0) {
 365       fprintf (stderr, "test_ls_0: expected \"newer\" but got \"%s\"\n", r[2]);
 366       return -1;
 367     }
 368     if (!r[3]) {
 369       fprintf (stderr, "test_ls_0: short list returned from command\n");
 370       print_strings (r);
 371       return -1;
 372     }
 373     if (strcmp (r[3], "newest") != 0) {
 374       fprintf (stderr, "test_ls_0: expected \"newest\" but got \"%s\"\n", r[3]);
 375       return -1;
 376     }
 377     if (r[4] != NULL) {
 378       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
 379       print_strings (r);
 380       return -1;
 381     }
 382     for (i = 0; r[i] != NULL; ++i)
 383       free (r[i]);
 384     free (r);
 385   }
 386   return 0;
 387 }
 388
 389 static int test_list_devices_0 (void)
 390 {
 391   /* InitEmpty for list_devices (0) */
 392   {
 393     int r;
 394     suppress_error = 0;
 395     r = guestfs_umount_all (g);
 396     if (r == -1)
 397       return -1;
 398   }
 399   {
 400     int r;
 401     suppress_error = 0;
 402     r = guestfs_lvm_remove_all (g);
 403     if (r == -1)
 404       return -1;
 405   }
 406   /* TestOutputList for list_devices (0) */
 407   {
 408     char **r;
 409     int i;
 410     suppress_error = 0;
 411     r = guestfs_list_devices (g);
 412     if (r == NULL)
 413       return -1;
 414     if (!r[0]) {
 415       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
 416       print_strings (r);
 417       return -1;
 418     }
 419     if (strcmp (r[0], "/dev/sda") != 0) {
 420       fprintf (stderr, "test_list_devices_0: expected \"/dev/sda\" but got \"%s\"\n", r[0]);
 421       return -1;
 422     }
 423     if (!r[1]) {
 424       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
 425       print_strings (r);
 426       return -1;
 427     }
 428     if (strcmp (r[1], "/dev/sdb") != 0) {
 429       fprintf (stderr, "test_list_devices_0: expected \"/dev/sdb\" but got \"%s\"\n", r[1]);
 430       return -1;
 431     }
 432     if (!r[2]) {
 433       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
 434       print_strings (r);
 435       return -1;
 436     }
 437     if (strcmp (r[2], "/dev/sdc") != 0) {
 438       fprintf (stderr, "test_list_devices_0: expected \"/dev/sdc\" but got \"%s\"\n", r[2]);
 439       return -1;
 440     }
 441     if (r[3] != NULL) {
 442       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
 443       print_strings (r);
 444       return -1;
 445     }
 446     for (i = 0; r[i] != NULL; ++i)
 447       free (r[i]);
 448     free (r);
 449   }
 450   return 0;
 451 }
 452
 453 static int test_list_partitions_0 (void)
 454 {
 455   /* InitBasicFS for list_partitions (0): create ext2 on /dev/sda1 */
 456   {
 457     int r;
 458     suppress_error = 0;
 459     r = guestfs_umount_all (g);
 460     if (r == -1)
 461       return -1;
 462   }
 463   {
 464     int r;
 465     suppress_error = 0;
 466     r = guestfs_lvm_remove_all (g);
 467     if (r == -1)
 468       return -1;
 469   }
 470   {
 471     char *lines[] = {
 472       ",",
 473       NULL
 474     };
 475     int r;
 476     suppress_error = 0;
 477     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 478     if (r == -1)
 479       return -1;
 480   }
 481   {
 482     int r;
 483     suppress_error = 0;
 484     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
 485     if (r == -1)
 486       return -1;
 487   }
 488   {
 489     int r;
 490     suppress_error = 0;
 491     r = guestfs_mount (g, "/dev/sda1", "/");
 492     if (r == -1)
 493       return -1;
 494   }
 495   /* TestOutputList for list_partitions (0) */
 496   {
 497     char **r;
 498     int i;
 499     suppress_error = 0;
 500     r = guestfs_list_partitions (g);
 501     if (r == NULL)
 502       return -1;
 503     if (!r[0]) {
 504       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
 505       print_strings (r);
 506       return -1;
 507     }
 508     if (strcmp (r[0], "/dev/sda1") != 0) {
 509       fprintf (stderr, "test_list_partitions_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
 510       return -1;
 511     }
 512     if (r[1] != NULL) {
 513       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
 514       print_strings (r);
 515       return -1;
 516     }
 517     for (i = 0; r[i] != NULL; ++i)
 518       free (r[i]);
 519     free (r);
 520   }
 521   return 0;
 522 }
 523
 524 static int test_list_partitions_1 (void)
 525 {
 526   /* InitEmpty for list_partitions (1) */
 527   {
 528     int r;
 529     suppress_error = 0;
 530     r = guestfs_umount_all (g);
 531     if (r == -1)
 532       return -1;
 533   }
 534   {
 535     int r;
 536     suppress_error = 0;
 537     r = guestfs_lvm_remove_all (g);
 538     if (r == -1)
 539       return -1;
 540   }
 541   /* TestOutputList for list_partitions (1) */
 542   {
 543     char *lines[] = {
 544       ",10",
 545       ",20",
 546       ",",
 547       NULL
 548     };
 549     int r;
 550     suppress_error = 0;
 551     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 552     if (r == -1)
 553       return -1;
 554   }
 555   {
 556     char **r;
 557     int i;
 558     suppress_error = 0;
 559     r = guestfs_list_partitions (g);
 560     if (r == NULL)
 561       return -1;
 562     if (!r[0]) {
 563       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
 564       print_strings (r);
 565       return -1;
 566     }
 567     if (strcmp (r[0], "/dev/sda1") != 0) {
 568       fprintf (stderr, "test_list_partitions_1: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
 569       return -1;
 570     }
 571     if (!r[1]) {
 572       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
 573       print_strings (r);
 574       return -1;
 575     }
 576     if (strcmp (r[1], "/dev/sda2") != 0) {
 577       fprintf (stderr, "test_list_partitions_1: expected \"/dev/sda2\" but got \"%s\"\n", r[1]);
 578       return -1;
 579     }
 580     if (!r[2]) {
 581       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
 582       print_strings (r);
 583       return -1;
 584     }
 585     if (strcmp (r[2], "/dev/sda3") != 0) {
 586       fprintf (stderr, "test_list_partitions_1: expected \"/dev/sda3\" but got \"%s\"\n", r[2]);
 587       return -1;
 588     }
 589     if (r[3] != NULL) {
 590       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
 591       print_strings (r);
 592       return -1;
 593     }
 594     for (i = 0; r[i] != NULL; ++i)
 595       free (r[i]);
 596     free (r);
 597   }
 598   return 0;
 599 }
 600
 601 static int test_pvs_0 (void)
 602 {
 603   /* InitBasicFSonLVM for pvs (0): create ext2 on /dev/VG/LV */
 604   {
 605     int r;
 606     suppress_error = 0;
 607     r = guestfs_umount_all (g);
 608     if (r == -1)
 609       return -1;
 610   }
 611   {
 612     int r;
 613     suppress_error = 0;
 614     r = guestfs_lvm_remove_all (g);
 615     if (r == -1)
 616       return -1;
 617   }
 618   {
 619     char *lines[] = {
 620       ",",
 621       NULL
 622     };
 623     int r;
 624     suppress_error = 0;
 625     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 626     if (r == -1)
 627       return -1;
 628   }
 629   {
 630     int r;
 631     suppress_error = 0;
 632     r = guestfs_pvcreate (g, "/dev/sda1");
 633     if (r == -1)
 634       return -1;
 635   }
 636   {
 637     char *physvols[] = {
 638       "/dev/sda1",
 639       NULL
 640     };
 641     int r;
 642     suppress_error = 0;
 643     r = guestfs_vgcreate (g, "VG", physvols);
 644     if (r == -1)
 645       return -1;
 646   }
 647   {
 648     int r;
 649     suppress_error = 0;
 650     r = guestfs_lvcreate (g, "LV", "VG", 8);
 651     if (r == -1)
 652       return -1;
 653   }
 654   {
 655     int r;
 656     suppress_error = 0;
 657     r = guestfs_mkfs (g, "ext2", "/dev/VG/LV");
 658     if (r == -1)
 659       return -1;
 660   }
 661   {
 662     int r;
 663     suppress_error = 0;
 664     r = guestfs_mount (g, "/dev/VG/LV", "/");
 665     if (r == -1)
 666       return -1;
 667   }
 668   /* TestOutputList for pvs (0) */
 669   {
 670     char **r;
 671     int i;
 672     suppress_error = 0;
 673     r = guestfs_pvs (g);
 674     if (r == NULL)
 675       return -1;
 676     if (!r[0]) {
 677       fprintf (stderr, "test_pvs_0: short list returned from command\n");
 678       print_strings (r);
 679       return -1;
 680     }
 681     if (strcmp (r[0], "/dev/sda1") != 0) {
 682       fprintf (stderr, "test_pvs_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
 683       return -1;
 684     }
 685     if (r[1] != NULL) {
 686       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
 687       print_strings (r);
 688       return -1;
 689     }
 690     for (i = 0; r[i] != NULL; ++i)
 691       free (r[i]);
 692     free (r);
 693   }
 694   return 0;
 695 }
 696
 697 static int test_pvs_1 (void)
 698 {
 699   /* InitEmpty for pvs (1) */
 700   {
 701     int r;
 702     suppress_error = 0;
 703     r = guestfs_umount_all (g);
 704     if (r == -1)
 705       return -1;
 706   }
 707   {
 708     int r;
 709     suppress_error = 0;
 710     r = guestfs_lvm_remove_all (g);
 711     if (r == -1)
 712       return -1;
 713   }
 714   /* TestOutputList for pvs (1) */
 715   {
 716     char *lines[] = {
 717       ",10",
 718       ",20",
 719       ",",
 720       NULL
 721     };
 722     int r;
 723     suppress_error = 0;
 724     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 725     if (r == -1)
 726       return -1;
 727   }
 728   {
 729     int r;
 730     suppress_error = 0;
 731     r = guestfs_pvcreate (g, "/dev/sda1");
 732     if (r == -1)
 733       return -1;
 734   }
 735   {
 736     int r;
 737     suppress_error = 0;
 738     r = guestfs_pvcreate (g, "/dev/sda2");
 739     if (r == -1)
 740       return -1;
 741   }
 742   {
 743     int r;
 744     suppress_error = 0;
 745     r = guestfs_pvcreate (g, "/dev/sda3");
 746     if (r == -1)
 747       return -1;
 748   }
 749   {
 750     char **r;
 751     int i;
 752     suppress_error = 0;
 753     r = guestfs_pvs (g);
 754     if (r == NULL)
 755       return -1;
 756     if (!r[0]) {
 757       fprintf (stderr, "test_pvs_1: short list returned from command\n");
 758       print_strings (r);
 759       return -1;
 760     }
 761     if (strcmp (r[0], "/dev/sda1") != 0) {
 762       fprintf (stderr, "test_pvs_1: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
 763       return -1;
 764     }
 765     if (!r[1]) {
 766       fprintf (stderr, "test_pvs_1: short list returned from command\n");
 767       print_strings (r);
 768       return -1;
 769     }
 770     if (strcmp (r[1], "/dev/sda2") != 0) {
 771       fprintf (stderr, "test_pvs_1: expected \"/dev/sda2\" but got \"%s\"\n", r[1]);
 772       return -1;
 773     }
 774     if (!r[2]) {
 775       fprintf (stderr, "test_pvs_1: short list returned from command\n");
 776       print_strings (r);
 777       return -1;
 778     }
 779     if (strcmp (r[2], "/dev/sda3") != 0) {
 780       fprintf (stderr, "test_pvs_1: expected \"/dev/sda3\" but got \"%s\"\n", r[2]);
 781       return -1;
 782     }
 783     if (r[3] != NULL) {
 784       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
 785       print_strings (r);
 786       return -1;
 787     }
 788     for (i = 0; r[i] != NULL; ++i)
 789       free (r[i]);
 790     free (r);
 791   }
 792   return 0;
 793 }
 794
 795 static int test_vgs_0 (void)
 796 {
 797   /* InitBasicFSonLVM for vgs (0): create ext2 on /dev/VG/LV */
 798   {
 799     int r;
 800     suppress_error = 0;
 801     r = guestfs_umount_all (g);
 802     if (r == -1)
 803       return -1;
 804   }
 805   {
 806     int r;
 807     suppress_error = 0;
 808     r = guestfs_lvm_remove_all (g);
 809     if (r == -1)
 810       return -1;
 811   }
 812   {
 813     char *lines[] = {
 814       ",",
 815       NULL
 816     };
 817     int r;
 818     suppress_error = 0;
 819     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 820     if (r == -1)
 821       return -1;
 822   }
 823   {
 824     int r;
 825     suppress_error = 0;
 826     r = guestfs_pvcreate (g, "/dev/sda1");
 827     if (r == -1)
 828       return -1;
 829   }
 830   {
 831     char *physvols[] = {
 832       "/dev/sda1",
 833       NULL
 834     };
 835     int r;
 836     suppress_error = 0;
 837     r = guestfs_vgcreate (g, "VG", physvols);
 838     if (r == -1)
 839       return -1;
 840   }
 841   {
 842     int r;
 843     suppress_error = 0;
 844     r = guestfs_lvcreate (g, "LV", "VG", 8);
 845     if (r == -1)
 846       return -1;
 847   }
 848   {
 849     int r;
 850     suppress_error = 0;
 851     r = guestfs_mkfs (g, "ext2", "/dev/VG/LV");
 852     if (r == -1)
 853       return -1;
 854   }
 855   {
 856     int r;
 857     suppress_error = 0;
 858     r = guestfs_mount (g, "/dev/VG/LV", "/");
 859     if (r == -1)
 860       return -1;
 861   }
 862   /* TestOutputList for vgs (0) */
 863   {
 864     char **r;
 865     int i;
 866     suppress_error = 0;
 867     r = guestfs_vgs (g);
 868     if (r == NULL)
 869       return -1;
 870     if (!r[0]) {
 871       fprintf (stderr, "test_vgs_0: short list returned from command\n");
 872       print_strings (r);
 873       return -1;
 874     }
 875     if (strcmp (r[0], "VG") != 0) {
 876       fprintf (stderr, "test_vgs_0: expected \"VG\" but got \"%s\"\n", r[0]);
 877       return -1;
 878     }
 879     if (r[1] != NULL) {
 880       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
 881       print_strings (r);
 882       return -1;
 883     }
 884     for (i = 0; r[i] != NULL; ++i)
 885       free (r[i]);
 886     free (r);
 887   }
 888   return 0;
 889 }
 890
 891 static int test_vgs_1 (void)
 892 {
 893   /* InitEmpty for vgs (1) */
 894   {
 895     int r;
 896     suppress_error = 0;
 897     r = guestfs_umount_all (g);
 898     if (r == -1)
 899       return -1;
 900   }
 901   {
 902     int r;
 903     suppress_error = 0;
 904     r = guestfs_lvm_remove_all (g);
 905     if (r == -1)
 906       return -1;
 907   }
 908   /* TestOutputList for vgs (1) */
 909   {
 910     char *lines[] = {
 911       ",10",
 912       ",20",
 913       ",",
 914       NULL
 915     };
 916     int r;
 917     suppress_error = 0;
 918     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
 919     if (r == -1)
 920       return -1;
 921   }
 922   {
 923     int r;
 924     suppress_error = 0;
 925     r = guestfs_pvcreate (g, "/dev/sda1");
 926     if (r == -1)
 927       return -1;
 928   }
 929   {
 930     int r;
 931     suppress_error = 0;
 932     r = guestfs_pvcreate (g, "/dev/sda2");
 933     if (r == -1)
 934       return -1;
 935   }
 936   {
 937     int r;
 938     suppress_error = 0;
 939     r = guestfs_pvcreate (g, "/dev/sda3");
 940     if (r == -1)
 941       return -1;
 942   }
 943   {
 944     char *physvols[] = {
 945       "/dev/sda1",
 946       "/dev/sda2",
 947       NULL
 948     };
 949     int r;
 950     suppress_error = 0;
 951     r = guestfs_vgcreate (g, "VG1", physvols);
 952     if (r == -1)
 953       return -1;
 954   }
 955   {
 956     char *physvols[] = {
 957       "/dev/sda3",
 958       NULL
 959     };
 960     int r;
 961     suppress_error = 0;
 962     r = guestfs_vgcreate (g, "VG2", physvols);
 963     if (r == -1)
 964       return -1;
 965   }
 966   {
 967     char **r;
 968     int i;
 969     suppress_error = 0;
 970     r = guestfs_vgs (g);
 971     if (r == NULL)
 972       return -1;
 973     if (!r[0]) {
 974       fprintf (stderr, "test_vgs_1: short list returned from command\n");
 975       print_strings (r);
 976       return -1;
 977     }
 978     if (strcmp (r[0], "VG1") != 0) {
 979       fprintf (stderr, "test_vgs_1: expected \"VG1\" but got \"%s\"\n", r[0]);
 980       return -1;
 981     }
 982     if (!r[1]) {
 983       fprintf (stderr, "test_vgs_1: short list returned from command\n");
 984       print_strings (r);
 985       return -1;
 986     }
 987     if (strcmp (r[1], "VG2") != 0) {
 988       fprintf (stderr, "test_vgs_1: expected \"VG2\" but got \"%s\"\n", r[1]);
 989       return -1;
 990     }
 991     if (r[2] != NULL) {
 992       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
 993       print_strings (r);
 994       return -1;
 995     }
 996     for (i = 0; r[i] != NULL; ++i)
 997       free (r[i]);
 998     free (r);
 999   }
1000   return 0;
1001 }
1002
1003 static int test_lvs_0 (void)
1004 {
1005   /* InitBasicFSonLVM for lvs (0): create ext2 on /dev/VG/LV */
1006   {
1007     int r;
1008     suppress_error = 0;
1009     r = guestfs_umount_all (g);
1010     if (r == -1)
1011       return -1;
1012   }
1013   {
1014     int r;
1015     suppress_error = 0;
1016     r = guestfs_lvm_remove_all (g);
1017     if (r == -1)
1018       return -1;
1019   }
1020   {
1021     char *lines[] = {
1022       ",",
1023       NULL
1024     };
1025     int r;
1026     suppress_error = 0;
1027     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1028     if (r == -1)
1029       return -1;
1030   }
1031   {
1032     int r;
1033     suppress_error = 0;
1034     r = guestfs_pvcreate (g, "/dev/sda1");
1035     if (r == -1)
1036       return -1;
1037   }
1038   {
1039     char *physvols[] = {
1040       "/dev/sda1",
1041       NULL
1042     };
1043     int r;
1044     suppress_error = 0;
1045     r = guestfs_vgcreate (g, "VG", physvols);
1046     if (r == -1)
1047       return -1;
1048   }
1049   {
1050     int r;
1051     suppress_error = 0;
1052     r = guestfs_lvcreate (g, "LV", "VG", 8);
1053     if (r == -1)
1054       return -1;
1055   }
1056   {
1057     int r;
1058     suppress_error = 0;
1059     r = guestfs_mkfs (g, "ext2", "/dev/VG/LV");
1060     if (r == -1)
1061       return -1;
1062   }
1063   {
1064     int r;
1065     suppress_error = 0;
1066     r = guestfs_mount (g, "/dev/VG/LV", "/");
1067     if (r == -1)
1068       return -1;
1069   }
1070   /* TestOutputList for lvs (0) */
1071   {
1072     char **r;
1073     int i;
1074     suppress_error = 0;
1075     r = guestfs_lvs (g);
1076     if (r == NULL)
1077       return -1;
1078     if (!r[0]) {
1079       fprintf (stderr, "test_lvs_0: short list returned from command\n");
1080       print_strings (r);
1081       return -1;
1082     }
1083     if (strcmp (r[0], "/dev/VG/LV") != 0) {
1084       fprintf (stderr, "test_lvs_0: expected \"/dev/VG/LV\" but got \"%s\"\n", r[0]);
1085       return -1;
1086     }
1087     if (r[1] != NULL) {
1088       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
1089       print_strings (r);
1090       return -1;
1091     }
1092     for (i = 0; r[i] != NULL; ++i)
1093       free (r[i]);
1094     free (r);
1095   }
1096   return 0;
1097 }
1098
1099 static int test_lvs_1 (void)
1100 {
1101   /* InitEmpty for lvs (1) */
1102   {
1103     int r;
1104     suppress_error = 0;
1105     r = guestfs_umount_all (g);
1106     if (r == -1)
1107       return -1;
1108   }
1109   {
1110     int r;
1111     suppress_error = 0;
1112     r = guestfs_lvm_remove_all (g);
1113     if (r == -1)
1114       return -1;
1115   }
1116   /* TestOutputList for lvs (1) */
1117   {
1118     char *lines[] = {
1119       ",10",
1120       ",20",
1121       ",",
1122       NULL
1123     };
1124     int r;
1125     suppress_error = 0;
1126     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1127     if (r == -1)
1128       return -1;
1129   }
1130   {
1131     int r;
1132     suppress_error = 0;
1133     r = guestfs_pvcreate (g, "/dev/sda1");
1134     if (r == -1)
1135       return -1;
1136   }
1137   {
1138     int r;
1139     suppress_error = 0;
1140     r = guestfs_pvcreate (g, "/dev/sda2");
1141     if (r == -1)
1142       return -1;
1143   }
1144   {
1145     int r;
1146     suppress_error = 0;
1147     r = guestfs_pvcreate (g, "/dev/sda3");
1148     if (r == -1)
1149       return -1;
1150   }
1151   {
1152     char *physvols[] = {
1153       "/dev/sda1",
1154       "/dev/sda2",
1155       NULL
1156     };
1157     int r;
1158     suppress_error = 0;
1159     r = guestfs_vgcreate (g, "VG1", physvols);
1160     if (r == -1)
1161       return -1;
1162   }
1163   {
1164     char *physvols[] = {
1165       "/dev/sda3",
1166       NULL
1167     };
1168     int r;
1169     suppress_error = 0;
1170     r = guestfs_vgcreate (g, "VG2", physvols);
1171     if (r == -1)
1172       return -1;
1173   }
1174   {
1175     int r;
1176     suppress_error = 0;
1177     r = guestfs_lvcreate (g, "LV1", "VG1", 50);
1178     if (r == -1)
1179       return -1;
1180   }
1181   {
1182     int r;
1183     suppress_error = 0;
1184     r = guestfs_lvcreate (g, "LV2", "VG1", 50);
1185     if (r == -1)
1186       return -1;
1187   }
1188   {
1189     int r;
1190     suppress_error = 0;
1191     r = guestfs_lvcreate (g, "LV3", "VG2", 50);
1192     if (r == -1)
1193       return -1;
1194   }
1195   {
1196     char **r;
1197     int i;
1198     suppress_error = 0;
1199     r = guestfs_lvs (g);
1200     if (r == NULL)
1201       return -1;
1202     if (!r[0]) {
1203       fprintf (stderr, "test_lvs_1: short list returned from command\n");
1204       print_strings (r);
1205       return -1;
1206     }
1207     if (strcmp (r[0], "/dev/VG1/LV1") != 0) {
1208       fprintf (stderr, "test_lvs_1: expected \"/dev/VG1/LV1\" but got \"%s\"\n", r[0]);
1209       return -1;
1210     }
1211     if (!r[1]) {
1212       fprintf (stderr, "test_lvs_1: short list returned from command\n");
1213       print_strings (r);
1214       return -1;
1215     }
1216     if (strcmp (r[1], "/dev/VG1/LV2") != 0) {
1217       fprintf (stderr, "test_lvs_1: expected \"/dev/VG1/LV2\" but got \"%s\"\n", r[1]);
1218       return -1;
1219     }
1220     if (!r[2]) {
1221       fprintf (stderr, "test_lvs_1: short list returned from command\n");
1222       print_strings (r);
1223       return -1;
1224     }
1225     if (strcmp (r[2], "/dev/VG2/LV3") != 0) {
1226       fprintf (stderr, "test_lvs_1: expected \"/dev/VG2/LV3\" but got \"%s\"\n", r[2]);
1227       return -1;
1228     }
1229     if (r[3] != NULL) {
1230       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
1231       print_strings (r);
1232       return -1;
1233     }
1234     for (i = 0; r[i] != NULL; ++i)
1235       free (r[i]);
1236     free (r);
1237   }
1238   return 0;
1239 }
1240
1241 static int test_read_lines_0 (void)
1242 {
1243   /* InitBasicFS for read_lines (0): create ext2 on /dev/sda1 */
1244   {
1245     int r;
1246     suppress_error = 0;
1247     r = guestfs_umount_all (g);
1248     if (r == -1)
1249       return -1;
1250   }
1251   {
1252     int r;
1253     suppress_error = 0;
1254     r = guestfs_lvm_remove_all (g);
1255     if (r == -1)
1256       return -1;
1257   }
1258   {
1259     char *lines[] = {
1260       ",",
1261       NULL
1262     };
1263     int r;
1264     suppress_error = 0;
1265     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1266     if (r == -1)
1267       return -1;
1268   }
1269   {
1270     int r;
1271     suppress_error = 0;
1272     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1273     if (r == -1)
1274       return -1;
1275   }
1276   {
1277     int r;
1278     suppress_error = 0;
1279     r = guestfs_mount (g, "/dev/sda1", "/");
1280     if (r == -1)
1281       return -1;
1282   }
1283   /* TestOutputList for read_lines (0) */
1284   {
1285     int r;
1286     suppress_error = 0;
1287     r = guestfs_write_file (g, "/new", "line1\r\nline2\nline3", 0);
1288     if (r == -1)
1289       return -1;
1290   }
1291   {
1292     char **r;
1293     int i;
1294     suppress_error = 0;
1295     r = guestfs_read_lines (g, "/new");
1296     if (r == NULL)
1297       return -1;
1298     if (!r[0]) {
1299       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
1300       print_strings (r);
1301       return -1;
1302     }
1303     if (strcmp (r[0], "line1") != 0) {
1304       fprintf (stderr, "test_read_lines_0: expected \"line1\" but got \"%s\"\n", r[0]);
1305       return -1;
1306     }
1307     if (!r[1]) {
1308       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
1309       print_strings (r);
1310       return -1;
1311     }
1312     if (strcmp (r[1], "line2") != 0) {
1313       fprintf (stderr, "test_read_lines_0: expected \"line2\" but got \"%s\"\n", r[1]);
1314       return -1;
1315     }
1316     if (!r[2]) {
1317       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
1318       print_strings (r);
1319       return -1;
1320     }
1321     if (strcmp (r[2], "line3") != 0) {
1322       fprintf (stderr, "test_read_lines_0: expected \"line3\" but got \"%s\"\n", r[2]);
1323       return -1;
1324     }
1325     if (r[3] != NULL) {
1326       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
1327       print_strings (r);
1328       return -1;
1329     }
1330     for (i = 0; r[i] != NULL; ++i)
1331       free (r[i]);
1332     free (r);
1333   }
1334   return 0;
1335 }
1336
1337 static int test_read_lines_1 (void)
1338 {
1339   /* InitBasicFS for read_lines (1): create ext2 on /dev/sda1 */
1340   {
1341     int r;
1342     suppress_error = 0;
1343     r = guestfs_umount_all (g);
1344     if (r == -1)
1345       return -1;
1346   }
1347   {
1348     int r;
1349     suppress_error = 0;
1350     r = guestfs_lvm_remove_all (g);
1351     if (r == -1)
1352       return -1;
1353   }
1354   {
1355     char *lines[] = {
1356       ",",
1357       NULL
1358     };
1359     int r;
1360     suppress_error = 0;
1361     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1362     if (r == -1)
1363       return -1;
1364   }
1365   {
1366     int r;
1367     suppress_error = 0;
1368     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1369     if (r == -1)
1370       return -1;
1371   }
1372   {
1373     int r;
1374     suppress_error = 0;
1375     r = guestfs_mount (g, "/dev/sda1", "/");
1376     if (r == -1)
1377       return -1;
1378   }
1379   /* TestOutputList for read_lines (1) */
1380   {
1381     int r;
1382     suppress_error = 0;
1383     r = guestfs_write_file (g, "/new", "", 0);
1384     if (r == -1)
1385       return -1;
1386   }
1387   {
1388     char **r;
1389     int i;
1390     suppress_error = 0;
1391     r = guestfs_read_lines (g, "/new");
1392     if (r == NULL)
1393       return -1;
1394     if (r[0] != NULL) {
1395       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
1396       print_strings (r);
1397       return -1;
1398     }
1399     for (i = 0; r[i] != NULL; ++i)
1400       free (r[i]);
1401     free (r);
1402   }
1403   return 0;
1404 }
1405
1406 static int test_rm_0 (void)
1407 {
1408   /* InitBasicFS for rm (0): create ext2 on /dev/sda1 */
1409   {
1410     int r;
1411     suppress_error = 0;
1412     r = guestfs_umount_all (g);
1413     if (r == -1)
1414       return -1;
1415   }
1416   {
1417     int r;
1418     suppress_error = 0;
1419     r = guestfs_lvm_remove_all (g);
1420     if (r == -1)
1421       return -1;
1422   }
1423   {
1424     char *lines[] = {
1425       ",",
1426       NULL
1427     };
1428     int r;
1429     suppress_error = 0;
1430     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1431     if (r == -1)
1432       return -1;
1433   }
1434   {
1435     int r;
1436     suppress_error = 0;
1437     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1438     if (r == -1)
1439       return -1;
1440   }
1441   {
1442     int r;
1443     suppress_error = 0;
1444     r = guestfs_mount (g, "/dev/sda1", "/");
1445     if (r == -1)
1446       return -1;
1447   }
1448   /* TestRun for rm (0) */
1449   {
1450     int r;
1451     suppress_error = 0;
1452     r = guestfs_touch (g, "/new");
1453     if (r == -1)
1454       return -1;
1455   }
1456   {
1457     int r;
1458     suppress_error = 0;
1459     r = guestfs_rm (g, "/new");
1460     if (r == -1)
1461       return -1;
1462   }
1463   return 0;
1464 }
1465
1466 static int test_rm_1 (void)
1467 {
1468   /* InitBasicFS for rm (1): create ext2 on /dev/sda1 */
1469   {
1470     int r;
1471     suppress_error = 0;
1472     r = guestfs_umount_all (g);
1473     if (r == -1)
1474       return -1;
1475   }
1476   {
1477     int r;
1478     suppress_error = 0;
1479     r = guestfs_lvm_remove_all (g);
1480     if (r == -1)
1481       return -1;
1482   }
1483   {
1484     char *lines[] = {
1485       ",",
1486       NULL
1487     };
1488     int r;
1489     suppress_error = 0;
1490     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1491     if (r == -1)
1492       return -1;
1493   }
1494   {
1495     int r;
1496     suppress_error = 0;
1497     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1498     if (r == -1)
1499       return -1;
1500   }
1501   {
1502     int r;
1503     suppress_error = 0;
1504     r = guestfs_mount (g, "/dev/sda1", "/");
1505     if (r == -1)
1506       return -1;
1507   }
1508   /* TestLastFail for rm (1) */
1509   {
1510     int r;
1511     suppress_error = 1;
1512     r = guestfs_rm (g, "/new");
1513     if (r != -1)
1514       return -1;
1515   }
1516   return 0;
1517 }
1518
1519 static int test_rm_2 (void)
1520 {
1521   /* InitBasicFS for rm (2): create ext2 on /dev/sda1 */
1522   {
1523     int r;
1524     suppress_error = 0;
1525     r = guestfs_umount_all (g);
1526     if (r == -1)
1527       return -1;
1528   }
1529   {
1530     int r;
1531     suppress_error = 0;
1532     r = guestfs_lvm_remove_all (g);
1533     if (r == -1)
1534       return -1;
1535   }
1536   {
1537     char *lines[] = {
1538       ",",
1539       NULL
1540     };
1541     int r;
1542     suppress_error = 0;
1543     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1544     if (r == -1)
1545       return -1;
1546   }
1547   {
1548     int r;
1549     suppress_error = 0;
1550     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1551     if (r == -1)
1552       return -1;
1553   }
1554   {
1555     int r;
1556     suppress_error = 0;
1557     r = guestfs_mount (g, "/dev/sda1", "/");
1558     if (r == -1)
1559       return -1;
1560   }
1561   /* TestLastFail for rm (2) */
1562   {
1563     int r;
1564     suppress_error = 0;
1565     r = guestfs_mkdir (g, "/new");
1566     if (r == -1)
1567       return -1;
1568   }
1569   {
1570     int r;
1571     suppress_error = 1;
1572     r = guestfs_rm (g, "/new");
1573     if (r != -1)
1574       return -1;
1575   }
1576   return 0;
1577 }
1578
1579 static int test_rmdir_0 (void)
1580 {
1581   /* InitBasicFS for rmdir (0): create ext2 on /dev/sda1 */
1582   {
1583     int r;
1584     suppress_error = 0;
1585     r = guestfs_umount_all (g);
1586     if (r == -1)
1587       return -1;
1588   }
1589   {
1590     int r;
1591     suppress_error = 0;
1592     r = guestfs_lvm_remove_all (g);
1593     if (r == -1)
1594       return -1;
1595   }
1596   {
1597     char *lines[] = {
1598       ",",
1599       NULL
1600     };
1601     int r;
1602     suppress_error = 0;
1603     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1604     if (r == -1)
1605       return -1;
1606   }
1607   {
1608     int r;
1609     suppress_error = 0;
1610     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1611     if (r == -1)
1612       return -1;
1613   }
1614   {
1615     int r;
1616     suppress_error = 0;
1617     r = guestfs_mount (g, "/dev/sda1", "/");
1618     if (r == -1)
1619       return -1;
1620   }
1621   /* TestRun for rmdir (0) */
1622   {
1623     int r;
1624     suppress_error = 0;
1625     r = guestfs_mkdir (g, "/new");
1626     if (r == -1)
1627       return -1;
1628   }
1629   {
1630     int r;
1631     suppress_error = 0;
1632     r = guestfs_rmdir (g, "/new");
1633     if (r == -1)
1634       return -1;
1635   }
1636   return 0;
1637 }
1638
1639 static int test_rmdir_1 (void)
1640 {
1641   /* InitBasicFS for rmdir (1): create ext2 on /dev/sda1 */
1642   {
1643     int r;
1644     suppress_error = 0;
1645     r = guestfs_umount_all (g);
1646     if (r == -1)
1647       return -1;
1648   }
1649   {
1650     int r;
1651     suppress_error = 0;
1652     r = guestfs_lvm_remove_all (g);
1653     if (r == -1)
1654       return -1;
1655   }
1656   {
1657     char *lines[] = {
1658       ",",
1659       NULL
1660     };
1661     int r;
1662     suppress_error = 0;
1663     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1664     if (r == -1)
1665       return -1;
1666   }
1667   {
1668     int r;
1669     suppress_error = 0;
1670     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1671     if (r == -1)
1672       return -1;
1673   }
1674   {
1675     int r;
1676     suppress_error = 0;
1677     r = guestfs_mount (g, "/dev/sda1", "/");
1678     if (r == -1)
1679       return -1;
1680   }
1681   /* TestLastFail for rmdir (1) */
1682   {
1683     int r;
1684     suppress_error = 1;
1685     r = guestfs_rmdir (g, "/new");
1686     if (r != -1)
1687       return -1;
1688   }
1689   return 0;
1690 }
1691
1692 static int test_rmdir_2 (void)
1693 {
1694   /* InitBasicFS for rmdir (2): create ext2 on /dev/sda1 */
1695   {
1696     int r;
1697     suppress_error = 0;
1698     r = guestfs_umount_all (g);
1699     if (r == -1)
1700       return -1;
1701   }
1702   {
1703     int r;
1704     suppress_error = 0;
1705     r = guestfs_lvm_remove_all (g);
1706     if (r == -1)
1707       return -1;
1708   }
1709   {
1710     char *lines[] = {
1711       ",",
1712       NULL
1713     };
1714     int r;
1715     suppress_error = 0;
1716     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1717     if (r == -1)
1718       return -1;
1719   }
1720   {
1721     int r;
1722     suppress_error = 0;
1723     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1724     if (r == -1)
1725       return -1;
1726   }
1727   {
1728     int r;
1729     suppress_error = 0;
1730     r = guestfs_mount (g, "/dev/sda1", "/");
1731     if (r == -1)
1732       return -1;
1733   }
1734   /* TestLastFail for rmdir (2) */
1735   {
1736     int r;
1737     suppress_error = 0;
1738     r = guestfs_touch (g, "/new");
1739     if (r == -1)
1740       return -1;
1741   }
1742   {
1743     int r;
1744     suppress_error = 1;
1745     r = guestfs_rmdir (g, "/new");
1746     if (r != -1)
1747       return -1;
1748   }
1749   return 0;
1750 }
1751
1752 static int test_rm_rf_0 (void)
1753 {
1754   /* InitBasicFS for rm_rf (0): create ext2 on /dev/sda1 */
1755   {
1756     int r;
1757     suppress_error = 0;
1758     r = guestfs_umount_all (g);
1759     if (r == -1)
1760       return -1;
1761   }
1762   {
1763     int r;
1764     suppress_error = 0;
1765     r = guestfs_lvm_remove_all (g);
1766     if (r == -1)
1767       return -1;
1768   }
1769   {
1770     char *lines[] = {
1771       ",",
1772       NULL
1773     };
1774     int r;
1775     suppress_error = 0;
1776     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1777     if (r == -1)
1778       return -1;
1779   }
1780   {
1781     int r;
1782     suppress_error = 0;
1783     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1784     if (r == -1)
1785       return -1;
1786   }
1787   {
1788     int r;
1789     suppress_error = 0;
1790     r = guestfs_mount (g, "/dev/sda1", "/");
1791     if (r == -1)
1792       return -1;
1793   }
1794   /* TestOutputFalse for rm_rf (0) */
1795   {
1796     int r;
1797     suppress_error = 0;
1798     r = guestfs_mkdir (g, "/new");
1799     if (r == -1)
1800       return -1;
1801   }
1802   {
1803     int r;
1804     suppress_error = 0;
1805     r = guestfs_mkdir (g, "/new/foo");
1806     if (r == -1)
1807       return -1;
1808   }
1809   {
1810     int r;
1811     suppress_error = 0;
1812     r = guestfs_touch (g, "/new/foo/bar");
1813     if (r == -1)
1814       return -1;
1815   }
1816   {
1817     int r;
1818     suppress_error = 0;
1819     r = guestfs_rm_rf (g, "/new");
1820     if (r == -1)
1821       return -1;
1822   }
1823   {
1824     int r;
1825     suppress_error = 0;
1826     r = guestfs_exists (g, "/new");
1827     if (r == -1)
1828       return -1;
1829     if (r) {
1830       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
1831       return -1;
1832     }
1833   }
1834   return 0;
1835 }
1836
1837 static int test_mkdir_0 (void)
1838 {
1839   /* InitBasicFS for mkdir (0): create ext2 on /dev/sda1 */
1840   {
1841     int r;
1842     suppress_error = 0;
1843     r = guestfs_umount_all (g);
1844     if (r == -1)
1845       return -1;
1846   }
1847   {
1848     int r;
1849     suppress_error = 0;
1850     r = guestfs_lvm_remove_all (g);
1851     if (r == -1)
1852       return -1;
1853   }
1854   {
1855     char *lines[] = {
1856       ",",
1857       NULL
1858     };
1859     int r;
1860     suppress_error = 0;
1861     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1862     if (r == -1)
1863       return -1;
1864   }
1865   {
1866     int r;
1867     suppress_error = 0;
1868     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1869     if (r == -1)
1870       return -1;
1871   }
1872   {
1873     int r;
1874     suppress_error = 0;
1875     r = guestfs_mount (g, "/dev/sda1", "/");
1876     if (r == -1)
1877       return -1;
1878   }
1879   /* TestOutputTrue for mkdir (0) */
1880   {
1881     int r;
1882     suppress_error = 0;
1883     r = guestfs_mkdir (g, "/new");
1884     if (r == -1)
1885       return -1;
1886   }
1887   {
1888     int r;
1889     suppress_error = 0;
1890     r = guestfs_is_dir (g, "/new");
1891     if (r == -1)
1892       return -1;
1893     if (!r) {
1894       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
1895       return -1;
1896     }
1897   }
1898   return 0;
1899 }
1900
1901 static int test_mkdir_1 (void)
1902 {
1903   /* InitBasicFS for mkdir (1): create ext2 on /dev/sda1 */
1904   {
1905     int r;
1906     suppress_error = 0;
1907     r = guestfs_umount_all (g);
1908     if (r == -1)
1909       return -1;
1910   }
1911   {
1912     int r;
1913     suppress_error = 0;
1914     r = guestfs_lvm_remove_all (g);
1915     if (r == -1)
1916       return -1;
1917   }
1918   {
1919     char *lines[] = {
1920       ",",
1921       NULL
1922     };
1923     int r;
1924     suppress_error = 0;
1925     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1926     if (r == -1)
1927       return -1;
1928   }
1929   {
1930     int r;
1931     suppress_error = 0;
1932     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1933     if (r == -1)
1934       return -1;
1935   }
1936   {
1937     int r;
1938     suppress_error = 0;
1939     r = guestfs_mount (g, "/dev/sda1", "/");
1940     if (r == -1)
1941       return -1;
1942   }
1943   /* TestLastFail for mkdir (1) */
1944   {
1945     int r;
1946     suppress_error = 1;
1947     r = guestfs_mkdir (g, "/new/foo/bar");
1948     if (r != -1)
1949       return -1;
1950   }
1951   return 0;
1952 }
1953
1954 static int test_mkdir_p_0 (void)
1955 {
1956   /* InitBasicFS for mkdir_p (0): create ext2 on /dev/sda1 */
1957   {
1958     int r;
1959     suppress_error = 0;
1960     r = guestfs_umount_all (g);
1961     if (r == -1)
1962       return -1;
1963   }
1964   {
1965     int r;
1966     suppress_error = 0;
1967     r = guestfs_lvm_remove_all (g);
1968     if (r == -1)
1969       return -1;
1970   }
1971   {
1972     char *lines[] = {
1973       ",",
1974       NULL
1975     };
1976     int r;
1977     suppress_error = 0;
1978     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
1979     if (r == -1)
1980       return -1;
1981   }
1982   {
1983     int r;
1984     suppress_error = 0;
1985     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
1986     if (r == -1)
1987       return -1;
1988   }
1989   {
1990     int r;
1991     suppress_error = 0;
1992     r = guestfs_mount (g, "/dev/sda1", "/");
1993     if (r == -1)
1994       return -1;
1995   }
1996   /* TestOutputTrue for mkdir_p (0) */
1997   {
1998     int r;
1999     suppress_error = 0;
2000     r = guestfs_mkdir_p (g, "/new/foo/bar");
2001     if (r == -1)
2002       return -1;
2003   }
2004   {
2005     int r;
2006     suppress_error = 0;
2007     r = guestfs_is_dir (g, "/new/foo/bar");
2008     if (r == -1)
2009       return -1;
2010     if (!r) {
2011       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
2012       return -1;
2013     }
2014   }
2015   return 0;
2016 }
2017
2018 static int test_mkdir_p_1 (void)
2019 {
2020   /* InitBasicFS for mkdir_p (1): create ext2 on /dev/sda1 */
2021   {
2022     int r;
2023     suppress_error = 0;
2024     r = guestfs_umount_all (g);
2025     if (r == -1)
2026       return -1;
2027   }
2028   {
2029     int r;
2030     suppress_error = 0;
2031     r = guestfs_lvm_remove_all (g);
2032     if (r == -1)
2033       return -1;
2034   }
2035   {
2036     char *lines[] = {
2037       ",",
2038       NULL
2039     };
2040     int r;
2041     suppress_error = 0;
2042     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2043     if (r == -1)
2044       return -1;
2045   }
2046   {
2047     int r;
2048     suppress_error = 0;
2049     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2050     if (r == -1)
2051       return -1;
2052   }
2053   {
2054     int r;
2055     suppress_error = 0;
2056     r = guestfs_mount (g, "/dev/sda1", "/");
2057     if (r == -1)
2058       return -1;
2059   }
2060   /* TestOutputTrue for mkdir_p (1) */
2061   {
2062     int r;
2063     suppress_error = 0;
2064     r = guestfs_mkdir_p (g, "/new/foo/bar");
2065     if (r == -1)
2066       return -1;
2067   }
2068   {
2069     int r;
2070     suppress_error = 0;
2071     r = guestfs_is_dir (g, "/new/foo");
2072     if (r == -1)
2073       return -1;
2074     if (!r) {
2075       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
2076       return -1;
2077     }
2078   }
2079   return 0;
2080 }
2081
2082 static int test_mkdir_p_2 (void)
2083 {
2084   /* InitBasicFS for mkdir_p (2): create ext2 on /dev/sda1 */
2085   {
2086     int r;
2087     suppress_error = 0;
2088     r = guestfs_umount_all (g);
2089     if (r == -1)
2090       return -1;
2091   }
2092   {
2093     int r;
2094     suppress_error = 0;
2095     r = guestfs_lvm_remove_all (g);
2096     if (r == -1)
2097       return -1;
2098   }
2099   {
2100     char *lines[] = {
2101       ",",
2102       NULL
2103     };
2104     int r;
2105     suppress_error = 0;
2106     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2107     if (r == -1)
2108       return -1;
2109   }
2110   {
2111     int r;
2112     suppress_error = 0;
2113     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2114     if (r == -1)
2115       return -1;
2116   }
2117   {
2118     int r;
2119     suppress_error = 0;
2120     r = guestfs_mount (g, "/dev/sda1", "/");
2121     if (r == -1)
2122       return -1;
2123   }
2124   /* TestOutputTrue for mkdir_p (2) */
2125   {
2126     int r;
2127     suppress_error = 0;
2128     r = guestfs_mkdir_p (g, "/new/foo/bar");
2129     if (r == -1)
2130       return -1;
2131   }
2132   {
2133     int r;
2134     suppress_error = 0;
2135     r = guestfs_is_dir (g, "/new");
2136     if (r == -1)
2137       return -1;
2138     if (!r) {
2139       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
2140       return -1;
2141     }
2142   }
2143   return 0;
2144 }
2145
2146 static int test_exists_0 (void)
2147 {
2148   /* InitBasicFS for exists (0): create ext2 on /dev/sda1 */
2149   {
2150     int r;
2151     suppress_error = 0;
2152     r = guestfs_umount_all (g);
2153     if (r == -1)
2154       return -1;
2155   }
2156   {
2157     int r;
2158     suppress_error = 0;
2159     r = guestfs_lvm_remove_all (g);
2160     if (r == -1)
2161       return -1;
2162   }
2163   {
2164     char *lines[] = {
2165       ",",
2166       NULL
2167     };
2168     int r;
2169     suppress_error = 0;
2170     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2171     if (r == -1)
2172       return -1;
2173   }
2174   {
2175     int r;
2176     suppress_error = 0;
2177     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2178     if (r == -1)
2179       return -1;
2180   }
2181   {
2182     int r;
2183     suppress_error = 0;
2184     r = guestfs_mount (g, "/dev/sda1", "/");
2185     if (r == -1)
2186       return -1;
2187   }
2188   /* TestOutputTrue for exists (0) */
2189   {
2190     int r;
2191     suppress_error = 0;
2192     r = guestfs_touch (g, "/new");
2193     if (r == -1)
2194       return -1;
2195   }
2196   {
2197     int r;
2198     suppress_error = 0;
2199     r = guestfs_exists (g, "/new");
2200     if (r == -1)
2201       return -1;
2202     if (!r) {
2203       fprintf (stderr, "test_exists_0: expected true, got false\n");
2204       return -1;
2205     }
2206   }
2207   return 0;
2208 }
2209
2210 static int test_exists_1 (void)
2211 {
2212   /* InitBasicFS for exists (1): create ext2 on /dev/sda1 */
2213   {
2214     int r;
2215     suppress_error = 0;
2216     r = guestfs_umount_all (g);
2217     if (r == -1)
2218       return -1;
2219   }
2220   {
2221     int r;
2222     suppress_error = 0;
2223     r = guestfs_lvm_remove_all (g);
2224     if (r == -1)
2225       return -1;
2226   }
2227   {
2228     char *lines[] = {
2229       ",",
2230       NULL
2231     };
2232     int r;
2233     suppress_error = 0;
2234     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2235     if (r == -1)
2236       return -1;
2237   }
2238   {
2239     int r;
2240     suppress_error = 0;
2241     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2242     if (r == -1)
2243       return -1;
2244   }
2245   {
2246     int r;
2247     suppress_error = 0;
2248     r = guestfs_mount (g, "/dev/sda1", "/");
2249     if (r == -1)
2250       return -1;
2251   }
2252   /* TestOutputTrue for exists (1) */
2253   {
2254     int r;
2255     suppress_error = 0;
2256     r = guestfs_mkdir (g, "/new");
2257     if (r == -1)
2258       return -1;
2259   }
2260   {
2261     int r;
2262     suppress_error = 0;
2263     r = guestfs_exists (g, "/new");
2264     if (r == -1)
2265       return -1;
2266     if (!r) {
2267       fprintf (stderr, "test_exists_1: expected true, got false\n");
2268       return -1;
2269     }
2270   }
2271   return 0;
2272 }
2273
2274 static int test_is_file_0 (void)
2275 {
2276   /* InitBasicFS for is_file (0): create ext2 on /dev/sda1 */
2277   {
2278     int r;
2279     suppress_error = 0;
2280     r = guestfs_umount_all (g);
2281     if (r == -1)
2282       return -1;
2283   }
2284   {
2285     int r;
2286     suppress_error = 0;
2287     r = guestfs_lvm_remove_all (g);
2288     if (r == -1)
2289       return -1;
2290   }
2291   {
2292     char *lines[] = {
2293       ",",
2294       NULL
2295     };
2296     int r;
2297     suppress_error = 0;
2298     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2299     if (r == -1)
2300       return -1;
2301   }
2302   {
2303     int r;
2304     suppress_error = 0;
2305     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2306     if (r == -1)
2307       return -1;
2308   }
2309   {
2310     int r;
2311     suppress_error = 0;
2312     r = guestfs_mount (g, "/dev/sda1", "/");
2313     if (r == -1)
2314       return -1;
2315   }
2316   /* TestOutputTrue for is_file (0) */
2317   {
2318     int r;
2319     suppress_error = 0;
2320     r = guestfs_touch (g, "/new");
2321     if (r == -1)
2322       return -1;
2323   }
2324   {
2325     int r;
2326     suppress_error = 0;
2327     r = guestfs_is_file (g, "/new");
2328     if (r == -1)
2329       return -1;
2330     if (!r) {
2331       fprintf (stderr, "test_is_file_0: expected true, got false\n");
2332       return -1;
2333     }
2334   }
2335   return 0;
2336 }
2337
2338 static int test_is_file_1 (void)
2339 {
2340   /* InitBasicFS for is_file (1): create ext2 on /dev/sda1 */
2341   {
2342     int r;
2343     suppress_error = 0;
2344     r = guestfs_umount_all (g);
2345     if (r == -1)
2346       return -1;
2347   }
2348   {
2349     int r;
2350     suppress_error = 0;
2351     r = guestfs_lvm_remove_all (g);
2352     if (r == -1)
2353       return -1;
2354   }
2355   {
2356     char *lines[] = {
2357       ",",
2358       NULL
2359     };
2360     int r;
2361     suppress_error = 0;
2362     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2363     if (r == -1)
2364       return -1;
2365   }
2366   {
2367     int r;
2368     suppress_error = 0;
2369     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2370     if (r == -1)
2371       return -1;
2372   }
2373   {
2374     int r;
2375     suppress_error = 0;
2376     r = guestfs_mount (g, "/dev/sda1", "/");
2377     if (r == -1)
2378       return -1;
2379   }
2380   /* TestOutputFalse for is_file (1) */
2381   {
2382     int r;
2383     suppress_error = 0;
2384     r = guestfs_mkdir (g, "/new");
2385     if (r == -1)
2386       return -1;
2387   }
2388   {
2389     int r;
2390     suppress_error = 0;
2391     r = guestfs_is_file (g, "/new");
2392     if (r == -1)
2393       return -1;
2394     if (r) {
2395       fprintf (stderr, "test_is_file_1: expected false, got true\n");
2396       return -1;
2397     }
2398   }
2399   return 0;
2400 }
2401
2402 static int test_is_dir_0 (void)
2403 {
2404   /* InitBasicFS for is_dir (0): create ext2 on /dev/sda1 */
2405   {
2406     int r;
2407     suppress_error = 0;
2408     r = guestfs_umount_all (g);
2409     if (r == -1)
2410       return -1;
2411   }
2412   {
2413     int r;
2414     suppress_error = 0;
2415     r = guestfs_lvm_remove_all (g);
2416     if (r == -1)
2417       return -1;
2418   }
2419   {
2420     char *lines[] = {
2421       ",",
2422       NULL
2423     };
2424     int r;
2425     suppress_error = 0;
2426     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2427     if (r == -1)
2428       return -1;
2429   }
2430   {
2431     int r;
2432     suppress_error = 0;
2433     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2434     if (r == -1)
2435       return -1;
2436   }
2437   {
2438     int r;
2439     suppress_error = 0;
2440     r = guestfs_mount (g, "/dev/sda1", "/");
2441     if (r == -1)
2442       return -1;
2443   }
2444   /* TestOutputFalse for is_dir (0) */
2445   {
2446     int r;
2447     suppress_error = 0;
2448     r = guestfs_touch (g, "/new");
2449     if (r == -1)
2450       return -1;
2451   }
2452   {
2453     int r;
2454     suppress_error = 0;
2455     r = guestfs_is_dir (g, "/new");
2456     if (r == -1)
2457       return -1;
2458     if (r) {
2459       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
2460       return -1;
2461     }
2462   }
2463   return 0;
2464 }
2465
2466 static int test_is_dir_1 (void)
2467 {
2468   /* InitBasicFS for is_dir (1): create ext2 on /dev/sda1 */
2469   {
2470     int r;
2471     suppress_error = 0;
2472     r = guestfs_umount_all (g);
2473     if (r == -1)
2474       return -1;
2475   }
2476   {
2477     int r;
2478     suppress_error = 0;
2479     r = guestfs_lvm_remove_all (g);
2480     if (r == -1)
2481       return -1;
2482   }
2483   {
2484     char *lines[] = {
2485       ",",
2486       NULL
2487     };
2488     int r;
2489     suppress_error = 0;
2490     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2491     if (r == -1)
2492       return -1;
2493   }
2494   {
2495     int r;
2496     suppress_error = 0;
2497     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2498     if (r == -1)
2499       return -1;
2500   }
2501   {
2502     int r;
2503     suppress_error = 0;
2504     r = guestfs_mount (g, "/dev/sda1", "/");
2505     if (r == -1)
2506       return -1;
2507   }
2508   /* TestOutputTrue for is_dir (1) */
2509   {
2510     int r;
2511     suppress_error = 0;
2512     r = guestfs_mkdir (g, "/new");
2513     if (r == -1)
2514       return -1;
2515   }
2516   {
2517     int r;
2518     suppress_error = 0;
2519     r = guestfs_is_dir (g, "/new");
2520     if (r == -1)
2521       return -1;
2522     if (!r) {
2523       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
2524       return -1;
2525     }
2526   }
2527   return 0;
2528 }
2529
2530 static int test_pvcreate_0 (void)
2531 {
2532   /* InitEmpty for pvcreate (0) */
2533   {
2534     int r;
2535     suppress_error = 0;
2536     r = guestfs_umount_all (g);
2537     if (r == -1)
2538       return -1;
2539   }
2540   {
2541     int r;
2542     suppress_error = 0;
2543     r = guestfs_lvm_remove_all (g);
2544     if (r == -1)
2545       return -1;
2546   }
2547   /* TestOutputList for pvcreate (0) */
2548   {
2549     char *lines[] = {
2550       ",10",
2551       ",20",
2552       ",",
2553       NULL
2554     };
2555     int r;
2556     suppress_error = 0;
2557     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2558     if (r == -1)
2559       return -1;
2560   }
2561   {
2562     int r;
2563     suppress_error = 0;
2564     r = guestfs_pvcreate (g, "/dev/sda1");
2565     if (r == -1)
2566       return -1;
2567   }
2568   {
2569     int r;
2570     suppress_error = 0;
2571     r = guestfs_pvcreate (g, "/dev/sda2");
2572     if (r == -1)
2573       return -1;
2574   }
2575   {
2576     int r;
2577     suppress_error = 0;
2578     r = guestfs_pvcreate (g, "/dev/sda3");
2579     if (r == -1)
2580       return -1;
2581   }
2582   {
2583     char **r;
2584     int i;
2585     suppress_error = 0;
2586     r = guestfs_pvs (g);
2587     if (r == NULL)
2588       return -1;
2589     if (!r[0]) {
2590       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
2591       print_strings (r);
2592       return -1;
2593     }
2594     if (strcmp (r[0], "/dev/sda1") != 0) {
2595       fprintf (stderr, "test_pvcreate_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
2596       return -1;
2597     }
2598     if (!r[1]) {
2599       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
2600       print_strings (r);
2601       return -1;
2602     }
2603     if (strcmp (r[1], "/dev/sda2") != 0) {
2604       fprintf (stderr, "test_pvcreate_0: expected \"/dev/sda2\" but got \"%s\"\n", r[1]);
2605       return -1;
2606     }
2607     if (!r[2]) {
2608       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
2609       print_strings (r);
2610       return -1;
2611     }
2612     if (strcmp (r[2], "/dev/sda3") != 0) {
2613       fprintf (stderr, "test_pvcreate_0: expected \"/dev/sda3\" but got \"%s\"\n", r[2]);
2614       return -1;
2615     }
2616     if (r[3] != NULL) {
2617       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
2618       print_strings (r);
2619       return -1;
2620     }
2621     for (i = 0; r[i] != NULL; ++i)
2622       free (r[i]);
2623     free (r);
2624   }
2625   return 0;
2626 }
2627
2628 static int test_vgcreate_0 (void)
2629 {
2630   /* InitEmpty for vgcreate (0) */
2631   {
2632     int r;
2633     suppress_error = 0;
2634     r = guestfs_umount_all (g);
2635     if (r == -1)
2636       return -1;
2637   }
2638   {
2639     int r;
2640     suppress_error = 0;
2641     r = guestfs_lvm_remove_all (g);
2642     if (r == -1)
2643       return -1;
2644   }
2645   /* TestOutputList for vgcreate (0) */
2646   {
2647     char *lines[] = {
2648       ",10",
2649       ",20",
2650       ",",
2651       NULL
2652     };
2653     int r;
2654     suppress_error = 0;
2655     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2656     if (r == -1)
2657       return -1;
2658   }
2659   {
2660     int r;
2661     suppress_error = 0;
2662     r = guestfs_pvcreate (g, "/dev/sda1");
2663     if (r == -1)
2664       return -1;
2665   }
2666   {
2667     int r;
2668     suppress_error = 0;
2669     r = guestfs_pvcreate (g, "/dev/sda2");
2670     if (r == -1)
2671       return -1;
2672   }
2673   {
2674     int r;
2675     suppress_error = 0;
2676     r = guestfs_pvcreate (g, "/dev/sda3");
2677     if (r == -1)
2678       return -1;
2679   }
2680   {
2681     char *physvols[] = {
2682       "/dev/sda1",
2683       "/dev/sda2",
2684       NULL
2685     };
2686     int r;
2687     suppress_error = 0;
2688     r = guestfs_vgcreate (g, "VG1", physvols);
2689     if (r == -1)
2690       return -1;
2691   }
2692   {
2693     char *physvols[] = {
2694       "/dev/sda3",
2695       NULL
2696     };
2697     int r;
2698     suppress_error = 0;
2699     r = guestfs_vgcreate (g, "VG2", physvols);
2700     if (r == -1)
2701       return -1;
2702   }
2703   {
2704     char **r;
2705     int i;
2706     suppress_error = 0;
2707     r = guestfs_vgs (g);
2708     if (r == NULL)
2709       return -1;
2710     if (!r[0]) {
2711       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
2712       print_strings (r);
2713       return -1;
2714     }
2715     if (strcmp (r[0], "VG1") != 0) {
2716       fprintf (stderr, "test_vgcreate_0: expected \"VG1\" but got \"%s\"\n", r[0]);
2717       return -1;
2718     }
2719     if (!r[1]) {
2720       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
2721       print_strings (r);
2722       return -1;
2723     }
2724     if (strcmp (r[1], "VG2") != 0) {
2725       fprintf (stderr, "test_vgcreate_0: expected \"VG2\" but got \"%s\"\n", r[1]);
2726       return -1;
2727     }
2728     if (r[2] != NULL) {
2729       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
2730       print_strings (r);
2731       return -1;
2732     }
2733     for (i = 0; r[i] != NULL; ++i)
2734       free (r[i]);
2735     free (r);
2736   }
2737   return 0;
2738 }
2739
2740 static int test_lvcreate_0 (void)
2741 {
2742   /* InitEmpty for lvcreate (0) */
2743   {
2744     int r;
2745     suppress_error = 0;
2746     r = guestfs_umount_all (g);
2747     if (r == -1)
2748       return -1;
2749   }
2750   {
2751     int r;
2752     suppress_error = 0;
2753     r = guestfs_lvm_remove_all (g);
2754     if (r == -1)
2755       return -1;
2756   }
2757   /* TestOutputList for lvcreate (0) */
2758   {
2759     char *lines[] = {
2760       ",10",
2761       ",20",
2762       ",",
2763       NULL
2764     };
2765     int r;
2766     suppress_error = 0;
2767     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2768     if (r == -1)
2769       return -1;
2770   }
2771   {
2772     int r;
2773     suppress_error = 0;
2774     r = guestfs_pvcreate (g, "/dev/sda1");
2775     if (r == -1)
2776       return -1;
2777   }
2778   {
2779     int r;
2780     suppress_error = 0;
2781     r = guestfs_pvcreate (g, "/dev/sda2");
2782     if (r == -1)
2783       return -1;
2784   }
2785   {
2786     int r;
2787     suppress_error = 0;
2788     r = guestfs_pvcreate (g, "/dev/sda3");
2789     if (r == -1)
2790       return -1;
2791   }
2792   {
2793     char *physvols[] = {
2794       "/dev/sda1",
2795       "/dev/sda2",
2796       NULL
2797     };
2798     int r;
2799     suppress_error = 0;
2800     r = guestfs_vgcreate (g, "VG1", physvols);
2801     if (r == -1)
2802       return -1;
2803   }
2804   {
2805     char *physvols[] = {
2806       "/dev/sda3",
2807       NULL
2808     };
2809     int r;
2810     suppress_error = 0;
2811     r = guestfs_vgcreate (g, "VG2", physvols);
2812     if (r == -1)
2813       return -1;
2814   }
2815   {
2816     int r;
2817     suppress_error = 0;
2818     r = guestfs_lvcreate (g, "LV1", "VG1", 50);
2819     if (r == -1)
2820       return -1;
2821   }
2822   {
2823     int r;
2824     suppress_error = 0;
2825     r = guestfs_lvcreate (g, "LV2", "VG1", 50);
2826     if (r == -1)
2827       return -1;
2828   }
2829   {
2830     int r;
2831     suppress_error = 0;
2832     r = guestfs_lvcreate (g, "LV3", "VG2", 50);
2833     if (r == -1)
2834       return -1;
2835   }
2836   {
2837     int r;
2838     suppress_error = 0;
2839     r = guestfs_lvcreate (g, "LV4", "VG2", 50);
2840     if (r == -1)
2841       return -1;
2842   }
2843   {
2844     int r;
2845     suppress_error = 0;
2846     r = guestfs_lvcreate (g, "LV5", "VG2", 50);
2847     if (r == -1)
2848       return -1;
2849   }
2850   {
2851     char **r;
2852     int i;
2853     suppress_error = 0;
2854     r = guestfs_lvs (g);
2855     if (r == NULL)
2856       return -1;
2857     if (!r[0]) {
2858       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
2859       print_strings (r);
2860       return -1;
2861     }
2862     if (strcmp (r[0], "/dev/VG1/LV1") != 0) {
2863       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG1/LV1\" but got \"%s\"\n", r[0]);
2864       return -1;
2865     }
2866     if (!r[1]) {
2867       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
2868       print_strings (r);
2869       return -1;
2870     }
2871     if (strcmp (r[1], "/dev/VG1/LV2") != 0) {
2872       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG1/LV2\" but got \"%s\"\n", r[1]);
2873       return -1;
2874     }
2875     if (!r[2]) {
2876       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
2877       print_strings (r);
2878       return -1;
2879     }
2880     if (strcmp (r[2], "/dev/VG2/LV3") != 0) {
2881       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG2/LV3\" but got \"%s\"\n", r[2]);
2882       return -1;
2883     }
2884     if (!r[3]) {
2885       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
2886       print_strings (r);
2887       return -1;
2888     }
2889     if (strcmp (r[3], "/dev/VG2/LV4") != 0) {
2890       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG2/LV4\" but got \"%s\"\n", r[3]);
2891       return -1;
2892     }
2893     if (!r[4]) {
2894       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
2895       print_strings (r);
2896       return -1;
2897     }
2898     if (strcmp (r[4], "/dev/VG2/LV5") != 0) {
2899       fprintf (stderr, "test_lvcreate_0: expected \"/dev/VG2/LV5\" but got \"%s\"\n", r[4]);
2900       return -1;
2901     }
2902     if (r[5] != NULL) {
2903       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
2904       print_strings (r);
2905       return -1;
2906     }
2907     for (i = 0; r[i] != NULL; ++i)
2908       free (r[i]);
2909     free (r);
2910   }
2911   return 0;
2912 }
2913
2914 static int test_mkfs_0 (void)
2915 {
2916   /* InitEmpty for mkfs (0) */
2917   {
2918     int r;
2919     suppress_error = 0;
2920     r = guestfs_umount_all (g);
2921     if (r == -1)
2922       return -1;
2923   }
2924   {
2925     int r;
2926     suppress_error = 0;
2927     r = guestfs_lvm_remove_all (g);
2928     if (r == -1)
2929       return -1;
2930   }
2931   /* TestOutput for mkfs (0) */
2932   {
2933     char *lines[] = {
2934       ",",
2935       NULL
2936     };
2937     int r;
2938     suppress_error = 0;
2939     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
2940     if (r == -1)
2941       return -1;
2942   }
2943   {
2944     int r;
2945     suppress_error = 0;
2946     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
2947     if (r == -1)
2948       return -1;
2949   }
2950   {
2951     int r;
2952     suppress_error = 0;
2953     r = guestfs_mount (g, "/dev/sda1", "/");
2954     if (r == -1)
2955       return -1;
2956   }
2957   {
2958     int r;
2959     suppress_error = 0;
2960     r = guestfs_write_file (g, "/new", "new file contents", 0);
2961     if (r == -1)
2962       return -1;
2963   }
2964   {
2965     char *r;
2966     suppress_error = 0;
2967     r = guestfs_cat (g, "/new");
2968     if (r == NULL)
2969       return -1;
2970     if (strcmp (r, "new file contents") != 0) {
2971       fprintf (stderr, "test_mkfs_0: expected \"new file contents\" but got \"%s\"\n", r);
2972       return -1;
2973     }
2974     free (r);
2975   }
2976   return 0;
2977 }
2978
2979 static int test_write_file_0 (void)
2980 {
2981   /* InitEmpty for write_file (0) */
2982   {
2983     int r;
2984     suppress_error = 0;
2985     r = guestfs_umount_all (g);
2986     if (r == -1)
2987       return -1;
2988   }
2989   {
2990     int r;
2991     suppress_error = 0;
2992     r = guestfs_lvm_remove_all (g);
2993     if (r == -1)
2994       return -1;
2995   }
2996   /* TestOutput for write_file (0) */
2997   {
2998     char *lines[] = {
2999       ",",
3000       NULL
3001     };
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3005     if (r == -1)
3006       return -1;
3007   }
3008   {
3009     int r;
3010     suppress_error = 0;
3011     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3012     if (r == -1)
3013       return -1;
3014   }
3015   {
3016     int r;
3017     suppress_error = 0;
3018     r = guestfs_mount (g, "/dev/sda1", "/");
3019     if (r == -1)
3020       return -1;
3021   }
3022   {
3023     int r;
3024     suppress_error = 0;
3025     r = guestfs_write_file (g, "/new", "new file contents", 0);
3026     if (r == -1)
3027       return -1;
3028   }
3029   {
3030     char *r;
3031     suppress_error = 0;
3032     r = guestfs_cat (g, "/new");
3033     if (r == NULL)
3034       return -1;
3035     if (strcmp (r, "new file contents") != 0) {
3036       fprintf (stderr, "test_write_file_0: expected \"new file contents\" but got \"%s\"\n", r);
3037       return -1;
3038     }
3039     free (r);
3040   }
3041   return 0;
3042 }
3043
3044 static int test_umount_0 (void)
3045 {
3046   /* InitEmpty for umount (0) */
3047   {
3048     int r;
3049     suppress_error = 0;
3050     r = guestfs_umount_all (g);
3051     if (r == -1)
3052       return -1;
3053   }
3054   {
3055     int r;
3056     suppress_error = 0;
3057     r = guestfs_lvm_remove_all (g);
3058     if (r == -1)
3059       return -1;
3060   }
3061   /* TestOutputList for umount (0) */
3062   {
3063     char *lines[] = {
3064       ",",
3065       NULL
3066     };
3067     int r;
3068     suppress_error = 0;
3069     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3070     if (r == -1)
3071       return -1;
3072   }
3073   {
3074     int r;
3075     suppress_error = 0;
3076     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3077     if (r == -1)
3078       return -1;
3079   }
3080   {
3081     int r;
3082     suppress_error = 0;
3083     r = guestfs_mount (g, "/dev/sda1", "/");
3084     if (r == -1)
3085       return -1;
3086   }
3087   {
3088     char **r;
3089     int i;
3090     suppress_error = 0;
3091     r = guestfs_mounts (g);
3092     if (r == NULL)
3093       return -1;
3094     if (!r[0]) {
3095       fprintf (stderr, "test_umount_0: short list returned from command\n");
3096       print_strings (r);
3097       return -1;
3098     }
3099     if (strcmp (r[0], "/dev/sda1") != 0) {
3100       fprintf (stderr, "test_umount_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
3101       return -1;
3102     }
3103     if (r[1] != NULL) {
3104       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
3105       print_strings (r);
3106       return -1;
3107     }
3108     for (i = 0; r[i] != NULL; ++i)
3109       free (r[i]);
3110     free (r);
3111   }
3112   return 0;
3113 }
3114
3115 static int test_umount_1 (void)
3116 {
3117   /* InitEmpty for umount (1) */
3118   {
3119     int r;
3120     suppress_error = 0;
3121     r = guestfs_umount_all (g);
3122     if (r == -1)
3123       return -1;
3124   }
3125   {
3126     int r;
3127     suppress_error = 0;
3128     r = guestfs_lvm_remove_all (g);
3129     if (r == -1)
3130       return -1;
3131   }
3132   /* TestOutputList for umount (1) */
3133   {
3134     char *lines[] = {
3135       ",",
3136       NULL
3137     };
3138     int r;
3139     suppress_error = 0;
3140     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3141     if (r == -1)
3142       return -1;
3143   }
3144   {
3145     int r;
3146     suppress_error = 0;
3147     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3148     if (r == -1)
3149       return -1;
3150   }
3151   {
3152     int r;
3153     suppress_error = 0;
3154     r = guestfs_mount (g, "/dev/sda1", "/");
3155     if (r == -1)
3156       return -1;
3157   }
3158   {
3159     int r;
3160     suppress_error = 0;
3161     r = guestfs_umount (g, "/");
3162     if (r == -1)
3163       return -1;
3164   }
3165   {
3166     char **r;
3167     int i;
3168     suppress_error = 0;
3169     r = guestfs_mounts (g);
3170     if (r == NULL)
3171       return -1;
3172     if (r[0] != NULL) {
3173       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
3174       print_strings (r);
3175       return -1;
3176     }
3177     for (i = 0; r[i] != NULL; ++i)
3178       free (r[i]);
3179     free (r);
3180   }
3181   return 0;
3182 }
3183
3184 static int test_mounts_0 (void)
3185 {
3186   /* InitBasicFS for mounts (0): create ext2 on /dev/sda1 */
3187   {
3188     int r;
3189     suppress_error = 0;
3190     r = guestfs_umount_all (g);
3191     if (r == -1)
3192       return -1;
3193   }
3194   {
3195     int r;
3196     suppress_error = 0;
3197     r = guestfs_lvm_remove_all (g);
3198     if (r == -1)
3199       return -1;
3200   }
3201   {
3202     char *lines[] = {
3203       ",",
3204       NULL
3205     };
3206     int r;
3207     suppress_error = 0;
3208     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3209     if (r == -1)
3210       return -1;
3211   }
3212   {
3213     int r;
3214     suppress_error = 0;
3215     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3216     if (r == -1)
3217       return -1;
3218   }
3219   {
3220     int r;
3221     suppress_error = 0;
3222     r = guestfs_mount (g, "/dev/sda1", "/");
3223     if (r == -1)
3224       return -1;
3225   }
3226   /* TestOutputList for mounts (0) */
3227   {
3228     char **r;
3229     int i;
3230     suppress_error = 0;
3231     r = guestfs_mounts (g);
3232     if (r == NULL)
3233       return -1;
3234     if (!r[0]) {
3235       fprintf (stderr, "test_mounts_0: short list returned from command\n");
3236       print_strings (r);
3237       return -1;
3238     }
3239     if (strcmp (r[0], "/dev/sda1") != 0) {
3240       fprintf (stderr, "test_mounts_0: expected \"/dev/sda1\" but got \"%s\"\n", r[0]);
3241       return -1;
3242     }
3243     if (r[1] != NULL) {
3244       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
3245       print_strings (r);
3246       return -1;
3247     }
3248     for (i = 0; r[i] != NULL; ++i)
3249       free (r[i]);
3250     free (r);
3251   }
3252   return 0;
3253 }
3254
3255 static int test_umount_all_0 (void)
3256 {
3257   /* InitBasicFS for umount_all (0): create ext2 on /dev/sda1 */
3258   {
3259     int r;
3260     suppress_error = 0;
3261     r = guestfs_umount_all (g);
3262     if (r == -1)
3263       return -1;
3264   }
3265   {
3266     int r;
3267     suppress_error = 0;
3268     r = guestfs_lvm_remove_all (g);
3269     if (r == -1)
3270       return -1;
3271   }
3272   {
3273     char *lines[] = {
3274       ",",
3275       NULL
3276     };
3277     int r;
3278     suppress_error = 0;
3279     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3280     if (r == -1)
3281       return -1;
3282   }
3283   {
3284     int r;
3285     suppress_error = 0;
3286     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3287     if (r == -1)
3288       return -1;
3289   }
3290   {
3291     int r;
3292     suppress_error = 0;
3293     r = guestfs_mount (g, "/dev/sda1", "/");
3294     if (r == -1)
3295       return -1;
3296   }
3297   /* TestOutputList for umount_all (0) */
3298   {
3299     int r;
3300     suppress_error = 0;
3301     r = guestfs_umount_all (g);
3302     if (r == -1)
3303       return -1;
3304   }
3305   {
3306     char **r;
3307     int i;
3308     suppress_error = 0;
3309     r = guestfs_mounts (g);
3310     if (r == NULL)
3311       return -1;
3312     if (r[0] != NULL) {
3313       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
3314       print_strings (r);
3315       return -1;
3316     }
3317     for (i = 0; r[i] != NULL; ++i)
3318       free (r[i]);
3319     free (r);
3320   }
3321   return 0;
3322 }
3323
3324 static int test_file_0 (void)
3325 {
3326   /* InitBasicFS for file (0): create ext2 on /dev/sda1 */
3327   {
3328     int r;
3329     suppress_error = 0;
3330     r = guestfs_umount_all (g);
3331     if (r == -1)
3332       return -1;
3333   }
3334   {
3335     int r;
3336     suppress_error = 0;
3337     r = guestfs_lvm_remove_all (g);
3338     if (r == -1)
3339       return -1;
3340   }
3341   {
3342     char *lines[] = {
3343       ",",
3344       NULL
3345     };
3346     int r;
3347     suppress_error = 0;
3348     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3349     if (r == -1)
3350       return -1;
3351   }
3352   {
3353     int r;
3354     suppress_error = 0;
3355     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3356     if (r == -1)
3357       return -1;
3358   }
3359   {
3360     int r;
3361     suppress_error = 0;
3362     r = guestfs_mount (g, "/dev/sda1", "/");
3363     if (r == -1)
3364       return -1;
3365   }
3366   /* TestOutput for file (0) */
3367   {
3368     int r;
3369     suppress_error = 0;
3370     r = guestfs_touch (g, "/new");
3371     if (r == -1)
3372       return -1;
3373   }
3374   {
3375     char *r;
3376     suppress_error = 0;
3377     r = guestfs_file (g, "/new");
3378     if (r == NULL)
3379       return -1;
3380     if (strcmp (r, "empty") != 0) {
3381       fprintf (stderr, "test_file_0: expected \"empty\" but got \"%s\"\n", r);
3382       return -1;
3383     }
3384     free (r);
3385   }
3386   return 0;
3387 }
3388
3389 static int test_file_1 (void)
3390 {
3391   /* InitBasicFS for file (1): create ext2 on /dev/sda1 */
3392   {
3393     int r;
3394     suppress_error = 0;
3395     r = guestfs_umount_all (g);
3396     if (r == -1)
3397       return -1;
3398   }
3399   {
3400     int r;
3401     suppress_error = 0;
3402     r = guestfs_lvm_remove_all (g);
3403     if (r == -1)
3404       return -1;
3405   }
3406   {
3407     char *lines[] = {
3408       ",",
3409       NULL
3410     };
3411     int r;
3412     suppress_error = 0;
3413     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3414     if (r == -1)
3415       return -1;
3416   }
3417   {
3418     int r;
3419     suppress_error = 0;
3420     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3421     if (r == -1)
3422       return -1;
3423   }
3424   {
3425     int r;
3426     suppress_error = 0;
3427     r = guestfs_mount (g, "/dev/sda1", "/");
3428     if (r == -1)
3429       return -1;
3430   }
3431   /* TestOutput for file (1) */
3432   {
3433     int r;
3434     suppress_error = 0;
3435     r = guestfs_write_file (g, "/new", "some content\n", 0);
3436     if (r == -1)
3437       return -1;
3438   }
3439   {
3440     char *r;
3441     suppress_error = 0;
3442     r = guestfs_file (g, "/new");
3443     if (r == NULL)
3444       return -1;
3445     if (strcmp (r, "ASCII text") != 0) {
3446       fprintf (stderr, "test_file_1: expected \"ASCII text\" but got \"%s\"\n", r);
3447       return -1;
3448     }
3449     free (r);
3450   }
3451   return 0;
3452 }
3453
3454 static int test_file_2 (void)
3455 {
3456   /* InitBasicFS for file (2): create ext2 on /dev/sda1 */
3457   {
3458     int r;
3459     suppress_error = 0;
3460     r = guestfs_umount_all (g);
3461     if (r == -1)
3462       return -1;
3463   }
3464   {
3465     int r;
3466     suppress_error = 0;
3467     r = guestfs_lvm_remove_all (g);
3468     if (r == -1)
3469       return -1;
3470   }
3471   {
3472     char *lines[] = {
3473       ",",
3474       NULL
3475     };
3476     int r;
3477     suppress_error = 0;
3478     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3479     if (r == -1)
3480       return -1;
3481   }
3482   {
3483     int r;
3484     suppress_error = 0;
3485     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3486     if (r == -1)
3487       return -1;
3488   }
3489   {
3490     int r;
3491     suppress_error = 0;
3492     r = guestfs_mount (g, "/dev/sda1", "/");
3493     if (r == -1)
3494       return -1;
3495   }
3496   /* TestLastFail for file (2) */
3497   {
3498     char *r;
3499     suppress_error = 1;
3500     r = guestfs_file (g, "/nofile");
3501     if (r != NULL)
3502       return -1;
3503     free (r);
3504   }
3505   return 0;
3506 }
3507
3508 static int test_stat_0 (void)
3509 {
3510   /* InitBasicFS for stat (0): create ext2 on /dev/sda1 */
3511   {
3512     int r;
3513     suppress_error = 0;
3514     r = guestfs_umount_all (g);
3515     if (r == -1)
3516       return -1;
3517   }
3518   {
3519     int r;
3520     suppress_error = 0;
3521     r = guestfs_lvm_remove_all (g);
3522     if (r == -1)
3523       return -1;
3524   }
3525   {
3526     char *lines[] = {
3527       ",",
3528       NULL
3529     };
3530     int r;
3531     suppress_error = 0;
3532     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3533     if (r == -1)
3534       return -1;
3535   }
3536   {
3537     int r;
3538     suppress_error = 0;
3539     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3540     if (r == -1)
3541       return -1;
3542   }
3543   {
3544     int r;
3545     suppress_error = 0;
3546     r = guestfs_mount (g, "/dev/sda1", "/");
3547     if (r == -1)
3548       return -1;
3549   }
3550   /* TestOutputStruct for stat (0) */
3551   {
3552     int r;
3553     suppress_error = 0;
3554     r = guestfs_touch (g, "/new");
3555     if (r == -1)
3556       return -1;
3557   }
3558   {
3559     struct guestfs_stat *r;
3560     suppress_error = 0;
3561     r = guestfs_stat (g, "/new");
3562     if (r == NULL)
3563       return -1;
3564     if (r->size != 0) {
3565       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
3566                (int) r->size);
3567       return -1;
3568     }
3569     free (r);
3570   }
3571   return 0;
3572 }
3573
3574 static int test_lstat_0 (void)
3575 {
3576   /* InitBasicFS for lstat (0): create ext2 on /dev/sda1 */
3577   {
3578     int r;
3579     suppress_error = 0;
3580     r = guestfs_umount_all (g);
3581     if (r == -1)
3582       return -1;
3583   }
3584   {
3585     int r;
3586     suppress_error = 0;
3587     r = guestfs_lvm_remove_all (g);
3588     if (r == -1)
3589       return -1;
3590   }
3591   {
3592     char *lines[] = {
3593       ",",
3594       NULL
3595     };
3596     int r;
3597     suppress_error = 0;
3598     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3599     if (r == -1)
3600       return -1;
3601   }
3602   {
3603     int r;
3604     suppress_error = 0;
3605     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3606     if (r == -1)
3607       return -1;
3608   }
3609   {
3610     int r;
3611     suppress_error = 0;
3612     r = guestfs_mount (g, "/dev/sda1", "/");
3613     if (r == -1)
3614       return -1;
3615   }
3616   /* TestOutputStruct for lstat (0) */
3617   {
3618     int r;
3619     suppress_error = 0;
3620     r = guestfs_touch (g, "/new");
3621     if (r == -1)
3622       return -1;
3623   }
3624   {
3625     struct guestfs_stat *r;
3626     suppress_error = 0;
3627     r = guestfs_lstat (g, "/new");
3628     if (r == NULL)
3629       return -1;
3630     if (r->size != 0) {
3631       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
3632                (int) r->size);
3633       return -1;
3634     }
3635     free (r);
3636   }
3637   return 0;
3638 }
3639
3640 static int test_statvfs_0 (void)
3641 {
3642   /* InitBasicFS for statvfs (0): create ext2 on /dev/sda1 */
3643   {
3644     int r;
3645     suppress_error = 0;
3646     r = guestfs_umount_all (g);
3647     if (r == -1)
3648       return -1;
3649   }
3650   {
3651     int r;
3652     suppress_error = 0;
3653     r = guestfs_lvm_remove_all (g);
3654     if (r == -1)
3655       return -1;
3656   }
3657   {
3658     char *lines[] = {
3659       ",",
3660       NULL
3661     };
3662     int r;
3663     suppress_error = 0;
3664     r = guestfs_sfdisk (g, "/dev/sda", 0, 0, 0, lines);
3665     if (r == -1)
3666       return -1;
3667   }
3668   {
3669     int r;
3670     suppress_error = 0;
3671     r = guestfs_mkfs (g, "ext2", "/dev/sda1");
3672     if (r == -1)
3673       return -1;
3674   }
3675   {
3676     int r;
3677     suppress_error = 0;
3678     r = guestfs_mount (g, "/dev/sda1", "/");
3679     if (r == -1)
3680       return -1;
3681   }
3682   /* TestOutputStruct for statvfs (0) */
3683   {
3684     struct guestfs_statvfs *r;
3685     suppress_error = 0;
3686     r = guestfs_statvfs (g, "/");
3687     if (r == NULL)
3688       return -1;
3689     if (r->bfree != 487702) {
3690       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
3691                (int) r->bfree);
3692       return -1;
3693     }
3694     if (r->blocks != 490020) {
3695       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
3696                (int) r->blocks);
3697       return -1;
3698     }
3699     if (r->bsize != 1024) {
3700       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
3701                (int) r->bsize);
3702       return -1;
3703     }
3704     free (r);
3705   }
3706   return 0;
3707 }
3708
3709 int main (int argc, char *argv[])
3710 {
3711   char c = 0;
3712   int failed = 0;
3713   const char *srcdir;
3714   int fd;
3715   char buf[256];
3716   int nr_tests;
3717
3718   g = guestfs_create ();
3719   if (g == NULL) {
3720     printf ("guestfs_create FAILED\n");
3721     exit (1);
3722   }
3723
3724   guestfs_set_error_handler (g, print_error, NULL);
3725
3726   srcdir = getenv ("srcdir");
3727   if (!srcdir) srcdir = ".";
3728   guestfs_set_path (g, srcdir);
3729
3730   snprintf (buf, sizeof buf, "%s/test1.img", srcdir);
3731   fd = open (buf, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
3732   if (fd == -1) {
3733     perror (buf);
3734     exit (1);
3735   }
3736   if (lseek (fd, 524288000, SEEK_SET) == -1) {
3737     perror ("lseek");
3738     close (fd);
3739     unlink (buf);
3740     exit (1);
3741   }
3742   if (write (fd, &c, 1) == -1) {
3743     perror ("write");
3744     close (fd);
3745     unlink (buf);
3746     exit (1);
3747   }
3748   if (close (fd) == -1) {
3749     perror (buf);
3750     unlink (buf);
3751     exit (1);
3752   }
3753   if (guestfs_add_drive (g, buf) == -1) {
3754     printf ("guestfs_add_drive %s FAILED\n", buf);
3755     exit (1);
3756   }
3757
3758   snprintf (buf, sizeof buf, "%s/test2.img", srcdir);
3759   fd = open (buf, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
3760   if (fd == -1) {
3761     perror (buf);
3762     exit (1);
3763   }
3764   if (lseek (fd, 52428800, SEEK_SET) == -1) {
3765     perror ("lseek");
3766     close (fd);
3767     unlink (buf);
3768     exit (1);
3769   }
3770   if (write (fd, &c, 1) == -1) {
3771     perror ("write");
3772     close (fd);
3773     unlink (buf);
3774     exit (1);
3775   }
3776   if (close (fd) == -1) {
3777     perror (buf);
3778     unlink (buf);
3779     exit (1);
3780   }
3781   if (guestfs_add_drive (g, buf) == -1) {
3782     printf ("guestfs_add_drive %s FAILED\n", buf);
3783     exit (1);
3784   }
3785
3786   snprintf (buf, sizeof buf, "%s/test3.img", srcdir);
3787   fd = open (buf, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
3788   if (fd == -1) {
3789     perror (buf);
3790     exit (1);
3791   }
3792   if (lseek (fd, 10485760, SEEK_SET) == -1) {
3793     perror ("lseek");
3794     close (fd);
3795     unlink (buf);
3796     exit (1);
3797   }
3798   if (write (fd, &c, 1) == -1) {
3799     perror ("write");
3800     close (fd);
3801     unlink (buf);
3802     exit (1);
3803   }
3804   if (close (fd) == -1) {
3805     perror (buf);
3806     unlink (buf);
3807     exit (1);
3808   }
3809   if (guestfs_add_drive (g, buf) == -1) {
3810     printf ("guestfs_add_drive %s FAILED\n", buf);
3811     exit (1);
3812   }
3813
3814   if (guestfs_launch (g) == -1) {
3815     printf ("guestfs_launch FAILED\n");
3816     exit (1);
3817   }
3818   if (guestfs_wait_ready (g) == -1) {
3819     printf ("guestfs_wait_ready FAILED\n");
3820     exit (1);
3821   }
3822
3823   nr_tests = 49;
3824   printf ("  1/%3d test_mount_0\n", nr_tests);
3825   if (test_mount_0 () == -1) {
3826     printf ("test_mount_0 FAILED\n");
3827     failed++;
3828   }
3829   printf ("  2/%3d test_sync_0\n", nr_tests);
3830   if (test_sync_0 () == -1) {
3831     printf ("test_sync_0 FAILED\n");
3832     failed++;
3833   }
3834   printf ("  3/%3d test_touch_0\n", nr_tests);
3835   if (test_touch_0 () == -1) {
3836     printf ("test_touch_0 FAILED\n");
3837     failed++;
3838   }
3839   printf ("  4/%3d test_cat_0\n", nr_tests);
3840   if (test_cat_0 () == -1) {
3841     printf ("test_cat_0 FAILED\n");
3842     failed++;
3843   }
3844   printf ("  5/%3d test_ls_0\n", nr_tests);
3845   if (test_ls_0 () == -1) {
3846     printf ("test_ls_0 FAILED\n");
3847     failed++;
3848   }
3849   printf ("  6/%3d test_list_devices_0\n", nr_tests);
3850   if (test_list_devices_0 () == -1) {
3851     printf ("test_list_devices_0 FAILED\n");
3852     failed++;
3853   }
3854   printf ("  7/%3d test_list_partitions_0\n", nr_tests);
3855   if (test_list_partitions_0 () == -1) {
3856     printf ("test_list_partitions_0 FAILED\n");
3857     failed++;
3858   }
3859   printf ("  8/%3d test_list_partitions_1\n", nr_tests);
3860   if (test_list_partitions_1 () == -1) {
3861     printf ("test_list_partitions_1 FAILED\n");
3862     failed++;
3863   }
3864   printf ("  9/%3d test_pvs_0\n", nr_tests);
3865   if (test_pvs_0 () == -1) {
3866     printf ("test_pvs_0 FAILED\n");
3867     failed++;
3868   }
3869   printf (" 10/%3d test_pvs_1\n", nr_tests);
3870   if (test_pvs_1 () == -1) {
3871     printf ("test_pvs_1 FAILED\n");
3872     failed++;
3873   }
3874   printf (" 11/%3d test_vgs_0\n", nr_tests);
3875   if (test_vgs_0 () == -1) {
3876     printf ("test_vgs_0 FAILED\n");
3877     failed++;
3878   }
3879   printf (" 12/%3d test_vgs_1\n", nr_tests);
3880   if (test_vgs_1 () == -1) {
3881     printf ("test_vgs_1 FAILED\n");
3882     failed++;
3883   }
3884   printf (" 13/%3d test_lvs_0\n", nr_tests);
3885   if (test_lvs_0 () == -1) {
3886     printf ("test_lvs_0 FAILED\n");
3887     failed++;
3888   }
3889   printf (" 14/%3d test_lvs_1\n", nr_tests);
3890   if (test_lvs_1 () == -1) {
3891     printf ("test_lvs_1 FAILED\n");
3892     failed++;
3893   }
3894   printf (" 15/%3d test_read_lines_0\n", nr_tests);
3895   if (test_read_lines_0 () == -1) {
3896     printf ("test_read_lines_0 FAILED\n");
3897     failed++;
3898   }
3899   printf (" 16/%3d test_read_lines_1\n", nr_tests);
3900   if (test_read_lines_1 () == -1) {
3901     printf ("test_read_lines_1 FAILED\n");
3902     failed++;
3903   }
3904   printf (" 17/%3d test_rm_0\n", nr_tests);
3905   if (test_rm_0 () == -1) {
3906     printf ("test_rm_0 FAILED\n");
3907     failed++;
3908   }
3909   printf (" 18/%3d test_rm_1\n", nr_tests);
3910   if (test_rm_1 () == -1) {
3911     printf ("test_rm_1 FAILED\n");
3912     failed++;
3913   }
3914   printf (" 19/%3d test_rm_2\n", nr_tests);
3915   if (test_rm_2 () == -1) {
3916     printf ("test_rm_2 FAILED\n");
3917     failed++;
3918   }
3919   printf (" 20/%3d test_rmdir_0\n", nr_tests);
3920   if (test_rmdir_0 () == -1) {
3921     printf ("test_rmdir_0 FAILED\n");
3922     failed++;
3923   }
3924   printf (" 21/%3d test_rmdir_1\n", nr_tests);
3925   if (test_rmdir_1 () == -1) {
3926     printf ("test_rmdir_1 FAILED\n");
3927     failed++;
3928   }
3929   printf (" 22/%3d test_rmdir_2\n", nr_tests);
3930   if (test_rmdir_2 () == -1) {
3931     printf ("test_rmdir_2 FAILED\n");
3932     failed++;
3933   }
3934   printf (" 23/%3d test_rm_rf_0\n", nr_tests);
3935   if (test_rm_rf_0 () == -1) {
3936     printf ("test_rm_rf_0 FAILED\n");
3937     failed++;
3938   }
3939   printf (" 24/%3d test_mkdir_0\n", nr_tests);
3940   if (test_mkdir_0 () == -1) {
3941     printf ("test_mkdir_0 FAILED\n");
3942     failed++;
3943   }
3944   printf (" 25/%3d test_mkdir_1\n", nr_tests);
3945   if (test_mkdir_1 () == -1) {
3946     printf ("test_mkdir_1 FAILED\n");
3947     failed++;
3948   }
3949   printf (" 26/%3d test_mkdir_p_0\n", nr_tests);
3950   if (test_mkdir_p_0 () == -1) {
3951     printf ("test_mkdir_p_0 FAILED\n");
3952     failed++;
3953   }
3954   printf (" 27/%3d test_mkdir_p_1\n", nr_tests);
3955   if (test_mkdir_p_1 () == -1) {
3956     printf ("test_mkdir_p_1 FAILED\n");
3957     failed++;
3958   }
3959   printf (" 28/%3d test_mkdir_p_2\n", nr_tests);
3960   if (test_mkdir_p_2 () == -1) {
3961     printf ("test_mkdir_p_2 FAILED\n");
3962     failed++;
3963   }
3964   printf (" 29/%3d test_exists_0\n", nr_tests);
3965   if (test_exists_0 () == -1) {
3966     printf ("test_exists_0 FAILED\n");
3967     failed++;
3968   }
3969   printf (" 30/%3d test_exists_1\n", nr_tests);
3970   if (test_exists_1 () == -1) {
3971     printf ("test_exists_1 FAILED\n");
3972     failed++;
3973   }
3974   printf (" 31/%3d test_is_file_0\n", nr_tests);
3975   if (test_is_file_0 () == -1) {
3976     printf ("test_is_file_0 FAILED\n");
3977     failed++;
3978   }
3979   printf (" 32/%3d test_is_file_1\n", nr_tests);
3980   if (test_is_file_1 () == -1) {
3981     printf ("test_is_file_1 FAILED\n");
3982     failed++;
3983   }
3984   printf (" 33/%3d test_is_dir_0\n", nr_tests);
3985   if (test_is_dir_0 () == -1) {
3986     printf ("test_is_dir_0 FAILED\n");
3987     failed++;
3988   }
3989   printf (" 34/%3d test_is_dir_1\n", nr_tests);
3990   if (test_is_dir_1 () == -1) {
3991     printf ("test_is_dir_1 FAILED\n");
3992     failed++;
3993   }
3994   printf (" 35/%3d test_pvcreate_0\n", nr_tests);
3995   if (test_pvcreate_0 () == -1) {
3996     printf ("test_pvcreate_0 FAILED\n");
3997     failed++;
3998   }
3999   printf (" 36/%3d test_vgcreate_0\n", nr_tests);
4000   if (test_vgcreate_0 () == -1) {
4001     printf ("test_vgcreate_0 FAILED\n");
4002     failed++;
4003   }
4004   printf (" 37/%3d test_lvcreate_0\n", nr_tests);
4005   if (test_lvcreate_0 () == -1) {
4006     printf ("test_lvcreate_0 FAILED\n");
4007     failed++;
4008   }
4009   printf (" 38/%3d test_mkfs_0\n", nr_tests);
4010   if (test_mkfs_0 () == -1) {
4011     printf ("test_mkfs_0 FAILED\n");
4012     failed++;
4013   }
4014   printf (" 39/%3d test_write_file_0\n", nr_tests);
4015   if (test_write_file_0 () == -1) {
4016     printf ("test_write_file_0 FAILED\n");
4017     failed++;
4018   }
4019   printf (" 40/%3d test_umount_0\n", nr_tests);
4020   if (test_umount_0 () == -1) {
4021     printf ("test_umount_0 FAILED\n");
4022     failed++;
4023   }
4024   printf (" 41/%3d test_umount_1\n", nr_tests);
4025   if (test_umount_1 () == -1) {
4026     printf ("test_umount_1 FAILED\n");
4027     failed++;
4028   }
4029   printf (" 42/%3d test_mounts_0\n", nr_tests);
4030   if (test_mounts_0 () == -1) {
4031     printf ("test_mounts_0 FAILED\n");
4032     failed++;
4033   }
4034   printf (" 43/%3d test_umount_all_0\n", nr_tests);
4035   if (test_umount_all_0 () == -1) {
4036     printf ("test_umount_all_0 FAILED\n");
4037     failed++;
4038   }
4039   printf (" 44/%3d test_file_0\n", nr_tests);
4040   if (test_file_0 () == -1) {
4041     printf ("test_file_0 FAILED\n");
4042     failed++;
4043   }
4044   printf (" 45/%3d test_file_1\n", nr_tests);
4045   if (test_file_1 () == -1) {
4046     printf ("test_file_1 FAILED\n");
4047     failed++;
4048   }
4049   printf (" 46/%3d test_file_2\n", nr_tests);
4050   if (test_file_2 () == -1) {
4051     printf ("test_file_2 FAILED\n");
4052     failed++;
4053   }
4054   printf (" 47/%3d test_stat_0\n", nr_tests);
4055   if (test_stat_0 () == -1) {
4056     printf ("test_stat_0 FAILED\n");
4057     failed++;
4058   }
4059   printf (" 48/%3d test_lstat_0\n", nr_tests);
4060   if (test_lstat_0 () == -1) {
4061     printf ("test_lstat_0 FAILED\n");
4062     failed++;
4063   }
4064   printf (" 49/%3d test_statvfs_0\n", nr_tests);
4065   if (test_statvfs_0 () == -1) {
4066     printf ("test_statvfs_0 FAILED\n");
4067     failed++;
4068   }
4069
4070   guestfs_close (g);
4071   snprintf (buf, sizeof buf, "%s/test1.img", srcdir);
4072   unlink (buf);
4073   snprintf (buf, sizeof buf, "%s/test2.img", srcdir);
4074   unlink (buf);
4075   snprintf (buf, sizeof buf, "%s/test3.img", srcdir);
4076   unlink (buf);
4077
4078   if (failed > 0) {
4079     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
4080     exit (1);
4081   }
4082
4083   exit (0);
4084 }