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