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