tests.c

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