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 /* This will be 's' or 'h' depending on whether the guest kernel
  35  * names IDE devices /dev/sd* or /dev/hd*.
  36  */
  37 static char devchar = 's';
  38
  39 static void print_error (guestfs_h *g, void *data, const char *msg)
  40 {
  41   if (!suppress_error)
  42     fprintf (stderr, "%s\n", msg);
  43 }
  44
  45 static void print_strings (char * const * const argv)
  46 {
  47   int argc;
  48
  49   for (argc = 0; argv[argc] != NULL; ++argc)
  50     printf ("\t%s\n", argv[argc]);
  51 }
  52
  53 /*
  54 static void print_table (char * const * const argv)
  55 {
  56   int i;
  57
  58   for (i = 0; argv[i] != NULL; i += 2)
  59     printf ("%s: %s\n", argv[i], argv[i+1]);
  60 }
  61 */
  62
  63 static void no_test_warnings (void)
  64 {
  65   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 127 }
 128
 129 static int test_lvresize_0 (void)
 130 {
 131   /* InitNone|InitEmpty for test_lvresize_0 */
 132   {
 133     char device[] = "/dev/sda";
 134     device[5] = devchar;
 135     int r;
 136     suppress_error = 0;
 137     r = guestfs_blockdev_setrw (g, device);
 138     if (r == -1)
 139       return -1;
 140   }
 141   {
 142     int r;
 143     suppress_error = 0;
 144     r = guestfs_umount_all (g);
 145     if (r == -1)
 146       return -1;
 147   }
 148   {
 149     int r;
 150     suppress_error = 0;
 151     r = guestfs_lvm_remove_all (g);
 152     if (r == -1)
 153       return -1;
 154   }
 155   /* TestOutput for lvresize (0) */
 156   char expected[] = "test content";
 157   {
 158     char device[] = "/dev/sda";
 159     device[5] = devchar;
 160     char lines_0[] = ",";
 161     char *lines[] = {
 162       lines_0,
 163       NULL
 164     };
 165     int r;
 166     suppress_error = 0;
 167     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 168     if (r == -1)
 169       return -1;
 170   }
 171   {
 172     char device[] = "/dev/sda1";
 173     device[5] = devchar;
 174     int r;
 175     suppress_error = 0;
 176     r = guestfs_pvcreate (g, device);
 177     if (r == -1)
 178       return -1;
 179   }
 180   {
 181     char volgroup[] = "VG";
 182     char physvols_0[] = "/dev/sda1";
 183     physvols_0[5] = devchar;
 184     char *physvols[] = {
 185       physvols_0,
 186       NULL
 187     };
 188     int r;
 189     suppress_error = 0;
 190     r = guestfs_vgcreate (g, volgroup, physvols);
 191     if (r == -1)
 192       return -1;
 193   }
 194   {
 195     char logvol[] = "LV";
 196     char volgroup[] = "VG";
 197     int r;
 198     suppress_error = 0;
 199     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 200     if (r == -1)
 201       return -1;
 202   }
 203   {
 204     char fstype[] = "ext2";
 205     char device[] = "/dev/VG/LV";
 206     int r;
 207     suppress_error = 0;
 208     r = guestfs_mkfs (g, fstype, device);
 209     if (r == -1)
 210       return -1;
 211   }
 212   {
 213     char device[] = "/dev/VG/LV";
 214     char mountpoint[] = "/";
 215     int r;
 216     suppress_error = 0;
 217     r = guestfs_mount (g, device, mountpoint);
 218     if (r == -1)
 219       return -1;
 220   }
 221   {
 222     char path[] = "/new";
 223     char content[] = "test content";
 224     int r;
 225     suppress_error = 0;
 226     r = guestfs_write_file (g, path, content, 0);
 227     if (r == -1)
 228       return -1;
 229   }
 230   {
 231     char pathordevice[] = "/";
 232     int r;
 233     suppress_error = 0;
 234     r = guestfs_umount (g, pathordevice);
 235     if (r == -1)
 236       return -1;
 237   }
 238   {
 239     char device[] = "/dev/VG/LV";
 240     int r;
 241     suppress_error = 0;
 242     r = guestfs_lvresize (g, device, 20);
 243     if (r == -1)
 244       return -1;
 245   }
 246   {
 247     char device[] = "/dev/VG/LV";
 248     int r;
 249     suppress_error = 0;
 250     r = guestfs_resize2fs (g, device);
 251     if (r == -1)
 252       return -1;
 253   }
 254   {
 255     char device[] = "/dev/VG/LV";
 256     char mountpoint[] = "/";
 257     int r;
 258     suppress_error = 0;
 259     r = guestfs_mount (g, device, mountpoint);
 260     if (r == -1)
 261       return -1;
 262   }
 263   {
 264     char path[] = "/new";
 265     char *r;
 266     suppress_error = 0;
 267     r = guestfs_cat (g, path);
 268     if (r == NULL)
 269       return -1;
 270     if (strcmp (r, expected) != 0) {
 271       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 272       return -1;
 273     }
 274     free (r);
 275   }
 276   return 0;
 277 }
 278
 279 static int test_zerofree_0 (void)
 280 {
 281   /* InitNone|InitEmpty for test_zerofree_0 */
 282   {
 283     char device[] = "/dev/sda";
 284     device[5] = devchar;
 285     int r;
 286     suppress_error = 0;
 287     r = guestfs_blockdev_setrw (g, device);
 288     if (r == -1)
 289       return -1;
 290   }
 291   {
 292     int r;
 293     suppress_error = 0;
 294     r = guestfs_umount_all (g);
 295     if (r == -1)
 296       return -1;
 297   }
 298   {
 299     int r;
 300     suppress_error = 0;
 301     r = guestfs_lvm_remove_all (g);
 302     if (r == -1)
 303       return -1;
 304   }
 305   /* TestOutput for zerofree (0) */
 306   char expected[] = "test file";
 307   {
 308     char device[] = "/dev/sda";
 309     device[5] = devchar;
 310     char lines_0[] = ",";
 311     char *lines[] = {
 312       lines_0,
 313       NULL
 314     };
 315     int r;
 316     suppress_error = 0;
 317     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 318     if (r == -1)
 319       return -1;
 320   }
 321   {
 322     char fstype[] = "ext3";
 323     char device[] = "/dev/sda1";
 324     device[5] = devchar;
 325     int r;
 326     suppress_error = 0;
 327     r = guestfs_mkfs (g, fstype, device);
 328     if (r == -1)
 329       return -1;
 330   }
 331   {
 332     char device[] = "/dev/sda1";
 333     device[5] = devchar;
 334     char mountpoint[] = "/";
 335     int r;
 336     suppress_error = 0;
 337     r = guestfs_mount (g, device, mountpoint);
 338     if (r == -1)
 339       return -1;
 340   }
 341   {
 342     char path[] = "/new";
 343     char content[] = "test file";
 344     int r;
 345     suppress_error = 0;
 346     r = guestfs_write_file (g, path, content, 0);
 347     if (r == -1)
 348       return -1;
 349   }
 350   {
 351     char pathordevice[] = "/dev/sda1";
 352     pathordevice[5] = devchar;
 353     int r;
 354     suppress_error = 0;
 355     r = guestfs_umount (g, pathordevice);
 356     if (r == -1)
 357       return -1;
 358   }
 359   {
 360     char device[] = "/dev/sda1";
 361     device[5] = devchar;
 362     int r;
 363     suppress_error = 0;
 364     r = guestfs_zerofree (g, device);
 365     if (r == -1)
 366       return -1;
 367   }
 368   {
 369     char device[] = "/dev/sda1";
 370     device[5] = devchar;
 371     char mountpoint[] = "/";
 372     int r;
 373     suppress_error = 0;
 374     r = guestfs_mount (g, device, mountpoint);
 375     if (r == -1)
 376       return -1;
 377   }
 378   {
 379     char path[] = "/new";
 380     char *r;
 381     suppress_error = 0;
 382     r = guestfs_cat (g, path);
 383     if (r == NULL)
 384       return -1;
 385     if (strcmp (r, expected) != 0) {
 386       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
 387       return -1;
 388     }
 389     free (r);
 390   }
 391   return 0;
 392 }
 393
 394 static int test_hexdump_0 (void)
 395 {
 396   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
 397   {
 398     char device[] = "/dev/sda";
 399     device[5] = devchar;
 400     int r;
 401     suppress_error = 0;
 402     r = guestfs_blockdev_setrw (g, device);
 403     if (r == -1)
 404       return -1;
 405   }
 406   {
 407     int r;
 408     suppress_error = 0;
 409     r = guestfs_umount_all (g);
 410     if (r == -1)
 411       return -1;
 412   }
 413   {
 414     int r;
 415     suppress_error = 0;
 416     r = guestfs_lvm_remove_all (g);
 417     if (r == -1)
 418       return -1;
 419   }
 420   {
 421     char device[] = "/dev/sda";
 422     device[5] = devchar;
 423     char lines_0[] = ",";
 424     char *lines[] = {
 425       lines_0,
 426       NULL
 427     };
 428     int r;
 429     suppress_error = 0;
 430     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 431     if (r == -1)
 432       return -1;
 433   }
 434   {
 435     char fstype[] = "ext2";
 436     char device[] = "/dev/sda1";
 437     device[5] = devchar;
 438     int r;
 439     suppress_error = 0;
 440     r = guestfs_mkfs (g, fstype, device);
 441     if (r == -1)
 442       return -1;
 443   }
 444   {
 445     char device[] = "/dev/sda1";
 446     device[5] = devchar;
 447     char mountpoint[] = "/";
 448     int r;
 449     suppress_error = 0;
 450     r = guestfs_mount (g, device, mountpoint);
 451     if (r == -1)
 452       return -1;
 453   }
 454   /* TestOutput for hexdump (0) */
 455   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
 456   {
 457     char path[] = "/new";
 458     char content[] = "hello\nworld\n";
 459     int r;
 460     suppress_error = 0;
 461     r = guestfs_write_file (g, path, content, 12);
 462     if (r == -1)
 463       return -1;
 464   }
 465   {
 466     char path[] = "/new";
 467     char *r;
 468     suppress_error = 0;
 469     r = guestfs_hexdump (g, path);
 470     if (r == NULL)
 471       return -1;
 472     if (strcmp (r, expected) != 0) {
 473       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
 474       return -1;
 475     }
 476     free (r);
 477   }
 478   return 0;
 479 }
 480
 481 static int test_strings_e_0 (void)
 482 {
 483   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
 484   {
 485     char device[] = "/dev/sda";
 486     device[5] = devchar;
 487     int r;
 488     suppress_error = 0;
 489     r = guestfs_blockdev_setrw (g, device);
 490     if (r == -1)
 491       return -1;
 492   }
 493   {
 494     int r;
 495     suppress_error = 0;
 496     r = guestfs_umount_all (g);
 497     if (r == -1)
 498       return -1;
 499   }
 500   {
 501     int r;
 502     suppress_error = 0;
 503     r = guestfs_lvm_remove_all (g);
 504     if (r == -1)
 505       return -1;
 506   }
 507   {
 508     char device[] = "/dev/sda";
 509     device[5] = devchar;
 510     char lines_0[] = ",";
 511     char *lines[] = {
 512       lines_0,
 513       NULL
 514     };
 515     int r;
 516     suppress_error = 0;
 517     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 518     if (r == -1)
 519       return -1;
 520   }
 521   {
 522     char fstype[] = "ext2";
 523     char device[] = "/dev/sda1";
 524     device[5] = devchar;
 525     int r;
 526     suppress_error = 0;
 527     r = guestfs_mkfs (g, fstype, device);
 528     if (r == -1)
 529       return -1;
 530   }
 531   {
 532     char device[] = "/dev/sda1";
 533     device[5] = devchar;
 534     char mountpoint[] = "/";
 535     int r;
 536     suppress_error = 0;
 537     r = guestfs_mount (g, device, mountpoint);
 538     if (r == -1)
 539       return -1;
 540   }
 541   /* TestOutputList for strings_e (0) */
 542   {
 543     char path[] = "/new";
 544     char content[] = "hello\nworld\n";
 545     int r;
 546     suppress_error = 0;
 547     r = guestfs_write_file (g, path, content, 0);
 548     if (r == -1)
 549       return -1;
 550   }
 551   {
 552     char encoding[] = "b";
 553     char path[] = "/new";
 554     char **r;
 555     int i;
 556     suppress_error = 0;
 557     r = guestfs_strings_e (g, encoding, path);
 558     if (r == NULL)
 559       return -1;
 560     if (r[0] != NULL) {
 561       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
 562       print_strings (r);
 563       return -1;
 564     }
 565     for (i = 0; r[i] != NULL; ++i)
 566       free (r[i]);
 567     free (r);
 568   }
 569   return 0;
 570 }
 571
 572 static int test_strings_e_1 (void)
 573 {
 574   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
 575   return 0;
 576 }
 577
 578 static int test_strings_0 (void)
 579 {
 580   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
 581   {
 582     char device[] = "/dev/sda";
 583     device[5] = devchar;
 584     int r;
 585     suppress_error = 0;
 586     r = guestfs_blockdev_setrw (g, device);
 587     if (r == -1)
 588       return -1;
 589   }
 590   {
 591     int r;
 592     suppress_error = 0;
 593     r = guestfs_umount_all (g);
 594     if (r == -1)
 595       return -1;
 596   }
 597   {
 598     int r;
 599     suppress_error = 0;
 600     r = guestfs_lvm_remove_all (g);
 601     if (r == -1)
 602       return -1;
 603   }
 604   {
 605     char device[] = "/dev/sda";
 606     device[5] = devchar;
 607     char lines_0[] = ",";
 608     char *lines[] = {
 609       lines_0,
 610       NULL
 611     };
 612     int r;
 613     suppress_error = 0;
 614     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 615     if (r == -1)
 616       return -1;
 617   }
 618   {
 619     char fstype[] = "ext2";
 620     char device[] = "/dev/sda1";
 621     device[5] = devchar;
 622     int r;
 623     suppress_error = 0;
 624     r = guestfs_mkfs (g, fstype, device);
 625     if (r == -1)
 626       return -1;
 627   }
 628   {
 629     char device[] = "/dev/sda1";
 630     device[5] = devchar;
 631     char mountpoint[] = "/";
 632     int r;
 633     suppress_error = 0;
 634     r = guestfs_mount (g, device, mountpoint);
 635     if (r == -1)
 636       return -1;
 637   }
 638   /* TestOutputList for strings (0) */
 639   {
 640     char path[] = "/new";
 641     char content[] = "hello\nworld\n";
 642     int r;
 643     suppress_error = 0;
 644     r = guestfs_write_file (g, path, content, 0);
 645     if (r == -1)
 646       return -1;
 647   }
 648   {
 649     char path[] = "/new";
 650     char **r;
 651     int i;
 652     suppress_error = 0;
 653     r = guestfs_strings (g, path);
 654     if (r == NULL)
 655       return -1;
 656     if (!r[0]) {
 657       fprintf (stderr, "test_strings_0: short list returned from command\n");
 658       print_strings (r);
 659       return -1;
 660     }
 661     {
 662       char expected[] = "hello";
 663       if (strcmp (r[0], expected) != 0) {
 664         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 665         return -1;
 666       }
 667     }
 668     if (!r[1]) {
 669       fprintf (stderr, "test_strings_0: short list returned from command\n");
 670       print_strings (r);
 671       return -1;
 672     }
 673     {
 674       char expected[] = "world";
 675       if (strcmp (r[1], expected) != 0) {
 676         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 677         return -1;
 678       }
 679     }
 680     if (r[2] != NULL) {
 681       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
 682       print_strings (r);
 683       return -1;
 684     }
 685     for (i = 0; r[i] != NULL; ++i)
 686       free (r[i]);
 687     free (r);
 688   }
 689   return 0;
 690 }
 691
 692 static int test_strings_1 (void)
 693 {
 694   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
 695   {
 696     char device[] = "/dev/sda";
 697     device[5] = devchar;
 698     int r;
 699     suppress_error = 0;
 700     r = guestfs_blockdev_setrw (g, device);
 701     if (r == -1)
 702       return -1;
 703   }
 704   {
 705     int r;
 706     suppress_error = 0;
 707     r = guestfs_umount_all (g);
 708     if (r == -1)
 709       return -1;
 710   }
 711   {
 712     int r;
 713     suppress_error = 0;
 714     r = guestfs_lvm_remove_all (g);
 715     if (r == -1)
 716       return -1;
 717   }
 718   {
 719     char device[] = "/dev/sda";
 720     device[5] = devchar;
 721     char lines_0[] = ",";
 722     char *lines[] = {
 723       lines_0,
 724       NULL
 725     };
 726     int r;
 727     suppress_error = 0;
 728     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 729     if (r == -1)
 730       return -1;
 731   }
 732   {
 733     char fstype[] = "ext2";
 734     char device[] = "/dev/sda1";
 735     device[5] = devchar;
 736     int r;
 737     suppress_error = 0;
 738     r = guestfs_mkfs (g, fstype, device);
 739     if (r == -1)
 740       return -1;
 741   }
 742   {
 743     char device[] = "/dev/sda1";
 744     device[5] = devchar;
 745     char mountpoint[] = "/";
 746     int r;
 747     suppress_error = 0;
 748     r = guestfs_mount (g, device, mountpoint);
 749     if (r == -1)
 750       return -1;
 751   }
 752   /* TestOutputList for strings (1) */
 753   {
 754     char path[] = "/new";
 755     int r;
 756     suppress_error = 0;
 757     r = guestfs_touch (g, path);
 758     if (r == -1)
 759       return -1;
 760   }
 761   {
 762     char path[] = "/new";
 763     char **r;
 764     int i;
 765     suppress_error = 0;
 766     r = guestfs_strings (g, path);
 767     if (r == NULL)
 768       return -1;
 769     if (r[0] != NULL) {
 770       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
 771       print_strings (r);
 772       return -1;
 773     }
 774     for (i = 0; r[i] != NULL; ++i)
 775       free (r[i]);
 776     free (r);
 777   }
 778   return 0;
 779 }
 780
 781 static int test_equal_0 (void)
 782 {
 783   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
 784   {
 785     char device[] = "/dev/sda";
 786     device[5] = devchar;
 787     int r;
 788     suppress_error = 0;
 789     r = guestfs_blockdev_setrw (g, device);
 790     if (r == -1)
 791       return -1;
 792   }
 793   {
 794     int r;
 795     suppress_error = 0;
 796     r = guestfs_umount_all (g);
 797     if (r == -1)
 798       return -1;
 799   }
 800   {
 801     int r;
 802     suppress_error = 0;
 803     r = guestfs_lvm_remove_all (g);
 804     if (r == -1)
 805       return -1;
 806   }
 807   {
 808     char device[] = "/dev/sda";
 809     device[5] = devchar;
 810     char lines_0[] = ",";
 811     char *lines[] = {
 812       lines_0,
 813       NULL
 814     };
 815     int r;
 816     suppress_error = 0;
 817     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 818     if (r == -1)
 819       return -1;
 820   }
 821   {
 822     char fstype[] = "ext2";
 823     char device[] = "/dev/sda1";
 824     device[5] = devchar;
 825     int r;
 826     suppress_error = 0;
 827     r = guestfs_mkfs (g, fstype, device);
 828     if (r == -1)
 829       return -1;
 830   }
 831   {
 832     char device[] = "/dev/sda1";
 833     device[5] = devchar;
 834     char mountpoint[] = "/";
 835     int r;
 836     suppress_error = 0;
 837     r = guestfs_mount (g, device, mountpoint);
 838     if (r == -1)
 839       return -1;
 840   }
 841   /* TestOutputTrue for equal (0) */
 842   {
 843     char path[] = "/file1";
 844     char content[] = "contents of a file";
 845     int r;
 846     suppress_error = 0;
 847     r = guestfs_write_file (g, path, content, 0);
 848     if (r == -1)
 849       return -1;
 850   }
 851   {
 852     char src[] = "/file1";
 853     char dest[] = "/file2";
 854     int r;
 855     suppress_error = 0;
 856     r = guestfs_cp (g, src, dest);
 857     if (r == -1)
 858       return -1;
 859   }
 860   {
 861     char file1[] = "/file1";
 862     char file2[] = "/file2";
 863     int r;
 864     suppress_error = 0;
 865     r = guestfs_equal (g, file1, file2);
 866     if (r == -1)
 867       return -1;
 868     if (!r) {
 869       fprintf (stderr, "test_equal_0: expected true, got false\n");
 870       return -1;
 871     }
 872   }
 873   return 0;
 874 }
 875
 876 static int test_equal_1 (void)
 877 {
 878   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
 879   {
 880     char device[] = "/dev/sda";
 881     device[5] = devchar;
 882     int r;
 883     suppress_error = 0;
 884     r = guestfs_blockdev_setrw (g, device);
 885     if (r == -1)
 886       return -1;
 887   }
 888   {
 889     int r;
 890     suppress_error = 0;
 891     r = guestfs_umount_all (g);
 892     if (r == -1)
 893       return -1;
 894   }
 895   {
 896     int r;
 897     suppress_error = 0;
 898     r = guestfs_lvm_remove_all (g);
 899     if (r == -1)
 900       return -1;
 901   }
 902   {
 903     char device[] = "/dev/sda";
 904     device[5] = devchar;
 905     char lines_0[] = ",";
 906     char *lines[] = {
 907       lines_0,
 908       NULL
 909     };
 910     int r;
 911     suppress_error = 0;
 912     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 913     if (r == -1)
 914       return -1;
 915   }
 916   {
 917     char fstype[] = "ext2";
 918     char device[] = "/dev/sda1";
 919     device[5] = devchar;
 920     int r;
 921     suppress_error = 0;
 922     r = guestfs_mkfs (g, fstype, device);
 923     if (r == -1)
 924       return -1;
 925   }
 926   {
 927     char device[] = "/dev/sda1";
 928     device[5] = devchar;
 929     char mountpoint[] = "/";
 930     int r;
 931     suppress_error = 0;
 932     r = guestfs_mount (g, device, mountpoint);
 933     if (r == -1)
 934       return -1;
 935   }
 936   /* TestOutputFalse for equal (1) */
 937   {
 938     char path[] = "/file1";
 939     char content[] = "contents of a file";
 940     int r;
 941     suppress_error = 0;
 942     r = guestfs_write_file (g, path, content, 0);
 943     if (r == -1)
 944       return -1;
 945   }
 946   {
 947     char path[] = "/file2";
 948     char content[] = "contents of another file";
 949     int r;
 950     suppress_error = 0;
 951     r = guestfs_write_file (g, path, content, 0);
 952     if (r == -1)
 953       return -1;
 954   }
 955   {
 956     char file1[] = "/file1";
 957     char file2[] = "/file2";
 958     int r;
 959     suppress_error = 0;
 960     r = guestfs_equal (g, file1, file2);
 961     if (r == -1)
 962       return -1;
 963     if (r) {
 964       fprintf (stderr, "test_equal_1: expected false, got true\n");
 965       return -1;
 966     }
 967   }
 968   return 0;
 969 }
 970
 971 static int test_equal_2 (void)
 972 {
 973   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
 974   {
 975     char device[] = "/dev/sda";
 976     device[5] = devchar;
 977     int r;
 978     suppress_error = 0;
 979     r = guestfs_blockdev_setrw (g, device);
 980     if (r == -1)
 981       return -1;
 982   }
 983   {
 984     int r;
 985     suppress_error = 0;
 986     r = guestfs_umount_all (g);
 987     if (r == -1)
 988       return -1;
 989   }
 990   {
 991     int r;
 992     suppress_error = 0;
 993     r = guestfs_lvm_remove_all (g);
 994     if (r == -1)
 995       return -1;
 996   }
 997   {
 998     char device[] = "/dev/sda";
 999     device[5] = devchar;
1000     char lines_0[] = ",";
1001     char *lines[] = {
1002       lines_0,
1003       NULL
1004     };
1005     int r;
1006     suppress_error = 0;
1007     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1008     if (r == -1)
1009       return -1;
1010   }
1011   {
1012     char fstype[] = "ext2";
1013     char device[] = "/dev/sda1";
1014     device[5] = devchar;
1015     int r;
1016     suppress_error = 0;
1017     r = guestfs_mkfs (g, fstype, device);
1018     if (r == -1)
1019       return -1;
1020   }
1021   {
1022     char device[] = "/dev/sda1";
1023     device[5] = devchar;
1024     char mountpoint[] = "/";
1025     int r;
1026     suppress_error = 0;
1027     r = guestfs_mount (g, device, mountpoint);
1028     if (r == -1)
1029       return -1;
1030   }
1031   /* TestLastFail for equal (2) */
1032   {
1033     char file1[] = "/file1";
1034     char file2[] = "/file2";
1035     int r;
1036     suppress_error = 1;
1037     r = guestfs_equal (g, file1, file2);
1038     if (r != -1)
1039       return -1;
1040   }
1041   return 0;
1042 }
1043
1044 static int test_ping_daemon_0 (void)
1045 {
1046   /* InitNone|InitEmpty for test_ping_daemon_0 */
1047   {
1048     char device[] = "/dev/sda";
1049     device[5] = devchar;
1050     int r;
1051     suppress_error = 0;
1052     r = guestfs_blockdev_setrw (g, device);
1053     if (r == -1)
1054       return -1;
1055   }
1056   {
1057     int r;
1058     suppress_error = 0;
1059     r = guestfs_umount_all (g);
1060     if (r == -1)
1061       return -1;
1062   }
1063   {
1064     int r;
1065     suppress_error = 0;
1066     r = guestfs_lvm_remove_all (g);
1067     if (r == -1)
1068       return -1;
1069   }
1070   /* TestRun for ping_daemon (0) */
1071   {
1072     int r;
1073     suppress_error = 0;
1074     r = guestfs_ping_daemon (g);
1075     if (r == -1)
1076       return -1;
1077   }
1078   return 0;
1079 }
1080
1081 static int test_dmesg_0 (void)
1082 {
1083   /* InitNone|InitEmpty for test_dmesg_0 */
1084   {
1085     char device[] = "/dev/sda";
1086     device[5] = devchar;
1087     int r;
1088     suppress_error = 0;
1089     r = guestfs_blockdev_setrw (g, device);
1090     if (r == -1)
1091       return -1;
1092   }
1093   {
1094     int r;
1095     suppress_error = 0;
1096     r = guestfs_umount_all (g);
1097     if (r == -1)
1098       return -1;
1099   }
1100   {
1101     int r;
1102     suppress_error = 0;
1103     r = guestfs_lvm_remove_all (g);
1104     if (r == -1)
1105       return -1;
1106   }
1107   /* TestRun for dmesg (0) */
1108   {
1109     char *r;
1110     suppress_error = 0;
1111     r = guestfs_dmesg (g);
1112     if (r == NULL)
1113       return -1;
1114     free (r);
1115   }
1116   return 0;
1117 }
1118
1119 static int test_drop_caches_0 (void)
1120 {
1121   /* InitNone|InitEmpty for test_drop_caches_0 */
1122   {
1123     char device[] = "/dev/sda";
1124     device[5] = devchar;
1125     int r;
1126     suppress_error = 0;
1127     r = guestfs_blockdev_setrw (g, device);
1128     if (r == -1)
1129       return -1;
1130   }
1131   {
1132     int r;
1133     suppress_error = 0;
1134     r = guestfs_umount_all (g);
1135     if (r == -1)
1136       return -1;
1137   }
1138   {
1139     int r;
1140     suppress_error = 0;
1141     r = guestfs_lvm_remove_all (g);
1142     if (r == -1)
1143       return -1;
1144   }
1145   /* TestRun for drop_caches (0) */
1146   {
1147     int r;
1148     suppress_error = 0;
1149     r = guestfs_drop_caches (g, 3);
1150     if (r == -1)
1151       return -1;
1152   }
1153   return 0;
1154 }
1155
1156 static int test_mv_0 (void)
1157 {
1158   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1159   {
1160     char device[] = "/dev/sda";
1161     device[5] = devchar;
1162     int r;
1163     suppress_error = 0;
1164     r = guestfs_blockdev_setrw (g, device);
1165     if (r == -1)
1166       return -1;
1167   }
1168   {
1169     int r;
1170     suppress_error = 0;
1171     r = guestfs_umount_all (g);
1172     if (r == -1)
1173       return -1;
1174   }
1175   {
1176     int r;
1177     suppress_error = 0;
1178     r = guestfs_lvm_remove_all (g);
1179     if (r == -1)
1180       return -1;
1181   }
1182   {
1183     char device[] = "/dev/sda";
1184     device[5] = devchar;
1185     char lines_0[] = ",";
1186     char *lines[] = {
1187       lines_0,
1188       NULL
1189     };
1190     int r;
1191     suppress_error = 0;
1192     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1193     if (r == -1)
1194       return -1;
1195   }
1196   {
1197     char fstype[] = "ext2";
1198     char device[] = "/dev/sda1";
1199     device[5] = devchar;
1200     int r;
1201     suppress_error = 0;
1202     r = guestfs_mkfs (g, fstype, device);
1203     if (r == -1)
1204       return -1;
1205   }
1206   {
1207     char device[] = "/dev/sda1";
1208     device[5] = devchar;
1209     char mountpoint[] = "/";
1210     int r;
1211     suppress_error = 0;
1212     r = guestfs_mount (g, device, mountpoint);
1213     if (r == -1)
1214       return -1;
1215   }
1216   /* TestOutput for mv (0) */
1217   char expected[] = "file content";
1218   {
1219     char path[] = "/old";
1220     char content[] = "file content";
1221     int r;
1222     suppress_error = 0;
1223     r = guestfs_write_file (g, path, content, 0);
1224     if (r == -1)
1225       return -1;
1226   }
1227   {
1228     char src[] = "/old";
1229     char dest[] = "/new";
1230     int r;
1231     suppress_error = 0;
1232     r = guestfs_mv (g, src, dest);
1233     if (r == -1)
1234       return -1;
1235   }
1236   {
1237     char path[] = "/new";
1238     char *r;
1239     suppress_error = 0;
1240     r = guestfs_cat (g, path);
1241     if (r == NULL)
1242       return -1;
1243     if (strcmp (r, expected) != 0) {
1244       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1245       return -1;
1246     }
1247     free (r);
1248   }
1249   return 0;
1250 }
1251
1252 static int test_mv_1 (void)
1253 {
1254   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1255   {
1256     char device[] = "/dev/sda";
1257     device[5] = devchar;
1258     int r;
1259     suppress_error = 0;
1260     r = guestfs_blockdev_setrw (g, device);
1261     if (r == -1)
1262       return -1;
1263   }
1264   {
1265     int r;
1266     suppress_error = 0;
1267     r = guestfs_umount_all (g);
1268     if (r == -1)
1269       return -1;
1270   }
1271   {
1272     int r;
1273     suppress_error = 0;
1274     r = guestfs_lvm_remove_all (g);
1275     if (r == -1)
1276       return -1;
1277   }
1278   {
1279     char device[] = "/dev/sda";
1280     device[5] = devchar;
1281     char lines_0[] = ",";
1282     char *lines[] = {
1283       lines_0,
1284       NULL
1285     };
1286     int r;
1287     suppress_error = 0;
1288     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1289     if (r == -1)
1290       return -1;
1291   }
1292   {
1293     char fstype[] = "ext2";
1294     char device[] = "/dev/sda1";
1295     device[5] = devchar;
1296     int r;
1297     suppress_error = 0;
1298     r = guestfs_mkfs (g, fstype, device);
1299     if (r == -1)
1300       return -1;
1301   }
1302   {
1303     char device[] = "/dev/sda1";
1304     device[5] = devchar;
1305     char mountpoint[] = "/";
1306     int r;
1307     suppress_error = 0;
1308     r = guestfs_mount (g, device, mountpoint);
1309     if (r == -1)
1310       return -1;
1311   }
1312   /* TestOutputFalse for mv (1) */
1313   {
1314     char path[] = "/old";
1315     char content[] = "file content";
1316     int r;
1317     suppress_error = 0;
1318     r = guestfs_write_file (g, path, content, 0);
1319     if (r == -1)
1320       return -1;
1321   }
1322   {
1323     char src[] = "/old";
1324     char dest[] = "/new";
1325     int r;
1326     suppress_error = 0;
1327     r = guestfs_mv (g, src, dest);
1328     if (r == -1)
1329       return -1;
1330   }
1331   {
1332     char path[] = "/old";
1333     int r;
1334     suppress_error = 0;
1335     r = guestfs_is_file (g, path);
1336     if (r == -1)
1337       return -1;
1338     if (r) {
1339       fprintf (stderr, "test_mv_1: expected false, got true\n");
1340       return -1;
1341     }
1342   }
1343   return 0;
1344 }
1345
1346 static int test_cp_a_0 (void)
1347 {
1348   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
1349   {
1350     char device[] = "/dev/sda";
1351     device[5] = devchar;
1352     int r;
1353     suppress_error = 0;
1354     r = guestfs_blockdev_setrw (g, device);
1355     if (r == -1)
1356       return -1;
1357   }
1358   {
1359     int r;
1360     suppress_error = 0;
1361     r = guestfs_umount_all (g);
1362     if (r == -1)
1363       return -1;
1364   }
1365   {
1366     int r;
1367     suppress_error = 0;
1368     r = guestfs_lvm_remove_all (g);
1369     if (r == -1)
1370       return -1;
1371   }
1372   {
1373     char device[] = "/dev/sda";
1374     device[5] = devchar;
1375     char lines_0[] = ",";
1376     char *lines[] = {
1377       lines_0,
1378       NULL
1379     };
1380     int r;
1381     suppress_error = 0;
1382     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1383     if (r == -1)
1384       return -1;
1385   }
1386   {
1387     char fstype[] = "ext2";
1388     char device[] = "/dev/sda1";
1389     device[5] = devchar;
1390     int r;
1391     suppress_error = 0;
1392     r = guestfs_mkfs (g, fstype, device);
1393     if (r == -1)
1394       return -1;
1395   }
1396   {
1397     char device[] = "/dev/sda1";
1398     device[5] = devchar;
1399     char mountpoint[] = "/";
1400     int r;
1401     suppress_error = 0;
1402     r = guestfs_mount (g, device, mountpoint);
1403     if (r == -1)
1404       return -1;
1405   }
1406   /* TestOutput for cp_a (0) */
1407   char expected[] = "file content";
1408   {
1409     char path[] = "/olddir";
1410     int r;
1411     suppress_error = 0;
1412     r = guestfs_mkdir (g, path);
1413     if (r == -1)
1414       return -1;
1415   }
1416   {
1417     char path[] = "/newdir";
1418     int r;
1419     suppress_error = 0;
1420     r = guestfs_mkdir (g, path);
1421     if (r == -1)
1422       return -1;
1423   }
1424   {
1425     char path[] = "/olddir/file";
1426     char content[] = "file content";
1427     int r;
1428     suppress_error = 0;
1429     r = guestfs_write_file (g, path, content, 0);
1430     if (r == -1)
1431       return -1;
1432   }
1433   {
1434     char src[] = "/olddir";
1435     char dest[] = "/newdir";
1436     int r;
1437     suppress_error = 0;
1438     r = guestfs_cp_a (g, src, dest);
1439     if (r == -1)
1440       return -1;
1441   }
1442   {
1443     char path[] = "/newdir/olddir/file";
1444     char *r;
1445     suppress_error = 0;
1446     r = guestfs_cat (g, path);
1447     if (r == NULL)
1448       return -1;
1449     if (strcmp (r, expected) != 0) {
1450       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1451       return -1;
1452     }
1453     free (r);
1454   }
1455   return 0;
1456 }
1457
1458 static int test_cp_0 (void)
1459 {
1460   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
1461   {
1462     char device[] = "/dev/sda";
1463     device[5] = devchar;
1464     int r;
1465     suppress_error = 0;
1466     r = guestfs_blockdev_setrw (g, device);
1467     if (r == -1)
1468       return -1;
1469   }
1470   {
1471     int r;
1472     suppress_error = 0;
1473     r = guestfs_umount_all (g);
1474     if (r == -1)
1475       return -1;
1476   }
1477   {
1478     int r;
1479     suppress_error = 0;
1480     r = guestfs_lvm_remove_all (g);
1481     if (r == -1)
1482       return -1;
1483   }
1484   {
1485     char device[] = "/dev/sda";
1486     device[5] = devchar;
1487     char lines_0[] = ",";
1488     char *lines[] = {
1489       lines_0,
1490       NULL
1491     };
1492     int r;
1493     suppress_error = 0;
1494     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1495     if (r == -1)
1496       return -1;
1497   }
1498   {
1499     char fstype[] = "ext2";
1500     char device[] = "/dev/sda1";
1501     device[5] = devchar;
1502     int r;
1503     suppress_error = 0;
1504     r = guestfs_mkfs (g, fstype, device);
1505     if (r == -1)
1506       return -1;
1507   }
1508   {
1509     char device[] = "/dev/sda1";
1510     device[5] = devchar;
1511     char mountpoint[] = "/";
1512     int r;
1513     suppress_error = 0;
1514     r = guestfs_mount (g, device, mountpoint);
1515     if (r == -1)
1516       return -1;
1517   }
1518   /* TestOutput for cp (0) */
1519   char expected[] = "file content";
1520   {
1521     char path[] = "/old";
1522     char content[] = "file content";
1523     int r;
1524     suppress_error = 0;
1525     r = guestfs_write_file (g, path, content, 0);
1526     if (r == -1)
1527       return -1;
1528   }
1529   {
1530     char src[] = "/old";
1531     char dest[] = "/new";
1532     int r;
1533     suppress_error = 0;
1534     r = guestfs_cp (g, src, dest);
1535     if (r == -1)
1536       return -1;
1537   }
1538   {
1539     char path[] = "/new";
1540     char *r;
1541     suppress_error = 0;
1542     r = guestfs_cat (g, path);
1543     if (r == NULL)
1544       return -1;
1545     if (strcmp (r, expected) != 0) {
1546       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1547       return -1;
1548     }
1549     free (r);
1550   }
1551   return 0;
1552 }
1553
1554 static int test_cp_1 (void)
1555 {
1556   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
1557   {
1558     char device[] = "/dev/sda";
1559     device[5] = devchar;
1560     int r;
1561     suppress_error = 0;
1562     r = guestfs_blockdev_setrw (g, device);
1563     if (r == -1)
1564       return -1;
1565   }
1566   {
1567     int r;
1568     suppress_error = 0;
1569     r = guestfs_umount_all (g);
1570     if (r == -1)
1571       return -1;
1572   }
1573   {
1574     int r;
1575     suppress_error = 0;
1576     r = guestfs_lvm_remove_all (g);
1577     if (r == -1)
1578       return -1;
1579   }
1580   {
1581     char device[] = "/dev/sda";
1582     device[5] = devchar;
1583     char lines_0[] = ",";
1584     char *lines[] = {
1585       lines_0,
1586       NULL
1587     };
1588     int r;
1589     suppress_error = 0;
1590     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1591     if (r == -1)
1592       return -1;
1593   }
1594   {
1595     char fstype[] = "ext2";
1596     char device[] = "/dev/sda1";
1597     device[5] = devchar;
1598     int r;
1599     suppress_error = 0;
1600     r = guestfs_mkfs (g, fstype, device);
1601     if (r == -1)
1602       return -1;
1603   }
1604   {
1605     char device[] = "/dev/sda1";
1606     device[5] = devchar;
1607     char mountpoint[] = "/";
1608     int r;
1609     suppress_error = 0;
1610     r = guestfs_mount (g, device, mountpoint);
1611     if (r == -1)
1612       return -1;
1613   }
1614   /* TestOutputTrue for cp (1) */
1615   {
1616     char path[] = "/old";
1617     char content[] = "file content";
1618     int r;
1619     suppress_error = 0;
1620     r = guestfs_write_file (g, path, content, 0);
1621     if (r == -1)
1622       return -1;
1623   }
1624   {
1625     char src[] = "/old";
1626     char dest[] = "/new";
1627     int r;
1628     suppress_error = 0;
1629     r = guestfs_cp (g, src, dest);
1630     if (r == -1)
1631       return -1;
1632   }
1633   {
1634     char path[] = "/old";
1635     int r;
1636     suppress_error = 0;
1637     r = guestfs_is_file (g, path);
1638     if (r == -1)
1639       return -1;
1640     if (!r) {
1641       fprintf (stderr, "test_cp_1: expected true, got false\n");
1642       return -1;
1643     }
1644   }
1645   return 0;
1646 }
1647
1648 static int test_cp_2 (void)
1649 {
1650   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
1651   {
1652     char device[] = "/dev/sda";
1653     device[5] = devchar;
1654     int r;
1655     suppress_error = 0;
1656     r = guestfs_blockdev_setrw (g, device);
1657     if (r == -1)
1658       return -1;
1659   }
1660   {
1661     int r;
1662     suppress_error = 0;
1663     r = guestfs_umount_all (g);
1664     if (r == -1)
1665       return -1;
1666   }
1667   {
1668     int r;
1669     suppress_error = 0;
1670     r = guestfs_lvm_remove_all (g);
1671     if (r == -1)
1672       return -1;
1673   }
1674   {
1675     char device[] = "/dev/sda";
1676     device[5] = devchar;
1677     char lines_0[] = ",";
1678     char *lines[] = {
1679       lines_0,
1680       NULL
1681     };
1682     int r;
1683     suppress_error = 0;
1684     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1685     if (r == -1)
1686       return -1;
1687   }
1688   {
1689     char fstype[] = "ext2";
1690     char device[] = "/dev/sda1";
1691     device[5] = devchar;
1692     int r;
1693     suppress_error = 0;
1694     r = guestfs_mkfs (g, fstype, device);
1695     if (r == -1)
1696       return -1;
1697   }
1698   {
1699     char device[] = "/dev/sda1";
1700     device[5] = devchar;
1701     char mountpoint[] = "/";
1702     int r;
1703     suppress_error = 0;
1704     r = guestfs_mount (g, device, mountpoint);
1705     if (r == -1)
1706       return -1;
1707   }
1708   /* TestOutput for cp (2) */
1709   char expected[] = "file content";
1710   {
1711     char path[] = "/old";
1712     char content[] = "file content";
1713     int r;
1714     suppress_error = 0;
1715     r = guestfs_write_file (g, path, content, 0);
1716     if (r == -1)
1717       return -1;
1718   }
1719   {
1720     char path[] = "/dir";
1721     int r;
1722     suppress_error = 0;
1723     r = guestfs_mkdir (g, path);
1724     if (r == -1)
1725       return -1;
1726   }
1727   {
1728     char src[] = "/old";
1729     char dest[] = "/dir/new";
1730     int r;
1731     suppress_error = 0;
1732     r = guestfs_cp (g, src, dest);
1733     if (r == -1)
1734       return -1;
1735   }
1736   {
1737     char path[] = "/dir/new";
1738     char *r;
1739     suppress_error = 0;
1740     r = guestfs_cat (g, path);
1741     if (r == NULL)
1742       return -1;
1743     if (strcmp (r, expected) != 0) {
1744       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
1745       return -1;
1746     }
1747     free (r);
1748   }
1749   return 0;
1750 }
1751
1752 static int test_grub_install_0 (void)
1753 {
1754   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
1755   {
1756     char device[] = "/dev/sda";
1757     device[5] = devchar;
1758     int r;
1759     suppress_error = 0;
1760     r = guestfs_blockdev_setrw (g, device);
1761     if (r == -1)
1762       return -1;
1763   }
1764   {
1765     int r;
1766     suppress_error = 0;
1767     r = guestfs_umount_all (g);
1768     if (r == -1)
1769       return -1;
1770   }
1771   {
1772     int r;
1773     suppress_error = 0;
1774     r = guestfs_lvm_remove_all (g);
1775     if (r == -1)
1776       return -1;
1777   }
1778   {
1779     char device[] = "/dev/sda";
1780     device[5] = devchar;
1781     char lines_0[] = ",";
1782     char *lines[] = {
1783       lines_0,
1784       NULL
1785     };
1786     int r;
1787     suppress_error = 0;
1788     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1789     if (r == -1)
1790       return -1;
1791   }
1792   {
1793     char fstype[] = "ext2";
1794     char device[] = "/dev/sda1";
1795     device[5] = devchar;
1796     int r;
1797     suppress_error = 0;
1798     r = guestfs_mkfs (g, fstype, device);
1799     if (r == -1)
1800       return -1;
1801   }
1802   {
1803     char device[] = "/dev/sda1";
1804     device[5] = devchar;
1805     char mountpoint[] = "/";
1806     int r;
1807     suppress_error = 0;
1808     r = guestfs_mount (g, device, mountpoint);
1809     if (r == -1)
1810       return -1;
1811   }
1812   /* TestOutputTrue for grub_install (0) */
1813   {
1814     char root[] = "/";
1815     char device[] = "/dev/sda1";
1816     device[5] = devchar;
1817     int r;
1818     suppress_error = 0;
1819     r = guestfs_grub_install (g, root, device);
1820     if (r == -1)
1821       return -1;
1822   }
1823   {
1824     char path[] = "/boot";
1825     int r;
1826     suppress_error = 0;
1827     r = guestfs_is_dir (g, path);
1828     if (r == -1)
1829       return -1;
1830     if (!r) {
1831       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
1832       return -1;
1833     }
1834   }
1835   return 0;
1836 }
1837
1838 static int test_zero_0 (void)
1839 {
1840   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
1841   {
1842     char device[] = "/dev/sda";
1843     device[5] = devchar;
1844     int r;
1845     suppress_error = 0;
1846     r = guestfs_blockdev_setrw (g, device);
1847     if (r == -1)
1848       return -1;
1849   }
1850   {
1851     int r;
1852     suppress_error = 0;
1853     r = guestfs_umount_all (g);
1854     if (r == -1)
1855       return -1;
1856   }
1857   {
1858     int r;
1859     suppress_error = 0;
1860     r = guestfs_lvm_remove_all (g);
1861     if (r == -1)
1862       return -1;
1863   }
1864   {
1865     char device[] = "/dev/sda";
1866     device[5] = devchar;
1867     char lines_0[] = ",";
1868     char *lines[] = {
1869       lines_0,
1870       NULL
1871     };
1872     int r;
1873     suppress_error = 0;
1874     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1875     if (r == -1)
1876       return -1;
1877   }
1878   {
1879     char fstype[] = "ext2";
1880     char device[] = "/dev/sda1";
1881     device[5] = devchar;
1882     int r;
1883     suppress_error = 0;
1884     r = guestfs_mkfs (g, fstype, device);
1885     if (r == -1)
1886       return -1;
1887   }
1888   {
1889     char device[] = "/dev/sda1";
1890     device[5] = devchar;
1891     char mountpoint[] = "/";
1892     int r;
1893     suppress_error = 0;
1894     r = guestfs_mount (g, device, mountpoint);
1895     if (r == -1)
1896       return -1;
1897   }
1898   /* TestOutput for zero (0) */
1899   char expected[] = "data";
1900   {
1901     char pathordevice[] = "/dev/sda1";
1902     pathordevice[5] = devchar;
1903     int r;
1904     suppress_error = 0;
1905     r = guestfs_umount (g, pathordevice);
1906     if (r == -1)
1907       return -1;
1908   }
1909   {
1910     char device[] = "/dev/sda1";
1911     device[5] = devchar;
1912     int r;
1913     suppress_error = 0;
1914     r = guestfs_zero (g, device);
1915     if (r == -1)
1916       return -1;
1917   }
1918   {
1919     char path[] = "/dev/sda1";
1920     path[5] = devchar;
1921     char *r;
1922     suppress_error = 0;
1923     r = guestfs_file (g, path);
1924     if (r == NULL)
1925       return -1;
1926     if (strcmp (r, expected) != 0) {
1927       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
1928       return -1;
1929     }
1930     free (r);
1931   }
1932   return 0;
1933 }
1934
1935 static int test_fsck_0 (void)
1936 {
1937   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
1938   {
1939     char device[] = "/dev/sda";
1940     device[5] = devchar;
1941     int r;
1942     suppress_error = 0;
1943     r = guestfs_blockdev_setrw (g, device);
1944     if (r == -1)
1945       return -1;
1946   }
1947   {
1948     int r;
1949     suppress_error = 0;
1950     r = guestfs_umount_all (g);
1951     if (r == -1)
1952       return -1;
1953   }
1954   {
1955     int r;
1956     suppress_error = 0;
1957     r = guestfs_lvm_remove_all (g);
1958     if (r == -1)
1959       return -1;
1960   }
1961   {
1962     char device[] = "/dev/sda";
1963     device[5] = devchar;
1964     char lines_0[] = ",";
1965     char *lines[] = {
1966       lines_0,
1967       NULL
1968     };
1969     int r;
1970     suppress_error = 0;
1971     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1972     if (r == -1)
1973       return -1;
1974   }
1975   {
1976     char fstype[] = "ext2";
1977     char device[] = "/dev/sda1";
1978     device[5] = devchar;
1979     int r;
1980     suppress_error = 0;
1981     r = guestfs_mkfs (g, fstype, device);
1982     if (r == -1)
1983       return -1;
1984   }
1985   {
1986     char device[] = "/dev/sda1";
1987     device[5] = devchar;
1988     char mountpoint[] = "/";
1989     int r;
1990     suppress_error = 0;
1991     r = guestfs_mount (g, device, mountpoint);
1992     if (r == -1)
1993       return -1;
1994   }
1995   /* TestOutputInt for fsck (0) */
1996   {
1997     char pathordevice[] = "/dev/sda1";
1998     pathordevice[5] = devchar;
1999     int r;
2000     suppress_error = 0;
2001     r = guestfs_umount (g, pathordevice);
2002     if (r == -1)
2003       return -1;
2004   }
2005   {
2006     char fstype[] = "ext2";
2007     char device[] = "/dev/sda1";
2008     device[5] = devchar;
2009     int r;
2010     suppress_error = 0;
2011     r = guestfs_fsck (g, fstype, device);
2012     if (r == -1)
2013       return -1;
2014     if (r != 0) {
2015       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
2016       return -1;
2017     }
2018   }
2019   return 0;
2020 }
2021
2022 static int test_fsck_1 (void)
2023 {
2024   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2025   {
2026     char device[] = "/dev/sda";
2027     device[5] = devchar;
2028     int r;
2029     suppress_error = 0;
2030     r = guestfs_blockdev_setrw (g, device);
2031     if (r == -1)
2032       return -1;
2033   }
2034   {
2035     int r;
2036     suppress_error = 0;
2037     r = guestfs_umount_all (g);
2038     if (r == -1)
2039       return -1;
2040   }
2041   {
2042     int r;
2043     suppress_error = 0;
2044     r = guestfs_lvm_remove_all (g);
2045     if (r == -1)
2046       return -1;
2047   }
2048   {
2049     char device[] = "/dev/sda";
2050     device[5] = devchar;
2051     char lines_0[] = ",";
2052     char *lines[] = {
2053       lines_0,
2054       NULL
2055     };
2056     int r;
2057     suppress_error = 0;
2058     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2059     if (r == -1)
2060       return -1;
2061   }
2062   {
2063     char fstype[] = "ext2";
2064     char device[] = "/dev/sda1";
2065     device[5] = devchar;
2066     int r;
2067     suppress_error = 0;
2068     r = guestfs_mkfs (g, fstype, device);
2069     if (r == -1)
2070       return -1;
2071   }
2072   {
2073     char device[] = "/dev/sda1";
2074     device[5] = devchar;
2075     char mountpoint[] = "/";
2076     int r;
2077     suppress_error = 0;
2078     r = guestfs_mount (g, device, mountpoint);
2079     if (r == -1)
2080       return -1;
2081   }
2082   /* TestOutputInt for fsck (1) */
2083   {
2084     char pathordevice[] = "/dev/sda1";
2085     pathordevice[5] = devchar;
2086     int r;
2087     suppress_error = 0;
2088     r = guestfs_umount (g, pathordevice);
2089     if (r == -1)
2090       return -1;
2091   }
2092   {
2093     char device[] = "/dev/sda1";
2094     device[5] = devchar;
2095     int r;
2096     suppress_error = 0;
2097     r = guestfs_zero (g, device);
2098     if (r == -1)
2099       return -1;
2100   }
2101   {
2102     char fstype[] = "ext2";
2103     char device[] = "/dev/sda1";
2104     device[5] = devchar;
2105     int r;
2106     suppress_error = 0;
2107     r = guestfs_fsck (g, fstype, device);
2108     if (r == -1)
2109       return -1;
2110     if (r != 8) {
2111       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
2112       return -1;
2113     }
2114   }
2115   return 0;
2116 }
2117
2118 static int test_set_e2uuid_0 (void)
2119 {
2120   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2121   {
2122     char device[] = "/dev/sda";
2123     device[5] = devchar;
2124     int r;
2125     suppress_error = 0;
2126     r = guestfs_blockdev_setrw (g, device);
2127     if (r == -1)
2128       return -1;
2129   }
2130   {
2131     int r;
2132     suppress_error = 0;
2133     r = guestfs_umount_all (g);
2134     if (r == -1)
2135       return -1;
2136   }
2137   {
2138     int r;
2139     suppress_error = 0;
2140     r = guestfs_lvm_remove_all (g);
2141     if (r == -1)
2142       return -1;
2143   }
2144   {
2145     char device[] = "/dev/sda";
2146     device[5] = devchar;
2147     char lines_0[] = ",";
2148     char *lines[] = {
2149       lines_0,
2150       NULL
2151     };
2152     int r;
2153     suppress_error = 0;
2154     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2155     if (r == -1)
2156       return -1;
2157   }
2158   {
2159     char fstype[] = "ext2";
2160     char device[] = "/dev/sda1";
2161     device[5] = devchar;
2162     int r;
2163     suppress_error = 0;
2164     r = guestfs_mkfs (g, fstype, device);
2165     if (r == -1)
2166       return -1;
2167   }
2168   {
2169     char device[] = "/dev/sda1";
2170     device[5] = devchar;
2171     char mountpoint[] = "/";
2172     int r;
2173     suppress_error = 0;
2174     r = guestfs_mount (g, device, mountpoint);
2175     if (r == -1)
2176       return -1;
2177   }
2178   /* TestOutput for set_e2uuid (0) */
2179   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2180   {
2181     char device[] = "/dev/sda1";
2182     device[5] = devchar;
2183     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2184     int r;
2185     suppress_error = 0;
2186     r = guestfs_set_e2uuid (g, device, uuid);
2187     if (r == -1)
2188       return -1;
2189   }
2190   {
2191     char device[] = "/dev/sda1";
2192     device[5] = devchar;
2193     char *r;
2194     suppress_error = 0;
2195     r = guestfs_get_e2uuid (g, device);
2196     if (r == NULL)
2197       return -1;
2198     if (strcmp (r, expected) != 0) {
2199       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2200       return -1;
2201     }
2202     free (r);
2203   }
2204   return 0;
2205 }
2206
2207 static int test_set_e2uuid_1 (void)
2208 {
2209   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
2210   {
2211     char device[] = "/dev/sda";
2212     device[5] = devchar;
2213     int r;
2214     suppress_error = 0;
2215     r = guestfs_blockdev_setrw (g, device);
2216     if (r == -1)
2217       return -1;
2218   }
2219   {
2220     int r;
2221     suppress_error = 0;
2222     r = guestfs_umount_all (g);
2223     if (r == -1)
2224       return -1;
2225   }
2226   {
2227     int r;
2228     suppress_error = 0;
2229     r = guestfs_lvm_remove_all (g);
2230     if (r == -1)
2231       return -1;
2232   }
2233   {
2234     char device[] = "/dev/sda";
2235     device[5] = devchar;
2236     char lines_0[] = ",";
2237     char *lines[] = {
2238       lines_0,
2239       NULL
2240     };
2241     int r;
2242     suppress_error = 0;
2243     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2244     if (r == -1)
2245       return -1;
2246   }
2247   {
2248     char fstype[] = "ext2";
2249     char device[] = "/dev/sda1";
2250     device[5] = devchar;
2251     int r;
2252     suppress_error = 0;
2253     r = guestfs_mkfs (g, fstype, device);
2254     if (r == -1)
2255       return -1;
2256   }
2257   {
2258     char device[] = "/dev/sda1";
2259     device[5] = devchar;
2260     char mountpoint[] = "/";
2261     int r;
2262     suppress_error = 0;
2263     r = guestfs_mount (g, device, mountpoint);
2264     if (r == -1)
2265       return -1;
2266   }
2267   /* TestOutput for set_e2uuid (1) */
2268   char expected[] = "";
2269   {
2270     char device[] = "/dev/sda1";
2271     device[5] = devchar;
2272     char uuid[] = "clear";
2273     int r;
2274     suppress_error = 0;
2275     r = guestfs_set_e2uuid (g, device, uuid);
2276     if (r == -1)
2277       return -1;
2278   }
2279   {
2280     char device[] = "/dev/sda1";
2281     device[5] = devchar;
2282     char *r;
2283     suppress_error = 0;
2284     r = guestfs_get_e2uuid (g, device);
2285     if (r == NULL)
2286       return -1;
2287     if (strcmp (r, expected) != 0) {
2288       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2289       return -1;
2290     }
2291     free (r);
2292   }
2293   return 0;
2294 }
2295
2296 static int test_set_e2uuid_2 (void)
2297 {
2298   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
2299   {
2300     char device[] = "/dev/sda";
2301     device[5] = devchar;
2302     int r;
2303     suppress_error = 0;
2304     r = guestfs_blockdev_setrw (g, device);
2305     if (r == -1)
2306       return -1;
2307   }
2308   {
2309     int r;
2310     suppress_error = 0;
2311     r = guestfs_umount_all (g);
2312     if (r == -1)
2313       return -1;
2314   }
2315   {
2316     int r;
2317     suppress_error = 0;
2318     r = guestfs_lvm_remove_all (g);
2319     if (r == -1)
2320       return -1;
2321   }
2322   {
2323     char device[] = "/dev/sda";
2324     device[5] = devchar;
2325     char lines_0[] = ",";
2326     char *lines[] = {
2327       lines_0,
2328       NULL
2329     };
2330     int r;
2331     suppress_error = 0;
2332     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2333     if (r == -1)
2334       return -1;
2335   }
2336   {
2337     char fstype[] = "ext2";
2338     char device[] = "/dev/sda1";
2339     device[5] = devchar;
2340     int r;
2341     suppress_error = 0;
2342     r = guestfs_mkfs (g, fstype, device);
2343     if (r == -1)
2344       return -1;
2345   }
2346   {
2347     char device[] = "/dev/sda1";
2348     device[5] = devchar;
2349     char mountpoint[] = "/";
2350     int r;
2351     suppress_error = 0;
2352     r = guestfs_mount (g, device, mountpoint);
2353     if (r == -1)
2354       return -1;
2355   }
2356   /* TestRun for set_e2uuid (2) */
2357   {
2358     char device[] = "/dev/sda1";
2359     device[5] = devchar;
2360     char uuid[] = "random";
2361     int r;
2362     suppress_error = 0;
2363     r = guestfs_set_e2uuid (g, device, uuid);
2364     if (r == -1)
2365       return -1;
2366   }
2367   return 0;
2368 }
2369
2370 static int test_set_e2uuid_3 (void)
2371 {
2372   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
2373   {
2374     char device[] = "/dev/sda";
2375     device[5] = devchar;
2376     int r;
2377     suppress_error = 0;
2378     r = guestfs_blockdev_setrw (g, device);
2379     if (r == -1)
2380       return -1;
2381   }
2382   {
2383     int r;
2384     suppress_error = 0;
2385     r = guestfs_umount_all (g);
2386     if (r == -1)
2387       return -1;
2388   }
2389   {
2390     int r;
2391     suppress_error = 0;
2392     r = guestfs_lvm_remove_all (g);
2393     if (r == -1)
2394       return -1;
2395   }
2396   {
2397     char device[] = "/dev/sda";
2398     device[5] = devchar;
2399     char lines_0[] = ",";
2400     char *lines[] = {
2401       lines_0,
2402       NULL
2403     };
2404     int r;
2405     suppress_error = 0;
2406     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2407     if (r == -1)
2408       return -1;
2409   }
2410   {
2411     char fstype[] = "ext2";
2412     char device[] = "/dev/sda1";
2413     device[5] = devchar;
2414     int r;
2415     suppress_error = 0;
2416     r = guestfs_mkfs (g, fstype, device);
2417     if (r == -1)
2418       return -1;
2419   }
2420   {
2421     char device[] = "/dev/sda1";
2422     device[5] = devchar;
2423     char mountpoint[] = "/";
2424     int r;
2425     suppress_error = 0;
2426     r = guestfs_mount (g, device, mountpoint);
2427     if (r == -1)
2428       return -1;
2429   }
2430   /* TestRun for set_e2uuid (3) */
2431   {
2432     char device[] = "/dev/sda1";
2433     device[5] = devchar;
2434     char uuid[] = "time";
2435     int r;
2436     suppress_error = 0;
2437     r = guestfs_set_e2uuid (g, device, uuid);
2438     if (r == -1)
2439       return -1;
2440   }
2441   return 0;
2442 }
2443
2444 static int test_set_e2label_0 (void)
2445 {
2446   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
2447   {
2448     char device[] = "/dev/sda";
2449     device[5] = devchar;
2450     int r;
2451     suppress_error = 0;
2452     r = guestfs_blockdev_setrw (g, device);
2453     if (r == -1)
2454       return -1;
2455   }
2456   {
2457     int r;
2458     suppress_error = 0;
2459     r = guestfs_umount_all (g);
2460     if (r == -1)
2461       return -1;
2462   }
2463   {
2464     int r;
2465     suppress_error = 0;
2466     r = guestfs_lvm_remove_all (g);
2467     if (r == -1)
2468       return -1;
2469   }
2470   {
2471     char device[] = "/dev/sda";
2472     device[5] = devchar;
2473     char lines_0[] = ",";
2474     char *lines[] = {
2475       lines_0,
2476       NULL
2477     };
2478     int r;
2479     suppress_error = 0;
2480     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2481     if (r == -1)
2482       return -1;
2483   }
2484   {
2485     char fstype[] = "ext2";
2486     char device[] = "/dev/sda1";
2487     device[5] = devchar;
2488     int r;
2489     suppress_error = 0;
2490     r = guestfs_mkfs (g, fstype, device);
2491     if (r == -1)
2492       return -1;
2493   }
2494   {
2495     char device[] = "/dev/sda1";
2496     device[5] = devchar;
2497     char mountpoint[] = "/";
2498     int r;
2499     suppress_error = 0;
2500     r = guestfs_mount (g, device, mountpoint);
2501     if (r == -1)
2502       return -1;
2503   }
2504   /* TestOutput for set_e2label (0) */
2505   char expected[] = "testlabel";
2506   {
2507     char device[] = "/dev/sda1";
2508     device[5] = devchar;
2509     char label[] = "testlabel";
2510     int r;
2511     suppress_error = 0;
2512     r = guestfs_set_e2label (g, device, label);
2513     if (r == -1)
2514       return -1;
2515   }
2516   {
2517     char device[] = "/dev/sda1";
2518     device[5] = devchar;
2519     char *r;
2520     suppress_error = 0;
2521     r = guestfs_get_e2label (g, device);
2522     if (r == NULL)
2523       return -1;
2524     if (strcmp (r, expected) != 0) {
2525       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2526       return -1;
2527     }
2528     free (r);
2529   }
2530   return 0;
2531 }
2532
2533 static int test_pvremove_0 (void)
2534 {
2535   /* InitNone|InitEmpty for test_pvremove_0 */
2536   {
2537     char device[] = "/dev/sda";
2538     device[5] = devchar;
2539     int r;
2540     suppress_error = 0;
2541     r = guestfs_blockdev_setrw (g, device);
2542     if (r == -1)
2543       return -1;
2544   }
2545   {
2546     int r;
2547     suppress_error = 0;
2548     r = guestfs_umount_all (g);
2549     if (r == -1)
2550       return -1;
2551   }
2552   {
2553     int r;
2554     suppress_error = 0;
2555     r = guestfs_lvm_remove_all (g);
2556     if (r == -1)
2557       return -1;
2558   }
2559   /* TestOutputList for pvremove (0) */
2560   {
2561     char device[] = "/dev/sda";
2562     device[5] = devchar;
2563     int r;
2564     suppress_error = 0;
2565     r = guestfs_pvcreate (g, device);
2566     if (r == -1)
2567       return -1;
2568   }
2569   {
2570     char volgroup[] = "VG";
2571     char physvols_0[] = "/dev/sda";
2572     physvols_0[5] = devchar;
2573     char *physvols[] = {
2574       physvols_0,
2575       NULL
2576     };
2577     int r;
2578     suppress_error = 0;
2579     r = guestfs_vgcreate (g, volgroup, physvols);
2580     if (r == -1)
2581       return -1;
2582   }
2583   {
2584     char logvol[] = "LV1";
2585     char volgroup[] = "VG";
2586     int r;
2587     suppress_error = 0;
2588     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2589     if (r == -1)
2590       return -1;
2591   }
2592   {
2593     char logvol[] = "LV2";
2594     char volgroup[] = "VG";
2595     int r;
2596     suppress_error = 0;
2597     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2598     if (r == -1)
2599       return -1;
2600   }
2601   {
2602     char vgname[] = "VG";
2603     int r;
2604     suppress_error = 0;
2605     r = guestfs_vgremove (g, vgname);
2606     if (r == -1)
2607       return -1;
2608   }
2609   {
2610     char device[] = "/dev/sda";
2611     device[5] = devchar;
2612     int r;
2613     suppress_error = 0;
2614     r = guestfs_pvremove (g, device);
2615     if (r == -1)
2616       return -1;
2617   }
2618   {
2619     char **r;
2620     int i;
2621     suppress_error = 0;
2622     r = guestfs_lvs (g);
2623     if (r == NULL)
2624       return -1;
2625     if (r[0] != NULL) {
2626       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
2627       print_strings (r);
2628       return -1;
2629     }
2630     for (i = 0; r[i] != NULL; ++i)
2631       free (r[i]);
2632     free (r);
2633   }
2634   return 0;
2635 }
2636
2637 static int test_pvremove_1 (void)
2638 {
2639   /* InitNone|InitEmpty for test_pvremove_1 */
2640   {
2641     char device[] = "/dev/sda";
2642     device[5] = devchar;
2643     int r;
2644     suppress_error = 0;
2645     r = guestfs_blockdev_setrw (g, device);
2646     if (r == -1)
2647       return -1;
2648   }
2649   {
2650     int r;
2651     suppress_error = 0;
2652     r = guestfs_umount_all (g);
2653     if (r == -1)
2654       return -1;
2655   }
2656   {
2657     int r;
2658     suppress_error = 0;
2659     r = guestfs_lvm_remove_all (g);
2660     if (r == -1)
2661       return -1;
2662   }
2663   /* TestOutputList for pvremove (1) */
2664   {
2665     char device[] = "/dev/sda";
2666     device[5] = devchar;
2667     int r;
2668     suppress_error = 0;
2669     r = guestfs_pvcreate (g, device);
2670     if (r == -1)
2671       return -1;
2672   }
2673   {
2674     char volgroup[] = "VG";
2675     char physvols_0[] = "/dev/sda";
2676     physvols_0[5] = devchar;
2677     char *physvols[] = {
2678       physvols_0,
2679       NULL
2680     };
2681     int r;
2682     suppress_error = 0;
2683     r = guestfs_vgcreate (g, volgroup, physvols);
2684     if (r == -1)
2685       return -1;
2686   }
2687   {
2688     char logvol[] = "LV1";
2689     char volgroup[] = "VG";
2690     int r;
2691     suppress_error = 0;
2692     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2693     if (r == -1)
2694       return -1;
2695   }
2696   {
2697     char logvol[] = "LV2";
2698     char volgroup[] = "VG";
2699     int r;
2700     suppress_error = 0;
2701     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2702     if (r == -1)
2703       return -1;
2704   }
2705   {
2706     char vgname[] = "VG";
2707     int r;
2708     suppress_error = 0;
2709     r = guestfs_vgremove (g, vgname);
2710     if (r == -1)
2711       return -1;
2712   }
2713   {
2714     char device[] = "/dev/sda";
2715     device[5] = devchar;
2716     int r;
2717     suppress_error = 0;
2718     r = guestfs_pvremove (g, device);
2719     if (r == -1)
2720       return -1;
2721   }
2722   {
2723     char **r;
2724     int i;
2725     suppress_error = 0;
2726     r = guestfs_vgs (g);
2727     if (r == NULL)
2728       return -1;
2729     if (r[0] != NULL) {
2730       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
2731       print_strings (r);
2732       return -1;
2733     }
2734     for (i = 0; r[i] != NULL; ++i)
2735       free (r[i]);
2736     free (r);
2737   }
2738   return 0;
2739 }
2740
2741 static int test_pvremove_2 (void)
2742 {
2743   /* InitNone|InitEmpty for test_pvremove_2 */
2744   {
2745     char device[] = "/dev/sda";
2746     device[5] = devchar;
2747     int r;
2748     suppress_error = 0;
2749     r = guestfs_blockdev_setrw (g, device);
2750     if (r == -1)
2751       return -1;
2752   }
2753   {
2754     int r;
2755     suppress_error = 0;
2756     r = guestfs_umount_all (g);
2757     if (r == -1)
2758       return -1;
2759   }
2760   {
2761     int r;
2762     suppress_error = 0;
2763     r = guestfs_lvm_remove_all (g);
2764     if (r == -1)
2765       return -1;
2766   }
2767   /* TestOutputList for pvremove (2) */
2768   {
2769     char device[] = "/dev/sda";
2770     device[5] = devchar;
2771     int r;
2772     suppress_error = 0;
2773     r = guestfs_pvcreate (g, device);
2774     if (r == -1)
2775       return -1;
2776   }
2777   {
2778     char volgroup[] = "VG";
2779     char physvols_0[] = "/dev/sda";
2780     physvols_0[5] = devchar;
2781     char *physvols[] = {
2782       physvols_0,
2783       NULL
2784     };
2785     int r;
2786     suppress_error = 0;
2787     r = guestfs_vgcreate (g, volgroup, physvols);
2788     if (r == -1)
2789       return -1;
2790   }
2791   {
2792     char logvol[] = "LV1";
2793     char volgroup[] = "VG";
2794     int r;
2795     suppress_error = 0;
2796     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2797     if (r == -1)
2798       return -1;
2799   }
2800   {
2801     char logvol[] = "LV2";
2802     char volgroup[] = "VG";
2803     int r;
2804     suppress_error = 0;
2805     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2806     if (r == -1)
2807       return -1;
2808   }
2809   {
2810     char vgname[] = "VG";
2811     int r;
2812     suppress_error = 0;
2813     r = guestfs_vgremove (g, vgname);
2814     if (r == -1)
2815       return -1;
2816   }
2817   {
2818     char device[] = "/dev/sda";
2819     device[5] = devchar;
2820     int r;
2821     suppress_error = 0;
2822     r = guestfs_pvremove (g, device);
2823     if (r == -1)
2824       return -1;
2825   }
2826   {
2827     char **r;
2828     int i;
2829     suppress_error = 0;
2830     r = guestfs_pvs (g);
2831     if (r == NULL)
2832       return -1;
2833     if (r[0] != NULL) {
2834       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
2835       print_strings (r);
2836       return -1;
2837     }
2838     for (i = 0; r[i] != NULL; ++i)
2839       free (r[i]);
2840     free (r);
2841   }
2842   return 0;
2843 }
2844
2845 static int test_vgremove_0 (void)
2846 {
2847   /* InitNone|InitEmpty for test_vgremove_0 */
2848   {
2849     char device[] = "/dev/sda";
2850     device[5] = devchar;
2851     int r;
2852     suppress_error = 0;
2853     r = guestfs_blockdev_setrw (g, device);
2854     if (r == -1)
2855       return -1;
2856   }
2857   {
2858     int r;
2859     suppress_error = 0;
2860     r = guestfs_umount_all (g);
2861     if (r == -1)
2862       return -1;
2863   }
2864   {
2865     int r;
2866     suppress_error = 0;
2867     r = guestfs_lvm_remove_all (g);
2868     if (r == -1)
2869       return -1;
2870   }
2871   /* TestOutputList for vgremove (0) */
2872   {
2873     char device[] = "/dev/sda";
2874     device[5] = devchar;
2875     int r;
2876     suppress_error = 0;
2877     r = guestfs_pvcreate (g, device);
2878     if (r == -1)
2879       return -1;
2880   }
2881   {
2882     char volgroup[] = "VG";
2883     char physvols_0[] = "/dev/sda";
2884     physvols_0[5] = devchar;
2885     char *physvols[] = {
2886       physvols_0,
2887       NULL
2888     };
2889     int r;
2890     suppress_error = 0;
2891     r = guestfs_vgcreate (g, volgroup, physvols);
2892     if (r == -1)
2893       return -1;
2894   }
2895   {
2896     char logvol[] = "LV1";
2897     char volgroup[] = "VG";
2898     int r;
2899     suppress_error = 0;
2900     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2901     if (r == -1)
2902       return -1;
2903   }
2904   {
2905     char logvol[] = "LV2";
2906     char volgroup[] = "VG";
2907     int r;
2908     suppress_error = 0;
2909     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2910     if (r == -1)
2911       return -1;
2912   }
2913   {
2914     char vgname[] = "VG";
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_vgremove (g, vgname);
2918     if (r == -1)
2919       return -1;
2920   }
2921   {
2922     char **r;
2923     int i;
2924     suppress_error = 0;
2925     r = guestfs_lvs (g);
2926     if (r == NULL)
2927       return -1;
2928     if (r[0] != NULL) {
2929       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
2930       print_strings (r);
2931       return -1;
2932     }
2933     for (i = 0; r[i] != NULL; ++i)
2934       free (r[i]);
2935     free (r);
2936   }
2937   return 0;
2938 }
2939
2940 static int test_vgremove_1 (void)
2941 {
2942   /* InitNone|InitEmpty for test_vgremove_1 */
2943   {
2944     char device[] = "/dev/sda";
2945     device[5] = devchar;
2946     int r;
2947     suppress_error = 0;
2948     r = guestfs_blockdev_setrw (g, device);
2949     if (r == -1)
2950       return -1;
2951   }
2952   {
2953     int r;
2954     suppress_error = 0;
2955     r = guestfs_umount_all (g);
2956     if (r == -1)
2957       return -1;
2958   }
2959   {
2960     int r;
2961     suppress_error = 0;
2962     r = guestfs_lvm_remove_all (g);
2963     if (r == -1)
2964       return -1;
2965   }
2966   /* TestOutputList for vgremove (1) */
2967   {
2968     char device[] = "/dev/sda";
2969     device[5] = devchar;
2970     int r;
2971     suppress_error = 0;
2972     r = guestfs_pvcreate (g, device);
2973     if (r == -1)
2974       return -1;
2975   }
2976   {
2977     char volgroup[] = "VG";
2978     char physvols_0[] = "/dev/sda";
2979     physvols_0[5] = devchar;
2980     char *physvols[] = {
2981       physvols_0,
2982       NULL
2983     };
2984     int r;
2985     suppress_error = 0;
2986     r = guestfs_vgcreate (g, volgroup, physvols);
2987     if (r == -1)
2988       return -1;
2989   }
2990   {
2991     char logvol[] = "LV1";
2992     char volgroup[] = "VG";
2993     int r;
2994     suppress_error = 0;
2995     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2996     if (r == -1)
2997       return -1;
2998   }
2999   {
3000     char logvol[] = "LV2";
3001     char volgroup[] = "VG";
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3005     if (r == -1)
3006       return -1;
3007   }
3008   {
3009     char vgname[] = "VG";
3010     int r;
3011     suppress_error = 0;
3012     r = guestfs_vgremove (g, vgname);
3013     if (r == -1)
3014       return -1;
3015   }
3016   {
3017     char **r;
3018     int i;
3019     suppress_error = 0;
3020     r = guestfs_vgs (g);
3021     if (r == NULL)
3022       return -1;
3023     if (r[0] != NULL) {
3024       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
3025       print_strings (r);
3026       return -1;
3027     }
3028     for (i = 0; r[i] != NULL; ++i)
3029       free (r[i]);
3030     free (r);
3031   }
3032   return 0;
3033 }
3034
3035 static int test_lvremove_0 (void)
3036 {
3037   /* InitNone|InitEmpty for test_lvremove_0 */
3038   {
3039     char device[] = "/dev/sda";
3040     device[5] = devchar;
3041     int r;
3042     suppress_error = 0;
3043     r = guestfs_blockdev_setrw (g, device);
3044     if (r == -1)
3045       return -1;
3046   }
3047   {
3048     int r;
3049     suppress_error = 0;
3050     r = guestfs_umount_all (g);
3051     if (r == -1)
3052       return -1;
3053   }
3054   {
3055     int r;
3056     suppress_error = 0;
3057     r = guestfs_lvm_remove_all (g);
3058     if (r == -1)
3059       return -1;
3060   }
3061   /* TestOutputList for lvremove (0) */
3062   {
3063     char device[] = "/dev/sda";
3064     device[5] = devchar;
3065     int r;
3066     suppress_error = 0;
3067     r = guestfs_pvcreate (g, device);
3068     if (r == -1)
3069       return -1;
3070   }
3071   {
3072     char volgroup[] = "VG";
3073     char physvols_0[] = "/dev/sda";
3074     physvols_0[5] = devchar;
3075     char *physvols[] = {
3076       physvols_0,
3077       NULL
3078     };
3079     int r;
3080     suppress_error = 0;
3081     r = guestfs_vgcreate (g, volgroup, physvols);
3082     if (r == -1)
3083       return -1;
3084   }
3085   {
3086     char logvol[] = "LV1";
3087     char volgroup[] = "VG";
3088     int r;
3089     suppress_error = 0;
3090     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3091     if (r == -1)
3092       return -1;
3093   }
3094   {
3095     char logvol[] = "LV2";
3096     char volgroup[] = "VG";
3097     int r;
3098     suppress_error = 0;
3099     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3100     if (r == -1)
3101       return -1;
3102   }
3103   {
3104     char device[] = "/dev/VG/LV1";
3105     int r;
3106     suppress_error = 0;
3107     r = guestfs_lvremove (g, device);
3108     if (r == -1)
3109       return -1;
3110   }
3111   {
3112     char **r;
3113     int i;
3114     suppress_error = 0;
3115     r = guestfs_lvs (g);
3116     if (r == NULL)
3117       return -1;
3118     if (!r[0]) {
3119       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
3120       print_strings (r);
3121       return -1;
3122     }
3123     {
3124       char expected[] = "/dev/VG/LV2";
3125       if (strcmp (r[0], expected) != 0) {
3126         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3127         return -1;
3128       }
3129     }
3130     if (r[1] != NULL) {
3131       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
3132       print_strings (r);
3133       return -1;
3134     }
3135     for (i = 0; r[i] != NULL; ++i)
3136       free (r[i]);
3137     free (r);
3138   }
3139   return 0;
3140 }
3141
3142 static int test_lvremove_1 (void)
3143 {
3144   /* InitNone|InitEmpty for test_lvremove_1 */
3145   {
3146     char device[] = "/dev/sda";
3147     device[5] = devchar;
3148     int r;
3149     suppress_error = 0;
3150     r = guestfs_blockdev_setrw (g, device);
3151     if (r == -1)
3152       return -1;
3153   }
3154   {
3155     int r;
3156     suppress_error = 0;
3157     r = guestfs_umount_all (g);
3158     if (r == -1)
3159       return -1;
3160   }
3161   {
3162     int r;
3163     suppress_error = 0;
3164     r = guestfs_lvm_remove_all (g);
3165     if (r == -1)
3166       return -1;
3167   }
3168   /* TestOutputList for lvremove (1) */
3169   {
3170     char device[] = "/dev/sda";
3171     device[5] = devchar;
3172     int r;
3173     suppress_error = 0;
3174     r = guestfs_pvcreate (g, device);
3175     if (r == -1)
3176       return -1;
3177   }
3178   {
3179     char volgroup[] = "VG";
3180     char physvols_0[] = "/dev/sda";
3181     physvols_0[5] = devchar;
3182     char *physvols[] = {
3183       physvols_0,
3184       NULL
3185     };
3186     int r;
3187     suppress_error = 0;
3188     r = guestfs_vgcreate (g, volgroup, physvols);
3189     if (r == -1)
3190       return -1;
3191   }
3192   {
3193     char logvol[] = "LV1";
3194     char volgroup[] = "VG";
3195     int r;
3196     suppress_error = 0;
3197     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3198     if (r == -1)
3199       return -1;
3200   }
3201   {
3202     char logvol[] = "LV2";
3203     char volgroup[] = "VG";
3204     int r;
3205     suppress_error = 0;
3206     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3207     if (r == -1)
3208       return -1;
3209   }
3210   {
3211     char device[] = "/dev/VG";
3212     int r;
3213     suppress_error = 0;
3214     r = guestfs_lvremove (g, device);
3215     if (r == -1)
3216       return -1;
3217   }
3218   {
3219     char **r;
3220     int i;
3221     suppress_error = 0;
3222     r = guestfs_lvs (g);
3223     if (r == NULL)
3224       return -1;
3225     if (r[0] != NULL) {
3226       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3227       print_strings (r);
3228       return -1;
3229     }
3230     for (i = 0; r[i] != NULL; ++i)
3231       free (r[i]);
3232     free (r);
3233   }
3234   return 0;
3235 }
3236
3237 static int test_lvremove_2 (void)
3238 {
3239   /* InitNone|InitEmpty for test_lvremove_2 */
3240   {
3241     char device[] = "/dev/sda";
3242     device[5] = devchar;
3243     int r;
3244     suppress_error = 0;
3245     r = guestfs_blockdev_setrw (g, device);
3246     if (r == -1)
3247       return -1;
3248   }
3249   {
3250     int r;
3251     suppress_error = 0;
3252     r = guestfs_umount_all (g);
3253     if (r == -1)
3254       return -1;
3255   }
3256   {
3257     int r;
3258     suppress_error = 0;
3259     r = guestfs_lvm_remove_all (g);
3260     if (r == -1)
3261       return -1;
3262   }
3263   /* TestOutputList for lvremove (2) */
3264   {
3265     char device[] = "/dev/sda";
3266     device[5] = devchar;
3267     int r;
3268     suppress_error = 0;
3269     r = guestfs_pvcreate (g, device);
3270     if (r == -1)
3271       return -1;
3272   }
3273   {
3274     char volgroup[] = "VG";
3275     char physvols_0[] = "/dev/sda";
3276     physvols_0[5] = devchar;
3277     char *physvols[] = {
3278       physvols_0,
3279       NULL
3280     };
3281     int r;
3282     suppress_error = 0;
3283     r = guestfs_vgcreate (g, volgroup, physvols);
3284     if (r == -1)
3285       return -1;
3286   }
3287   {
3288     char logvol[] = "LV1";
3289     char volgroup[] = "VG";
3290     int r;
3291     suppress_error = 0;
3292     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3293     if (r == -1)
3294       return -1;
3295   }
3296   {
3297     char logvol[] = "LV2";
3298     char volgroup[] = "VG";
3299     int r;
3300     suppress_error = 0;
3301     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3302     if (r == -1)
3303       return -1;
3304   }
3305   {
3306     char device[] = "/dev/VG";
3307     int r;
3308     suppress_error = 0;
3309     r = guestfs_lvremove (g, device);
3310     if (r == -1)
3311       return -1;
3312   }
3313   {
3314     char **r;
3315     int i;
3316     suppress_error = 0;
3317     r = guestfs_vgs (g);
3318     if (r == NULL)
3319       return -1;
3320     if (!r[0]) {
3321       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3322       print_strings (r);
3323       return -1;
3324     }
3325     {
3326       char expected[] = "VG";
3327       if (strcmp (r[0], expected) != 0) {
3328         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3329         return -1;
3330       }
3331     }
3332     if (r[1] != NULL) {
3333       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3334       print_strings (r);
3335       return -1;
3336     }
3337     for (i = 0; r[i] != NULL; ++i)
3338       free (r[i]);
3339     free (r);
3340   }
3341   return 0;
3342 }
3343
3344 static int test_mount_ro_0 (void)
3345 {
3346   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
3347   {
3348     char device[] = "/dev/sda";
3349     device[5] = devchar;
3350     int r;
3351     suppress_error = 0;
3352     r = guestfs_blockdev_setrw (g, device);
3353     if (r == -1)
3354       return -1;
3355   }
3356   {
3357     int r;
3358     suppress_error = 0;
3359     r = guestfs_umount_all (g);
3360     if (r == -1)
3361       return -1;
3362   }
3363   {
3364     int r;
3365     suppress_error = 0;
3366     r = guestfs_lvm_remove_all (g);
3367     if (r == -1)
3368       return -1;
3369   }
3370   {
3371     char device[] = "/dev/sda";
3372     device[5] = devchar;
3373     char lines_0[] = ",";
3374     char *lines[] = {
3375       lines_0,
3376       NULL
3377     };
3378     int r;
3379     suppress_error = 0;
3380     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3381     if (r == -1)
3382       return -1;
3383   }
3384   {
3385     char fstype[] = "ext2";
3386     char device[] = "/dev/sda1";
3387     device[5] = devchar;
3388     int r;
3389     suppress_error = 0;
3390     r = guestfs_mkfs (g, fstype, device);
3391     if (r == -1)
3392       return -1;
3393   }
3394   {
3395     char device[] = "/dev/sda1";
3396     device[5] = devchar;
3397     char mountpoint[] = "/";
3398     int r;
3399     suppress_error = 0;
3400     r = guestfs_mount (g, device, mountpoint);
3401     if (r == -1)
3402       return -1;
3403   }
3404   /* TestLastFail for mount_ro (0) */
3405   {
3406     char pathordevice[] = "/";
3407     int r;
3408     suppress_error = 0;
3409     r = guestfs_umount (g, pathordevice);
3410     if (r == -1)
3411       return -1;
3412   }
3413   {
3414     char device[] = "/dev/sda1";
3415     device[5] = devchar;
3416     char mountpoint[] = "/";
3417     int r;
3418     suppress_error = 0;
3419     r = guestfs_mount_ro (g, device, mountpoint);
3420     if (r == -1)
3421       return -1;
3422   }
3423   {
3424     char path[] = "/new";
3425     int r;
3426     suppress_error = 1;
3427     r = guestfs_touch (g, path);
3428     if (r != -1)
3429       return -1;
3430   }
3431   return 0;
3432 }
3433
3434 static int test_mount_ro_1 (void)
3435 {
3436   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
3437   {
3438     char device[] = "/dev/sda";
3439     device[5] = devchar;
3440     int r;
3441     suppress_error = 0;
3442     r = guestfs_blockdev_setrw (g, device);
3443     if (r == -1)
3444       return -1;
3445   }
3446   {
3447     int r;
3448     suppress_error = 0;
3449     r = guestfs_umount_all (g);
3450     if (r == -1)
3451       return -1;
3452   }
3453   {
3454     int r;
3455     suppress_error = 0;
3456     r = guestfs_lvm_remove_all (g);
3457     if (r == -1)
3458       return -1;
3459   }
3460   {
3461     char device[] = "/dev/sda";
3462     device[5] = devchar;
3463     char lines_0[] = ",";
3464     char *lines[] = {
3465       lines_0,
3466       NULL
3467     };
3468     int r;
3469     suppress_error = 0;
3470     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3471     if (r == -1)
3472       return -1;
3473   }
3474   {
3475     char fstype[] = "ext2";
3476     char device[] = "/dev/sda1";
3477     device[5] = devchar;
3478     int r;
3479     suppress_error = 0;
3480     r = guestfs_mkfs (g, fstype, device);
3481     if (r == -1)
3482       return -1;
3483   }
3484   {
3485     char device[] = "/dev/sda1";
3486     device[5] = devchar;
3487     char mountpoint[] = "/";
3488     int r;
3489     suppress_error = 0;
3490     r = guestfs_mount (g, device, mountpoint);
3491     if (r == -1)
3492       return -1;
3493   }
3494   /* TestOutput for mount_ro (1) */
3495   char expected[] = "data";
3496   {
3497     char path[] = "/new";
3498     char content[] = "data";
3499     int r;
3500     suppress_error = 0;
3501     r = guestfs_write_file (g, path, content, 0);
3502     if (r == -1)
3503       return -1;
3504   }
3505   {
3506     char pathordevice[] = "/";
3507     int r;
3508     suppress_error = 0;
3509     r = guestfs_umount (g, pathordevice);
3510     if (r == -1)
3511       return -1;
3512   }
3513   {
3514     char device[] = "/dev/sda1";
3515     device[5] = devchar;
3516     char mountpoint[] = "/";
3517     int r;
3518     suppress_error = 0;
3519     r = guestfs_mount_ro (g, device, mountpoint);
3520     if (r == -1)
3521       return -1;
3522   }
3523   {
3524     char path[] = "/new";
3525     char *r;
3526     suppress_error = 0;
3527     r = guestfs_cat (g, path);
3528     if (r == NULL)
3529       return -1;
3530     if (strcmp (r, expected) != 0) {
3531       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3532       return -1;
3533     }
3534     free (r);
3535   }
3536   return 0;
3537 }
3538
3539 static int test_tgz_in_0 (void)
3540 {
3541   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
3542   {
3543     char device[] = "/dev/sda";
3544     device[5] = devchar;
3545     int r;
3546     suppress_error = 0;
3547     r = guestfs_blockdev_setrw (g, device);
3548     if (r == -1)
3549       return -1;
3550   }
3551   {
3552     int r;
3553     suppress_error = 0;
3554     r = guestfs_umount_all (g);
3555     if (r == -1)
3556       return -1;
3557   }
3558   {
3559     int r;
3560     suppress_error = 0;
3561     r = guestfs_lvm_remove_all (g);
3562     if (r == -1)
3563       return -1;
3564   }
3565   {
3566     char device[] = "/dev/sda";
3567     device[5] = devchar;
3568     char lines_0[] = ",";
3569     char *lines[] = {
3570       lines_0,
3571       NULL
3572     };
3573     int r;
3574     suppress_error = 0;
3575     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3576     if (r == -1)
3577       return -1;
3578   }
3579   {
3580     char fstype[] = "ext2";
3581     char device[] = "/dev/sda1";
3582     device[5] = devchar;
3583     int r;
3584     suppress_error = 0;
3585     r = guestfs_mkfs (g, fstype, device);
3586     if (r == -1)
3587       return -1;
3588   }
3589   {
3590     char device[] = "/dev/sda1";
3591     device[5] = devchar;
3592     char mountpoint[] = "/";
3593     int r;
3594     suppress_error = 0;
3595     r = guestfs_mount (g, device, mountpoint);
3596     if (r == -1)
3597       return -1;
3598   }
3599   /* TestOutput for tgz_in (0) */
3600   char expected[] = "hello\n";
3601   {
3602     char directory[] = "/";
3603     int r;
3604     suppress_error = 0;
3605     r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3606     if (r == -1)
3607       return -1;
3608   }
3609   {
3610     char path[] = "/hello";
3611     char *r;
3612     suppress_error = 0;
3613     r = guestfs_cat (g, path);
3614     if (r == NULL)
3615       return -1;
3616     if (strcmp (r, expected) != 0) {
3617       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3618       return -1;
3619     }
3620     free (r);
3621   }
3622   return 0;
3623 }
3624
3625 static int test_tar_in_0 (void)
3626 {
3627   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
3628   {
3629     char device[] = "/dev/sda";
3630     device[5] = devchar;
3631     int r;
3632     suppress_error = 0;
3633     r = guestfs_blockdev_setrw (g, device);
3634     if (r == -1)
3635       return -1;
3636   }
3637   {
3638     int r;
3639     suppress_error = 0;
3640     r = guestfs_umount_all (g);
3641     if (r == -1)
3642       return -1;
3643   }
3644   {
3645     int r;
3646     suppress_error = 0;
3647     r = guestfs_lvm_remove_all (g);
3648     if (r == -1)
3649       return -1;
3650   }
3651   {
3652     char device[] = "/dev/sda";
3653     device[5] = devchar;
3654     char lines_0[] = ",";
3655     char *lines[] = {
3656       lines_0,
3657       NULL
3658     };
3659     int r;
3660     suppress_error = 0;
3661     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3662     if (r == -1)
3663       return -1;
3664   }
3665   {
3666     char fstype[] = "ext2";
3667     char device[] = "/dev/sda1";
3668     device[5] = devchar;
3669     int r;
3670     suppress_error = 0;
3671     r = guestfs_mkfs (g, fstype, device);
3672     if (r == -1)
3673       return -1;
3674   }
3675   {
3676     char device[] = "/dev/sda1";
3677     device[5] = devchar;
3678     char mountpoint[] = "/";
3679     int r;
3680     suppress_error = 0;
3681     r = guestfs_mount (g, device, mountpoint);
3682     if (r == -1)
3683       return -1;
3684   }
3685   /* TestOutput for tar_in (0) */
3686   char expected[] = "hello\n";
3687   {
3688     char directory[] = "/";
3689     int r;
3690     suppress_error = 0;
3691     r = guestfs_tar_in (g, "images/helloworld.tar", directory);
3692     if (r == -1)
3693       return -1;
3694   }
3695   {
3696     char path[] = "/hello";
3697     char *r;
3698     suppress_error = 0;
3699     r = guestfs_cat (g, path);
3700     if (r == NULL)
3701       return -1;
3702     if (strcmp (r, expected) != 0) {
3703       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3704       return -1;
3705     }
3706     free (r);
3707   }
3708   return 0;
3709 }
3710
3711 static int test_checksum_0 (void)
3712 {
3713   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
3714   {
3715     char device[] = "/dev/sda";
3716     device[5] = devchar;
3717     int r;
3718     suppress_error = 0;
3719     r = guestfs_blockdev_setrw (g, device);
3720     if (r == -1)
3721       return -1;
3722   }
3723   {
3724     int r;
3725     suppress_error = 0;
3726     r = guestfs_umount_all (g);
3727     if (r == -1)
3728       return -1;
3729   }
3730   {
3731     int r;
3732     suppress_error = 0;
3733     r = guestfs_lvm_remove_all (g);
3734     if (r == -1)
3735       return -1;
3736   }
3737   {
3738     char device[] = "/dev/sda";
3739     device[5] = devchar;
3740     char lines_0[] = ",";
3741     char *lines[] = {
3742       lines_0,
3743       NULL
3744     };
3745     int r;
3746     suppress_error = 0;
3747     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3748     if (r == -1)
3749       return -1;
3750   }
3751   {
3752     char fstype[] = "ext2";
3753     char device[] = "/dev/sda1";
3754     device[5] = devchar;
3755     int r;
3756     suppress_error = 0;
3757     r = guestfs_mkfs (g, fstype, device);
3758     if (r == -1)
3759       return -1;
3760   }
3761   {
3762     char device[] = "/dev/sda1";
3763     device[5] = devchar;
3764     char mountpoint[] = "/";
3765     int r;
3766     suppress_error = 0;
3767     r = guestfs_mount (g, device, mountpoint);
3768     if (r == -1)
3769       return -1;
3770   }
3771   /* TestOutput for checksum (0) */
3772   char expected[] = "935282863";
3773   {
3774     char path[] = "/new";
3775     char content[] = "test\n";
3776     int r;
3777     suppress_error = 0;
3778     r = guestfs_write_file (g, path, content, 0);
3779     if (r == -1)
3780       return -1;
3781   }
3782   {
3783     char csumtype[] = "crc";
3784     char path[] = "/new";
3785     char *r;
3786     suppress_error = 0;
3787     r = guestfs_checksum (g, csumtype, path);
3788     if (r == NULL)
3789       return -1;
3790     if (strcmp (r, expected) != 0) {
3791       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
3792       return -1;
3793     }
3794     free (r);
3795   }
3796   return 0;
3797 }
3798
3799 static int test_checksum_1 (void)
3800 {
3801   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
3802   {
3803     char device[] = "/dev/sda";
3804     device[5] = devchar;
3805     int r;
3806     suppress_error = 0;
3807     r = guestfs_blockdev_setrw (g, device);
3808     if (r == -1)
3809       return -1;
3810   }
3811   {
3812     int r;
3813     suppress_error = 0;
3814     r = guestfs_umount_all (g);
3815     if (r == -1)
3816       return -1;
3817   }
3818   {
3819     int r;
3820     suppress_error = 0;
3821     r = guestfs_lvm_remove_all (g);
3822     if (r == -1)
3823       return -1;
3824   }
3825   {
3826     char device[] = "/dev/sda";
3827     device[5] = devchar;
3828     char lines_0[] = ",";
3829     char *lines[] = {
3830       lines_0,
3831       NULL
3832     };
3833     int r;
3834     suppress_error = 0;
3835     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3836     if (r == -1)
3837       return -1;
3838   }
3839   {
3840     char fstype[] = "ext2";
3841     char device[] = "/dev/sda1";
3842     device[5] = devchar;
3843     int r;
3844     suppress_error = 0;
3845     r = guestfs_mkfs (g, fstype, device);
3846     if (r == -1)
3847       return -1;
3848   }
3849   {
3850     char device[] = "/dev/sda1";
3851     device[5] = devchar;
3852     char mountpoint[] = "/";
3853     int r;
3854     suppress_error = 0;
3855     r = guestfs_mount (g, device, mountpoint);
3856     if (r == -1)
3857       return -1;
3858   }
3859   /* TestLastFail for checksum (1) */
3860   {
3861     char csumtype[] = "crc";
3862     char path[] = "/new";
3863     char *r;
3864     suppress_error = 1;
3865     r = guestfs_checksum (g, csumtype, path);
3866     if (r != NULL)
3867       return -1;
3868     free (r);
3869   }
3870   return 0;
3871 }
3872
3873 static int test_checksum_2 (void)
3874 {
3875   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
3876   {
3877     char device[] = "/dev/sda";
3878     device[5] = devchar;
3879     int r;
3880     suppress_error = 0;
3881     r = guestfs_blockdev_setrw (g, device);
3882     if (r == -1)
3883       return -1;
3884   }
3885   {
3886     int r;
3887     suppress_error = 0;
3888     r = guestfs_umount_all (g);
3889     if (r == -1)
3890       return -1;
3891   }
3892   {
3893     int r;
3894     suppress_error = 0;
3895     r = guestfs_lvm_remove_all (g);
3896     if (r == -1)
3897       return -1;
3898   }
3899   {
3900     char device[] = "/dev/sda";
3901     device[5] = devchar;
3902     char lines_0[] = ",";
3903     char *lines[] = {
3904       lines_0,
3905       NULL
3906     };
3907     int r;
3908     suppress_error = 0;
3909     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3910     if (r == -1)
3911       return -1;
3912   }
3913   {
3914     char fstype[] = "ext2";
3915     char device[] = "/dev/sda1";
3916     device[5] = devchar;
3917     int r;
3918     suppress_error = 0;
3919     r = guestfs_mkfs (g, fstype, device);
3920     if (r == -1)
3921       return -1;
3922   }
3923   {
3924     char device[] = "/dev/sda1";
3925     device[5] = devchar;
3926     char mountpoint[] = "/";
3927     int r;
3928     suppress_error = 0;
3929     r = guestfs_mount (g, device, mountpoint);
3930     if (r == -1)
3931       return -1;
3932   }
3933   /* TestOutput for checksum (2) */
3934   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
3935   {
3936     char path[] = "/new";
3937     char content[] = "test\n";
3938     int r;
3939     suppress_error = 0;
3940     r = guestfs_write_file (g, path, content, 0);
3941     if (r == -1)
3942       return -1;
3943   }
3944   {
3945     char csumtype[] = "md5";
3946     char path[] = "/new";
3947     char *r;
3948     suppress_error = 0;
3949     r = guestfs_checksum (g, csumtype, path);
3950     if (r == NULL)
3951       return -1;
3952     if (strcmp (r, expected) != 0) {
3953       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
3954       return -1;
3955     }
3956     free (r);
3957   }
3958   return 0;
3959 }
3960
3961 static int test_checksum_3 (void)
3962 {
3963   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
3964   {
3965     char device[] = "/dev/sda";
3966     device[5] = devchar;
3967     int r;
3968     suppress_error = 0;
3969     r = guestfs_blockdev_setrw (g, device);
3970     if (r == -1)
3971       return -1;
3972   }
3973   {
3974     int r;
3975     suppress_error = 0;
3976     r = guestfs_umount_all (g);
3977     if (r == -1)
3978       return -1;
3979   }
3980   {
3981     int r;
3982     suppress_error = 0;
3983     r = guestfs_lvm_remove_all (g);
3984     if (r == -1)
3985       return -1;
3986   }
3987   {
3988     char device[] = "/dev/sda";
3989     device[5] = devchar;
3990     char lines_0[] = ",";
3991     char *lines[] = {
3992       lines_0,
3993       NULL
3994     };
3995     int r;
3996     suppress_error = 0;
3997     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3998     if (r == -1)
3999       return -1;
4000   }
4001   {
4002     char fstype[] = "ext2";
4003     char device[] = "/dev/sda1";
4004     device[5] = devchar;
4005     int r;
4006     suppress_error = 0;
4007     r = guestfs_mkfs (g, fstype, device);
4008     if (r == -1)
4009       return -1;
4010   }
4011   {
4012     char device[] = "/dev/sda1";
4013     device[5] = devchar;
4014     char mountpoint[] = "/";
4015     int r;
4016     suppress_error = 0;
4017     r = guestfs_mount (g, device, mountpoint);
4018     if (r == -1)
4019       return -1;
4020   }
4021   /* TestOutput for checksum (3) */
4022   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
4023   {
4024     char path[] = "/new";
4025     char content[] = "test\n";
4026     int r;
4027     suppress_error = 0;
4028     r = guestfs_write_file (g, path, content, 0);
4029     if (r == -1)
4030       return -1;
4031   }
4032   {
4033     char csumtype[] = "sha1";
4034     char path[] = "/new";
4035     char *r;
4036     suppress_error = 0;
4037     r = guestfs_checksum (g, csumtype, path);
4038     if (r == NULL)
4039       return -1;
4040     if (strcmp (r, expected) != 0) {
4041       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
4042       return -1;
4043     }
4044     free (r);
4045   }
4046   return 0;
4047 }
4048
4049 static int test_checksum_4 (void)
4050 {
4051   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
4052   {
4053     char device[] = "/dev/sda";
4054     device[5] = devchar;
4055     int r;
4056     suppress_error = 0;
4057     r = guestfs_blockdev_setrw (g, device);
4058     if (r == -1)
4059       return -1;
4060   }
4061   {
4062     int r;
4063     suppress_error = 0;
4064     r = guestfs_umount_all (g);
4065     if (r == -1)
4066       return -1;
4067   }
4068   {
4069     int r;
4070     suppress_error = 0;
4071     r = guestfs_lvm_remove_all (g);
4072     if (r == -1)
4073       return -1;
4074   }
4075   {
4076     char device[] = "/dev/sda";
4077     device[5] = devchar;
4078     char lines_0[] = ",";
4079     char *lines[] = {
4080       lines_0,
4081       NULL
4082     };
4083     int r;
4084     suppress_error = 0;
4085     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4086     if (r == -1)
4087       return -1;
4088   }
4089   {
4090     char fstype[] = "ext2";
4091     char device[] = "/dev/sda1";
4092     device[5] = devchar;
4093     int r;
4094     suppress_error = 0;
4095     r = guestfs_mkfs (g, fstype, device);
4096     if (r == -1)
4097       return -1;
4098   }
4099   {
4100     char device[] = "/dev/sda1";
4101     device[5] = devchar;
4102     char mountpoint[] = "/";
4103     int r;
4104     suppress_error = 0;
4105     r = guestfs_mount (g, device, mountpoint);
4106     if (r == -1)
4107       return -1;
4108   }
4109   /* TestOutput for checksum (4) */
4110   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
4111   {
4112     char path[] = "/new";
4113     char content[] = "test\n";
4114     int r;
4115     suppress_error = 0;
4116     r = guestfs_write_file (g, path, content, 0);
4117     if (r == -1)
4118       return -1;
4119   }
4120   {
4121     char csumtype[] = "sha224";
4122     char path[] = "/new";
4123     char *r;
4124     suppress_error = 0;
4125     r = guestfs_checksum (g, csumtype, path);
4126     if (r == NULL)
4127       return -1;
4128     if (strcmp (r, expected) != 0) {
4129       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
4130       return -1;
4131     }
4132     free (r);
4133   }
4134   return 0;
4135 }
4136
4137 static int test_checksum_5 (void)
4138 {
4139   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
4140   {
4141     char device[] = "/dev/sda";
4142     device[5] = devchar;
4143     int r;
4144     suppress_error = 0;
4145     r = guestfs_blockdev_setrw (g, device);
4146     if (r == -1)
4147       return -1;
4148   }
4149   {
4150     int r;
4151     suppress_error = 0;
4152     r = guestfs_umount_all (g);
4153     if (r == -1)
4154       return -1;
4155   }
4156   {
4157     int r;
4158     suppress_error = 0;
4159     r = guestfs_lvm_remove_all (g);
4160     if (r == -1)
4161       return -1;
4162   }
4163   {
4164     char device[] = "/dev/sda";
4165     device[5] = devchar;
4166     char lines_0[] = ",";
4167     char *lines[] = {
4168       lines_0,
4169       NULL
4170     };
4171     int r;
4172     suppress_error = 0;
4173     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4174     if (r == -1)
4175       return -1;
4176   }
4177   {
4178     char fstype[] = "ext2";
4179     char device[] = "/dev/sda1";
4180     device[5] = devchar;
4181     int r;
4182     suppress_error = 0;
4183     r = guestfs_mkfs (g, fstype, device);
4184     if (r == -1)
4185       return -1;
4186   }
4187   {
4188     char device[] = "/dev/sda1";
4189     device[5] = devchar;
4190     char mountpoint[] = "/";
4191     int r;
4192     suppress_error = 0;
4193     r = guestfs_mount (g, device, mountpoint);
4194     if (r == -1)
4195       return -1;
4196   }
4197   /* TestOutput for checksum (5) */
4198   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4199   {
4200     char path[] = "/new";
4201     char content[] = "test\n";
4202     int r;
4203     suppress_error = 0;
4204     r = guestfs_write_file (g, path, content, 0);
4205     if (r == -1)
4206       return -1;
4207   }
4208   {
4209     char csumtype[] = "sha256";
4210     char path[] = "/new";
4211     char *r;
4212     suppress_error = 0;
4213     r = guestfs_checksum (g, csumtype, path);
4214     if (r == NULL)
4215       return -1;
4216     if (strcmp (r, expected) != 0) {
4217       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4218       return -1;
4219     }
4220     free (r);
4221   }
4222   return 0;
4223 }
4224
4225 static int test_checksum_6 (void)
4226 {
4227   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
4228   {
4229     char device[] = "/dev/sda";
4230     device[5] = devchar;
4231     int r;
4232     suppress_error = 0;
4233     r = guestfs_blockdev_setrw (g, device);
4234     if (r == -1)
4235       return -1;
4236   }
4237   {
4238     int r;
4239     suppress_error = 0;
4240     r = guestfs_umount_all (g);
4241     if (r == -1)
4242       return -1;
4243   }
4244   {
4245     int r;
4246     suppress_error = 0;
4247     r = guestfs_lvm_remove_all (g);
4248     if (r == -1)
4249       return -1;
4250   }
4251   {
4252     char device[] = "/dev/sda";
4253     device[5] = devchar;
4254     char lines_0[] = ",";
4255     char *lines[] = {
4256       lines_0,
4257       NULL
4258     };
4259     int r;
4260     suppress_error = 0;
4261     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4262     if (r == -1)
4263       return -1;
4264   }
4265   {
4266     char fstype[] = "ext2";
4267     char device[] = "/dev/sda1";
4268     device[5] = devchar;
4269     int r;
4270     suppress_error = 0;
4271     r = guestfs_mkfs (g, fstype, device);
4272     if (r == -1)
4273       return -1;
4274   }
4275   {
4276     char device[] = "/dev/sda1";
4277     device[5] = devchar;
4278     char mountpoint[] = "/";
4279     int r;
4280     suppress_error = 0;
4281     r = guestfs_mount (g, device, mountpoint);
4282     if (r == -1)
4283       return -1;
4284   }
4285   /* TestOutput for checksum (6) */
4286   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4287   {
4288     char path[] = "/new";
4289     char content[] = "test\n";
4290     int r;
4291     suppress_error = 0;
4292     r = guestfs_write_file (g, path, content, 0);
4293     if (r == -1)
4294       return -1;
4295   }
4296   {
4297     char csumtype[] = "sha384";
4298     char path[] = "/new";
4299     char *r;
4300     suppress_error = 0;
4301     r = guestfs_checksum (g, csumtype, path);
4302     if (r == NULL)
4303       return -1;
4304     if (strcmp (r, expected) != 0) {
4305       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4306       return -1;
4307     }
4308     free (r);
4309   }
4310   return 0;
4311 }
4312
4313 static int test_checksum_7 (void)
4314 {
4315   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
4316   {
4317     char device[] = "/dev/sda";
4318     device[5] = devchar;
4319     int r;
4320     suppress_error = 0;
4321     r = guestfs_blockdev_setrw (g, device);
4322     if (r == -1)
4323       return -1;
4324   }
4325   {
4326     int r;
4327     suppress_error = 0;
4328     r = guestfs_umount_all (g);
4329     if (r == -1)
4330       return -1;
4331   }
4332   {
4333     int r;
4334     suppress_error = 0;
4335     r = guestfs_lvm_remove_all (g);
4336     if (r == -1)
4337       return -1;
4338   }
4339   {
4340     char device[] = "/dev/sda";
4341     device[5] = devchar;
4342     char lines_0[] = ",";
4343     char *lines[] = {
4344       lines_0,
4345       NULL
4346     };
4347     int r;
4348     suppress_error = 0;
4349     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4350     if (r == -1)
4351       return -1;
4352   }
4353   {
4354     char fstype[] = "ext2";
4355     char device[] = "/dev/sda1";
4356     device[5] = devchar;
4357     int r;
4358     suppress_error = 0;
4359     r = guestfs_mkfs (g, fstype, device);
4360     if (r == -1)
4361       return -1;
4362   }
4363   {
4364     char device[] = "/dev/sda1";
4365     device[5] = devchar;
4366     char mountpoint[] = "/";
4367     int r;
4368     suppress_error = 0;
4369     r = guestfs_mount (g, device, mountpoint);
4370     if (r == -1)
4371       return -1;
4372   }
4373   /* TestOutput for checksum (7) */
4374   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4375   {
4376     char path[] = "/new";
4377     char content[] = "test\n";
4378     int r;
4379     suppress_error = 0;
4380     r = guestfs_write_file (g, path, content, 0);
4381     if (r == -1)
4382       return -1;
4383   }
4384   {
4385     char csumtype[] = "sha512";
4386     char path[] = "/new";
4387     char *r;
4388     suppress_error = 0;
4389     r = guestfs_checksum (g, csumtype, path);
4390     if (r == NULL)
4391       return -1;
4392     if (strcmp (r, expected) != 0) {
4393       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4394       return -1;
4395     }
4396     free (r);
4397   }
4398   return 0;
4399 }
4400
4401 static int test_download_0 (void)
4402 {
4403   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
4404   {
4405     char device[] = "/dev/sda";
4406     device[5] = devchar;
4407     int r;
4408     suppress_error = 0;
4409     r = guestfs_blockdev_setrw (g, device);
4410     if (r == -1)
4411       return -1;
4412   }
4413   {
4414     int r;
4415     suppress_error = 0;
4416     r = guestfs_umount_all (g);
4417     if (r == -1)
4418       return -1;
4419   }
4420   {
4421     int r;
4422     suppress_error = 0;
4423     r = guestfs_lvm_remove_all (g);
4424     if (r == -1)
4425       return -1;
4426   }
4427   {
4428     char device[] = "/dev/sda";
4429     device[5] = devchar;
4430     char lines_0[] = ",";
4431     char *lines[] = {
4432       lines_0,
4433       NULL
4434     };
4435     int r;
4436     suppress_error = 0;
4437     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4438     if (r == -1)
4439       return -1;
4440   }
4441   {
4442     char fstype[] = "ext2";
4443     char device[] = "/dev/sda1";
4444     device[5] = devchar;
4445     int r;
4446     suppress_error = 0;
4447     r = guestfs_mkfs (g, fstype, device);
4448     if (r == -1)
4449       return -1;
4450   }
4451   {
4452     char device[] = "/dev/sda1";
4453     device[5] = devchar;
4454     char mountpoint[] = "/";
4455     int r;
4456     suppress_error = 0;
4457     r = guestfs_mount (g, device, mountpoint);
4458     if (r == -1)
4459       return -1;
4460   }
4461   /* TestOutput for download (0) */
4462   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4463   {
4464     char remotefilename[] = "/COPYING.LIB";
4465     int r;
4466     suppress_error = 0;
4467     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4468     if (r == -1)
4469       return -1;
4470   }
4471   {
4472     char remotefilename[] = "/COPYING.LIB";
4473     int r;
4474     suppress_error = 0;
4475     r = guestfs_download (g, remotefilename, "testdownload.tmp");
4476     if (r == -1)
4477       return -1;
4478   }
4479   {
4480     char remotefilename[] = "/upload";
4481     int r;
4482     suppress_error = 0;
4483     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4484     if (r == -1)
4485       return -1;
4486   }
4487   {
4488     char csumtype[] = "md5";
4489     char path[] = "/upload";
4490     char *r;
4491     suppress_error = 0;
4492     r = guestfs_checksum (g, csumtype, path);
4493     if (r == NULL)
4494       return -1;
4495     if (strcmp (r, expected) != 0) {
4496       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4497       return -1;
4498     }
4499     free (r);
4500   }
4501   return 0;
4502 }
4503
4504 static int test_upload_0 (void)
4505 {
4506   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
4507   {
4508     char device[] = "/dev/sda";
4509     device[5] = devchar;
4510     int r;
4511     suppress_error = 0;
4512     r = guestfs_blockdev_setrw (g, device);
4513     if (r == -1)
4514       return -1;
4515   }
4516   {
4517     int r;
4518     suppress_error = 0;
4519     r = guestfs_umount_all (g);
4520     if (r == -1)
4521       return -1;
4522   }
4523   {
4524     int r;
4525     suppress_error = 0;
4526     r = guestfs_lvm_remove_all (g);
4527     if (r == -1)
4528       return -1;
4529   }
4530   {
4531     char device[] = "/dev/sda";
4532     device[5] = devchar;
4533     char lines_0[] = ",";
4534     char *lines[] = {
4535       lines_0,
4536       NULL
4537     };
4538     int r;
4539     suppress_error = 0;
4540     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4541     if (r == -1)
4542       return -1;
4543   }
4544   {
4545     char fstype[] = "ext2";
4546     char device[] = "/dev/sda1";
4547     device[5] = devchar;
4548     int r;
4549     suppress_error = 0;
4550     r = guestfs_mkfs (g, fstype, device);
4551     if (r == -1)
4552       return -1;
4553   }
4554   {
4555     char device[] = "/dev/sda1";
4556     device[5] = devchar;
4557     char mountpoint[] = "/";
4558     int r;
4559     suppress_error = 0;
4560     r = guestfs_mount (g, device, mountpoint);
4561     if (r == -1)
4562       return -1;
4563   }
4564   /* TestOutput for upload (0) */
4565   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4566   {
4567     char remotefilename[] = "/COPYING.LIB";
4568     int r;
4569     suppress_error = 0;
4570     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4571     if (r == -1)
4572       return -1;
4573   }
4574   {
4575     char csumtype[] = "md5";
4576     char path[] = "/COPYING.LIB";
4577     char *r;
4578     suppress_error = 0;
4579     r = guestfs_checksum (g, csumtype, path);
4580     if (r == NULL)
4581       return -1;
4582     if (strcmp (r, expected) != 0) {
4583       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4584       return -1;
4585     }
4586     free (r);
4587   }
4588   return 0;
4589 }
4590
4591 static int test_blockdev_rereadpt_0 (void)
4592 {
4593   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
4594   {
4595     char device[] = "/dev/sda";
4596     device[5] = devchar;
4597     int r;
4598     suppress_error = 0;
4599     r = guestfs_blockdev_setrw (g, device);
4600     if (r == -1)
4601       return -1;
4602   }
4603   {
4604     int r;
4605     suppress_error = 0;
4606     r = guestfs_umount_all (g);
4607     if (r == -1)
4608       return -1;
4609   }
4610   {
4611     int r;
4612     suppress_error = 0;
4613     r = guestfs_lvm_remove_all (g);
4614     if (r == -1)
4615       return -1;
4616   }
4617   /* TestRun for blockdev_rereadpt (0) */
4618   {
4619     char device[] = "/dev/sda";
4620     device[5] = devchar;
4621     int r;
4622     suppress_error = 0;
4623     r = guestfs_blockdev_rereadpt (g, device);
4624     if (r == -1)
4625       return -1;
4626   }
4627   return 0;
4628 }
4629
4630 static int test_blockdev_flushbufs_0 (void)
4631 {
4632   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
4633   {
4634     char device[] = "/dev/sda";
4635     device[5] = devchar;
4636     int r;
4637     suppress_error = 0;
4638     r = guestfs_blockdev_setrw (g, device);
4639     if (r == -1)
4640       return -1;
4641   }
4642   {
4643     int r;
4644     suppress_error = 0;
4645     r = guestfs_umount_all (g);
4646     if (r == -1)
4647       return -1;
4648   }
4649   {
4650     int r;
4651     suppress_error = 0;
4652     r = guestfs_lvm_remove_all (g);
4653     if (r == -1)
4654       return -1;
4655   }
4656   /* TestRun for blockdev_flushbufs (0) */
4657   {
4658     char device[] = "/dev/sda";
4659     device[5] = devchar;
4660     int r;
4661     suppress_error = 0;
4662     r = guestfs_blockdev_flushbufs (g, device);
4663     if (r == -1)
4664       return -1;
4665   }
4666   return 0;
4667 }
4668
4669 static int test_blockdev_getsize64_0 (void)
4670 {
4671   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
4672   {
4673     char device[] = "/dev/sda";
4674     device[5] = devchar;
4675     int r;
4676     suppress_error = 0;
4677     r = guestfs_blockdev_setrw (g, device);
4678     if (r == -1)
4679       return -1;
4680   }
4681   {
4682     int r;
4683     suppress_error = 0;
4684     r = guestfs_umount_all (g);
4685     if (r == -1)
4686       return -1;
4687   }
4688   {
4689     int r;
4690     suppress_error = 0;
4691     r = guestfs_lvm_remove_all (g);
4692     if (r == -1)
4693       return -1;
4694   }
4695   /* TestOutputInt for blockdev_getsize64 (0) */
4696   {
4697     char device[] = "/dev/sda";
4698     device[5] = devchar;
4699     int64_t r;
4700     suppress_error = 0;
4701     r = guestfs_blockdev_getsize64 (g, device);
4702     if (r == -1)
4703       return -1;
4704     if (r != 524288000) {
4705       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
4706       return -1;
4707     }
4708   }
4709   return 0;
4710 }
4711
4712 static int test_blockdev_getsz_0 (void)
4713 {
4714   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
4715   {
4716     char device[] = "/dev/sda";
4717     device[5] = devchar;
4718     int r;
4719     suppress_error = 0;
4720     r = guestfs_blockdev_setrw (g, device);
4721     if (r == -1)
4722       return -1;
4723   }
4724   {
4725     int r;
4726     suppress_error = 0;
4727     r = guestfs_umount_all (g);
4728     if (r == -1)
4729       return -1;
4730   }
4731   {
4732     int r;
4733     suppress_error = 0;
4734     r = guestfs_lvm_remove_all (g);
4735     if (r == -1)
4736       return -1;
4737   }
4738   /* TestOutputInt for blockdev_getsz (0) */
4739   {
4740     char device[] = "/dev/sda";
4741     device[5] = devchar;
4742     int64_t r;
4743     suppress_error = 0;
4744     r = guestfs_blockdev_getsz (g, device);
4745     if (r == -1)
4746       return -1;
4747     if (r != 1024000) {
4748       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
4749       return -1;
4750     }
4751   }
4752   return 0;
4753 }
4754
4755 static int test_blockdev_getbsz_0 (void)
4756 {
4757   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
4758   {
4759     char device[] = "/dev/sda";
4760     device[5] = devchar;
4761     int r;
4762     suppress_error = 0;
4763     r = guestfs_blockdev_setrw (g, device);
4764     if (r == -1)
4765       return -1;
4766   }
4767   {
4768     int r;
4769     suppress_error = 0;
4770     r = guestfs_umount_all (g);
4771     if (r == -1)
4772       return -1;
4773   }
4774   {
4775     int r;
4776     suppress_error = 0;
4777     r = guestfs_lvm_remove_all (g);
4778     if (r == -1)
4779       return -1;
4780   }
4781   /* TestOutputInt for blockdev_getbsz (0) */
4782   {
4783     char device[] = "/dev/sda";
4784     device[5] = devchar;
4785     int r;
4786     suppress_error = 0;
4787     r = guestfs_blockdev_getbsz (g, device);
4788     if (r == -1)
4789       return -1;
4790     if (r != 4096) {
4791       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
4792       return -1;
4793     }
4794   }
4795   return 0;
4796 }
4797
4798 static int test_blockdev_getss_0 (void)
4799 {
4800   /* InitNone|InitEmpty for test_blockdev_getss_0 */
4801   {
4802     char device[] = "/dev/sda";
4803     device[5] = devchar;
4804     int r;
4805     suppress_error = 0;
4806     r = guestfs_blockdev_setrw (g, device);
4807     if (r == -1)
4808       return -1;
4809   }
4810   {
4811     int r;
4812     suppress_error = 0;
4813     r = guestfs_umount_all (g);
4814     if (r == -1)
4815       return -1;
4816   }
4817   {
4818     int r;
4819     suppress_error = 0;
4820     r = guestfs_lvm_remove_all (g);
4821     if (r == -1)
4822       return -1;
4823   }
4824   /* TestOutputInt for blockdev_getss (0) */
4825   {
4826     char device[] = "/dev/sda";
4827     device[5] = devchar;
4828     int r;
4829     suppress_error = 0;
4830     r = guestfs_blockdev_getss (g, device);
4831     if (r == -1)
4832       return -1;
4833     if (r != 512) {
4834       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
4835       return -1;
4836     }
4837   }
4838   return 0;
4839 }
4840
4841 static int test_blockdev_getro_0 (void)
4842 {
4843   /* InitNone|InitEmpty for test_blockdev_getro_0 */
4844   {
4845     char device[] = "/dev/sda";
4846     device[5] = devchar;
4847     int r;
4848     suppress_error = 0;
4849     r = guestfs_blockdev_setrw (g, device);
4850     if (r == -1)
4851       return -1;
4852   }
4853   {
4854     int r;
4855     suppress_error = 0;
4856     r = guestfs_umount_all (g);
4857     if (r == -1)
4858       return -1;
4859   }
4860   {
4861     int r;
4862     suppress_error = 0;
4863     r = guestfs_lvm_remove_all (g);
4864     if (r == -1)
4865       return -1;
4866   }
4867   /* TestOutputTrue for blockdev_getro (0) */
4868   {
4869     char device[] = "/dev/sda";
4870     device[5] = devchar;
4871     int r;
4872     suppress_error = 0;
4873     r = guestfs_blockdev_setro (g, device);
4874     if (r == -1)
4875       return -1;
4876   }
4877   {
4878     char device[] = "/dev/sda";
4879     device[5] = devchar;
4880     int r;
4881     suppress_error = 0;
4882     r = guestfs_blockdev_getro (g, device);
4883     if (r == -1)
4884       return -1;
4885     if (!r) {
4886       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
4887       return -1;
4888     }
4889   }
4890   return 0;
4891 }
4892
4893 static int test_blockdev_setrw_0 (void)
4894 {
4895   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
4896   {
4897     char device[] = "/dev/sda";
4898     device[5] = devchar;
4899     int r;
4900     suppress_error = 0;
4901     r = guestfs_blockdev_setrw (g, device);
4902     if (r == -1)
4903       return -1;
4904   }
4905   {
4906     int r;
4907     suppress_error = 0;
4908     r = guestfs_umount_all (g);
4909     if (r == -1)
4910       return -1;
4911   }
4912   {
4913     int r;
4914     suppress_error = 0;
4915     r = guestfs_lvm_remove_all (g);
4916     if (r == -1)
4917       return -1;
4918   }
4919   /* TestOutputFalse for blockdev_setrw (0) */
4920   {
4921     char device[] = "/dev/sda";
4922     device[5] = devchar;
4923     int r;
4924     suppress_error = 0;
4925     r = guestfs_blockdev_setrw (g, device);
4926     if (r == -1)
4927       return -1;
4928   }
4929   {
4930     char device[] = "/dev/sda";
4931     device[5] = devchar;
4932     int r;
4933     suppress_error = 0;
4934     r = guestfs_blockdev_getro (g, device);
4935     if (r == -1)
4936       return -1;
4937     if (r) {
4938       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
4939       return -1;
4940     }
4941   }
4942   return 0;
4943 }
4944
4945 static int test_blockdev_setro_0 (void)
4946 {
4947   /* InitNone|InitEmpty for test_blockdev_setro_0 */
4948   {
4949     char device[] = "/dev/sda";
4950     device[5] = devchar;
4951     int r;
4952     suppress_error = 0;
4953     r = guestfs_blockdev_setrw (g, device);
4954     if (r == -1)
4955       return -1;
4956   }
4957   {
4958     int r;
4959     suppress_error = 0;
4960     r = guestfs_umount_all (g);
4961     if (r == -1)
4962       return -1;
4963   }
4964   {
4965     int r;
4966     suppress_error = 0;
4967     r = guestfs_lvm_remove_all (g);
4968     if (r == -1)
4969       return -1;
4970   }
4971   /* TestOutputTrue for blockdev_setro (0) */
4972   {
4973     char device[] = "/dev/sda";
4974     device[5] = devchar;
4975     int r;
4976     suppress_error = 0;
4977     r = guestfs_blockdev_setro (g, device);
4978     if (r == -1)
4979       return -1;
4980   }
4981   {
4982     char device[] = "/dev/sda";
4983     device[5] = devchar;
4984     int r;
4985     suppress_error = 0;
4986     r = guestfs_blockdev_getro (g, device);
4987     if (r == -1)
4988       return -1;
4989     if (!r) {
4990       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
4991       return -1;
4992     }
4993   }
4994   return 0;
4995 }
4996
4997 static int test_statvfs_0 (void)
4998 {
4999   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
5000   {
5001     char device[] = "/dev/sda";
5002     device[5] = devchar;
5003     int r;
5004     suppress_error = 0;
5005     r = guestfs_blockdev_setrw (g, device);
5006     if (r == -1)
5007       return -1;
5008   }
5009   {
5010     int r;
5011     suppress_error = 0;
5012     r = guestfs_umount_all (g);
5013     if (r == -1)
5014       return -1;
5015   }
5016   {
5017     int r;
5018     suppress_error = 0;
5019     r = guestfs_lvm_remove_all (g);
5020     if (r == -1)
5021       return -1;
5022   }
5023   {
5024     char device[] = "/dev/sda";
5025     device[5] = devchar;
5026     char lines_0[] = ",";
5027     char *lines[] = {
5028       lines_0,
5029       NULL
5030     };
5031     int r;
5032     suppress_error = 0;
5033     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5034     if (r == -1)
5035       return -1;
5036   }
5037   {
5038     char fstype[] = "ext2";
5039     char device[] = "/dev/sda1";
5040     device[5] = devchar;
5041     int r;
5042     suppress_error = 0;
5043     r = guestfs_mkfs (g, fstype, device);
5044     if (r == -1)
5045       return -1;
5046   }
5047   {
5048     char device[] = "/dev/sda1";
5049     device[5] = devchar;
5050     char mountpoint[] = "/";
5051     int r;
5052     suppress_error = 0;
5053     r = guestfs_mount (g, device, mountpoint);
5054     if (r == -1)
5055       return -1;
5056   }
5057   /* TestOutputStruct for statvfs (0) */
5058   {
5059     char path[] = "/";
5060     struct guestfs_statvfs *r;
5061     suppress_error = 0;
5062     r = guestfs_statvfs (g, path);
5063     if (r == NULL)
5064       return -1;
5065     if (r->bfree != 487702) {
5066       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
5067                (int) r->bfree);
5068       return -1;
5069     }
5070     if (r->blocks != 490020) {
5071       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
5072                (int) r->blocks);
5073       return -1;
5074     }
5075     if (r->bsize != 1024) {
5076       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
5077                (int) r->bsize);
5078       return -1;
5079     }
5080     free (r);
5081   }
5082   return 0;
5083 }
5084
5085 static int test_lstat_0 (void)
5086 {
5087   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
5088   {
5089     char device[] = "/dev/sda";
5090     device[5] = devchar;
5091     int r;
5092     suppress_error = 0;
5093     r = guestfs_blockdev_setrw (g, device);
5094     if (r == -1)
5095       return -1;
5096   }
5097   {
5098     int r;
5099     suppress_error = 0;
5100     r = guestfs_umount_all (g);
5101     if (r == -1)
5102       return -1;
5103   }
5104   {
5105     int r;
5106     suppress_error = 0;
5107     r = guestfs_lvm_remove_all (g);
5108     if (r == -1)
5109       return -1;
5110   }
5111   {
5112     char device[] = "/dev/sda";
5113     device[5] = devchar;
5114     char lines_0[] = ",";
5115     char *lines[] = {
5116       lines_0,
5117       NULL
5118     };
5119     int r;
5120     suppress_error = 0;
5121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5122     if (r == -1)
5123       return -1;
5124   }
5125   {
5126     char fstype[] = "ext2";
5127     char device[] = "/dev/sda1";
5128     device[5] = devchar;
5129     int r;
5130     suppress_error = 0;
5131     r = guestfs_mkfs (g, fstype, device);
5132     if (r == -1)
5133       return -1;
5134   }
5135   {
5136     char device[] = "/dev/sda1";
5137     device[5] = devchar;
5138     char mountpoint[] = "/";
5139     int r;
5140     suppress_error = 0;
5141     r = guestfs_mount (g, device, mountpoint);
5142     if (r == -1)
5143       return -1;
5144   }
5145   /* TestOutputStruct for lstat (0) */
5146   {
5147     char path[] = "/new";
5148     int r;
5149     suppress_error = 0;
5150     r = guestfs_touch (g, path);
5151     if (r == -1)
5152       return -1;
5153   }
5154   {
5155     char path[] = "/new";
5156     struct guestfs_stat *r;
5157     suppress_error = 0;
5158     r = guestfs_lstat (g, path);
5159     if (r == NULL)
5160       return -1;
5161     if (r->size != 0) {
5162       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
5163                (int) r->size);
5164       return -1;
5165     }
5166     free (r);
5167   }
5168   return 0;
5169 }
5170
5171 static int test_stat_0 (void)
5172 {
5173   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
5174   {
5175     char device[] = "/dev/sda";
5176     device[5] = devchar;
5177     int r;
5178     suppress_error = 0;
5179     r = guestfs_blockdev_setrw (g, device);
5180     if (r == -1)
5181       return -1;
5182   }
5183   {
5184     int r;
5185     suppress_error = 0;
5186     r = guestfs_umount_all (g);
5187     if (r == -1)
5188       return -1;
5189   }
5190   {
5191     int r;
5192     suppress_error = 0;
5193     r = guestfs_lvm_remove_all (g);
5194     if (r == -1)
5195       return -1;
5196   }
5197   {
5198     char device[] = "/dev/sda";
5199     device[5] = devchar;
5200     char lines_0[] = ",";
5201     char *lines[] = {
5202       lines_0,
5203       NULL
5204     };
5205     int r;
5206     suppress_error = 0;
5207     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5208     if (r == -1)
5209       return -1;
5210   }
5211   {
5212     char fstype[] = "ext2";
5213     char device[] = "/dev/sda1";
5214     device[5] = devchar;
5215     int r;
5216     suppress_error = 0;
5217     r = guestfs_mkfs (g, fstype, device);
5218     if (r == -1)
5219       return -1;
5220   }
5221   {
5222     char device[] = "/dev/sda1";
5223     device[5] = devchar;
5224     char mountpoint[] = "/";
5225     int r;
5226     suppress_error = 0;
5227     r = guestfs_mount (g, device, mountpoint);
5228     if (r == -1)
5229       return -1;
5230   }
5231   /* TestOutputStruct for stat (0) */
5232   {
5233     char path[] = "/new";
5234     int r;
5235     suppress_error = 0;
5236     r = guestfs_touch (g, path);
5237     if (r == -1)
5238       return -1;
5239   }
5240   {
5241     char path[] = "/new";
5242     struct guestfs_stat *r;
5243     suppress_error = 0;
5244     r = guestfs_stat (g, path);
5245     if (r == NULL)
5246       return -1;
5247     if (r->size != 0) {
5248       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5249                (int) r->size);
5250       return -1;
5251     }
5252     free (r);
5253   }
5254   return 0;
5255 }
5256
5257 static int test_command_lines_0_prereq (void)
5258 {
5259   const char *str = getenv ("SKIP_TEST_COMMAND");
5260   return str && strcmp (str, "1") == 0;
5261 }
5262
5263 static int test_command_lines_0 (void)
5264 {
5265   if (! test_command_lines_0_prereq ()) {
5266   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
5267   {
5268     char device[] = "/dev/sda";
5269     device[5] = devchar;
5270     int r;
5271     suppress_error = 0;
5272     r = guestfs_blockdev_setrw (g, device);
5273     if (r == -1)
5274       return -1;
5275   }
5276   {
5277     int r;
5278     suppress_error = 0;
5279     r = guestfs_umount_all (g);
5280     if (r == -1)
5281       return -1;
5282   }
5283   {
5284     int r;
5285     suppress_error = 0;
5286     r = guestfs_lvm_remove_all (g);
5287     if (r == -1)
5288       return -1;
5289   }
5290   {
5291     char device[] = "/dev/sda";
5292     device[5] = devchar;
5293     char lines_0[] = ",";
5294     char *lines[] = {
5295       lines_0,
5296       NULL
5297     };
5298     int r;
5299     suppress_error = 0;
5300     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5301     if (r == -1)
5302       return -1;
5303   }
5304   {
5305     char fstype[] = "ext2";
5306     char device[] = "/dev/sda1";
5307     device[5] = devchar;
5308     int r;
5309     suppress_error = 0;
5310     r = guestfs_mkfs (g, fstype, device);
5311     if (r == -1)
5312       return -1;
5313   }
5314   {
5315     char device[] = "/dev/sda1";
5316     device[5] = devchar;
5317     char mountpoint[] = "/";
5318     int r;
5319     suppress_error = 0;
5320     r = guestfs_mount (g, device, mountpoint);
5321     if (r == -1)
5322       return -1;
5323   }
5324   /* TestOutputList for command_lines (0) */
5325   {
5326     char remotefilename[] = "/test-command";
5327     int r;
5328     suppress_error = 0;
5329     r = guestfs_upload (g, "test-command", remotefilename);
5330     if (r == -1)
5331       return -1;
5332   }
5333   {
5334     char path[] = "/test-command";
5335     int r;
5336     suppress_error = 0;
5337     r = guestfs_chmod (g, 493, path);
5338     if (r == -1)
5339       return -1;
5340   }
5341   {
5342     char arguments_0[] = "/test-command";
5343     char arguments_1[] = "1";
5344     char *arguments[] = {
5345       arguments_0,
5346       arguments_1,
5347       NULL
5348     };
5349     char **r;
5350     int i;
5351     suppress_error = 0;
5352     r = guestfs_command_lines (g, arguments);
5353     if (r == NULL)
5354       return -1;
5355     if (!r[0]) {
5356       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5357       print_strings (r);
5358       return -1;
5359     }
5360     {
5361       char expected[] = "Result1";
5362       if (strcmp (r[0], expected) != 0) {
5363         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5364         return -1;
5365       }
5366     }
5367     if (r[1] != NULL) {
5368       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5369       print_strings (r);
5370       return -1;
5371     }
5372     for (i = 0; r[i] != NULL; ++i)
5373       free (r[i]);
5374     free (r);
5375   }
5376   } else
5377     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5378   return 0;
5379 }
5380
5381 static int test_command_lines_1_prereq (void)
5382 {
5383   const char *str = getenv ("SKIP_TEST_COMMAND");
5384   return str && strcmp (str, "1") == 0;
5385 }
5386
5387 static int test_command_lines_1 (void)
5388 {
5389   if (! test_command_lines_1_prereq ()) {
5390   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
5391   {
5392     char device[] = "/dev/sda";
5393     device[5] = devchar;
5394     int r;
5395     suppress_error = 0;
5396     r = guestfs_blockdev_setrw (g, device);
5397     if (r == -1)
5398       return -1;
5399   }
5400   {
5401     int r;
5402     suppress_error = 0;
5403     r = guestfs_umount_all (g);
5404     if (r == -1)
5405       return -1;
5406   }
5407   {
5408     int r;
5409     suppress_error = 0;
5410     r = guestfs_lvm_remove_all (g);
5411     if (r == -1)
5412       return -1;
5413   }
5414   {
5415     char device[] = "/dev/sda";
5416     device[5] = devchar;
5417     char lines_0[] = ",";
5418     char *lines[] = {
5419       lines_0,
5420       NULL
5421     };
5422     int r;
5423     suppress_error = 0;
5424     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5425     if (r == -1)
5426       return -1;
5427   }
5428   {
5429     char fstype[] = "ext2";
5430     char device[] = "/dev/sda1";
5431     device[5] = devchar;
5432     int r;
5433     suppress_error = 0;
5434     r = guestfs_mkfs (g, fstype, device);
5435     if (r == -1)
5436       return -1;
5437   }
5438   {
5439     char device[] = "/dev/sda1";
5440     device[5] = devchar;
5441     char mountpoint[] = "/";
5442     int r;
5443     suppress_error = 0;
5444     r = guestfs_mount (g, device, mountpoint);
5445     if (r == -1)
5446       return -1;
5447   }
5448   /* TestOutputList for command_lines (1) */
5449   {
5450     char remotefilename[] = "/test-command";
5451     int r;
5452     suppress_error = 0;
5453     r = guestfs_upload (g, "test-command", remotefilename);
5454     if (r == -1)
5455       return -1;
5456   }
5457   {
5458     char path[] = "/test-command";
5459     int r;
5460     suppress_error = 0;
5461     r = guestfs_chmod (g, 493, path);
5462     if (r == -1)
5463       return -1;
5464   }
5465   {
5466     char arguments_0[] = "/test-command";
5467     char arguments_1[] = "2";
5468     char *arguments[] = {
5469       arguments_0,
5470       arguments_1,
5471       NULL
5472     };
5473     char **r;
5474     int i;
5475     suppress_error = 0;
5476     r = guestfs_command_lines (g, arguments);
5477     if (r == NULL)
5478       return -1;
5479     if (!r[0]) {
5480       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5481       print_strings (r);
5482       return -1;
5483     }
5484     {
5485       char expected[] = "Result2";
5486       if (strcmp (r[0], expected) != 0) {
5487         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5488         return -1;
5489       }
5490     }
5491     if (r[1] != NULL) {
5492       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5493       print_strings (r);
5494       return -1;
5495     }
5496     for (i = 0; r[i] != NULL; ++i)
5497       free (r[i]);
5498     free (r);
5499   }
5500   } else
5501     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5502   return 0;
5503 }
5504
5505 static int test_command_lines_2_prereq (void)
5506 {
5507   const char *str = getenv ("SKIP_TEST_COMMAND");
5508   return str && strcmp (str, "1") == 0;
5509 }
5510
5511 static int test_command_lines_2 (void)
5512 {
5513   if (! test_command_lines_2_prereq ()) {
5514   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
5515   {
5516     char device[] = "/dev/sda";
5517     device[5] = devchar;
5518     int r;
5519     suppress_error = 0;
5520     r = guestfs_blockdev_setrw (g, device);
5521     if (r == -1)
5522       return -1;
5523   }
5524   {
5525     int r;
5526     suppress_error = 0;
5527     r = guestfs_umount_all (g);
5528     if (r == -1)
5529       return -1;
5530   }
5531   {
5532     int r;
5533     suppress_error = 0;
5534     r = guestfs_lvm_remove_all (g);
5535     if (r == -1)
5536       return -1;
5537   }
5538   {
5539     char device[] = "/dev/sda";
5540     device[5] = devchar;
5541     char lines_0[] = ",";
5542     char *lines[] = {
5543       lines_0,
5544       NULL
5545     };
5546     int r;
5547     suppress_error = 0;
5548     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5549     if (r == -1)
5550       return -1;
5551   }
5552   {
5553     char fstype[] = "ext2";
5554     char device[] = "/dev/sda1";
5555     device[5] = devchar;
5556     int r;
5557     suppress_error = 0;
5558     r = guestfs_mkfs (g, fstype, device);
5559     if (r == -1)
5560       return -1;
5561   }
5562   {
5563     char device[] = "/dev/sda1";
5564     device[5] = devchar;
5565     char mountpoint[] = "/";
5566     int r;
5567     suppress_error = 0;
5568     r = guestfs_mount (g, device, mountpoint);
5569     if (r == -1)
5570       return -1;
5571   }
5572   /* TestOutputList for command_lines (2) */
5573   {
5574     char remotefilename[] = "/test-command";
5575     int r;
5576     suppress_error = 0;
5577     r = guestfs_upload (g, "test-command", remotefilename);
5578     if (r == -1)
5579       return -1;
5580   }
5581   {
5582     char path[] = "/test-command";
5583     int r;
5584     suppress_error = 0;
5585     r = guestfs_chmod (g, 493, path);
5586     if (r == -1)
5587       return -1;
5588   }
5589   {
5590     char arguments_0[] = "/test-command";
5591     char arguments_1[] = "3";
5592     char *arguments[] = {
5593       arguments_0,
5594       arguments_1,
5595       NULL
5596     };
5597     char **r;
5598     int i;
5599     suppress_error = 0;
5600     r = guestfs_command_lines (g, arguments);
5601     if (r == NULL)
5602       return -1;
5603     if (!r[0]) {
5604       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5605       print_strings (r);
5606       return -1;
5607     }
5608     {
5609       char expected[] = "";
5610       if (strcmp (r[0], expected) != 0) {
5611         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5612         return -1;
5613       }
5614     }
5615     if (!r[1]) {
5616       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5617       print_strings (r);
5618       return -1;
5619     }
5620     {
5621       char expected[] = "Result3";
5622       if (strcmp (r[1], expected) != 0) {
5623         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5624         return -1;
5625       }
5626     }
5627     if (r[2] != NULL) {
5628       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
5629       print_strings (r);
5630       return -1;
5631     }
5632     for (i = 0; r[i] != NULL; ++i)
5633       free (r[i]);
5634     free (r);
5635   }
5636   } else
5637     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
5638   return 0;
5639 }
5640
5641 static int test_command_lines_3_prereq (void)
5642 {
5643   const char *str = getenv ("SKIP_TEST_COMMAND");
5644   return str && strcmp (str, "1") == 0;
5645 }
5646
5647 static int test_command_lines_3 (void)
5648 {
5649   if (! test_command_lines_3_prereq ()) {
5650   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
5651   {
5652     char device[] = "/dev/sda";
5653     device[5] = devchar;
5654     int r;
5655     suppress_error = 0;
5656     r = guestfs_blockdev_setrw (g, device);
5657     if (r == -1)
5658       return -1;
5659   }
5660   {
5661     int r;
5662     suppress_error = 0;
5663     r = guestfs_umount_all (g);
5664     if (r == -1)
5665       return -1;
5666   }
5667   {
5668     int r;
5669     suppress_error = 0;
5670     r = guestfs_lvm_remove_all (g);
5671     if (r == -1)
5672       return -1;
5673   }
5674   {
5675     char device[] = "/dev/sda";
5676     device[5] = devchar;
5677     char lines_0[] = ",";
5678     char *lines[] = {
5679       lines_0,
5680       NULL
5681     };
5682     int r;
5683     suppress_error = 0;
5684     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5685     if (r == -1)
5686       return -1;
5687   }
5688   {
5689     char fstype[] = "ext2";
5690     char device[] = "/dev/sda1";
5691     device[5] = devchar;
5692     int r;
5693     suppress_error = 0;
5694     r = guestfs_mkfs (g, fstype, device);
5695     if (r == -1)
5696       return -1;
5697   }
5698   {
5699     char device[] = "/dev/sda1";
5700     device[5] = devchar;
5701     char mountpoint[] = "/";
5702     int r;
5703     suppress_error = 0;
5704     r = guestfs_mount (g, device, mountpoint);
5705     if (r == -1)
5706       return -1;
5707   }
5708   /* TestOutputList for command_lines (3) */
5709   {
5710     char remotefilename[] = "/test-command";
5711     int r;
5712     suppress_error = 0;
5713     r = guestfs_upload (g, "test-command", remotefilename);
5714     if (r == -1)
5715       return -1;
5716   }
5717   {
5718     char path[] = "/test-command";
5719     int r;
5720     suppress_error = 0;
5721     r = guestfs_chmod (g, 493, path);
5722     if (r == -1)
5723       return -1;
5724   }
5725   {
5726     char arguments_0[] = "/test-command";
5727     char arguments_1[] = "4";
5728     char *arguments[] = {
5729       arguments_0,
5730       arguments_1,
5731       NULL
5732     };
5733     char **r;
5734     int i;
5735     suppress_error = 0;
5736     r = guestfs_command_lines (g, arguments);
5737     if (r == NULL)
5738       return -1;
5739     if (!r[0]) {
5740       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5741       print_strings (r);
5742       return -1;
5743     }
5744     {
5745       char expected[] = "";
5746       if (strcmp (r[0], expected) != 0) {
5747         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5748         return -1;
5749       }
5750     }
5751     if (!r[1]) {
5752       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5753       print_strings (r);
5754       return -1;
5755     }
5756     {
5757       char expected[] = "Result4";
5758       if (strcmp (r[1], expected) != 0) {
5759         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5760         return -1;
5761       }
5762     }
5763     if (r[2] != NULL) {
5764       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
5765       print_strings (r);
5766       return -1;
5767     }
5768     for (i = 0; r[i] != NULL; ++i)
5769       free (r[i]);
5770     free (r);
5771   }
5772   } else
5773     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
5774   return 0;
5775 }
5776
5777 static int test_command_lines_4_prereq (void)
5778 {
5779   const char *str = getenv ("SKIP_TEST_COMMAND");
5780   return str && strcmp (str, "1") == 0;
5781 }
5782
5783 static int test_command_lines_4 (void)
5784 {
5785   if (! test_command_lines_4_prereq ()) {
5786   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
5787   {
5788     char device[] = "/dev/sda";
5789     device[5] = devchar;
5790     int r;
5791     suppress_error = 0;
5792     r = guestfs_blockdev_setrw (g, device);
5793     if (r == -1)
5794       return -1;
5795   }
5796   {
5797     int r;
5798     suppress_error = 0;
5799     r = guestfs_umount_all (g);
5800     if (r == -1)
5801       return -1;
5802   }
5803   {
5804     int r;
5805     suppress_error = 0;
5806     r = guestfs_lvm_remove_all (g);
5807     if (r == -1)
5808       return -1;
5809   }
5810   {
5811     char device[] = "/dev/sda";
5812     device[5] = devchar;
5813     char lines_0[] = ",";
5814     char *lines[] = {
5815       lines_0,
5816       NULL
5817     };
5818     int r;
5819     suppress_error = 0;
5820     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5821     if (r == -1)
5822       return -1;
5823   }
5824   {
5825     char fstype[] = "ext2";
5826     char device[] = "/dev/sda1";
5827     device[5] = devchar;
5828     int r;
5829     suppress_error = 0;
5830     r = guestfs_mkfs (g, fstype, device);
5831     if (r == -1)
5832       return -1;
5833   }
5834   {
5835     char device[] = "/dev/sda1";
5836     device[5] = devchar;
5837     char mountpoint[] = "/";
5838     int r;
5839     suppress_error = 0;
5840     r = guestfs_mount (g, device, mountpoint);
5841     if (r == -1)
5842       return -1;
5843   }
5844   /* TestOutputList for command_lines (4) */
5845   {
5846     char remotefilename[] = "/test-command";
5847     int r;
5848     suppress_error = 0;
5849     r = guestfs_upload (g, "test-command", remotefilename);
5850     if (r == -1)
5851       return -1;
5852   }
5853   {
5854     char path[] = "/test-command";
5855     int r;
5856     suppress_error = 0;
5857     r = guestfs_chmod (g, 493, path);
5858     if (r == -1)
5859       return -1;
5860   }
5861   {
5862     char arguments_0[] = "/test-command";
5863     char arguments_1[] = "5";
5864     char *arguments[] = {
5865       arguments_0,
5866       arguments_1,
5867       NULL
5868     };
5869     char **r;
5870     int i;
5871     suppress_error = 0;
5872     r = guestfs_command_lines (g, arguments);
5873     if (r == NULL)
5874       return -1;
5875     if (!r[0]) {
5876       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5877       print_strings (r);
5878       return -1;
5879     }
5880     {
5881       char expected[] = "";
5882       if (strcmp (r[0], expected) != 0) {
5883         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5884         return -1;
5885       }
5886     }
5887     if (!r[1]) {
5888       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5889       print_strings (r);
5890       return -1;
5891     }
5892     {
5893       char expected[] = "Result5";
5894       if (strcmp (r[1], expected) != 0) {
5895         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5896         return -1;
5897       }
5898     }
5899     if (!r[2]) {
5900       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5901       print_strings (r);
5902       return -1;
5903     }
5904     {
5905       char expected[] = "";
5906       if (strcmp (r[2], expected) != 0) {
5907         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5908         return -1;
5909       }
5910     }
5911     if (r[3] != NULL) {
5912       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
5913       print_strings (r);
5914       return -1;
5915     }
5916     for (i = 0; r[i] != NULL; ++i)
5917       free (r[i]);
5918     free (r);
5919   }
5920   } else
5921     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
5922   return 0;
5923 }
5924
5925 static int test_command_lines_5_prereq (void)
5926 {
5927   const char *str = getenv ("SKIP_TEST_COMMAND");
5928   return str && strcmp (str, "1") == 0;
5929 }
5930
5931 static int test_command_lines_5 (void)
5932 {
5933   if (! test_command_lines_5_prereq ()) {
5934   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
5935   {
5936     char device[] = "/dev/sda";
5937     device[5] = devchar;
5938     int r;
5939     suppress_error = 0;
5940     r = guestfs_blockdev_setrw (g, device);
5941     if (r == -1)
5942       return -1;
5943   }
5944   {
5945     int r;
5946     suppress_error = 0;
5947     r = guestfs_umount_all (g);
5948     if (r == -1)
5949       return -1;
5950   }
5951   {
5952     int r;
5953     suppress_error = 0;
5954     r = guestfs_lvm_remove_all (g);
5955     if (r == -1)
5956       return -1;
5957   }
5958   {
5959     char device[] = "/dev/sda";
5960     device[5] = devchar;
5961     char lines_0[] = ",";
5962     char *lines[] = {
5963       lines_0,
5964       NULL
5965     };
5966     int r;
5967     suppress_error = 0;
5968     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5969     if (r == -1)
5970       return -1;
5971   }
5972   {
5973     char fstype[] = "ext2";
5974     char device[] = "/dev/sda1";
5975     device[5] = devchar;
5976     int r;
5977     suppress_error = 0;
5978     r = guestfs_mkfs (g, fstype, device);
5979     if (r == -1)
5980       return -1;
5981   }
5982   {
5983     char device[] = "/dev/sda1";
5984     device[5] = devchar;
5985     char mountpoint[] = "/";
5986     int r;
5987     suppress_error = 0;
5988     r = guestfs_mount (g, device, mountpoint);
5989     if (r == -1)
5990       return -1;
5991   }
5992   /* TestOutputList for command_lines (5) */
5993   {
5994     char remotefilename[] = "/test-command";
5995     int r;
5996     suppress_error = 0;
5997     r = guestfs_upload (g, "test-command", remotefilename);
5998     if (r == -1)
5999       return -1;
6000   }
6001   {
6002     char path[] = "/test-command";
6003     int r;
6004     suppress_error = 0;
6005     r = guestfs_chmod (g, 493, path);
6006     if (r == -1)
6007       return -1;
6008   }
6009   {
6010     char arguments_0[] = "/test-command";
6011     char arguments_1[] = "6";
6012     char *arguments[] = {
6013       arguments_0,
6014       arguments_1,
6015       NULL
6016     };
6017     char **r;
6018     int i;
6019     suppress_error = 0;
6020     r = guestfs_command_lines (g, arguments);
6021     if (r == NULL)
6022       return -1;
6023     if (!r[0]) {
6024       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6025       print_strings (r);
6026       return -1;
6027     }
6028     {
6029       char expected[] = "";
6030       if (strcmp (r[0], expected) != 0) {
6031         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6032         return -1;
6033       }
6034     }
6035     if (!r[1]) {
6036       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6037       print_strings (r);
6038       return -1;
6039     }
6040     {
6041       char expected[] = "";
6042       if (strcmp (r[1], expected) != 0) {
6043         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6044         return -1;
6045       }
6046     }
6047     if (!r[2]) {
6048       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6049       print_strings (r);
6050       return -1;
6051     }
6052     {
6053       char expected[] = "Result6";
6054       if (strcmp (r[2], expected) != 0) {
6055         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6056         return -1;
6057       }
6058     }
6059     if (!r[3]) {
6060       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6061       print_strings (r);
6062       return -1;
6063     }
6064     {
6065       char expected[] = "";
6066       if (strcmp (r[3], expected) != 0) {
6067         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
6068         return -1;
6069       }
6070     }
6071     if (r[4] != NULL) {
6072       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
6073       print_strings (r);
6074       return -1;
6075     }
6076     for (i = 0; r[i] != NULL; ++i)
6077       free (r[i]);
6078     free (r);
6079   }
6080   } else
6081     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
6082   return 0;
6083 }
6084
6085 static int test_command_lines_6_prereq (void)
6086 {
6087   const char *str = getenv ("SKIP_TEST_COMMAND");
6088   return str && strcmp (str, "1") == 0;
6089 }
6090
6091 static int test_command_lines_6 (void)
6092 {
6093   if (! test_command_lines_6_prereq ()) {
6094   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
6095   {
6096     char device[] = "/dev/sda";
6097     device[5] = devchar;
6098     int r;
6099     suppress_error = 0;
6100     r = guestfs_blockdev_setrw (g, device);
6101     if (r == -1)
6102       return -1;
6103   }
6104   {
6105     int r;
6106     suppress_error = 0;
6107     r = guestfs_umount_all (g);
6108     if (r == -1)
6109       return -1;
6110   }
6111   {
6112     int r;
6113     suppress_error = 0;
6114     r = guestfs_lvm_remove_all (g);
6115     if (r == -1)
6116       return -1;
6117   }
6118   {
6119     char device[] = "/dev/sda";
6120     device[5] = devchar;
6121     char lines_0[] = ",";
6122     char *lines[] = {
6123       lines_0,
6124       NULL
6125     };
6126     int r;
6127     suppress_error = 0;
6128     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6129     if (r == -1)
6130       return -1;
6131   }
6132   {
6133     char fstype[] = "ext2";
6134     char device[] = "/dev/sda1";
6135     device[5] = devchar;
6136     int r;
6137     suppress_error = 0;
6138     r = guestfs_mkfs (g, fstype, device);
6139     if (r == -1)
6140       return -1;
6141   }
6142   {
6143     char device[] = "/dev/sda1";
6144     device[5] = devchar;
6145     char mountpoint[] = "/";
6146     int r;
6147     suppress_error = 0;
6148     r = guestfs_mount (g, device, mountpoint);
6149     if (r == -1)
6150       return -1;
6151   }
6152   /* TestOutputList for command_lines (6) */
6153   {
6154     char remotefilename[] = "/test-command";
6155     int r;
6156     suppress_error = 0;
6157     r = guestfs_upload (g, "test-command", remotefilename);
6158     if (r == -1)
6159       return -1;
6160   }
6161   {
6162     char path[] = "/test-command";
6163     int r;
6164     suppress_error = 0;
6165     r = guestfs_chmod (g, 493, path);
6166     if (r == -1)
6167       return -1;
6168   }
6169   {
6170     char arguments_0[] = "/test-command";
6171     char arguments_1[] = "7";
6172     char *arguments[] = {
6173       arguments_0,
6174       arguments_1,
6175       NULL
6176     };
6177     char **r;
6178     int i;
6179     suppress_error = 0;
6180     r = guestfs_command_lines (g, arguments);
6181     if (r == NULL)
6182       return -1;
6183     if (r[0] != NULL) {
6184       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6185       print_strings (r);
6186       return -1;
6187     }
6188     for (i = 0; r[i] != NULL; ++i)
6189       free (r[i]);
6190     free (r);
6191   }
6192   } else
6193     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6194   return 0;
6195 }
6196
6197 static int test_command_lines_7_prereq (void)
6198 {
6199   const char *str = getenv ("SKIP_TEST_COMMAND");
6200   return str && strcmp (str, "1") == 0;
6201 }
6202
6203 static int test_command_lines_7 (void)
6204 {
6205   if (! test_command_lines_7_prereq ()) {
6206   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
6207   {
6208     char device[] = "/dev/sda";
6209     device[5] = devchar;
6210     int r;
6211     suppress_error = 0;
6212     r = guestfs_blockdev_setrw (g, device);
6213     if (r == -1)
6214       return -1;
6215   }
6216   {
6217     int r;
6218     suppress_error = 0;
6219     r = guestfs_umount_all (g);
6220     if (r == -1)
6221       return -1;
6222   }
6223   {
6224     int r;
6225     suppress_error = 0;
6226     r = guestfs_lvm_remove_all (g);
6227     if (r == -1)
6228       return -1;
6229   }
6230   {
6231     char device[] = "/dev/sda";
6232     device[5] = devchar;
6233     char lines_0[] = ",";
6234     char *lines[] = {
6235       lines_0,
6236       NULL
6237     };
6238     int r;
6239     suppress_error = 0;
6240     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6241     if (r == -1)
6242       return -1;
6243   }
6244   {
6245     char fstype[] = "ext2";
6246     char device[] = "/dev/sda1";
6247     device[5] = devchar;
6248     int r;
6249     suppress_error = 0;
6250     r = guestfs_mkfs (g, fstype, device);
6251     if (r == -1)
6252       return -1;
6253   }
6254   {
6255     char device[] = "/dev/sda1";
6256     device[5] = devchar;
6257     char mountpoint[] = "/";
6258     int r;
6259     suppress_error = 0;
6260     r = guestfs_mount (g, device, mountpoint);
6261     if (r == -1)
6262       return -1;
6263   }
6264   /* TestOutputList for command_lines (7) */
6265   {
6266     char remotefilename[] = "/test-command";
6267     int r;
6268     suppress_error = 0;
6269     r = guestfs_upload (g, "test-command", remotefilename);
6270     if (r == -1)
6271       return -1;
6272   }
6273   {
6274     char path[] = "/test-command";
6275     int r;
6276     suppress_error = 0;
6277     r = guestfs_chmod (g, 493, path);
6278     if (r == -1)
6279       return -1;
6280   }
6281   {
6282     char arguments_0[] = "/test-command";
6283     char arguments_1[] = "8";
6284     char *arguments[] = {
6285       arguments_0,
6286       arguments_1,
6287       NULL
6288     };
6289     char **r;
6290     int i;
6291     suppress_error = 0;
6292     r = guestfs_command_lines (g, arguments);
6293     if (r == NULL)
6294       return -1;
6295     if (!r[0]) {
6296       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6297       print_strings (r);
6298       return -1;
6299     }
6300     {
6301       char expected[] = "";
6302       if (strcmp (r[0], expected) != 0) {
6303         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6304         return -1;
6305       }
6306     }
6307     if (r[1] != NULL) {
6308       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6309       print_strings (r);
6310       return -1;
6311     }
6312     for (i = 0; r[i] != NULL; ++i)
6313       free (r[i]);
6314     free (r);
6315   }
6316   } else
6317     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6318   return 0;
6319 }
6320
6321 static int test_command_lines_8_prereq (void)
6322 {
6323   const char *str = getenv ("SKIP_TEST_COMMAND");
6324   return str && strcmp (str, "1") == 0;
6325 }
6326
6327 static int test_command_lines_8 (void)
6328 {
6329   if (! test_command_lines_8_prereq ()) {
6330   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
6331   {
6332     char device[] = "/dev/sda";
6333     device[5] = devchar;
6334     int r;
6335     suppress_error = 0;
6336     r = guestfs_blockdev_setrw (g, device);
6337     if (r == -1)
6338       return -1;
6339   }
6340   {
6341     int r;
6342     suppress_error = 0;
6343     r = guestfs_umount_all (g);
6344     if (r == -1)
6345       return -1;
6346   }
6347   {
6348     int r;
6349     suppress_error = 0;
6350     r = guestfs_lvm_remove_all (g);
6351     if (r == -1)
6352       return -1;
6353   }
6354   {
6355     char device[] = "/dev/sda";
6356     device[5] = devchar;
6357     char lines_0[] = ",";
6358     char *lines[] = {
6359       lines_0,
6360       NULL
6361     };
6362     int r;
6363     suppress_error = 0;
6364     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6365     if (r == -1)
6366       return -1;
6367   }
6368   {
6369     char fstype[] = "ext2";
6370     char device[] = "/dev/sda1";
6371     device[5] = devchar;
6372     int r;
6373     suppress_error = 0;
6374     r = guestfs_mkfs (g, fstype, device);
6375     if (r == -1)
6376       return -1;
6377   }
6378   {
6379     char device[] = "/dev/sda1";
6380     device[5] = devchar;
6381     char mountpoint[] = "/";
6382     int r;
6383     suppress_error = 0;
6384     r = guestfs_mount (g, device, mountpoint);
6385     if (r == -1)
6386       return -1;
6387   }
6388   /* TestOutputList for command_lines (8) */
6389   {
6390     char remotefilename[] = "/test-command";
6391     int r;
6392     suppress_error = 0;
6393     r = guestfs_upload (g, "test-command", remotefilename);
6394     if (r == -1)
6395       return -1;
6396   }
6397   {
6398     char path[] = "/test-command";
6399     int r;
6400     suppress_error = 0;
6401     r = guestfs_chmod (g, 493, path);
6402     if (r == -1)
6403       return -1;
6404   }
6405   {
6406     char arguments_0[] = "/test-command";
6407     char arguments_1[] = "9";
6408     char *arguments[] = {
6409       arguments_0,
6410       arguments_1,
6411       NULL
6412     };
6413     char **r;
6414     int i;
6415     suppress_error = 0;
6416     r = guestfs_command_lines (g, arguments);
6417     if (r == NULL)
6418       return -1;
6419     if (!r[0]) {
6420       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6421       print_strings (r);
6422       return -1;
6423     }
6424     {
6425       char expected[] = "";
6426       if (strcmp (r[0], expected) != 0) {
6427         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6428         return -1;
6429       }
6430     }
6431     if (!r[1]) {
6432       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6433       print_strings (r);
6434       return -1;
6435     }
6436     {
6437       char expected[] = "";
6438       if (strcmp (r[1], expected) != 0) {
6439         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6440         return -1;
6441       }
6442     }
6443     if (r[2] != NULL) {
6444       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6445       print_strings (r);
6446       return -1;
6447     }
6448     for (i = 0; r[i] != NULL; ++i)
6449       free (r[i]);
6450     free (r);
6451   }
6452   } else
6453     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6454   return 0;
6455 }
6456
6457 static int test_command_lines_9_prereq (void)
6458 {
6459   const char *str = getenv ("SKIP_TEST_COMMAND");
6460   return str && strcmp (str, "1") == 0;
6461 }
6462
6463 static int test_command_lines_9 (void)
6464 {
6465   if (! test_command_lines_9_prereq ()) {
6466   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
6467   {
6468     char device[] = "/dev/sda";
6469     device[5] = devchar;
6470     int r;
6471     suppress_error = 0;
6472     r = guestfs_blockdev_setrw (g, device);
6473     if (r == -1)
6474       return -1;
6475   }
6476   {
6477     int r;
6478     suppress_error = 0;
6479     r = guestfs_umount_all (g);
6480     if (r == -1)
6481       return -1;
6482   }
6483   {
6484     int r;
6485     suppress_error = 0;
6486     r = guestfs_lvm_remove_all (g);
6487     if (r == -1)
6488       return -1;
6489   }
6490   {
6491     char device[] = "/dev/sda";
6492     device[5] = devchar;
6493     char lines_0[] = ",";
6494     char *lines[] = {
6495       lines_0,
6496       NULL
6497     };
6498     int r;
6499     suppress_error = 0;
6500     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6501     if (r == -1)
6502       return -1;
6503   }
6504   {
6505     char fstype[] = "ext2";
6506     char device[] = "/dev/sda1";
6507     device[5] = devchar;
6508     int r;
6509     suppress_error = 0;
6510     r = guestfs_mkfs (g, fstype, device);
6511     if (r == -1)
6512       return -1;
6513   }
6514   {
6515     char device[] = "/dev/sda1";
6516     device[5] = devchar;
6517     char mountpoint[] = "/";
6518     int r;
6519     suppress_error = 0;
6520     r = guestfs_mount (g, device, mountpoint);
6521     if (r == -1)
6522       return -1;
6523   }
6524   /* TestOutputList for command_lines (9) */
6525   {
6526     char remotefilename[] = "/test-command";
6527     int r;
6528     suppress_error = 0;
6529     r = guestfs_upload (g, "test-command", remotefilename);
6530     if (r == -1)
6531       return -1;
6532   }
6533   {
6534     char path[] = "/test-command";
6535     int r;
6536     suppress_error = 0;
6537     r = guestfs_chmod (g, 493, path);
6538     if (r == -1)
6539       return -1;
6540   }
6541   {
6542     char arguments_0[] = "/test-command";
6543     char arguments_1[] = "10";
6544     char *arguments[] = {
6545       arguments_0,
6546       arguments_1,
6547       NULL
6548     };
6549     char **r;
6550     int i;
6551     suppress_error = 0;
6552     r = guestfs_command_lines (g, arguments);
6553     if (r == NULL)
6554       return -1;
6555     if (!r[0]) {
6556       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6557       print_strings (r);
6558       return -1;
6559     }
6560     {
6561       char expected[] = "Result10-1";
6562       if (strcmp (r[0], expected) != 0) {
6563         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6564         return -1;
6565       }
6566     }
6567     if (!r[1]) {
6568       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6569       print_strings (r);
6570       return -1;
6571     }
6572     {
6573       char expected[] = "Result10-2";
6574       if (strcmp (r[1], expected) != 0) {
6575         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6576         return -1;
6577       }
6578     }
6579     if (r[2] != NULL) {
6580       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6581       print_strings (r);
6582       return -1;
6583     }
6584     for (i = 0; r[i] != NULL; ++i)
6585       free (r[i]);
6586     free (r);
6587   }
6588   } else
6589     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
6590   return 0;
6591 }
6592
6593 static int test_command_lines_10_prereq (void)
6594 {
6595   const char *str = getenv ("SKIP_TEST_COMMAND");
6596   return str && strcmp (str, "1") == 0;
6597 }
6598
6599 static int test_command_lines_10 (void)
6600 {
6601   if (! test_command_lines_10_prereq ()) {
6602   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
6603   {
6604     char device[] = "/dev/sda";
6605     device[5] = devchar;
6606     int r;
6607     suppress_error = 0;
6608     r = guestfs_blockdev_setrw (g, device);
6609     if (r == -1)
6610       return -1;
6611   }
6612   {
6613     int r;
6614     suppress_error = 0;
6615     r = guestfs_umount_all (g);
6616     if (r == -1)
6617       return -1;
6618   }
6619   {
6620     int r;
6621     suppress_error = 0;
6622     r = guestfs_lvm_remove_all (g);
6623     if (r == -1)
6624       return -1;
6625   }
6626   {
6627     char device[] = "/dev/sda";
6628     device[5] = devchar;
6629     char lines_0[] = ",";
6630     char *lines[] = {
6631       lines_0,
6632       NULL
6633     };
6634     int r;
6635     suppress_error = 0;
6636     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6637     if (r == -1)
6638       return -1;
6639   }
6640   {
6641     char fstype[] = "ext2";
6642     char device[] = "/dev/sda1";
6643     device[5] = devchar;
6644     int r;
6645     suppress_error = 0;
6646     r = guestfs_mkfs (g, fstype, device);
6647     if (r == -1)
6648       return -1;
6649   }
6650   {
6651     char device[] = "/dev/sda1";
6652     device[5] = devchar;
6653     char mountpoint[] = "/";
6654     int r;
6655     suppress_error = 0;
6656     r = guestfs_mount (g, device, mountpoint);
6657     if (r == -1)
6658       return -1;
6659   }
6660   /* TestOutputList for command_lines (10) */
6661   {
6662     char remotefilename[] = "/test-command";
6663     int r;
6664     suppress_error = 0;
6665     r = guestfs_upload (g, "test-command", remotefilename);
6666     if (r == -1)
6667       return -1;
6668   }
6669   {
6670     char path[] = "/test-command";
6671     int r;
6672     suppress_error = 0;
6673     r = guestfs_chmod (g, 493, path);
6674     if (r == -1)
6675       return -1;
6676   }
6677   {
6678     char arguments_0[] = "/test-command";
6679     char arguments_1[] = "11";
6680     char *arguments[] = {
6681       arguments_0,
6682       arguments_1,
6683       NULL
6684     };
6685     char **r;
6686     int i;
6687     suppress_error = 0;
6688     r = guestfs_command_lines (g, arguments);
6689     if (r == NULL)
6690       return -1;
6691     if (!r[0]) {
6692       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6693       print_strings (r);
6694       return -1;
6695     }
6696     {
6697       char expected[] = "Result11-1";
6698       if (strcmp (r[0], expected) != 0) {
6699         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6700         return -1;
6701       }
6702     }
6703     if (!r[1]) {
6704       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6705       print_strings (r);
6706       return -1;
6707     }
6708     {
6709       char expected[] = "Result11-2";
6710       if (strcmp (r[1], expected) != 0) {
6711         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6712         return -1;
6713       }
6714     }
6715     if (r[2] != NULL) {
6716       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
6717       print_strings (r);
6718       return -1;
6719     }
6720     for (i = 0; r[i] != NULL; ++i)
6721       free (r[i]);
6722     free (r);
6723   }
6724   } else
6725     printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
6726   return 0;
6727 }
6728
6729 static int test_command_0_prereq (void)
6730 {
6731   const char *str = getenv ("SKIP_TEST_COMMAND");
6732   return str && strcmp (str, "1") == 0;
6733 }
6734
6735 static int test_command_0 (void)
6736 {
6737   if (! test_command_0_prereq ()) {
6738   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
6739   {
6740     char device[] = "/dev/sda";
6741     device[5] = devchar;
6742     int r;
6743     suppress_error = 0;
6744     r = guestfs_blockdev_setrw (g, device);
6745     if (r == -1)
6746       return -1;
6747   }
6748   {
6749     int r;
6750     suppress_error = 0;
6751     r = guestfs_umount_all (g);
6752     if (r == -1)
6753       return -1;
6754   }
6755   {
6756     int r;
6757     suppress_error = 0;
6758     r = guestfs_lvm_remove_all (g);
6759     if (r == -1)
6760       return -1;
6761   }
6762   {
6763     char device[] = "/dev/sda";
6764     device[5] = devchar;
6765     char lines_0[] = ",";
6766     char *lines[] = {
6767       lines_0,
6768       NULL
6769     };
6770     int r;
6771     suppress_error = 0;
6772     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6773     if (r == -1)
6774       return -1;
6775   }
6776   {
6777     char fstype[] = "ext2";
6778     char device[] = "/dev/sda1";
6779     device[5] = devchar;
6780     int r;
6781     suppress_error = 0;
6782     r = guestfs_mkfs (g, fstype, device);
6783     if (r == -1)
6784       return -1;
6785   }
6786   {
6787     char device[] = "/dev/sda1";
6788     device[5] = devchar;
6789     char mountpoint[] = "/";
6790     int r;
6791     suppress_error = 0;
6792     r = guestfs_mount (g, device, mountpoint);
6793     if (r == -1)
6794       return -1;
6795   }
6796   /* TestOutput for command (0) */
6797   char expected[] = "Result1";
6798   {
6799     char remotefilename[] = "/test-command";
6800     int r;
6801     suppress_error = 0;
6802     r = guestfs_upload (g, "test-command", remotefilename);
6803     if (r == -1)
6804       return -1;
6805   }
6806   {
6807     char path[] = "/test-command";
6808     int r;
6809     suppress_error = 0;
6810     r = guestfs_chmod (g, 493, path);
6811     if (r == -1)
6812       return -1;
6813   }
6814   {
6815     char arguments_0[] = "/test-command";
6816     char arguments_1[] = "1";
6817     char *arguments[] = {
6818       arguments_0,
6819       arguments_1,
6820       NULL
6821     };
6822     char *r;
6823     suppress_error = 0;
6824     r = guestfs_command (g, arguments);
6825     if (r == NULL)
6826       return -1;
6827     if (strcmp (r, expected) != 0) {
6828       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
6829       return -1;
6830     }
6831     free (r);
6832   }
6833   } else
6834     printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
6835   return 0;
6836 }
6837
6838 static int test_command_1_prereq (void)
6839 {
6840   const char *str = getenv ("SKIP_TEST_COMMAND");
6841   return str && strcmp (str, "1") == 0;
6842 }
6843
6844 static int test_command_1 (void)
6845 {
6846   if (! test_command_1_prereq ()) {
6847   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
6848   {
6849     char device[] = "/dev/sda";
6850     device[5] = devchar;
6851     int r;
6852     suppress_error = 0;
6853     r = guestfs_blockdev_setrw (g, device);
6854     if (r == -1)
6855       return -1;
6856   }
6857   {
6858     int r;
6859     suppress_error = 0;
6860     r = guestfs_umount_all (g);
6861     if (r == -1)
6862       return -1;
6863   }
6864   {
6865     int r;
6866     suppress_error = 0;
6867     r = guestfs_lvm_remove_all (g);
6868     if (r == -1)
6869       return -1;
6870   }
6871   {
6872     char device[] = "/dev/sda";
6873     device[5] = devchar;
6874     char lines_0[] = ",";
6875     char *lines[] = {
6876       lines_0,
6877       NULL
6878     };
6879     int r;
6880     suppress_error = 0;
6881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6882     if (r == -1)
6883       return -1;
6884   }
6885   {
6886     char fstype[] = "ext2";
6887     char device[] = "/dev/sda1";
6888     device[5] = devchar;
6889     int r;
6890     suppress_error = 0;
6891     r = guestfs_mkfs (g, fstype, device);
6892     if (r == -1)
6893       return -1;
6894   }
6895   {
6896     char device[] = "/dev/sda1";
6897     device[5] = devchar;
6898     char mountpoint[] = "/";
6899     int r;
6900     suppress_error = 0;
6901     r = guestfs_mount (g, device, mountpoint);
6902     if (r == -1)
6903       return -1;
6904   }
6905   /* TestOutput for command (1) */
6906   char expected[] = "Result2\n";
6907   {
6908     char remotefilename[] = "/test-command";
6909     int r;
6910     suppress_error = 0;
6911     r = guestfs_upload (g, "test-command", remotefilename);
6912     if (r == -1)
6913       return -1;
6914   }
6915   {
6916     char path[] = "/test-command";
6917     int r;
6918     suppress_error = 0;
6919     r = guestfs_chmod (g, 493, path);
6920     if (r == -1)
6921       return -1;
6922   }
6923   {
6924     char arguments_0[] = "/test-command";
6925     char arguments_1[] = "2";
6926     char *arguments[] = {
6927       arguments_0,
6928       arguments_1,
6929       NULL
6930     };
6931     char *r;
6932     suppress_error = 0;
6933     r = guestfs_command (g, arguments);
6934     if (r == NULL)
6935       return -1;
6936     if (strcmp (r, expected) != 0) {
6937       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
6938       return -1;
6939     }
6940     free (r);
6941   }
6942   } else
6943     printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
6944   return 0;
6945 }
6946
6947 static int test_command_2_prereq (void)
6948 {
6949   const char *str = getenv ("SKIP_TEST_COMMAND");
6950   return str && strcmp (str, "1") == 0;
6951 }
6952
6953 static int test_command_2 (void)
6954 {
6955   if (! test_command_2_prereq ()) {
6956   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
6957   {
6958     char device[] = "/dev/sda";
6959     device[5] = devchar;
6960     int r;
6961     suppress_error = 0;
6962     r = guestfs_blockdev_setrw (g, device);
6963     if (r == -1)
6964       return -1;
6965   }
6966   {
6967     int r;
6968     suppress_error = 0;
6969     r = guestfs_umount_all (g);
6970     if (r == -1)
6971       return -1;
6972   }
6973   {
6974     int r;
6975     suppress_error = 0;
6976     r = guestfs_lvm_remove_all (g);
6977     if (r == -1)
6978       return -1;
6979   }
6980   {
6981     char device[] = "/dev/sda";
6982     device[5] = devchar;
6983     char lines_0[] = ",";
6984     char *lines[] = {
6985       lines_0,
6986       NULL
6987     };
6988     int r;
6989     suppress_error = 0;
6990     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6991     if (r == -1)
6992       return -1;
6993   }
6994   {
6995     char fstype[] = "ext2";
6996     char device[] = "/dev/sda1";
6997     device[5] = devchar;
6998     int r;
6999     suppress_error = 0;
7000     r = guestfs_mkfs (g, fstype, device);
7001     if (r == -1)
7002       return -1;
7003   }
7004   {
7005     char device[] = "/dev/sda1";
7006     device[5] = devchar;
7007     char mountpoint[] = "/";
7008     int r;
7009     suppress_error = 0;
7010     r = guestfs_mount (g, device, mountpoint);
7011     if (r == -1)
7012       return -1;
7013   }
7014   /* TestOutput for command (2) */
7015   char expected[] = "\nResult3";
7016   {
7017     char remotefilename[] = "/test-command";
7018     int r;
7019     suppress_error = 0;
7020     r = guestfs_upload (g, "test-command", remotefilename);
7021     if (r == -1)
7022       return -1;
7023   }
7024   {
7025     char path[] = "/test-command";
7026     int r;
7027     suppress_error = 0;
7028     r = guestfs_chmod (g, 493, path);
7029     if (r == -1)
7030       return -1;
7031   }
7032   {
7033     char arguments_0[] = "/test-command";
7034     char arguments_1[] = "3";
7035     char *arguments[] = {
7036       arguments_0,
7037       arguments_1,
7038       NULL
7039     };
7040     char *r;
7041     suppress_error = 0;
7042     r = guestfs_command (g, arguments);
7043     if (r == NULL)
7044       return -1;
7045     if (strcmp (r, expected) != 0) {
7046       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
7047       return -1;
7048     }
7049     free (r);
7050   }
7051   } else
7052     printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
7053   return 0;
7054 }
7055
7056 static int test_command_3_prereq (void)
7057 {
7058   const char *str = getenv ("SKIP_TEST_COMMAND");
7059   return str && strcmp (str, "1") == 0;
7060 }
7061
7062 static int test_command_3 (void)
7063 {
7064   if (! test_command_3_prereq ()) {
7065   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
7066   {
7067     char device[] = "/dev/sda";
7068     device[5] = devchar;
7069     int r;
7070     suppress_error = 0;
7071     r = guestfs_blockdev_setrw (g, device);
7072     if (r == -1)
7073       return -1;
7074   }
7075   {
7076     int r;
7077     suppress_error = 0;
7078     r = guestfs_umount_all (g);
7079     if (r == -1)
7080       return -1;
7081   }
7082   {
7083     int r;
7084     suppress_error = 0;
7085     r = guestfs_lvm_remove_all (g);
7086     if (r == -1)
7087       return -1;
7088   }
7089   {
7090     char device[] = "/dev/sda";
7091     device[5] = devchar;
7092     char lines_0[] = ",";
7093     char *lines[] = {
7094       lines_0,
7095       NULL
7096     };
7097     int r;
7098     suppress_error = 0;
7099     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7100     if (r == -1)
7101       return -1;
7102   }
7103   {
7104     char fstype[] = "ext2";
7105     char device[] = "/dev/sda1";
7106     device[5] = devchar;
7107     int r;
7108     suppress_error = 0;
7109     r = guestfs_mkfs (g, fstype, device);
7110     if (r == -1)
7111       return -1;
7112   }
7113   {
7114     char device[] = "/dev/sda1";
7115     device[5] = devchar;
7116     char mountpoint[] = "/";
7117     int r;
7118     suppress_error = 0;
7119     r = guestfs_mount (g, device, mountpoint);
7120     if (r == -1)
7121       return -1;
7122   }
7123   /* TestOutput for command (3) */
7124   char expected[] = "\nResult4\n";
7125   {
7126     char remotefilename[] = "/test-command";
7127     int r;
7128     suppress_error = 0;
7129     r = guestfs_upload (g, "test-command", remotefilename);
7130     if (r == -1)
7131       return -1;
7132   }
7133   {
7134     char path[] = "/test-command";
7135     int r;
7136     suppress_error = 0;
7137     r = guestfs_chmod (g, 493, path);
7138     if (r == -1)
7139       return -1;
7140   }
7141   {
7142     char arguments_0[] = "/test-command";
7143     char arguments_1[] = "4";
7144     char *arguments[] = {
7145       arguments_0,
7146       arguments_1,
7147       NULL
7148     };
7149     char *r;
7150     suppress_error = 0;
7151     r = guestfs_command (g, arguments);
7152     if (r == NULL)
7153       return -1;
7154     if (strcmp (r, expected) != 0) {
7155       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
7156       return -1;
7157     }
7158     free (r);
7159   }
7160   } else
7161     printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
7162   return 0;
7163 }
7164
7165 static int test_command_4_prereq (void)
7166 {
7167   const char *str = getenv ("SKIP_TEST_COMMAND");
7168   return str && strcmp (str, "1") == 0;
7169 }
7170
7171 static int test_command_4 (void)
7172 {
7173   if (! test_command_4_prereq ()) {
7174   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
7175   {
7176     char device[] = "/dev/sda";
7177     device[5] = devchar;
7178     int r;
7179     suppress_error = 0;
7180     r = guestfs_blockdev_setrw (g, device);
7181     if (r == -1)
7182       return -1;
7183   }
7184   {
7185     int r;
7186     suppress_error = 0;
7187     r = guestfs_umount_all (g);
7188     if (r == -1)
7189       return -1;
7190   }
7191   {
7192     int r;
7193     suppress_error = 0;
7194     r = guestfs_lvm_remove_all (g);
7195     if (r == -1)
7196       return -1;
7197   }
7198   {
7199     char device[] = "/dev/sda";
7200     device[5] = devchar;
7201     char lines_0[] = ",";
7202     char *lines[] = {
7203       lines_0,
7204       NULL
7205     };
7206     int r;
7207     suppress_error = 0;
7208     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7209     if (r == -1)
7210       return -1;
7211   }
7212   {
7213     char fstype[] = "ext2";
7214     char device[] = "/dev/sda1";
7215     device[5] = devchar;
7216     int r;
7217     suppress_error = 0;
7218     r = guestfs_mkfs (g, fstype, device);
7219     if (r == -1)
7220       return -1;
7221   }
7222   {
7223     char device[] = "/dev/sda1";
7224     device[5] = devchar;
7225     char mountpoint[] = "/";
7226     int r;
7227     suppress_error = 0;
7228     r = guestfs_mount (g, device, mountpoint);
7229     if (r == -1)
7230       return -1;
7231   }
7232   /* TestOutput for command (4) */
7233   char expected[] = "\nResult5\n\n";
7234   {
7235     char remotefilename[] = "/test-command";
7236     int r;
7237     suppress_error = 0;
7238     r = guestfs_upload (g, "test-command", remotefilename);
7239     if (r == -1)
7240       return -1;
7241   }
7242   {
7243     char path[] = "/test-command";
7244     int r;
7245     suppress_error = 0;
7246     r = guestfs_chmod (g, 493, path);
7247     if (r == -1)
7248       return -1;
7249   }
7250   {
7251     char arguments_0[] = "/test-command";
7252     char arguments_1[] = "5";
7253     char *arguments[] = {
7254       arguments_0,
7255       arguments_1,
7256       NULL
7257     };
7258     char *r;
7259     suppress_error = 0;
7260     r = guestfs_command (g, arguments);
7261     if (r == NULL)
7262       return -1;
7263     if (strcmp (r, expected) != 0) {
7264       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7265       return -1;
7266     }
7267     free (r);
7268   }
7269   } else
7270     printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7271   return 0;
7272 }
7273
7274 static int test_command_5_prereq (void)
7275 {
7276   const char *str = getenv ("SKIP_TEST_COMMAND");
7277   return str && strcmp (str, "1") == 0;
7278 }
7279
7280 static int test_command_5 (void)
7281 {
7282   if (! test_command_5_prereq ()) {
7283   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
7284   {
7285     char device[] = "/dev/sda";
7286     device[5] = devchar;
7287     int r;
7288     suppress_error = 0;
7289     r = guestfs_blockdev_setrw (g, device);
7290     if (r == -1)
7291       return -1;
7292   }
7293   {
7294     int r;
7295     suppress_error = 0;
7296     r = guestfs_umount_all (g);
7297     if (r == -1)
7298       return -1;
7299   }
7300   {
7301     int r;
7302     suppress_error = 0;
7303     r = guestfs_lvm_remove_all (g);
7304     if (r == -1)
7305       return -1;
7306   }
7307   {
7308     char device[] = "/dev/sda";
7309     device[5] = devchar;
7310     char lines_0[] = ",";
7311     char *lines[] = {
7312       lines_0,
7313       NULL
7314     };
7315     int r;
7316     suppress_error = 0;
7317     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7318     if (r == -1)
7319       return -1;
7320   }
7321   {
7322     char fstype[] = "ext2";
7323     char device[] = "/dev/sda1";
7324     device[5] = devchar;
7325     int r;
7326     suppress_error = 0;
7327     r = guestfs_mkfs (g, fstype, device);
7328     if (r == -1)
7329       return -1;
7330   }
7331   {
7332     char device[] = "/dev/sda1";
7333     device[5] = devchar;
7334     char mountpoint[] = "/";
7335     int r;
7336     suppress_error = 0;
7337     r = guestfs_mount (g, device, mountpoint);
7338     if (r == -1)
7339       return -1;
7340   }
7341   /* TestOutput for command (5) */
7342   char expected[] = "\n\nResult6\n\n";
7343   {
7344     char remotefilename[] = "/test-command";
7345     int r;
7346     suppress_error = 0;
7347     r = guestfs_upload (g, "test-command", remotefilename);
7348     if (r == -1)
7349       return -1;
7350   }
7351   {
7352     char path[] = "/test-command";
7353     int r;
7354     suppress_error = 0;
7355     r = guestfs_chmod (g, 493, path);
7356     if (r == -1)
7357       return -1;
7358   }
7359   {
7360     char arguments_0[] = "/test-command";
7361     char arguments_1[] = "6";
7362     char *arguments[] = {
7363       arguments_0,
7364       arguments_1,
7365       NULL
7366     };
7367     char *r;
7368     suppress_error = 0;
7369     r = guestfs_command (g, arguments);
7370     if (r == NULL)
7371       return -1;
7372     if (strcmp (r, expected) != 0) {
7373       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7374       return -1;
7375     }
7376     free (r);
7377   }
7378   } else
7379     printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7380   return 0;
7381 }
7382
7383 static int test_command_6_prereq (void)
7384 {
7385   const char *str = getenv ("SKIP_TEST_COMMAND");
7386   return str && strcmp (str, "1") == 0;
7387 }
7388
7389 static int test_command_6 (void)
7390 {
7391   if (! test_command_6_prereq ()) {
7392   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
7393   {
7394     char device[] = "/dev/sda";
7395     device[5] = devchar;
7396     int r;
7397     suppress_error = 0;
7398     r = guestfs_blockdev_setrw (g, device);
7399     if (r == -1)
7400       return -1;
7401   }
7402   {
7403     int r;
7404     suppress_error = 0;
7405     r = guestfs_umount_all (g);
7406     if (r == -1)
7407       return -1;
7408   }
7409   {
7410     int r;
7411     suppress_error = 0;
7412     r = guestfs_lvm_remove_all (g);
7413     if (r == -1)
7414       return -1;
7415   }
7416   {
7417     char device[] = "/dev/sda";
7418     device[5] = devchar;
7419     char lines_0[] = ",";
7420     char *lines[] = {
7421       lines_0,
7422       NULL
7423     };
7424     int r;
7425     suppress_error = 0;
7426     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7427     if (r == -1)
7428       return -1;
7429   }
7430   {
7431     char fstype[] = "ext2";
7432     char device[] = "/dev/sda1";
7433     device[5] = devchar;
7434     int r;
7435     suppress_error = 0;
7436     r = guestfs_mkfs (g, fstype, device);
7437     if (r == -1)
7438       return -1;
7439   }
7440   {
7441     char device[] = "/dev/sda1";
7442     device[5] = devchar;
7443     char mountpoint[] = "/";
7444     int r;
7445     suppress_error = 0;
7446     r = guestfs_mount (g, device, mountpoint);
7447     if (r == -1)
7448       return -1;
7449   }
7450   /* TestOutput for command (6) */
7451   char expected[] = "";
7452   {
7453     char remotefilename[] = "/test-command";
7454     int r;
7455     suppress_error = 0;
7456     r = guestfs_upload (g, "test-command", remotefilename);
7457     if (r == -1)
7458       return -1;
7459   }
7460   {
7461     char path[] = "/test-command";
7462     int r;
7463     suppress_error = 0;
7464     r = guestfs_chmod (g, 493, path);
7465     if (r == -1)
7466       return -1;
7467   }
7468   {
7469     char arguments_0[] = "/test-command";
7470     char arguments_1[] = "7";
7471     char *arguments[] = {
7472       arguments_0,
7473       arguments_1,
7474       NULL
7475     };
7476     char *r;
7477     suppress_error = 0;
7478     r = guestfs_command (g, arguments);
7479     if (r == NULL)
7480       return -1;
7481     if (strcmp (r, expected) != 0) {
7482       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7483       return -1;
7484     }
7485     free (r);
7486   }
7487   } else
7488     printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7489   return 0;
7490 }
7491
7492 static int test_command_7_prereq (void)
7493 {
7494   const char *str = getenv ("SKIP_TEST_COMMAND");
7495   return str && strcmp (str, "1") == 0;
7496 }
7497
7498 static int test_command_7 (void)
7499 {
7500   if (! test_command_7_prereq ()) {
7501   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
7502   {
7503     char device[] = "/dev/sda";
7504     device[5] = devchar;
7505     int r;
7506     suppress_error = 0;
7507     r = guestfs_blockdev_setrw (g, device);
7508     if (r == -1)
7509       return -1;
7510   }
7511   {
7512     int r;
7513     suppress_error = 0;
7514     r = guestfs_umount_all (g);
7515     if (r == -1)
7516       return -1;
7517   }
7518   {
7519     int r;
7520     suppress_error = 0;
7521     r = guestfs_lvm_remove_all (g);
7522     if (r == -1)
7523       return -1;
7524   }
7525   {
7526     char device[] = "/dev/sda";
7527     device[5] = devchar;
7528     char lines_0[] = ",";
7529     char *lines[] = {
7530       lines_0,
7531       NULL
7532     };
7533     int r;
7534     suppress_error = 0;
7535     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7536     if (r == -1)
7537       return -1;
7538   }
7539   {
7540     char fstype[] = "ext2";
7541     char device[] = "/dev/sda1";
7542     device[5] = devchar;
7543     int r;
7544     suppress_error = 0;
7545     r = guestfs_mkfs (g, fstype, device);
7546     if (r == -1)
7547       return -1;
7548   }
7549   {
7550     char device[] = "/dev/sda1";
7551     device[5] = devchar;
7552     char mountpoint[] = "/";
7553     int r;
7554     suppress_error = 0;
7555     r = guestfs_mount (g, device, mountpoint);
7556     if (r == -1)
7557       return -1;
7558   }
7559   /* TestOutput for command (7) */
7560   char expected[] = "\n";
7561   {
7562     char remotefilename[] = "/test-command";
7563     int r;
7564     suppress_error = 0;
7565     r = guestfs_upload (g, "test-command", remotefilename);
7566     if (r == -1)
7567       return -1;
7568   }
7569   {
7570     char path[] = "/test-command";
7571     int r;
7572     suppress_error = 0;
7573     r = guestfs_chmod (g, 493, path);
7574     if (r == -1)
7575       return -1;
7576   }
7577   {
7578     char arguments_0[] = "/test-command";
7579     char arguments_1[] = "8";
7580     char *arguments[] = {
7581       arguments_0,
7582       arguments_1,
7583       NULL
7584     };
7585     char *r;
7586     suppress_error = 0;
7587     r = guestfs_command (g, arguments);
7588     if (r == NULL)
7589       return -1;
7590     if (strcmp (r, expected) != 0) {
7591       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7592       return -1;
7593     }
7594     free (r);
7595   }
7596   } else
7597     printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
7598   return 0;
7599 }
7600
7601 static int test_command_8_prereq (void)
7602 {
7603   const char *str = getenv ("SKIP_TEST_COMMAND");
7604   return str && strcmp (str, "1") == 0;
7605 }
7606
7607 static int test_command_8 (void)
7608 {
7609   if (! test_command_8_prereq ()) {
7610   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
7611   {
7612     char device[] = "/dev/sda";
7613     device[5] = devchar;
7614     int r;
7615     suppress_error = 0;
7616     r = guestfs_blockdev_setrw (g, device);
7617     if (r == -1)
7618       return -1;
7619   }
7620   {
7621     int r;
7622     suppress_error = 0;
7623     r = guestfs_umount_all (g);
7624     if (r == -1)
7625       return -1;
7626   }
7627   {
7628     int r;
7629     suppress_error = 0;
7630     r = guestfs_lvm_remove_all (g);
7631     if (r == -1)
7632       return -1;
7633   }
7634   {
7635     char device[] = "/dev/sda";
7636     device[5] = devchar;
7637     char lines_0[] = ",";
7638     char *lines[] = {
7639       lines_0,
7640       NULL
7641     };
7642     int r;
7643     suppress_error = 0;
7644     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7645     if (r == -1)
7646       return -1;
7647   }
7648   {
7649     char fstype[] = "ext2";
7650     char device[] = "/dev/sda1";
7651     device[5] = devchar;
7652     int r;
7653     suppress_error = 0;
7654     r = guestfs_mkfs (g, fstype, device);
7655     if (r == -1)
7656       return -1;
7657   }
7658   {
7659     char device[] = "/dev/sda1";
7660     device[5] = devchar;
7661     char mountpoint[] = "/";
7662     int r;
7663     suppress_error = 0;
7664     r = guestfs_mount (g, device, mountpoint);
7665     if (r == -1)
7666       return -1;
7667   }
7668   /* TestOutput for command (8) */
7669   char expected[] = "\n\n";
7670   {
7671     char remotefilename[] = "/test-command";
7672     int r;
7673     suppress_error = 0;
7674     r = guestfs_upload (g, "test-command", remotefilename);
7675     if (r == -1)
7676       return -1;
7677   }
7678   {
7679     char path[] = "/test-command";
7680     int r;
7681     suppress_error = 0;
7682     r = guestfs_chmod (g, 493, path);
7683     if (r == -1)
7684       return -1;
7685   }
7686   {
7687     char arguments_0[] = "/test-command";
7688     char arguments_1[] = "9";
7689     char *arguments[] = {
7690       arguments_0,
7691       arguments_1,
7692       NULL
7693     };
7694     char *r;
7695     suppress_error = 0;
7696     r = guestfs_command (g, arguments);
7697     if (r == NULL)
7698       return -1;
7699     if (strcmp (r, expected) != 0) {
7700       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
7701       return -1;
7702     }
7703     free (r);
7704   }
7705   } else
7706     printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
7707   return 0;
7708 }
7709
7710 static int test_command_9_prereq (void)
7711 {
7712   const char *str = getenv ("SKIP_TEST_COMMAND");
7713   return str && strcmp (str, "1") == 0;
7714 }
7715
7716 static int test_command_9 (void)
7717 {
7718   if (! test_command_9_prereq ()) {
7719   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
7720   {
7721     char device[] = "/dev/sda";
7722     device[5] = devchar;
7723     int r;
7724     suppress_error = 0;
7725     r = guestfs_blockdev_setrw (g, device);
7726     if (r == -1)
7727       return -1;
7728   }
7729   {
7730     int r;
7731     suppress_error = 0;
7732     r = guestfs_umount_all (g);
7733     if (r == -1)
7734       return -1;
7735   }
7736   {
7737     int r;
7738     suppress_error = 0;
7739     r = guestfs_lvm_remove_all (g);
7740     if (r == -1)
7741       return -1;
7742   }
7743   {
7744     char device[] = "/dev/sda";
7745     device[5] = devchar;
7746     char lines_0[] = ",";
7747     char *lines[] = {
7748       lines_0,
7749       NULL
7750     };
7751     int r;
7752     suppress_error = 0;
7753     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7754     if (r == -1)
7755       return -1;
7756   }
7757   {
7758     char fstype[] = "ext2";
7759     char device[] = "/dev/sda1";
7760     device[5] = devchar;
7761     int r;
7762     suppress_error = 0;
7763     r = guestfs_mkfs (g, fstype, device);
7764     if (r == -1)
7765       return -1;
7766   }
7767   {
7768     char device[] = "/dev/sda1";
7769     device[5] = devchar;
7770     char mountpoint[] = "/";
7771     int r;
7772     suppress_error = 0;
7773     r = guestfs_mount (g, device, mountpoint);
7774     if (r == -1)
7775       return -1;
7776   }
7777   /* TestOutput for command (9) */
7778   char expected[] = "Result10-1\nResult10-2\n";
7779   {
7780     char remotefilename[] = "/test-command";
7781     int r;
7782     suppress_error = 0;
7783     r = guestfs_upload (g, "test-command", remotefilename);
7784     if (r == -1)
7785       return -1;
7786   }
7787   {
7788     char path[] = "/test-command";
7789     int r;
7790     suppress_error = 0;
7791     r = guestfs_chmod (g, 493, path);
7792     if (r == -1)
7793       return -1;
7794   }
7795   {
7796     char arguments_0[] = "/test-command";
7797     char arguments_1[] = "10";
7798     char *arguments[] = {
7799       arguments_0,
7800       arguments_1,
7801       NULL
7802     };
7803     char *r;
7804     suppress_error = 0;
7805     r = guestfs_command (g, arguments);
7806     if (r == NULL)
7807       return -1;
7808     if (strcmp (r, expected) != 0) {
7809       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
7810       return -1;
7811     }
7812     free (r);
7813   }
7814   } else
7815     printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
7816   return 0;
7817 }
7818
7819 static int test_command_10_prereq (void)
7820 {
7821   const char *str = getenv ("SKIP_TEST_COMMAND");
7822   return str && strcmp (str, "1") == 0;
7823 }
7824
7825 static int test_command_10 (void)
7826 {
7827   if (! test_command_10_prereq ()) {
7828   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
7829   {
7830     char device[] = "/dev/sda";
7831     device[5] = devchar;
7832     int r;
7833     suppress_error = 0;
7834     r = guestfs_blockdev_setrw (g, device);
7835     if (r == -1)
7836       return -1;
7837   }
7838   {
7839     int r;
7840     suppress_error = 0;
7841     r = guestfs_umount_all (g);
7842     if (r == -1)
7843       return -1;
7844   }
7845   {
7846     int r;
7847     suppress_error = 0;
7848     r = guestfs_lvm_remove_all (g);
7849     if (r == -1)
7850       return -1;
7851   }
7852   {
7853     char device[] = "/dev/sda";
7854     device[5] = devchar;
7855     char lines_0[] = ",";
7856     char *lines[] = {
7857       lines_0,
7858       NULL
7859     };
7860     int r;
7861     suppress_error = 0;
7862     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7863     if (r == -1)
7864       return -1;
7865   }
7866   {
7867     char fstype[] = "ext2";
7868     char device[] = "/dev/sda1";
7869     device[5] = devchar;
7870     int r;
7871     suppress_error = 0;
7872     r = guestfs_mkfs (g, fstype, device);
7873     if (r == -1)
7874       return -1;
7875   }
7876   {
7877     char device[] = "/dev/sda1";
7878     device[5] = devchar;
7879     char mountpoint[] = "/";
7880     int r;
7881     suppress_error = 0;
7882     r = guestfs_mount (g, device, mountpoint);
7883     if (r == -1)
7884       return -1;
7885   }
7886   /* TestOutput for command (10) */
7887   char expected[] = "Result11-1\nResult11-2";
7888   {
7889     char remotefilename[] = "/test-command";
7890     int r;
7891     suppress_error = 0;
7892     r = guestfs_upload (g, "test-command", remotefilename);
7893     if (r == -1)
7894       return -1;
7895   }
7896   {
7897     char path[] = "/test-command";
7898     int r;
7899     suppress_error = 0;
7900     r = guestfs_chmod (g, 493, path);
7901     if (r == -1)
7902       return -1;
7903   }
7904   {
7905     char arguments_0[] = "/test-command";
7906     char arguments_1[] = "11";
7907     char *arguments[] = {
7908       arguments_0,
7909       arguments_1,
7910       NULL
7911     };
7912     char *r;
7913     suppress_error = 0;
7914     r = guestfs_command (g, arguments);
7915     if (r == NULL)
7916       return -1;
7917     if (strcmp (r, expected) != 0) {
7918       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
7919       return -1;
7920     }
7921     free (r);
7922   }
7923   } else
7924     printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
7925   return 0;
7926 }
7927
7928 static int test_command_11_prereq (void)
7929 {
7930   const char *str = getenv ("SKIP_TEST_COMMAND");
7931   return str && strcmp (str, "1") == 0;
7932 }
7933
7934 static int test_command_11 (void)
7935 {
7936   if (! test_command_11_prereq ()) {
7937   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
7938   {
7939     char device[] = "/dev/sda";
7940     device[5] = devchar;
7941     int r;
7942     suppress_error = 0;
7943     r = guestfs_blockdev_setrw (g, device);
7944     if (r == -1)
7945       return -1;
7946   }
7947   {
7948     int r;
7949     suppress_error = 0;
7950     r = guestfs_umount_all (g);
7951     if (r == -1)
7952       return -1;
7953   }
7954   {
7955     int r;
7956     suppress_error = 0;
7957     r = guestfs_lvm_remove_all (g);
7958     if (r == -1)
7959       return -1;
7960   }
7961   {
7962     char device[] = "/dev/sda";
7963     device[5] = devchar;
7964     char lines_0[] = ",";
7965     char *lines[] = {
7966       lines_0,
7967       NULL
7968     };
7969     int r;
7970     suppress_error = 0;
7971     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7972     if (r == -1)
7973       return -1;
7974   }
7975   {
7976     char fstype[] = "ext2";
7977     char device[] = "/dev/sda1";
7978     device[5] = devchar;
7979     int r;
7980     suppress_error = 0;
7981     r = guestfs_mkfs (g, fstype, device);
7982     if (r == -1)
7983       return -1;
7984   }
7985   {
7986     char device[] = "/dev/sda1";
7987     device[5] = devchar;
7988     char mountpoint[] = "/";
7989     int r;
7990     suppress_error = 0;
7991     r = guestfs_mount (g, device, mountpoint);
7992     if (r == -1)
7993       return -1;
7994   }
7995   /* TestLastFail for command (11) */
7996   {
7997     char remotefilename[] = "/test-command";
7998     int r;
7999     suppress_error = 0;
8000     r = guestfs_upload (g, "test-command", remotefilename);
8001     if (r == -1)
8002       return -1;
8003   }
8004   {
8005     char path[] = "/test-command";
8006     int r;
8007     suppress_error = 0;
8008     r = guestfs_chmod (g, 493, path);
8009     if (r == -1)
8010       return -1;
8011   }
8012   {
8013     char arguments_0[] = "/test-command";
8014     char *arguments[] = {
8015       arguments_0,
8016       NULL
8017     };
8018     char *r;
8019     suppress_error = 1;
8020     r = guestfs_command (g, arguments);
8021     if (r != NULL)
8022       return -1;
8023     free (r);
8024   }
8025   } else
8026     printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
8027   return 0;
8028 }
8029
8030 static int test_file_0 (void)
8031 {
8032   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
8033   {
8034     char device[] = "/dev/sda";
8035     device[5] = devchar;
8036     int r;
8037     suppress_error = 0;
8038     r = guestfs_blockdev_setrw (g, device);
8039     if (r == -1)
8040       return -1;
8041   }
8042   {
8043     int r;
8044     suppress_error = 0;
8045     r = guestfs_umount_all (g);
8046     if (r == -1)
8047       return -1;
8048   }
8049   {
8050     int r;
8051     suppress_error = 0;
8052     r = guestfs_lvm_remove_all (g);
8053     if (r == -1)
8054       return -1;
8055   }
8056   {
8057     char device[] = "/dev/sda";
8058     device[5] = devchar;
8059     char lines_0[] = ",";
8060     char *lines[] = {
8061       lines_0,
8062       NULL
8063     };
8064     int r;
8065     suppress_error = 0;
8066     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8067     if (r == -1)
8068       return -1;
8069   }
8070   {
8071     char fstype[] = "ext2";
8072     char device[] = "/dev/sda1";
8073     device[5] = devchar;
8074     int r;
8075     suppress_error = 0;
8076     r = guestfs_mkfs (g, fstype, device);
8077     if (r == -1)
8078       return -1;
8079   }
8080   {
8081     char device[] = "/dev/sda1";
8082     device[5] = devchar;
8083     char mountpoint[] = "/";
8084     int r;
8085     suppress_error = 0;
8086     r = guestfs_mount (g, device, mountpoint);
8087     if (r == -1)
8088       return -1;
8089   }
8090   /* TestOutput for file (0) */
8091   char expected[] = "empty";
8092   {
8093     char path[] = "/new";
8094     int r;
8095     suppress_error = 0;
8096     r = guestfs_touch (g, path);
8097     if (r == -1)
8098       return -1;
8099   }
8100   {
8101     char path[] = "/new";
8102     char *r;
8103     suppress_error = 0;
8104     r = guestfs_file (g, path);
8105     if (r == NULL)
8106       return -1;
8107     if (strcmp (r, expected) != 0) {
8108       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8109       return -1;
8110     }
8111     free (r);
8112   }
8113   return 0;
8114 }
8115
8116 static int test_file_1 (void)
8117 {
8118   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
8119   {
8120     char device[] = "/dev/sda";
8121     device[5] = devchar;
8122     int r;
8123     suppress_error = 0;
8124     r = guestfs_blockdev_setrw (g, device);
8125     if (r == -1)
8126       return -1;
8127   }
8128   {
8129     int r;
8130     suppress_error = 0;
8131     r = guestfs_umount_all (g);
8132     if (r == -1)
8133       return -1;
8134   }
8135   {
8136     int r;
8137     suppress_error = 0;
8138     r = guestfs_lvm_remove_all (g);
8139     if (r == -1)
8140       return -1;
8141   }
8142   {
8143     char device[] = "/dev/sda";
8144     device[5] = devchar;
8145     char lines_0[] = ",";
8146     char *lines[] = {
8147       lines_0,
8148       NULL
8149     };
8150     int r;
8151     suppress_error = 0;
8152     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8153     if (r == -1)
8154       return -1;
8155   }
8156   {
8157     char fstype[] = "ext2";
8158     char device[] = "/dev/sda1";
8159     device[5] = devchar;
8160     int r;
8161     suppress_error = 0;
8162     r = guestfs_mkfs (g, fstype, device);
8163     if (r == -1)
8164       return -1;
8165   }
8166   {
8167     char device[] = "/dev/sda1";
8168     device[5] = devchar;
8169     char mountpoint[] = "/";
8170     int r;
8171     suppress_error = 0;
8172     r = guestfs_mount (g, device, mountpoint);
8173     if (r == -1)
8174       return -1;
8175   }
8176   /* TestOutput for file (1) */
8177   char expected[] = "ASCII text";
8178   {
8179     char path[] = "/new";
8180     char content[] = "some content\n";
8181     int r;
8182     suppress_error = 0;
8183     r = guestfs_write_file (g, path, content, 0);
8184     if (r == -1)
8185       return -1;
8186   }
8187   {
8188     char path[] = "/new";
8189     char *r;
8190     suppress_error = 0;
8191     r = guestfs_file (g, path);
8192     if (r == NULL)
8193       return -1;
8194     if (strcmp (r, expected) != 0) {
8195       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8196       return -1;
8197     }
8198     free (r);
8199   }
8200   return 0;
8201 }
8202
8203 static int test_file_2 (void)
8204 {
8205   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
8206   {
8207     char device[] = "/dev/sda";
8208     device[5] = devchar;
8209     int r;
8210     suppress_error = 0;
8211     r = guestfs_blockdev_setrw (g, device);
8212     if (r == -1)
8213       return -1;
8214   }
8215   {
8216     int r;
8217     suppress_error = 0;
8218     r = guestfs_umount_all (g);
8219     if (r == -1)
8220       return -1;
8221   }
8222   {
8223     int r;
8224     suppress_error = 0;
8225     r = guestfs_lvm_remove_all (g);
8226     if (r == -1)
8227       return -1;
8228   }
8229   {
8230     char device[] = "/dev/sda";
8231     device[5] = devchar;
8232     char lines_0[] = ",";
8233     char *lines[] = {
8234       lines_0,
8235       NULL
8236     };
8237     int r;
8238     suppress_error = 0;
8239     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8240     if (r == -1)
8241       return -1;
8242   }
8243   {
8244     char fstype[] = "ext2";
8245     char device[] = "/dev/sda1";
8246     device[5] = devchar;
8247     int r;
8248     suppress_error = 0;
8249     r = guestfs_mkfs (g, fstype, device);
8250     if (r == -1)
8251       return -1;
8252   }
8253   {
8254     char device[] = "/dev/sda1";
8255     device[5] = devchar;
8256     char mountpoint[] = "/";
8257     int r;
8258     suppress_error = 0;
8259     r = guestfs_mount (g, device, mountpoint);
8260     if (r == -1)
8261       return -1;
8262   }
8263   /* TestLastFail for file (2) */
8264   {
8265     char path[] = "/nofile";
8266     char *r;
8267     suppress_error = 1;
8268     r = guestfs_file (g, path);
8269     if (r != NULL)
8270       return -1;
8271     free (r);
8272   }
8273   return 0;
8274 }
8275
8276 static int test_umount_all_0 (void)
8277 {
8278   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
8279   {
8280     char device[] = "/dev/sda";
8281     device[5] = devchar;
8282     int r;
8283     suppress_error = 0;
8284     r = guestfs_blockdev_setrw (g, device);
8285     if (r == -1)
8286       return -1;
8287   }
8288   {
8289     int r;
8290     suppress_error = 0;
8291     r = guestfs_umount_all (g);
8292     if (r == -1)
8293       return -1;
8294   }
8295   {
8296     int r;
8297     suppress_error = 0;
8298     r = guestfs_lvm_remove_all (g);
8299     if (r == -1)
8300       return -1;
8301   }
8302   {
8303     char device[] = "/dev/sda";
8304     device[5] = devchar;
8305     char lines_0[] = ",";
8306     char *lines[] = {
8307       lines_0,
8308       NULL
8309     };
8310     int r;
8311     suppress_error = 0;
8312     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8313     if (r == -1)
8314       return -1;
8315   }
8316   {
8317     char fstype[] = "ext2";
8318     char device[] = "/dev/sda1";
8319     device[5] = devchar;
8320     int r;
8321     suppress_error = 0;
8322     r = guestfs_mkfs (g, fstype, device);
8323     if (r == -1)
8324       return -1;
8325   }
8326   {
8327     char device[] = "/dev/sda1";
8328     device[5] = devchar;
8329     char mountpoint[] = "/";
8330     int r;
8331     suppress_error = 0;
8332     r = guestfs_mount (g, device, mountpoint);
8333     if (r == -1)
8334       return -1;
8335   }
8336   /* TestOutputList for umount_all (0) */
8337   {
8338     int r;
8339     suppress_error = 0;
8340     r = guestfs_umount_all (g);
8341     if (r == -1)
8342       return -1;
8343   }
8344   {
8345     char **r;
8346     int i;
8347     suppress_error = 0;
8348     r = guestfs_mounts (g);
8349     if (r == NULL)
8350       return -1;
8351     if (r[0] != NULL) {
8352       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8353       print_strings (r);
8354       return -1;
8355     }
8356     for (i = 0; r[i] != NULL; ++i)
8357       free (r[i]);
8358     free (r);
8359   }
8360   return 0;
8361 }
8362
8363 static int test_umount_all_1 (void)
8364 {
8365   /* InitNone|InitEmpty for test_umount_all_1 */
8366   {
8367     char device[] = "/dev/sda";
8368     device[5] = devchar;
8369     int r;
8370     suppress_error = 0;
8371     r = guestfs_blockdev_setrw (g, device);
8372     if (r == -1)
8373       return -1;
8374   }
8375   {
8376     int r;
8377     suppress_error = 0;
8378     r = guestfs_umount_all (g);
8379     if (r == -1)
8380       return -1;
8381   }
8382   {
8383     int r;
8384     suppress_error = 0;
8385     r = guestfs_lvm_remove_all (g);
8386     if (r == -1)
8387       return -1;
8388   }
8389   /* TestOutputList for umount_all (1) */
8390   {
8391     char device[] = "/dev/sda";
8392     device[5] = devchar;
8393     char lines_0[] = ",10";
8394     char lines_1[] = ",20";
8395     char lines_2[] = ",";
8396     char *lines[] = {
8397       lines_0,
8398       lines_1,
8399       lines_2,
8400       NULL
8401     };
8402     int r;
8403     suppress_error = 0;
8404     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8405     if (r == -1)
8406       return -1;
8407   }
8408   {
8409     char fstype[] = "ext2";
8410     char device[] = "/dev/sda1";
8411     device[5] = devchar;
8412     int r;
8413     suppress_error = 0;
8414     r = guestfs_mkfs (g, fstype, device);
8415     if (r == -1)
8416       return -1;
8417   }
8418   {
8419     char fstype[] = "ext2";
8420     char device[] = "/dev/sda2";
8421     device[5] = devchar;
8422     int r;
8423     suppress_error = 0;
8424     r = guestfs_mkfs (g, fstype, device);
8425     if (r == -1)
8426       return -1;
8427   }
8428   {
8429     char fstype[] = "ext2";
8430     char device[] = "/dev/sda3";
8431     device[5] = devchar;
8432     int r;
8433     suppress_error = 0;
8434     r = guestfs_mkfs (g, fstype, device);
8435     if (r == -1)
8436       return -1;
8437   }
8438   {
8439     char device[] = "/dev/sda1";
8440     device[5] = devchar;
8441     char mountpoint[] = "/";
8442     int r;
8443     suppress_error = 0;
8444     r = guestfs_mount (g, device, mountpoint);
8445     if (r == -1)
8446       return -1;
8447   }
8448   {
8449     char path[] = "/mp1";
8450     int r;
8451     suppress_error = 0;
8452     r = guestfs_mkdir (g, path);
8453     if (r == -1)
8454       return -1;
8455   }
8456   {
8457     char device[] = "/dev/sda2";
8458     device[5] = devchar;
8459     char mountpoint[] = "/mp1";
8460     int r;
8461     suppress_error = 0;
8462     r = guestfs_mount (g, device, mountpoint);
8463     if (r == -1)
8464       return -1;
8465   }
8466   {
8467     char path[] = "/mp1/mp2";
8468     int r;
8469     suppress_error = 0;
8470     r = guestfs_mkdir (g, path);
8471     if (r == -1)
8472       return -1;
8473   }
8474   {
8475     char device[] = "/dev/sda3";
8476     device[5] = devchar;
8477     char mountpoint[] = "/mp1/mp2";
8478     int r;
8479     suppress_error = 0;
8480     r = guestfs_mount (g, device, mountpoint);
8481     if (r == -1)
8482       return -1;
8483   }
8484   {
8485     char path[] = "/mp1/mp2/mp3";
8486     int r;
8487     suppress_error = 0;
8488     r = guestfs_mkdir (g, path);
8489     if (r == -1)
8490       return -1;
8491   }
8492   {
8493     int r;
8494     suppress_error = 0;
8495     r = guestfs_umount_all (g);
8496     if (r == -1)
8497       return -1;
8498   }
8499   {
8500     char **r;
8501     int i;
8502     suppress_error = 0;
8503     r = guestfs_mounts (g);
8504     if (r == NULL)
8505       return -1;
8506     if (r[0] != NULL) {
8507       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8508       print_strings (r);
8509       return -1;
8510     }
8511     for (i = 0; r[i] != NULL; ++i)
8512       free (r[i]);
8513     free (r);
8514   }
8515   return 0;
8516 }
8517
8518 static int test_mounts_0 (void)
8519 {
8520   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
8521   {
8522     char device[] = "/dev/sda";
8523     device[5] = devchar;
8524     int r;
8525     suppress_error = 0;
8526     r = guestfs_blockdev_setrw (g, device);
8527     if (r == -1)
8528       return -1;
8529   }
8530   {
8531     int r;
8532     suppress_error = 0;
8533     r = guestfs_umount_all (g);
8534     if (r == -1)
8535       return -1;
8536   }
8537   {
8538     int r;
8539     suppress_error = 0;
8540     r = guestfs_lvm_remove_all (g);
8541     if (r == -1)
8542       return -1;
8543   }
8544   {
8545     char device[] = "/dev/sda";
8546     device[5] = devchar;
8547     char lines_0[] = ",";
8548     char *lines[] = {
8549       lines_0,
8550       NULL
8551     };
8552     int r;
8553     suppress_error = 0;
8554     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8555     if (r == -1)
8556       return -1;
8557   }
8558   {
8559     char fstype[] = "ext2";
8560     char device[] = "/dev/sda1";
8561     device[5] = devchar;
8562     int r;
8563     suppress_error = 0;
8564     r = guestfs_mkfs (g, fstype, device);
8565     if (r == -1)
8566       return -1;
8567   }
8568   {
8569     char device[] = "/dev/sda1";
8570     device[5] = devchar;
8571     char mountpoint[] = "/";
8572     int r;
8573     suppress_error = 0;
8574     r = guestfs_mount (g, device, mountpoint);
8575     if (r == -1)
8576       return -1;
8577   }
8578   /* TestOutputList for mounts (0) */
8579   {
8580     char **r;
8581     int i;
8582     suppress_error = 0;
8583     r = guestfs_mounts (g);
8584     if (r == NULL)
8585       return -1;
8586     if (!r[0]) {
8587       fprintf (stderr, "test_mounts_0: short list returned from command\n");
8588       print_strings (r);
8589       return -1;
8590     }
8591     {
8592       char expected[] = "/dev/sda1";
8593       expected[5] = devchar;
8594       if (strcmp (r[0], expected) != 0) {
8595         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8596         return -1;
8597       }
8598     }
8599     if (r[1] != NULL) {
8600       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8601       print_strings (r);
8602       return -1;
8603     }
8604     for (i = 0; r[i] != NULL; ++i)
8605       free (r[i]);
8606     free (r);
8607   }
8608   return 0;
8609 }
8610
8611 static int test_umount_0 (void)
8612 {
8613   /* InitNone|InitEmpty for test_umount_0 */
8614   {
8615     char device[] = "/dev/sda";
8616     device[5] = devchar;
8617     int r;
8618     suppress_error = 0;
8619     r = guestfs_blockdev_setrw (g, device);
8620     if (r == -1)
8621       return -1;
8622   }
8623   {
8624     int r;
8625     suppress_error = 0;
8626     r = guestfs_umount_all (g);
8627     if (r == -1)
8628       return -1;
8629   }
8630   {
8631     int r;
8632     suppress_error = 0;
8633     r = guestfs_lvm_remove_all (g);
8634     if (r == -1)
8635       return -1;
8636   }
8637   /* TestOutputList for umount (0) */
8638   {
8639     char device[] = "/dev/sda";
8640     device[5] = devchar;
8641     char lines_0[] = ",";
8642     char *lines[] = {
8643       lines_0,
8644       NULL
8645     };
8646     int r;
8647     suppress_error = 0;
8648     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8649     if (r == -1)
8650       return -1;
8651   }
8652   {
8653     char fstype[] = "ext2";
8654     char device[] = "/dev/sda1";
8655     device[5] = devchar;
8656     int r;
8657     suppress_error = 0;
8658     r = guestfs_mkfs (g, fstype, device);
8659     if (r == -1)
8660       return -1;
8661   }
8662   {
8663     char device[] = "/dev/sda1";
8664     device[5] = devchar;
8665     char mountpoint[] = "/";
8666     int r;
8667     suppress_error = 0;
8668     r = guestfs_mount (g, device, mountpoint);
8669     if (r == -1)
8670       return -1;
8671   }
8672   {
8673     char **r;
8674     int i;
8675     suppress_error = 0;
8676     r = guestfs_mounts (g);
8677     if (r == NULL)
8678       return -1;
8679     if (!r[0]) {
8680       fprintf (stderr, "test_umount_0: short list returned from command\n");
8681       print_strings (r);
8682       return -1;
8683     }
8684     {
8685       char expected[] = "/dev/sda1";
8686       expected[5] = devchar;
8687       if (strcmp (r[0], expected) != 0) {
8688         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8689         return -1;
8690       }
8691     }
8692     if (r[1] != NULL) {
8693       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
8694       print_strings (r);
8695       return -1;
8696     }
8697     for (i = 0; r[i] != NULL; ++i)
8698       free (r[i]);
8699     free (r);
8700   }
8701   return 0;
8702 }
8703
8704 static int test_umount_1 (void)
8705 {
8706   /* InitNone|InitEmpty for test_umount_1 */
8707   {
8708     char device[] = "/dev/sda";
8709     device[5] = devchar;
8710     int r;
8711     suppress_error = 0;
8712     r = guestfs_blockdev_setrw (g, device);
8713     if (r == -1)
8714       return -1;
8715   }
8716   {
8717     int r;
8718     suppress_error = 0;
8719     r = guestfs_umount_all (g);
8720     if (r == -1)
8721       return -1;
8722   }
8723   {
8724     int r;
8725     suppress_error = 0;
8726     r = guestfs_lvm_remove_all (g);
8727     if (r == -1)
8728       return -1;
8729   }
8730   /* TestOutputList for umount (1) */
8731   {
8732     char device[] = "/dev/sda";
8733     device[5] = devchar;
8734     char lines_0[] = ",";
8735     char *lines[] = {
8736       lines_0,
8737       NULL
8738     };
8739     int r;
8740     suppress_error = 0;
8741     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8742     if (r == -1)
8743       return -1;
8744   }
8745   {
8746     char fstype[] = "ext2";
8747     char device[] = "/dev/sda1";
8748     device[5] = devchar;
8749     int r;
8750     suppress_error = 0;
8751     r = guestfs_mkfs (g, fstype, device);
8752     if (r == -1)
8753       return -1;
8754   }
8755   {
8756     char device[] = "/dev/sda1";
8757     device[5] = devchar;
8758     char mountpoint[] = "/";
8759     int r;
8760     suppress_error = 0;
8761     r = guestfs_mount (g, device, mountpoint);
8762     if (r == -1)
8763       return -1;
8764   }
8765   {
8766     char pathordevice[] = "/";
8767     int r;
8768     suppress_error = 0;
8769     r = guestfs_umount (g, pathordevice);
8770     if (r == -1)
8771       return -1;
8772   }
8773   {
8774     char **r;
8775     int i;
8776     suppress_error = 0;
8777     r = guestfs_mounts (g);
8778     if (r == NULL)
8779       return -1;
8780     if (r[0] != NULL) {
8781       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
8782       print_strings (r);
8783       return -1;
8784     }
8785     for (i = 0; r[i] != NULL; ++i)
8786       free (r[i]);
8787     free (r);
8788   }
8789   return 0;
8790 }
8791
8792 static int test_write_file_0 (void)
8793 {
8794   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
8795   {
8796     char device[] = "/dev/sda";
8797     device[5] = devchar;
8798     int r;
8799     suppress_error = 0;
8800     r = guestfs_blockdev_setrw (g, device);
8801     if (r == -1)
8802       return -1;
8803   }
8804   {
8805     int r;
8806     suppress_error = 0;
8807     r = guestfs_umount_all (g);
8808     if (r == -1)
8809       return -1;
8810   }
8811   {
8812     int r;
8813     suppress_error = 0;
8814     r = guestfs_lvm_remove_all (g);
8815     if (r == -1)
8816       return -1;
8817   }
8818   {
8819     char device[] = "/dev/sda";
8820     device[5] = devchar;
8821     char lines_0[] = ",";
8822     char *lines[] = {
8823       lines_0,
8824       NULL
8825     };
8826     int r;
8827     suppress_error = 0;
8828     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8829     if (r == -1)
8830       return -1;
8831   }
8832   {
8833     char fstype[] = "ext2";
8834     char device[] = "/dev/sda1";
8835     device[5] = devchar;
8836     int r;
8837     suppress_error = 0;
8838     r = guestfs_mkfs (g, fstype, device);
8839     if (r == -1)
8840       return -1;
8841   }
8842   {
8843     char device[] = "/dev/sda1";
8844     device[5] = devchar;
8845     char mountpoint[] = "/";
8846     int r;
8847     suppress_error = 0;
8848     r = guestfs_mount (g, device, mountpoint);
8849     if (r == -1)
8850       return -1;
8851   }
8852   /* TestOutput for write_file (0) */
8853   char expected[] = "new file contents";
8854   {
8855     char path[] = "/new";
8856     char content[] = "new file contents";
8857     int r;
8858     suppress_error = 0;
8859     r = guestfs_write_file (g, path, content, 0);
8860     if (r == -1)
8861       return -1;
8862   }
8863   {
8864     char path[] = "/new";
8865     char *r;
8866     suppress_error = 0;
8867     r = guestfs_cat (g, path);
8868     if (r == NULL)
8869       return -1;
8870     if (strcmp (r, expected) != 0) {
8871       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8872       return -1;
8873     }
8874     free (r);
8875   }
8876   return 0;
8877 }
8878
8879 static int test_write_file_1 (void)
8880 {
8881   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
8882   {
8883     char device[] = "/dev/sda";
8884     device[5] = devchar;
8885     int r;
8886     suppress_error = 0;
8887     r = guestfs_blockdev_setrw (g, device);
8888     if (r == -1)
8889       return -1;
8890   }
8891   {
8892     int r;
8893     suppress_error = 0;
8894     r = guestfs_umount_all (g);
8895     if (r == -1)
8896       return -1;
8897   }
8898   {
8899     int r;
8900     suppress_error = 0;
8901     r = guestfs_lvm_remove_all (g);
8902     if (r == -1)
8903       return -1;
8904   }
8905   {
8906     char device[] = "/dev/sda";
8907     device[5] = devchar;
8908     char lines_0[] = ",";
8909     char *lines[] = {
8910       lines_0,
8911       NULL
8912     };
8913     int r;
8914     suppress_error = 0;
8915     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8916     if (r == -1)
8917       return -1;
8918   }
8919   {
8920     char fstype[] = "ext2";
8921     char device[] = "/dev/sda1";
8922     device[5] = devchar;
8923     int r;
8924     suppress_error = 0;
8925     r = guestfs_mkfs (g, fstype, device);
8926     if (r == -1)
8927       return -1;
8928   }
8929   {
8930     char device[] = "/dev/sda1";
8931     device[5] = devchar;
8932     char mountpoint[] = "/";
8933     int r;
8934     suppress_error = 0;
8935     r = guestfs_mount (g, device, mountpoint);
8936     if (r == -1)
8937       return -1;
8938   }
8939   /* TestOutput for write_file (1) */
8940   char expected[] = "\nnew file contents\n";
8941   {
8942     char path[] = "/new";
8943     char content[] = "\nnew file contents\n";
8944     int r;
8945     suppress_error = 0;
8946     r = guestfs_write_file (g, path, content, 0);
8947     if (r == -1)
8948       return -1;
8949   }
8950   {
8951     char path[] = "/new";
8952     char *r;
8953     suppress_error = 0;
8954     r = guestfs_cat (g, path);
8955     if (r == NULL)
8956       return -1;
8957     if (strcmp (r, expected) != 0) {
8958       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8959       return -1;
8960     }
8961     free (r);
8962   }
8963   return 0;
8964 }
8965
8966 static int test_write_file_2 (void)
8967 {
8968   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
8969   {
8970     char device[] = "/dev/sda";
8971     device[5] = devchar;
8972     int r;
8973     suppress_error = 0;
8974     r = guestfs_blockdev_setrw (g, device);
8975     if (r == -1)
8976       return -1;
8977   }
8978   {
8979     int r;
8980     suppress_error = 0;
8981     r = guestfs_umount_all (g);
8982     if (r == -1)
8983       return -1;
8984   }
8985   {
8986     int r;
8987     suppress_error = 0;
8988     r = guestfs_lvm_remove_all (g);
8989     if (r == -1)
8990       return -1;
8991   }
8992   {
8993     char device[] = "/dev/sda";
8994     device[5] = devchar;
8995     char lines_0[] = ",";
8996     char *lines[] = {
8997       lines_0,
8998       NULL
8999     };
9000     int r;
9001     suppress_error = 0;
9002     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9003     if (r == -1)
9004       return -1;
9005   }
9006   {
9007     char fstype[] = "ext2";
9008     char device[] = "/dev/sda1";
9009     device[5] = devchar;
9010     int r;
9011     suppress_error = 0;
9012     r = guestfs_mkfs (g, fstype, device);
9013     if (r == -1)
9014       return -1;
9015   }
9016   {
9017     char device[] = "/dev/sda1";
9018     device[5] = devchar;
9019     char mountpoint[] = "/";
9020     int r;
9021     suppress_error = 0;
9022     r = guestfs_mount (g, device, mountpoint);
9023     if (r == -1)
9024       return -1;
9025   }
9026   /* TestOutput for write_file (2) */
9027   char expected[] = "\n\n";
9028   {
9029     char path[] = "/new";
9030     char content[] = "\n\n";
9031     int r;
9032     suppress_error = 0;
9033     r = guestfs_write_file (g, path, content, 0);
9034     if (r == -1)
9035       return -1;
9036   }
9037   {
9038     char path[] = "/new";
9039     char *r;
9040     suppress_error = 0;
9041     r = guestfs_cat (g, path);
9042     if (r == NULL)
9043       return -1;
9044     if (strcmp (r, expected) != 0) {
9045       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
9046       return -1;
9047     }
9048     free (r);
9049   }
9050   return 0;
9051 }
9052
9053 static int test_write_file_3 (void)
9054 {
9055   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
9056   {
9057     char device[] = "/dev/sda";
9058     device[5] = devchar;
9059     int r;
9060     suppress_error = 0;
9061     r = guestfs_blockdev_setrw (g, device);
9062     if (r == -1)
9063       return -1;
9064   }
9065   {
9066     int r;
9067     suppress_error = 0;
9068     r = guestfs_umount_all (g);
9069     if (r == -1)
9070       return -1;
9071   }
9072   {
9073     int r;
9074     suppress_error = 0;
9075     r = guestfs_lvm_remove_all (g);
9076     if (r == -1)
9077       return -1;
9078   }
9079   {
9080     char device[] = "/dev/sda";
9081     device[5] = devchar;
9082     char lines_0[] = ",";
9083     char *lines[] = {
9084       lines_0,
9085       NULL
9086     };
9087     int r;
9088     suppress_error = 0;
9089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9090     if (r == -1)
9091       return -1;
9092   }
9093   {
9094     char fstype[] = "ext2";
9095     char device[] = "/dev/sda1";
9096     device[5] = devchar;
9097     int r;
9098     suppress_error = 0;
9099     r = guestfs_mkfs (g, fstype, device);
9100     if (r == -1)
9101       return -1;
9102   }
9103   {
9104     char device[] = "/dev/sda1";
9105     device[5] = devchar;
9106     char mountpoint[] = "/";
9107     int r;
9108     suppress_error = 0;
9109     r = guestfs_mount (g, device, mountpoint);
9110     if (r == -1)
9111       return -1;
9112   }
9113   /* TestOutput for write_file (3) */
9114   char expected[] = "";
9115   {
9116     char path[] = "/new";
9117     char content[] = "";
9118     int r;
9119     suppress_error = 0;
9120     r = guestfs_write_file (g, path, content, 0);
9121     if (r == -1)
9122       return -1;
9123   }
9124   {
9125     char path[] = "/new";
9126     char *r;
9127     suppress_error = 0;
9128     r = guestfs_cat (g, path);
9129     if (r == NULL)
9130       return -1;
9131     if (strcmp (r, expected) != 0) {
9132       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
9133       return -1;
9134     }
9135     free (r);
9136   }
9137   return 0;
9138 }
9139
9140 static int test_write_file_4 (void)
9141 {
9142   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
9143   {
9144     char device[] = "/dev/sda";
9145     device[5] = devchar;
9146     int r;
9147     suppress_error = 0;
9148     r = guestfs_blockdev_setrw (g, device);
9149     if (r == -1)
9150       return -1;
9151   }
9152   {
9153     int r;
9154     suppress_error = 0;
9155     r = guestfs_umount_all (g);
9156     if (r == -1)
9157       return -1;
9158   }
9159   {
9160     int r;
9161     suppress_error = 0;
9162     r = guestfs_lvm_remove_all (g);
9163     if (r == -1)
9164       return -1;
9165   }
9166   {
9167     char device[] = "/dev/sda";
9168     device[5] = devchar;
9169     char lines_0[] = ",";
9170     char *lines[] = {
9171       lines_0,
9172       NULL
9173     };
9174     int r;
9175     suppress_error = 0;
9176     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9177     if (r == -1)
9178       return -1;
9179   }
9180   {
9181     char fstype[] = "ext2";
9182     char device[] = "/dev/sda1";
9183     device[5] = devchar;
9184     int r;
9185     suppress_error = 0;
9186     r = guestfs_mkfs (g, fstype, device);
9187     if (r == -1)
9188       return -1;
9189   }
9190   {
9191     char device[] = "/dev/sda1";
9192     device[5] = devchar;
9193     char mountpoint[] = "/";
9194     int r;
9195     suppress_error = 0;
9196     r = guestfs_mount (g, device, mountpoint);
9197     if (r == -1)
9198       return -1;
9199   }
9200   /* TestOutput for write_file (4) */
9201   char expected[] = "\n\n\n";
9202   {
9203     char path[] = "/new";
9204     char content[] = "\n\n\n";
9205     int r;
9206     suppress_error = 0;
9207     r = guestfs_write_file (g, path, content, 0);
9208     if (r == -1)
9209       return -1;
9210   }
9211   {
9212     char path[] = "/new";
9213     char *r;
9214     suppress_error = 0;
9215     r = guestfs_cat (g, path);
9216     if (r == NULL)
9217       return -1;
9218     if (strcmp (r, expected) != 0) {
9219       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9220       return -1;
9221     }
9222     free (r);
9223   }
9224   return 0;
9225 }
9226
9227 static int test_write_file_5 (void)
9228 {
9229   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
9230   {
9231     char device[] = "/dev/sda";
9232     device[5] = devchar;
9233     int r;
9234     suppress_error = 0;
9235     r = guestfs_blockdev_setrw (g, device);
9236     if (r == -1)
9237       return -1;
9238   }
9239   {
9240     int r;
9241     suppress_error = 0;
9242     r = guestfs_umount_all (g);
9243     if (r == -1)
9244       return -1;
9245   }
9246   {
9247     int r;
9248     suppress_error = 0;
9249     r = guestfs_lvm_remove_all (g);
9250     if (r == -1)
9251       return -1;
9252   }
9253   {
9254     char device[] = "/dev/sda";
9255     device[5] = devchar;
9256     char lines_0[] = ",";
9257     char *lines[] = {
9258       lines_0,
9259       NULL
9260     };
9261     int r;
9262     suppress_error = 0;
9263     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9264     if (r == -1)
9265       return -1;
9266   }
9267   {
9268     char fstype[] = "ext2";
9269     char device[] = "/dev/sda1";
9270     device[5] = devchar;
9271     int r;
9272     suppress_error = 0;
9273     r = guestfs_mkfs (g, fstype, device);
9274     if (r == -1)
9275       return -1;
9276   }
9277   {
9278     char device[] = "/dev/sda1";
9279     device[5] = devchar;
9280     char mountpoint[] = "/";
9281     int r;
9282     suppress_error = 0;
9283     r = guestfs_mount (g, device, mountpoint);
9284     if (r == -1)
9285       return -1;
9286   }
9287   /* TestOutput for write_file (5) */
9288   char expected[] = "\n";
9289   {
9290     char path[] = "/new";
9291     char content[] = "\n";
9292     int r;
9293     suppress_error = 0;
9294     r = guestfs_write_file (g, path, content, 0);
9295     if (r == -1)
9296       return -1;
9297   }
9298   {
9299     char path[] = "/new";
9300     char *r;
9301     suppress_error = 0;
9302     r = guestfs_cat (g, path);
9303     if (r == NULL)
9304       return -1;
9305     if (strcmp (r, expected) != 0) {
9306       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9307       return -1;
9308     }
9309     free (r);
9310   }
9311   return 0;
9312 }
9313
9314 static int test_mkfs_0 (void)
9315 {
9316   /* InitNone|InitEmpty for test_mkfs_0 */
9317   {
9318     char device[] = "/dev/sda";
9319     device[5] = devchar;
9320     int r;
9321     suppress_error = 0;
9322     r = guestfs_blockdev_setrw (g, device);
9323     if (r == -1)
9324       return -1;
9325   }
9326   {
9327     int r;
9328     suppress_error = 0;
9329     r = guestfs_umount_all (g);
9330     if (r == -1)
9331       return -1;
9332   }
9333   {
9334     int r;
9335     suppress_error = 0;
9336     r = guestfs_lvm_remove_all (g);
9337     if (r == -1)
9338       return -1;
9339   }
9340   /* TestOutput for mkfs (0) */
9341   char expected[] = "new file contents";
9342   {
9343     char device[] = "/dev/sda";
9344     device[5] = devchar;
9345     char lines_0[] = ",";
9346     char *lines[] = {
9347       lines_0,
9348       NULL
9349     };
9350     int r;
9351     suppress_error = 0;
9352     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9353     if (r == -1)
9354       return -1;
9355   }
9356   {
9357     char fstype[] = "ext2";
9358     char device[] = "/dev/sda1";
9359     device[5] = devchar;
9360     int r;
9361     suppress_error = 0;
9362     r = guestfs_mkfs (g, fstype, device);
9363     if (r == -1)
9364       return -1;
9365   }
9366   {
9367     char device[] = "/dev/sda1";
9368     device[5] = devchar;
9369     char mountpoint[] = "/";
9370     int r;
9371     suppress_error = 0;
9372     r = guestfs_mount (g, device, mountpoint);
9373     if (r == -1)
9374       return -1;
9375   }
9376   {
9377     char path[] = "/new";
9378     char content[] = "new file contents";
9379     int r;
9380     suppress_error = 0;
9381     r = guestfs_write_file (g, path, content, 0);
9382     if (r == -1)
9383       return -1;
9384   }
9385   {
9386     char path[] = "/new";
9387     char *r;
9388     suppress_error = 0;
9389     r = guestfs_cat (g, path);
9390     if (r == NULL)
9391       return -1;
9392     if (strcmp (r, expected) != 0) {
9393       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9394       return -1;
9395     }
9396     free (r);
9397   }
9398   return 0;
9399 }
9400
9401 static int test_lvcreate_0 (void)
9402 {
9403   /* InitNone|InitEmpty for test_lvcreate_0 */
9404   {
9405     char device[] = "/dev/sda";
9406     device[5] = devchar;
9407     int r;
9408     suppress_error = 0;
9409     r = guestfs_blockdev_setrw (g, device);
9410     if (r == -1)
9411       return -1;
9412   }
9413   {
9414     int r;
9415     suppress_error = 0;
9416     r = guestfs_umount_all (g);
9417     if (r == -1)
9418       return -1;
9419   }
9420   {
9421     int r;
9422     suppress_error = 0;
9423     r = guestfs_lvm_remove_all (g);
9424     if (r == -1)
9425       return -1;
9426   }
9427   /* TestOutputList for lvcreate (0) */
9428   {
9429     char device[] = "/dev/sda";
9430     device[5] = devchar;
9431     char lines_0[] = ",10";
9432     char lines_1[] = ",20";
9433     char lines_2[] = ",";
9434     char *lines[] = {
9435       lines_0,
9436       lines_1,
9437       lines_2,
9438       NULL
9439     };
9440     int r;
9441     suppress_error = 0;
9442     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9443     if (r == -1)
9444       return -1;
9445   }
9446   {
9447     char device[] = "/dev/sda1";
9448     device[5] = devchar;
9449     int r;
9450     suppress_error = 0;
9451     r = guestfs_pvcreate (g, device);
9452     if (r == -1)
9453       return -1;
9454   }
9455   {
9456     char device[] = "/dev/sda2";
9457     device[5] = devchar;
9458     int r;
9459     suppress_error = 0;
9460     r = guestfs_pvcreate (g, device);
9461     if (r == -1)
9462       return -1;
9463   }
9464   {
9465     char device[] = "/dev/sda3";
9466     device[5] = devchar;
9467     int r;
9468     suppress_error = 0;
9469     r = guestfs_pvcreate (g, device);
9470     if (r == -1)
9471       return -1;
9472   }
9473   {
9474     char volgroup[] = "VG1";
9475     char physvols_0[] = "/dev/sda1";
9476     physvols_0[5] = devchar;
9477     char physvols_1[] = "/dev/sda2";
9478     physvols_1[5] = devchar;
9479     char *physvols[] = {
9480       physvols_0,
9481       physvols_1,
9482       NULL
9483     };
9484     int r;
9485     suppress_error = 0;
9486     r = guestfs_vgcreate (g, volgroup, physvols);
9487     if (r == -1)
9488       return -1;
9489   }
9490   {
9491     char volgroup[] = "VG2";
9492     char physvols_0[] = "/dev/sda3";
9493     physvols_0[5] = devchar;
9494     char *physvols[] = {
9495       physvols_0,
9496       NULL
9497     };
9498     int r;
9499     suppress_error = 0;
9500     r = guestfs_vgcreate (g, volgroup, physvols);
9501     if (r == -1)
9502       return -1;
9503   }
9504   {
9505     char logvol[] = "LV1";
9506     char volgroup[] = "VG1";
9507     int r;
9508     suppress_error = 0;
9509     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9510     if (r == -1)
9511       return -1;
9512   }
9513   {
9514     char logvol[] = "LV2";
9515     char volgroup[] = "VG1";
9516     int r;
9517     suppress_error = 0;
9518     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9519     if (r == -1)
9520       return -1;
9521   }
9522   {
9523     char logvol[] = "LV3";
9524     char volgroup[] = "VG2";
9525     int r;
9526     suppress_error = 0;
9527     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9528     if (r == -1)
9529       return -1;
9530   }
9531   {
9532     char logvol[] = "LV4";
9533     char volgroup[] = "VG2";
9534     int r;
9535     suppress_error = 0;
9536     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9537     if (r == -1)
9538       return -1;
9539   }
9540   {
9541     char logvol[] = "LV5";
9542     char volgroup[] = "VG2";
9543     int r;
9544     suppress_error = 0;
9545     r = guestfs_lvcreate (g, logvol, volgroup, 50);
9546     if (r == -1)
9547       return -1;
9548   }
9549   {
9550     char **r;
9551     int i;
9552     suppress_error = 0;
9553     r = guestfs_lvs (g);
9554     if (r == NULL)
9555       return -1;
9556     if (!r[0]) {
9557       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9558       print_strings (r);
9559       return -1;
9560     }
9561     {
9562       char expected[] = "/dev/VG1/LV1";
9563       if (strcmp (r[0], expected) != 0) {
9564         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9565         return -1;
9566       }
9567     }
9568     if (!r[1]) {
9569       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9570       print_strings (r);
9571       return -1;
9572     }
9573     {
9574       char expected[] = "/dev/VG1/LV2";
9575       if (strcmp (r[1], expected) != 0) {
9576         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9577         return -1;
9578       }
9579     }
9580     if (!r[2]) {
9581       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9582       print_strings (r);
9583       return -1;
9584     }
9585     {
9586       char expected[] = "/dev/VG2/LV3";
9587       if (strcmp (r[2], expected) != 0) {
9588         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9589         return -1;
9590       }
9591     }
9592     if (!r[3]) {
9593       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9594       print_strings (r);
9595       return -1;
9596     }
9597     {
9598       char expected[] = "/dev/VG2/LV4";
9599       if (strcmp (r[3], expected) != 0) {
9600         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9601         return -1;
9602       }
9603     }
9604     if (!r[4]) {
9605       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9606       print_strings (r);
9607       return -1;
9608     }
9609     {
9610       char expected[] = "/dev/VG2/LV5";
9611       if (strcmp (r[4], expected) != 0) {
9612         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9613         return -1;
9614       }
9615     }
9616     if (r[5] != NULL) {
9617       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9618       print_strings (r);
9619       return -1;
9620     }
9621     for (i = 0; r[i] != NULL; ++i)
9622       free (r[i]);
9623     free (r);
9624   }
9625   return 0;
9626 }
9627
9628 static int test_vgcreate_0 (void)
9629 {
9630   /* InitNone|InitEmpty for test_vgcreate_0 */
9631   {
9632     char device[] = "/dev/sda";
9633     device[5] = devchar;
9634     int r;
9635     suppress_error = 0;
9636     r = guestfs_blockdev_setrw (g, device);
9637     if (r == -1)
9638       return -1;
9639   }
9640   {
9641     int r;
9642     suppress_error = 0;
9643     r = guestfs_umount_all (g);
9644     if (r == -1)
9645       return -1;
9646   }
9647   {
9648     int r;
9649     suppress_error = 0;
9650     r = guestfs_lvm_remove_all (g);
9651     if (r == -1)
9652       return -1;
9653   }
9654   /* TestOutputList for vgcreate (0) */
9655   {
9656     char device[] = "/dev/sda";
9657     device[5] = devchar;
9658     char lines_0[] = ",10";
9659     char lines_1[] = ",20";
9660     char lines_2[] = ",";
9661     char *lines[] = {
9662       lines_0,
9663       lines_1,
9664       lines_2,
9665       NULL
9666     };
9667     int r;
9668     suppress_error = 0;
9669     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9670     if (r == -1)
9671       return -1;
9672   }
9673   {
9674     char device[] = "/dev/sda1";
9675     device[5] = devchar;
9676     int r;
9677     suppress_error = 0;
9678     r = guestfs_pvcreate (g, device);
9679     if (r == -1)
9680       return -1;
9681   }
9682   {
9683     char device[] = "/dev/sda2";
9684     device[5] = devchar;
9685     int r;
9686     suppress_error = 0;
9687     r = guestfs_pvcreate (g, device);
9688     if (r == -1)
9689       return -1;
9690   }
9691   {
9692     char device[] = "/dev/sda3";
9693     device[5] = devchar;
9694     int r;
9695     suppress_error = 0;
9696     r = guestfs_pvcreate (g, device);
9697     if (r == -1)
9698       return -1;
9699   }
9700   {
9701     char volgroup[] = "VG1";
9702     char physvols_0[] = "/dev/sda1";
9703     physvols_0[5] = devchar;
9704     char physvols_1[] = "/dev/sda2";
9705     physvols_1[5] = devchar;
9706     char *physvols[] = {
9707       physvols_0,
9708       physvols_1,
9709       NULL
9710     };
9711     int r;
9712     suppress_error = 0;
9713     r = guestfs_vgcreate (g, volgroup, physvols);
9714     if (r == -1)
9715       return -1;
9716   }
9717   {
9718     char volgroup[] = "VG2";
9719     char physvols_0[] = "/dev/sda3";
9720     physvols_0[5] = devchar;
9721     char *physvols[] = {
9722       physvols_0,
9723       NULL
9724     };
9725     int r;
9726     suppress_error = 0;
9727     r = guestfs_vgcreate (g, volgroup, physvols);
9728     if (r == -1)
9729       return -1;
9730   }
9731   {
9732     char **r;
9733     int i;
9734     suppress_error = 0;
9735     r = guestfs_vgs (g);
9736     if (r == NULL)
9737       return -1;
9738     if (!r[0]) {
9739       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9740       print_strings (r);
9741       return -1;
9742     }
9743     {
9744       char expected[] = "VG1";
9745       if (strcmp (r[0], expected) != 0) {
9746         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9747         return -1;
9748       }
9749     }
9750     if (!r[1]) {
9751       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9752       print_strings (r);
9753       return -1;
9754     }
9755     {
9756       char expected[] = "VG2";
9757       if (strcmp (r[1], expected) != 0) {
9758         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9759         return -1;
9760       }
9761     }
9762     if (r[2] != NULL) {
9763       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
9764       print_strings (r);
9765       return -1;
9766     }
9767     for (i = 0; r[i] != NULL; ++i)
9768       free (r[i]);
9769     free (r);
9770   }
9771   return 0;
9772 }
9773
9774 static int test_pvcreate_0 (void)
9775 {
9776   /* InitNone|InitEmpty for test_pvcreate_0 */
9777   {
9778     char device[] = "/dev/sda";
9779     device[5] = devchar;
9780     int r;
9781     suppress_error = 0;
9782     r = guestfs_blockdev_setrw (g, device);
9783     if (r == -1)
9784       return -1;
9785   }
9786   {
9787     int r;
9788     suppress_error = 0;
9789     r = guestfs_umount_all (g);
9790     if (r == -1)
9791       return -1;
9792   }
9793   {
9794     int r;
9795     suppress_error = 0;
9796     r = guestfs_lvm_remove_all (g);
9797     if (r == -1)
9798       return -1;
9799   }
9800   /* TestOutputList for pvcreate (0) */
9801   {
9802     char device[] = "/dev/sda";
9803     device[5] = devchar;
9804     char lines_0[] = ",10";
9805     char lines_1[] = ",20";
9806     char lines_2[] = ",";
9807     char *lines[] = {
9808       lines_0,
9809       lines_1,
9810       lines_2,
9811       NULL
9812     };
9813     int r;
9814     suppress_error = 0;
9815     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9816     if (r == -1)
9817       return -1;
9818   }
9819   {
9820     char device[] = "/dev/sda1";
9821     device[5] = devchar;
9822     int r;
9823     suppress_error = 0;
9824     r = guestfs_pvcreate (g, device);
9825     if (r == -1)
9826       return -1;
9827   }
9828   {
9829     char device[] = "/dev/sda2";
9830     device[5] = devchar;
9831     int r;
9832     suppress_error = 0;
9833     r = guestfs_pvcreate (g, device);
9834     if (r == -1)
9835       return -1;
9836   }
9837   {
9838     char device[] = "/dev/sda3";
9839     device[5] = devchar;
9840     int r;
9841     suppress_error = 0;
9842     r = guestfs_pvcreate (g, device);
9843     if (r == -1)
9844       return -1;
9845   }
9846   {
9847     char **r;
9848     int i;
9849     suppress_error = 0;
9850     r = guestfs_pvs (g);
9851     if (r == NULL)
9852       return -1;
9853     if (!r[0]) {
9854       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9855       print_strings (r);
9856       return -1;
9857     }
9858     {
9859       char expected[] = "/dev/sda1";
9860       expected[5] = devchar;
9861       if (strcmp (r[0], expected) != 0) {
9862         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9863         return -1;
9864       }
9865     }
9866     if (!r[1]) {
9867       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9868       print_strings (r);
9869       return -1;
9870     }
9871     {
9872       char expected[] = "/dev/sda2";
9873       expected[5] = devchar;
9874       if (strcmp (r[1], expected) != 0) {
9875         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9876         return -1;
9877       }
9878     }
9879     if (!r[2]) {
9880       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9881       print_strings (r);
9882       return -1;
9883     }
9884     {
9885       char expected[] = "/dev/sda3";
9886       expected[5] = devchar;
9887       if (strcmp (r[2], expected) != 0) {
9888         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9889         return -1;
9890       }
9891     }
9892     if (r[3] != NULL) {
9893       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
9894       print_strings (r);
9895       return -1;
9896     }
9897     for (i = 0; r[i] != NULL; ++i)
9898       free (r[i]);
9899     free (r);
9900   }
9901   return 0;
9902 }
9903
9904 static int test_is_dir_0 (void)
9905 {
9906   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
9907   {
9908     char device[] = "/dev/sda";
9909     device[5] = devchar;
9910     int r;
9911     suppress_error = 0;
9912     r = guestfs_blockdev_setrw (g, device);
9913     if (r == -1)
9914       return -1;
9915   }
9916   {
9917     int r;
9918     suppress_error = 0;
9919     r = guestfs_umount_all (g);
9920     if (r == -1)
9921       return -1;
9922   }
9923   {
9924     int r;
9925     suppress_error = 0;
9926     r = guestfs_lvm_remove_all (g);
9927     if (r == -1)
9928       return -1;
9929   }
9930   {
9931     char device[] = "/dev/sda";
9932     device[5] = devchar;
9933     char lines_0[] = ",";
9934     char *lines[] = {
9935       lines_0,
9936       NULL
9937     };
9938     int r;
9939     suppress_error = 0;
9940     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9941     if (r == -1)
9942       return -1;
9943   }
9944   {
9945     char fstype[] = "ext2";
9946     char device[] = "/dev/sda1";
9947     device[5] = devchar;
9948     int r;
9949     suppress_error = 0;
9950     r = guestfs_mkfs (g, fstype, device);
9951     if (r == -1)
9952       return -1;
9953   }
9954   {
9955     char device[] = "/dev/sda1";
9956     device[5] = devchar;
9957     char mountpoint[] = "/";
9958     int r;
9959     suppress_error = 0;
9960     r = guestfs_mount (g, device, mountpoint);
9961     if (r == -1)
9962       return -1;
9963   }
9964   /* TestOutputFalse for is_dir (0) */
9965   {
9966     char path[] = "/new";
9967     int r;
9968     suppress_error = 0;
9969     r = guestfs_touch (g, path);
9970     if (r == -1)
9971       return -1;
9972   }
9973   {
9974     char path[] = "/new";
9975     int r;
9976     suppress_error = 0;
9977     r = guestfs_is_dir (g, path);
9978     if (r == -1)
9979       return -1;
9980     if (r) {
9981       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
9982       return -1;
9983     }
9984   }
9985   return 0;
9986 }
9987
9988 static int test_is_dir_1 (void)
9989 {
9990   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
9991   {
9992     char device[] = "/dev/sda";
9993     device[5] = devchar;
9994     int r;
9995     suppress_error = 0;
9996     r = guestfs_blockdev_setrw (g, device);
9997     if (r == -1)
9998       return -1;
9999   }
10000   {
10001     int r;
10002     suppress_error = 0;
10003     r = guestfs_umount_all (g);
10004     if (r == -1)
10005       return -1;
10006   }
10007   {
10008     int r;
10009     suppress_error = 0;
10010     r = guestfs_lvm_remove_all (g);
10011     if (r == -1)
10012       return -1;
10013   }
10014   {
10015     char device[] = "/dev/sda";
10016     device[5] = devchar;
10017     char lines_0[] = ",";
10018     char *lines[] = {
10019       lines_0,
10020       NULL
10021     };
10022     int r;
10023     suppress_error = 0;
10024     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10025     if (r == -1)
10026       return -1;
10027   }
10028   {
10029     char fstype[] = "ext2";
10030     char device[] = "/dev/sda1";
10031     device[5] = devchar;
10032     int r;
10033     suppress_error = 0;
10034     r = guestfs_mkfs (g, fstype, device);
10035     if (r == -1)
10036       return -1;
10037   }
10038   {
10039     char device[] = "/dev/sda1";
10040     device[5] = devchar;
10041     char mountpoint[] = "/";
10042     int r;
10043     suppress_error = 0;
10044     r = guestfs_mount (g, device, mountpoint);
10045     if (r == -1)
10046       return -1;
10047   }
10048   /* TestOutputTrue for is_dir (1) */
10049   {
10050     char path[] = "/new";
10051     int r;
10052     suppress_error = 0;
10053     r = guestfs_mkdir (g, path);
10054     if (r == -1)
10055       return -1;
10056   }
10057   {
10058     char path[] = "/new";
10059     int r;
10060     suppress_error = 0;
10061     r = guestfs_is_dir (g, path);
10062     if (r == -1)
10063       return -1;
10064     if (!r) {
10065       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
10066       return -1;
10067     }
10068   }
10069   return 0;
10070 }
10071
10072 static int test_is_file_0 (void)
10073 {
10074   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
10075   {
10076     char device[] = "/dev/sda";
10077     device[5] = devchar;
10078     int r;
10079     suppress_error = 0;
10080     r = guestfs_blockdev_setrw (g, device);
10081     if (r == -1)
10082       return -1;
10083   }
10084   {
10085     int r;
10086     suppress_error = 0;
10087     r = guestfs_umount_all (g);
10088     if (r == -1)
10089       return -1;
10090   }
10091   {
10092     int r;
10093     suppress_error = 0;
10094     r = guestfs_lvm_remove_all (g);
10095     if (r == -1)
10096       return -1;
10097   }
10098   {
10099     char device[] = "/dev/sda";
10100     device[5] = devchar;
10101     char lines_0[] = ",";
10102     char *lines[] = {
10103       lines_0,
10104       NULL
10105     };
10106     int r;
10107     suppress_error = 0;
10108     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10109     if (r == -1)
10110       return -1;
10111   }
10112   {
10113     char fstype[] = "ext2";
10114     char device[] = "/dev/sda1";
10115     device[5] = devchar;
10116     int r;
10117     suppress_error = 0;
10118     r = guestfs_mkfs (g, fstype, device);
10119     if (r == -1)
10120       return -1;
10121   }
10122   {
10123     char device[] = "/dev/sda1";
10124     device[5] = devchar;
10125     char mountpoint[] = "/";
10126     int r;
10127     suppress_error = 0;
10128     r = guestfs_mount (g, device, mountpoint);
10129     if (r == -1)
10130       return -1;
10131   }
10132   /* TestOutputTrue for is_file (0) */
10133   {
10134     char path[] = "/new";
10135     int r;
10136     suppress_error = 0;
10137     r = guestfs_touch (g, path);
10138     if (r == -1)
10139       return -1;
10140   }
10141   {
10142     char path[] = "/new";
10143     int r;
10144     suppress_error = 0;
10145     r = guestfs_is_file (g, path);
10146     if (r == -1)
10147       return -1;
10148     if (!r) {
10149       fprintf (stderr, "test_is_file_0: expected true, got false\n");
10150       return -1;
10151     }
10152   }
10153   return 0;
10154 }
10155
10156 static int test_is_file_1 (void)
10157 {
10158   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
10159   {
10160     char device[] = "/dev/sda";
10161     device[5] = devchar;
10162     int r;
10163     suppress_error = 0;
10164     r = guestfs_blockdev_setrw (g, device);
10165     if (r == -1)
10166       return -1;
10167   }
10168   {
10169     int r;
10170     suppress_error = 0;
10171     r = guestfs_umount_all (g);
10172     if (r == -1)
10173       return -1;
10174   }
10175   {
10176     int r;
10177     suppress_error = 0;
10178     r = guestfs_lvm_remove_all (g);
10179     if (r == -1)
10180       return -1;
10181   }
10182   {
10183     char device[] = "/dev/sda";
10184     device[5] = devchar;
10185     char lines_0[] = ",";
10186     char *lines[] = {
10187       lines_0,
10188       NULL
10189     };
10190     int r;
10191     suppress_error = 0;
10192     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10193     if (r == -1)
10194       return -1;
10195   }
10196   {
10197     char fstype[] = "ext2";
10198     char device[] = "/dev/sda1";
10199     device[5] = devchar;
10200     int r;
10201     suppress_error = 0;
10202     r = guestfs_mkfs (g, fstype, device);
10203     if (r == -1)
10204       return -1;
10205   }
10206   {
10207     char device[] = "/dev/sda1";
10208     device[5] = devchar;
10209     char mountpoint[] = "/";
10210     int r;
10211     suppress_error = 0;
10212     r = guestfs_mount (g, device, mountpoint);
10213     if (r == -1)
10214       return -1;
10215   }
10216   /* TestOutputFalse for is_file (1) */
10217   {
10218     char path[] = "/new";
10219     int r;
10220     suppress_error = 0;
10221     r = guestfs_mkdir (g, path);
10222     if (r == -1)
10223       return -1;
10224   }
10225   {
10226     char path[] = "/new";
10227     int r;
10228     suppress_error = 0;
10229     r = guestfs_is_file (g, path);
10230     if (r == -1)
10231       return -1;
10232     if (r) {
10233       fprintf (stderr, "test_is_file_1: expected false, got true\n");
10234       return -1;
10235     }
10236   }
10237   return 0;
10238 }
10239
10240 static int test_exists_0 (void)
10241 {
10242   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
10243   {
10244     char device[] = "/dev/sda";
10245     device[5] = devchar;
10246     int r;
10247     suppress_error = 0;
10248     r = guestfs_blockdev_setrw (g, device);
10249     if (r == -1)
10250       return -1;
10251   }
10252   {
10253     int r;
10254     suppress_error = 0;
10255     r = guestfs_umount_all (g);
10256     if (r == -1)
10257       return -1;
10258   }
10259   {
10260     int r;
10261     suppress_error = 0;
10262     r = guestfs_lvm_remove_all (g);
10263     if (r == -1)
10264       return -1;
10265   }
10266   {
10267     char device[] = "/dev/sda";
10268     device[5] = devchar;
10269     char lines_0[] = ",";
10270     char *lines[] = {
10271       lines_0,
10272       NULL
10273     };
10274     int r;
10275     suppress_error = 0;
10276     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10277     if (r == -1)
10278       return -1;
10279   }
10280   {
10281     char fstype[] = "ext2";
10282     char device[] = "/dev/sda1";
10283     device[5] = devchar;
10284     int r;
10285     suppress_error = 0;
10286     r = guestfs_mkfs (g, fstype, device);
10287     if (r == -1)
10288       return -1;
10289   }
10290   {
10291     char device[] = "/dev/sda1";
10292     device[5] = devchar;
10293     char mountpoint[] = "/";
10294     int r;
10295     suppress_error = 0;
10296     r = guestfs_mount (g, device, mountpoint);
10297     if (r == -1)
10298       return -1;
10299   }
10300   /* TestOutputTrue for exists (0) */
10301   {
10302     char path[] = "/new";
10303     int r;
10304     suppress_error = 0;
10305     r = guestfs_touch (g, path);
10306     if (r == -1)
10307       return -1;
10308   }
10309   {
10310     char path[] = "/new";
10311     int r;
10312     suppress_error = 0;
10313     r = guestfs_exists (g, path);
10314     if (r == -1)
10315       return -1;
10316     if (!r) {
10317       fprintf (stderr, "test_exists_0: expected true, got false\n");
10318       return -1;
10319     }
10320   }
10321   return 0;
10322 }
10323
10324 static int test_exists_1 (void)
10325 {
10326   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
10327   {
10328     char device[] = "/dev/sda";
10329     device[5] = devchar;
10330     int r;
10331     suppress_error = 0;
10332     r = guestfs_blockdev_setrw (g, device);
10333     if (r == -1)
10334       return -1;
10335   }
10336   {
10337     int r;
10338     suppress_error = 0;
10339     r = guestfs_umount_all (g);
10340     if (r == -1)
10341       return -1;
10342   }
10343   {
10344     int r;
10345     suppress_error = 0;
10346     r = guestfs_lvm_remove_all (g);
10347     if (r == -1)
10348       return -1;
10349   }
10350   {
10351     char device[] = "/dev/sda";
10352     device[5] = devchar;
10353     char lines_0[] = ",";
10354     char *lines[] = {
10355       lines_0,
10356       NULL
10357     };
10358     int r;
10359     suppress_error = 0;
10360     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10361     if (r == -1)
10362       return -1;
10363   }
10364   {
10365     char fstype[] = "ext2";
10366     char device[] = "/dev/sda1";
10367     device[5] = devchar;
10368     int r;
10369     suppress_error = 0;
10370     r = guestfs_mkfs (g, fstype, device);
10371     if (r == -1)
10372       return -1;
10373   }
10374   {
10375     char device[] = "/dev/sda1";
10376     device[5] = devchar;
10377     char mountpoint[] = "/";
10378     int r;
10379     suppress_error = 0;
10380     r = guestfs_mount (g, device, mountpoint);
10381     if (r == -1)
10382       return -1;
10383   }
10384   /* TestOutputTrue for exists (1) */
10385   {
10386     char path[] = "/new";
10387     int r;
10388     suppress_error = 0;
10389     r = guestfs_mkdir (g, path);
10390     if (r == -1)
10391       return -1;
10392   }
10393   {
10394     char path[] = "/new";
10395     int r;
10396     suppress_error = 0;
10397     r = guestfs_exists (g, path);
10398     if (r == -1)
10399       return -1;
10400     if (!r) {
10401       fprintf (stderr, "test_exists_1: expected true, got false\n");
10402       return -1;
10403     }
10404   }
10405   return 0;
10406 }
10407
10408 static int test_mkdir_p_0 (void)
10409 {
10410   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
10411   {
10412     char device[] = "/dev/sda";
10413     device[5] = devchar;
10414     int r;
10415     suppress_error = 0;
10416     r = guestfs_blockdev_setrw (g, device);
10417     if (r == -1)
10418       return -1;
10419   }
10420   {
10421     int r;
10422     suppress_error = 0;
10423     r = guestfs_umount_all (g);
10424     if (r == -1)
10425       return -1;
10426   }
10427   {
10428     int r;
10429     suppress_error = 0;
10430     r = guestfs_lvm_remove_all (g);
10431     if (r == -1)
10432       return -1;
10433   }
10434   {
10435     char device[] = "/dev/sda";
10436     device[5] = devchar;
10437     char lines_0[] = ",";
10438     char *lines[] = {
10439       lines_0,
10440       NULL
10441     };
10442     int r;
10443     suppress_error = 0;
10444     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10445     if (r == -1)
10446       return -1;
10447   }
10448   {
10449     char fstype[] = "ext2";
10450     char device[] = "/dev/sda1";
10451     device[5] = devchar;
10452     int r;
10453     suppress_error = 0;
10454     r = guestfs_mkfs (g, fstype, device);
10455     if (r == -1)
10456       return -1;
10457   }
10458   {
10459     char device[] = "/dev/sda1";
10460     device[5] = devchar;
10461     char mountpoint[] = "/";
10462     int r;
10463     suppress_error = 0;
10464     r = guestfs_mount (g, device, mountpoint);
10465     if (r == -1)
10466       return -1;
10467   }
10468   /* TestOutputTrue for mkdir_p (0) */
10469   {
10470     char path[] = "/new/foo/bar";
10471     int r;
10472     suppress_error = 0;
10473     r = guestfs_mkdir_p (g, path);
10474     if (r == -1)
10475       return -1;
10476   }
10477   {
10478     char path[] = "/new/foo/bar";
10479     int r;
10480     suppress_error = 0;
10481     r = guestfs_is_dir (g, path);
10482     if (r == -1)
10483       return -1;
10484     if (!r) {
10485       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10486       return -1;
10487     }
10488   }
10489   return 0;
10490 }
10491
10492 static int test_mkdir_p_1 (void)
10493 {
10494   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
10495   {
10496     char device[] = "/dev/sda";
10497     device[5] = devchar;
10498     int r;
10499     suppress_error = 0;
10500     r = guestfs_blockdev_setrw (g, device);
10501     if (r == -1)
10502       return -1;
10503   }
10504   {
10505     int r;
10506     suppress_error = 0;
10507     r = guestfs_umount_all (g);
10508     if (r == -1)
10509       return -1;
10510   }
10511   {
10512     int r;
10513     suppress_error = 0;
10514     r = guestfs_lvm_remove_all (g);
10515     if (r == -1)
10516       return -1;
10517   }
10518   {
10519     char device[] = "/dev/sda";
10520     device[5] = devchar;
10521     char lines_0[] = ",";
10522     char *lines[] = {
10523       lines_0,
10524       NULL
10525     };
10526     int r;
10527     suppress_error = 0;
10528     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10529     if (r == -1)
10530       return -1;
10531   }
10532   {
10533     char fstype[] = "ext2";
10534     char device[] = "/dev/sda1";
10535     device[5] = devchar;
10536     int r;
10537     suppress_error = 0;
10538     r = guestfs_mkfs (g, fstype, device);
10539     if (r == -1)
10540       return -1;
10541   }
10542   {
10543     char device[] = "/dev/sda1";
10544     device[5] = devchar;
10545     char mountpoint[] = "/";
10546     int r;
10547     suppress_error = 0;
10548     r = guestfs_mount (g, device, mountpoint);
10549     if (r == -1)
10550       return -1;
10551   }
10552   /* TestOutputTrue for mkdir_p (1) */
10553   {
10554     char path[] = "/new/foo/bar";
10555     int r;
10556     suppress_error = 0;
10557     r = guestfs_mkdir_p (g, path);
10558     if (r == -1)
10559       return -1;
10560   }
10561   {
10562     char path[] = "/new/foo";
10563     int r;
10564     suppress_error = 0;
10565     r = guestfs_is_dir (g, path);
10566     if (r == -1)
10567       return -1;
10568     if (!r) {
10569       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10570       return -1;
10571     }
10572   }
10573   return 0;
10574 }
10575
10576 static int test_mkdir_p_2 (void)
10577 {
10578   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
10579   {
10580     char device[] = "/dev/sda";
10581     device[5] = devchar;
10582     int r;
10583     suppress_error = 0;
10584     r = guestfs_blockdev_setrw (g, device);
10585     if (r == -1)
10586       return -1;
10587   }
10588   {
10589     int r;
10590     suppress_error = 0;
10591     r = guestfs_umount_all (g);
10592     if (r == -1)
10593       return -1;
10594   }
10595   {
10596     int r;
10597     suppress_error = 0;
10598     r = guestfs_lvm_remove_all (g);
10599     if (r == -1)
10600       return -1;
10601   }
10602   {
10603     char device[] = "/dev/sda";
10604     device[5] = devchar;
10605     char lines_0[] = ",";
10606     char *lines[] = {
10607       lines_0,
10608       NULL
10609     };
10610     int r;
10611     suppress_error = 0;
10612     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10613     if (r == -1)
10614       return -1;
10615   }
10616   {
10617     char fstype[] = "ext2";
10618     char device[] = "/dev/sda1";
10619     device[5] = devchar;
10620     int r;
10621     suppress_error = 0;
10622     r = guestfs_mkfs (g, fstype, device);
10623     if (r == -1)
10624       return -1;
10625   }
10626   {
10627     char device[] = "/dev/sda1";
10628     device[5] = devchar;
10629     char mountpoint[] = "/";
10630     int r;
10631     suppress_error = 0;
10632     r = guestfs_mount (g, device, mountpoint);
10633     if (r == -1)
10634       return -1;
10635   }
10636   /* TestOutputTrue for mkdir_p (2) */
10637   {
10638     char path[] = "/new/foo/bar";
10639     int r;
10640     suppress_error = 0;
10641     r = guestfs_mkdir_p (g, path);
10642     if (r == -1)
10643       return -1;
10644   }
10645   {
10646     char path[] = "/new";
10647     int r;
10648     suppress_error = 0;
10649     r = guestfs_is_dir (g, path);
10650     if (r == -1)
10651       return -1;
10652     if (!r) {
10653       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
10654       return -1;
10655     }
10656   }
10657   return 0;
10658 }
10659
10660 static int test_mkdir_0 (void)
10661 {
10662   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
10663   {
10664     char device[] = "/dev/sda";
10665     device[5] = devchar;
10666     int r;
10667     suppress_error = 0;
10668     r = guestfs_blockdev_setrw (g, device);
10669     if (r == -1)
10670       return -1;
10671   }
10672   {
10673     int r;
10674     suppress_error = 0;
10675     r = guestfs_umount_all (g);
10676     if (r == -1)
10677       return -1;
10678   }
10679   {
10680     int r;
10681     suppress_error = 0;
10682     r = guestfs_lvm_remove_all (g);
10683     if (r == -1)
10684       return -1;
10685   }
10686   {
10687     char device[] = "/dev/sda";
10688     device[5] = devchar;
10689     char lines_0[] = ",";
10690     char *lines[] = {
10691       lines_0,
10692       NULL
10693     };
10694     int r;
10695     suppress_error = 0;
10696     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10697     if (r == -1)
10698       return -1;
10699   }
10700   {
10701     char fstype[] = "ext2";
10702     char device[] = "/dev/sda1";
10703     device[5] = devchar;
10704     int r;
10705     suppress_error = 0;
10706     r = guestfs_mkfs (g, fstype, device);
10707     if (r == -1)
10708       return -1;
10709   }
10710   {
10711     char device[] = "/dev/sda1";
10712     device[5] = devchar;
10713     char mountpoint[] = "/";
10714     int r;
10715     suppress_error = 0;
10716     r = guestfs_mount (g, device, mountpoint);
10717     if (r == -1)
10718       return -1;
10719   }
10720   /* TestOutputTrue for mkdir (0) */
10721   {
10722     char path[] = "/new";
10723     int r;
10724     suppress_error = 0;
10725     r = guestfs_mkdir (g, path);
10726     if (r == -1)
10727       return -1;
10728   }
10729   {
10730     char path[] = "/new";
10731     int r;
10732     suppress_error = 0;
10733     r = guestfs_is_dir (g, path);
10734     if (r == -1)
10735       return -1;
10736     if (!r) {
10737       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
10738       return -1;
10739     }
10740   }
10741   return 0;
10742 }
10743
10744 static int test_mkdir_1 (void)
10745 {
10746   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
10747   {
10748     char device[] = "/dev/sda";
10749     device[5] = devchar;
10750     int r;
10751     suppress_error = 0;
10752     r = guestfs_blockdev_setrw (g, device);
10753     if (r == -1)
10754       return -1;
10755   }
10756   {
10757     int r;
10758     suppress_error = 0;
10759     r = guestfs_umount_all (g);
10760     if (r == -1)
10761       return -1;
10762   }
10763   {
10764     int r;
10765     suppress_error = 0;
10766     r = guestfs_lvm_remove_all (g);
10767     if (r == -1)
10768       return -1;
10769   }
10770   {
10771     char device[] = "/dev/sda";
10772     device[5] = devchar;
10773     char lines_0[] = ",";
10774     char *lines[] = {
10775       lines_0,
10776       NULL
10777     };
10778     int r;
10779     suppress_error = 0;
10780     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10781     if (r == -1)
10782       return -1;
10783   }
10784   {
10785     char fstype[] = "ext2";
10786     char device[] = "/dev/sda1";
10787     device[5] = devchar;
10788     int r;
10789     suppress_error = 0;
10790     r = guestfs_mkfs (g, fstype, device);
10791     if (r == -1)
10792       return -1;
10793   }
10794   {
10795     char device[] = "/dev/sda1";
10796     device[5] = devchar;
10797     char mountpoint[] = "/";
10798     int r;
10799     suppress_error = 0;
10800     r = guestfs_mount (g, device, mountpoint);
10801     if (r == -1)
10802       return -1;
10803   }
10804   /* TestLastFail for mkdir (1) */
10805   {
10806     char path[] = "/new/foo/bar";
10807     int r;
10808     suppress_error = 1;
10809     r = guestfs_mkdir (g, path);
10810     if (r != -1)
10811       return -1;
10812   }
10813   return 0;
10814 }
10815
10816 static int test_rm_rf_0 (void)
10817 {
10818   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
10819   {
10820     char device[] = "/dev/sda";
10821     device[5] = devchar;
10822     int r;
10823     suppress_error = 0;
10824     r = guestfs_blockdev_setrw (g, device);
10825     if (r == -1)
10826       return -1;
10827   }
10828   {
10829     int r;
10830     suppress_error = 0;
10831     r = guestfs_umount_all (g);
10832     if (r == -1)
10833       return -1;
10834   }
10835   {
10836     int r;
10837     suppress_error = 0;
10838     r = guestfs_lvm_remove_all (g);
10839     if (r == -1)
10840       return -1;
10841   }
10842   {
10843     char device[] = "/dev/sda";
10844     device[5] = devchar;
10845     char lines_0[] = ",";
10846     char *lines[] = {
10847       lines_0,
10848       NULL
10849     };
10850     int r;
10851     suppress_error = 0;
10852     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10853     if (r == -1)
10854       return -1;
10855   }
10856   {
10857     char fstype[] = "ext2";
10858     char device[] = "/dev/sda1";
10859     device[5] = devchar;
10860     int r;
10861     suppress_error = 0;
10862     r = guestfs_mkfs (g, fstype, device);
10863     if (r == -1)
10864       return -1;
10865   }
10866   {
10867     char device[] = "/dev/sda1";
10868     device[5] = devchar;
10869     char mountpoint[] = "/";
10870     int r;
10871     suppress_error = 0;
10872     r = guestfs_mount (g, device, mountpoint);
10873     if (r == -1)
10874       return -1;
10875   }
10876   /* TestOutputFalse for rm_rf (0) */
10877   {
10878     char path[] = "/new";
10879     int r;
10880     suppress_error = 0;
10881     r = guestfs_mkdir (g, path);
10882     if (r == -1)
10883       return -1;
10884   }
10885   {
10886     char path[] = "/new/foo";
10887     int r;
10888     suppress_error = 0;
10889     r = guestfs_mkdir (g, path);
10890     if (r == -1)
10891       return -1;
10892   }
10893   {
10894     char path[] = "/new/foo/bar";
10895     int r;
10896     suppress_error = 0;
10897     r = guestfs_touch (g, path);
10898     if (r == -1)
10899       return -1;
10900   }
10901   {
10902     char path[] = "/new";
10903     int r;
10904     suppress_error = 0;
10905     r = guestfs_rm_rf (g, path);
10906     if (r == -1)
10907       return -1;
10908   }
10909   {
10910     char path[] = "/new";
10911     int r;
10912     suppress_error = 0;
10913     r = guestfs_exists (g, path);
10914     if (r == -1)
10915       return -1;
10916     if (r) {
10917       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
10918       return -1;
10919     }
10920   }
10921   return 0;
10922 }
10923
10924 static int test_rmdir_0 (void)
10925 {
10926   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
10927   {
10928     char device[] = "/dev/sda";
10929     device[5] = devchar;
10930     int r;
10931     suppress_error = 0;
10932     r = guestfs_blockdev_setrw (g, device);
10933     if (r == -1)
10934       return -1;
10935   }
10936   {
10937     int r;
10938     suppress_error = 0;
10939     r = guestfs_umount_all (g);
10940     if (r == -1)
10941       return -1;
10942   }
10943   {
10944     int r;
10945     suppress_error = 0;
10946     r = guestfs_lvm_remove_all (g);
10947     if (r == -1)
10948       return -1;
10949   }
10950   {
10951     char device[] = "/dev/sda";
10952     device[5] = devchar;
10953     char lines_0[] = ",";
10954     char *lines[] = {
10955       lines_0,
10956       NULL
10957     };
10958     int r;
10959     suppress_error = 0;
10960     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10961     if (r == -1)
10962       return -1;
10963   }
10964   {
10965     char fstype[] = "ext2";
10966     char device[] = "/dev/sda1";
10967     device[5] = devchar;
10968     int r;
10969     suppress_error = 0;
10970     r = guestfs_mkfs (g, fstype, device);
10971     if (r == -1)
10972       return -1;
10973   }
10974   {
10975     char device[] = "/dev/sda1";
10976     device[5] = devchar;
10977     char mountpoint[] = "/";
10978     int r;
10979     suppress_error = 0;
10980     r = guestfs_mount (g, device, mountpoint);
10981     if (r == -1)
10982       return -1;
10983   }
10984   /* TestRun for rmdir (0) */
10985   {
10986     char path[] = "/new";
10987     int r;
10988     suppress_error = 0;
10989     r = guestfs_mkdir (g, path);
10990     if (r == -1)
10991       return -1;
10992   }
10993   {
10994     char path[] = "/new";
10995     int r;
10996     suppress_error = 0;
10997     r = guestfs_rmdir (g, path);
10998     if (r == -1)
10999       return -1;
11000   }
11001   return 0;
11002 }
11003
11004 static int test_rmdir_1 (void)
11005 {
11006   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
11007   {
11008     char device[] = "/dev/sda";
11009     device[5] = devchar;
11010     int r;
11011     suppress_error = 0;
11012     r = guestfs_blockdev_setrw (g, device);
11013     if (r == -1)
11014       return -1;
11015   }
11016   {
11017     int r;
11018     suppress_error = 0;
11019     r = guestfs_umount_all (g);
11020     if (r == -1)
11021       return -1;
11022   }
11023   {
11024     int r;
11025     suppress_error = 0;
11026     r = guestfs_lvm_remove_all (g);
11027     if (r == -1)
11028       return -1;
11029   }
11030   {
11031     char device[] = "/dev/sda";
11032     device[5] = devchar;
11033     char lines_0[] = ",";
11034     char *lines[] = {
11035       lines_0,
11036       NULL
11037     };
11038     int r;
11039     suppress_error = 0;
11040     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11041     if (r == -1)
11042       return -1;
11043   }
11044   {
11045     char fstype[] = "ext2";
11046     char device[] = "/dev/sda1";
11047     device[5] = devchar;
11048     int r;
11049     suppress_error = 0;
11050     r = guestfs_mkfs (g, fstype, device);
11051     if (r == -1)
11052       return -1;
11053   }
11054   {
11055     char device[] = "/dev/sda1";
11056     device[5] = devchar;
11057     char mountpoint[] = "/";
11058     int r;
11059     suppress_error = 0;
11060     r = guestfs_mount (g, device, mountpoint);
11061     if (r == -1)
11062       return -1;
11063   }
11064   /* TestLastFail for rmdir (1) */
11065   {
11066     char path[] = "/new";
11067     int r;
11068     suppress_error = 1;
11069     r = guestfs_rmdir (g, path);
11070     if (r != -1)
11071       return -1;
11072   }
11073   return 0;
11074 }
11075
11076 static int test_rmdir_2 (void)
11077 {
11078   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
11079   {
11080     char device[] = "/dev/sda";
11081     device[5] = devchar;
11082     int r;
11083     suppress_error = 0;
11084     r = guestfs_blockdev_setrw (g, device);
11085     if (r == -1)
11086       return -1;
11087   }
11088   {
11089     int r;
11090     suppress_error = 0;
11091     r = guestfs_umount_all (g);
11092     if (r == -1)
11093       return -1;
11094   }
11095   {
11096     int r;
11097     suppress_error = 0;
11098     r = guestfs_lvm_remove_all (g);
11099     if (r == -1)
11100       return -1;
11101   }
11102   {
11103     char device[] = "/dev/sda";
11104     device[5] = devchar;
11105     char lines_0[] = ",";
11106     char *lines[] = {
11107       lines_0,
11108       NULL
11109     };
11110     int r;
11111     suppress_error = 0;
11112     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11113     if (r == -1)
11114       return -1;
11115   }
11116   {
11117     char fstype[] = "ext2";
11118     char device[] = "/dev/sda1";
11119     device[5] = devchar;
11120     int r;
11121     suppress_error = 0;
11122     r = guestfs_mkfs (g, fstype, device);
11123     if (r == -1)
11124       return -1;
11125   }
11126   {
11127     char device[] = "/dev/sda1";
11128     device[5] = devchar;
11129     char mountpoint[] = "/";
11130     int r;
11131     suppress_error = 0;
11132     r = guestfs_mount (g, device, mountpoint);
11133     if (r == -1)
11134       return -1;
11135   }
11136   /* TestLastFail for rmdir (2) */
11137   {
11138     char path[] = "/new";
11139     int r;
11140     suppress_error = 0;
11141     r = guestfs_touch (g, path);
11142     if (r == -1)
11143       return -1;
11144   }
11145   {
11146     char path[] = "/new";
11147     int r;
11148     suppress_error = 1;
11149     r = guestfs_rmdir (g, path);
11150     if (r != -1)
11151       return -1;
11152   }
11153   return 0;
11154 }
11155
11156 static int test_rm_0 (void)
11157 {
11158   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
11159   {
11160     char device[] = "/dev/sda";
11161     device[5] = devchar;
11162     int r;
11163     suppress_error = 0;
11164     r = guestfs_blockdev_setrw (g, device);
11165     if (r == -1)
11166       return -1;
11167   }
11168   {
11169     int r;
11170     suppress_error = 0;
11171     r = guestfs_umount_all (g);
11172     if (r == -1)
11173       return -1;
11174   }
11175   {
11176     int r;
11177     suppress_error = 0;
11178     r = guestfs_lvm_remove_all (g);
11179     if (r == -1)
11180       return -1;
11181   }
11182   {
11183     char device[] = "/dev/sda";
11184     device[5] = devchar;
11185     char lines_0[] = ",";
11186     char *lines[] = {
11187       lines_0,
11188       NULL
11189     };
11190     int r;
11191     suppress_error = 0;
11192     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11193     if (r == -1)
11194       return -1;
11195   }
11196   {
11197     char fstype[] = "ext2";
11198     char device[] = "/dev/sda1";
11199     device[5] = devchar;
11200     int r;
11201     suppress_error = 0;
11202     r = guestfs_mkfs (g, fstype, device);
11203     if (r == -1)
11204       return -1;
11205   }
11206   {
11207     char device[] = "/dev/sda1";
11208     device[5] = devchar;
11209     char mountpoint[] = "/";
11210     int r;
11211     suppress_error = 0;
11212     r = guestfs_mount (g, device, mountpoint);
11213     if (r == -1)
11214       return -1;
11215   }
11216   /* TestRun for rm (0) */
11217   {
11218     char path[] = "/new";
11219     int r;
11220     suppress_error = 0;
11221     r = guestfs_touch (g, path);
11222     if (r == -1)
11223       return -1;
11224   }
11225   {
11226     char path[] = "/new";
11227     int r;
11228     suppress_error = 0;
11229     r = guestfs_rm (g, path);
11230     if (r == -1)
11231       return -1;
11232   }
11233   return 0;
11234 }
11235
11236 static int test_rm_1 (void)
11237 {
11238   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
11239   {
11240     char device[] = "/dev/sda";
11241     device[5] = devchar;
11242     int r;
11243     suppress_error = 0;
11244     r = guestfs_blockdev_setrw (g, device);
11245     if (r == -1)
11246       return -1;
11247   }
11248   {
11249     int r;
11250     suppress_error = 0;
11251     r = guestfs_umount_all (g);
11252     if (r == -1)
11253       return -1;
11254   }
11255   {
11256     int r;
11257     suppress_error = 0;
11258     r = guestfs_lvm_remove_all (g);
11259     if (r == -1)
11260       return -1;
11261   }
11262   {
11263     char device[] = "/dev/sda";
11264     device[5] = devchar;
11265     char lines_0[] = ",";
11266     char *lines[] = {
11267       lines_0,
11268       NULL
11269     };
11270     int r;
11271     suppress_error = 0;
11272     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11273     if (r == -1)
11274       return -1;
11275   }
11276   {
11277     char fstype[] = "ext2";
11278     char device[] = "/dev/sda1";
11279     device[5] = devchar;
11280     int r;
11281     suppress_error = 0;
11282     r = guestfs_mkfs (g, fstype, device);
11283     if (r == -1)
11284       return -1;
11285   }
11286   {
11287     char device[] = "/dev/sda1";
11288     device[5] = devchar;
11289     char mountpoint[] = "/";
11290     int r;
11291     suppress_error = 0;
11292     r = guestfs_mount (g, device, mountpoint);
11293     if (r == -1)
11294       return -1;
11295   }
11296   /* TestLastFail for rm (1) */
11297   {
11298     char path[] = "/new";
11299     int r;
11300     suppress_error = 1;
11301     r = guestfs_rm (g, path);
11302     if (r != -1)
11303       return -1;
11304   }
11305   return 0;
11306 }
11307
11308 static int test_rm_2 (void)
11309 {
11310   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
11311   {
11312     char device[] = "/dev/sda";
11313     device[5] = devchar;
11314     int r;
11315     suppress_error = 0;
11316     r = guestfs_blockdev_setrw (g, device);
11317     if (r == -1)
11318       return -1;
11319   }
11320   {
11321     int r;
11322     suppress_error = 0;
11323     r = guestfs_umount_all (g);
11324     if (r == -1)
11325       return -1;
11326   }
11327   {
11328     int r;
11329     suppress_error = 0;
11330     r = guestfs_lvm_remove_all (g);
11331     if (r == -1)
11332       return -1;
11333   }
11334   {
11335     char device[] = "/dev/sda";
11336     device[5] = devchar;
11337     char lines_0[] = ",";
11338     char *lines[] = {
11339       lines_0,
11340       NULL
11341     };
11342     int r;
11343     suppress_error = 0;
11344     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11345     if (r == -1)
11346       return -1;
11347   }
11348   {
11349     char fstype[] = "ext2";
11350     char device[] = "/dev/sda1";
11351     device[5] = devchar;
11352     int r;
11353     suppress_error = 0;
11354     r = guestfs_mkfs (g, fstype, device);
11355     if (r == -1)
11356       return -1;
11357   }
11358   {
11359     char device[] = "/dev/sda1";
11360     device[5] = devchar;
11361     char mountpoint[] = "/";
11362     int r;
11363     suppress_error = 0;
11364     r = guestfs_mount (g, device, mountpoint);
11365     if (r == -1)
11366       return -1;
11367   }
11368   /* TestLastFail for rm (2) */
11369   {
11370     char path[] = "/new";
11371     int r;
11372     suppress_error = 0;
11373     r = guestfs_mkdir (g, path);
11374     if (r == -1)
11375       return -1;
11376   }
11377   {
11378     char path[] = "/new";
11379     int r;
11380     suppress_error = 1;
11381     r = guestfs_rm (g, path);
11382     if (r != -1)
11383       return -1;
11384   }
11385   return 0;
11386 }
11387
11388 static int test_read_lines_0 (void)
11389 {
11390   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
11391   {
11392     char device[] = "/dev/sda";
11393     device[5] = devchar;
11394     int r;
11395     suppress_error = 0;
11396     r = guestfs_blockdev_setrw (g, device);
11397     if (r == -1)
11398       return -1;
11399   }
11400   {
11401     int r;
11402     suppress_error = 0;
11403     r = guestfs_umount_all (g);
11404     if (r == -1)
11405       return -1;
11406   }
11407   {
11408     int r;
11409     suppress_error = 0;
11410     r = guestfs_lvm_remove_all (g);
11411     if (r == -1)
11412       return -1;
11413   }
11414   {
11415     char device[] = "/dev/sda";
11416     device[5] = devchar;
11417     char lines_0[] = ",";
11418     char *lines[] = {
11419       lines_0,
11420       NULL
11421     };
11422     int r;
11423     suppress_error = 0;
11424     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11425     if (r == -1)
11426       return -1;
11427   }
11428   {
11429     char fstype[] = "ext2";
11430     char device[] = "/dev/sda1";
11431     device[5] = devchar;
11432     int r;
11433     suppress_error = 0;
11434     r = guestfs_mkfs (g, fstype, device);
11435     if (r == -1)
11436       return -1;
11437   }
11438   {
11439     char device[] = "/dev/sda1";
11440     device[5] = devchar;
11441     char mountpoint[] = "/";
11442     int r;
11443     suppress_error = 0;
11444     r = guestfs_mount (g, device, mountpoint);
11445     if (r == -1)
11446       return -1;
11447   }
11448   /* TestOutputList for read_lines (0) */
11449   {
11450     char path[] = "/new";
11451     char content[] = "line1\r\nline2\nline3";
11452     int r;
11453     suppress_error = 0;
11454     r = guestfs_write_file (g, path, content, 0);
11455     if (r == -1)
11456       return -1;
11457   }
11458   {
11459     char path[] = "/new";
11460     char **r;
11461     int i;
11462     suppress_error = 0;
11463     r = guestfs_read_lines (g, path);
11464     if (r == NULL)
11465       return -1;
11466     if (!r[0]) {
11467       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11468       print_strings (r);
11469       return -1;
11470     }
11471     {
11472       char expected[] = "line1";
11473       if (strcmp (r[0], expected) != 0) {
11474         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11475         return -1;
11476       }
11477     }
11478     if (!r[1]) {
11479       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11480       print_strings (r);
11481       return -1;
11482     }
11483     {
11484       char expected[] = "line2";
11485       if (strcmp (r[1], expected) != 0) {
11486         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11487         return -1;
11488       }
11489     }
11490     if (!r[2]) {
11491       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11492       print_strings (r);
11493       return -1;
11494     }
11495     {
11496       char expected[] = "line3";
11497       if (strcmp (r[2], expected) != 0) {
11498         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11499         return -1;
11500       }
11501     }
11502     if (r[3] != NULL) {
11503       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11504       print_strings (r);
11505       return -1;
11506     }
11507     for (i = 0; r[i] != NULL; ++i)
11508       free (r[i]);
11509     free (r);
11510   }
11511   return 0;
11512 }
11513
11514 static int test_read_lines_1 (void)
11515 {
11516   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
11517   {
11518     char device[] = "/dev/sda";
11519     device[5] = devchar;
11520     int r;
11521     suppress_error = 0;
11522     r = guestfs_blockdev_setrw (g, device);
11523     if (r == -1)
11524       return -1;
11525   }
11526   {
11527     int r;
11528     suppress_error = 0;
11529     r = guestfs_umount_all (g);
11530     if (r == -1)
11531       return -1;
11532   }
11533   {
11534     int r;
11535     suppress_error = 0;
11536     r = guestfs_lvm_remove_all (g);
11537     if (r == -1)
11538       return -1;
11539   }
11540   {
11541     char device[] = "/dev/sda";
11542     device[5] = devchar;
11543     char lines_0[] = ",";
11544     char *lines[] = {
11545       lines_0,
11546       NULL
11547     };
11548     int r;
11549     suppress_error = 0;
11550     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11551     if (r == -1)
11552       return -1;
11553   }
11554   {
11555     char fstype[] = "ext2";
11556     char device[] = "/dev/sda1";
11557     device[5] = devchar;
11558     int r;
11559     suppress_error = 0;
11560     r = guestfs_mkfs (g, fstype, device);
11561     if (r == -1)
11562       return -1;
11563   }
11564   {
11565     char device[] = "/dev/sda1";
11566     device[5] = devchar;
11567     char mountpoint[] = "/";
11568     int r;
11569     suppress_error = 0;
11570     r = guestfs_mount (g, device, mountpoint);
11571     if (r == -1)
11572       return -1;
11573   }
11574   /* TestOutputList for read_lines (1) */
11575   {
11576     char path[] = "/new";
11577     char content[] = "";
11578     int r;
11579     suppress_error = 0;
11580     r = guestfs_write_file (g, path, content, 0);
11581     if (r == -1)
11582       return -1;
11583   }
11584   {
11585     char path[] = "/new";
11586     char **r;
11587     int i;
11588     suppress_error = 0;
11589     r = guestfs_read_lines (g, path);
11590     if (r == NULL)
11591       return -1;
11592     if (r[0] != NULL) {
11593       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11594       print_strings (r);
11595       return -1;
11596     }
11597     for (i = 0; r[i] != NULL; ++i)
11598       free (r[i]);
11599     free (r);
11600   }
11601   return 0;
11602 }
11603
11604 static int test_lvs_0 (void)
11605 {
11606   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
11607   {
11608     char device[] = "/dev/sda";
11609     device[5] = devchar;
11610     int r;
11611     suppress_error = 0;
11612     r = guestfs_blockdev_setrw (g, device);
11613     if (r == -1)
11614       return -1;
11615   }
11616   {
11617     int r;
11618     suppress_error = 0;
11619     r = guestfs_umount_all (g);
11620     if (r == -1)
11621       return -1;
11622   }
11623   {
11624     int r;
11625     suppress_error = 0;
11626     r = guestfs_lvm_remove_all (g);
11627     if (r == -1)
11628       return -1;
11629   }
11630   {
11631     char device[] = "/dev/sda";
11632     device[5] = devchar;
11633     char lines_0[] = ",";
11634     char *lines[] = {
11635       lines_0,
11636       NULL
11637     };
11638     int r;
11639     suppress_error = 0;
11640     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11641     if (r == -1)
11642       return -1;
11643   }
11644   {
11645     char device[] = "/dev/sda1";
11646     device[5] = devchar;
11647     int r;
11648     suppress_error = 0;
11649     r = guestfs_pvcreate (g, device);
11650     if (r == -1)
11651       return -1;
11652   }
11653   {
11654     char volgroup[] = "VG";
11655     char physvols_0[] = "/dev/sda1";
11656     physvols_0[5] = devchar;
11657     char *physvols[] = {
11658       physvols_0,
11659       NULL
11660     };
11661     int r;
11662     suppress_error = 0;
11663     r = guestfs_vgcreate (g, volgroup, physvols);
11664     if (r == -1)
11665       return -1;
11666   }
11667   {
11668     char logvol[] = "LV";
11669     char volgroup[] = "VG";
11670     int r;
11671     suppress_error = 0;
11672     r = guestfs_lvcreate (g, logvol, volgroup, 8);
11673     if (r == -1)
11674       return -1;
11675   }
11676   {
11677     char fstype[] = "ext2";
11678     char device[] = "/dev/VG/LV";
11679     int r;
11680     suppress_error = 0;
11681     r = guestfs_mkfs (g, fstype, device);
11682     if (r == -1)
11683       return -1;
11684   }
11685   {
11686     char device[] = "/dev/VG/LV";
11687     char mountpoint[] = "/";
11688     int r;
11689     suppress_error = 0;
11690     r = guestfs_mount (g, device, mountpoint);
11691     if (r == -1)
11692       return -1;
11693   }
11694   /* TestOutputList for lvs (0) */
11695   {
11696     char **r;
11697     int i;
11698     suppress_error = 0;
11699     r = guestfs_lvs (g);
11700     if (r == NULL)
11701       return -1;
11702     if (!r[0]) {
11703       fprintf (stderr, "test_lvs_0: short list returned from command\n");
11704       print_strings (r);
11705       return -1;
11706     }
11707     {
11708       char expected[] = "/dev/VG/LV";
11709       if (strcmp (r[0], expected) != 0) {
11710         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11711         return -1;
11712       }
11713     }
11714     if (r[1] != NULL) {
11715       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
11716       print_strings (r);
11717       return -1;
11718     }
11719     for (i = 0; r[i] != NULL; ++i)
11720       free (r[i]);
11721     free (r);
11722   }
11723   return 0;
11724 }
11725
11726 static int test_lvs_1 (void)
11727 {
11728   /* InitNone|InitEmpty for test_lvs_1 */
11729   {
11730     char device[] = "/dev/sda";
11731     device[5] = devchar;
11732     int r;
11733     suppress_error = 0;
11734     r = guestfs_blockdev_setrw (g, device);
11735     if (r == -1)
11736       return -1;
11737   }
11738   {
11739     int r;
11740     suppress_error = 0;
11741     r = guestfs_umount_all (g);
11742     if (r == -1)
11743       return -1;
11744   }
11745   {
11746     int r;
11747     suppress_error = 0;
11748     r = guestfs_lvm_remove_all (g);
11749     if (r == -1)
11750       return -1;
11751   }
11752   /* TestOutputList for lvs (1) */
11753   {
11754     char device[] = "/dev/sda";
11755     device[5] = devchar;
11756     char lines_0[] = ",10";
11757     char lines_1[] = ",20";
11758     char lines_2[] = ",";
11759     char *lines[] = {
11760       lines_0,
11761       lines_1,
11762       lines_2,
11763       NULL
11764     };
11765     int r;
11766     suppress_error = 0;
11767     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11768     if (r == -1)
11769       return -1;
11770   }
11771   {
11772     char device[] = "/dev/sda1";
11773     device[5] = devchar;
11774     int r;
11775     suppress_error = 0;
11776     r = guestfs_pvcreate (g, device);
11777     if (r == -1)
11778       return -1;
11779   }
11780   {
11781     char device[] = "/dev/sda2";
11782     device[5] = devchar;
11783     int r;
11784     suppress_error = 0;
11785     r = guestfs_pvcreate (g, device);
11786     if (r == -1)
11787       return -1;
11788   }
11789   {
11790     char device[] = "/dev/sda3";
11791     device[5] = devchar;
11792     int r;
11793     suppress_error = 0;
11794     r = guestfs_pvcreate (g, device);
11795     if (r == -1)
11796       return -1;
11797   }
11798   {
11799     char volgroup[] = "VG1";
11800     char physvols_0[] = "/dev/sda1";
11801     physvols_0[5] = devchar;
11802     char physvols_1[] = "/dev/sda2";
11803     physvols_1[5] = devchar;
11804     char *physvols[] = {
11805       physvols_0,
11806       physvols_1,
11807       NULL
11808     };
11809     int r;
11810     suppress_error = 0;
11811     r = guestfs_vgcreate (g, volgroup, physvols);
11812     if (r == -1)
11813       return -1;
11814   }
11815   {
11816     char volgroup[] = "VG2";
11817     char physvols_0[] = "/dev/sda3";
11818     physvols_0[5] = devchar;
11819     char *physvols[] = {
11820       physvols_0,
11821       NULL
11822     };
11823     int r;
11824     suppress_error = 0;
11825     r = guestfs_vgcreate (g, volgroup, physvols);
11826     if (r == -1)
11827       return -1;
11828   }
11829   {
11830     char logvol[] = "LV1";
11831     char volgroup[] = "VG1";
11832     int r;
11833     suppress_error = 0;
11834     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11835     if (r == -1)
11836       return -1;
11837   }
11838   {
11839     char logvol[] = "LV2";
11840     char volgroup[] = "VG1";
11841     int r;
11842     suppress_error = 0;
11843     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11844     if (r == -1)
11845       return -1;
11846   }
11847   {
11848     char logvol[] = "LV3";
11849     char volgroup[] = "VG2";
11850     int r;
11851     suppress_error = 0;
11852     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11853     if (r == -1)
11854       return -1;
11855   }
11856   {
11857     char **r;
11858     int i;
11859     suppress_error = 0;
11860     r = guestfs_lvs (g);
11861     if (r == NULL)
11862       return -1;
11863     if (!r[0]) {
11864       fprintf (stderr, "test_lvs_1: short list returned from command\n");
11865       print_strings (r);
11866       return -1;
11867     }
11868     {
11869       char expected[] = "/dev/VG1/LV1";
11870       if (strcmp (r[0], expected) != 0) {
11871         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11872         return -1;
11873       }
11874     }
11875     if (!r[1]) {
11876       fprintf (stderr, "test_lvs_1: short list returned from command\n");
11877       print_strings (r);
11878       return -1;
11879     }
11880     {
11881       char expected[] = "/dev/VG1/LV2";
11882       if (strcmp (r[1], expected) != 0) {
11883         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11884         return -1;
11885       }
11886     }
11887     if (!r[2]) {
11888       fprintf (stderr, "test_lvs_1: short list returned from command\n");
11889       print_strings (r);
11890       return -1;
11891     }
11892     {
11893       char expected[] = "/dev/VG2/LV3";
11894       if (strcmp (r[2], expected) != 0) {
11895         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11896         return -1;
11897       }
11898     }
11899     if (r[3] != NULL) {
11900       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
11901       print_strings (r);
11902       return -1;
11903     }
11904     for (i = 0; r[i] != NULL; ++i)
11905       free (r[i]);
11906     free (r);
11907   }
11908   return 0;
11909 }
11910
11911 static int test_vgs_0 (void)
11912 {
11913   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
11914   {
11915     char device[] = "/dev/sda";
11916     device[5] = devchar;
11917     int r;
11918     suppress_error = 0;
11919     r = guestfs_blockdev_setrw (g, device);
11920     if (r == -1)
11921       return -1;
11922   }
11923   {
11924     int r;
11925     suppress_error = 0;
11926     r = guestfs_umount_all (g);
11927     if (r == -1)
11928       return -1;
11929   }
11930   {
11931     int r;
11932     suppress_error = 0;
11933     r = guestfs_lvm_remove_all (g);
11934     if (r == -1)
11935       return -1;
11936   }
11937   {
11938     char device[] = "/dev/sda";
11939     device[5] = devchar;
11940     char lines_0[] = ",";
11941     char *lines[] = {
11942       lines_0,
11943       NULL
11944     };
11945     int r;
11946     suppress_error = 0;
11947     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11948     if (r == -1)
11949       return -1;
11950   }
11951   {
11952     char device[] = "/dev/sda1";
11953     device[5] = devchar;
11954     int r;
11955     suppress_error = 0;
11956     r = guestfs_pvcreate (g, device);
11957     if (r == -1)
11958       return -1;
11959   }
11960   {
11961     char volgroup[] = "VG";
11962     char physvols_0[] = "/dev/sda1";
11963     physvols_0[5] = devchar;
11964     char *physvols[] = {
11965       physvols_0,
11966       NULL
11967     };
11968     int r;
11969     suppress_error = 0;
11970     r = guestfs_vgcreate (g, volgroup, physvols);
11971     if (r == -1)
11972       return -1;
11973   }
11974   {
11975     char logvol[] = "LV";
11976     char volgroup[] = "VG";
11977     int r;
11978     suppress_error = 0;
11979     r = guestfs_lvcreate (g, logvol, volgroup, 8);
11980     if (r == -1)
11981       return -1;
11982   }
11983   {
11984     char fstype[] = "ext2";
11985     char device[] = "/dev/VG/LV";
11986     int r;
11987     suppress_error = 0;
11988     r = guestfs_mkfs (g, fstype, device);
11989     if (r == -1)
11990       return -1;
11991   }
11992   {
11993     char device[] = "/dev/VG/LV";
11994     char mountpoint[] = "/";
11995     int r;
11996     suppress_error = 0;
11997     r = guestfs_mount (g, device, mountpoint);
11998     if (r == -1)
11999       return -1;
12000   }
12001   /* TestOutputList for vgs (0) */
12002   {
12003     char **r;
12004     int i;
12005     suppress_error = 0;
12006     r = guestfs_vgs (g);
12007     if (r == NULL)
12008       return -1;
12009     if (!r[0]) {
12010       fprintf (stderr, "test_vgs_0: short list returned from command\n");
12011       print_strings (r);
12012       return -1;
12013     }
12014     {
12015       char expected[] = "VG";
12016       if (strcmp (r[0], expected) != 0) {
12017         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12018         return -1;
12019       }
12020     }
12021     if (r[1] != NULL) {
12022       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
12023       print_strings (r);
12024       return -1;
12025     }
12026     for (i = 0; r[i] != NULL; ++i)
12027       free (r[i]);
12028     free (r);
12029   }
12030   return 0;
12031 }
12032
12033 static int test_vgs_1 (void)
12034 {
12035   /* InitNone|InitEmpty for test_vgs_1 */
12036   {
12037     char device[] = "/dev/sda";
12038     device[5] = devchar;
12039     int r;
12040     suppress_error = 0;
12041     r = guestfs_blockdev_setrw (g, device);
12042     if (r == -1)
12043       return -1;
12044   }
12045   {
12046     int r;
12047     suppress_error = 0;
12048     r = guestfs_umount_all (g);
12049     if (r == -1)
12050       return -1;
12051   }
12052   {
12053     int r;
12054     suppress_error = 0;
12055     r = guestfs_lvm_remove_all (g);
12056     if (r == -1)
12057       return -1;
12058   }
12059   /* TestOutputList for vgs (1) */
12060   {
12061     char device[] = "/dev/sda";
12062     device[5] = devchar;
12063     char lines_0[] = ",10";
12064     char lines_1[] = ",20";
12065     char lines_2[] = ",";
12066     char *lines[] = {
12067       lines_0,
12068       lines_1,
12069       lines_2,
12070       NULL
12071     };
12072     int r;
12073     suppress_error = 0;
12074     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12075     if (r == -1)
12076       return -1;
12077   }
12078   {
12079     char device[] = "/dev/sda1";
12080     device[5] = devchar;
12081     int r;
12082     suppress_error = 0;
12083     r = guestfs_pvcreate (g, device);
12084     if (r == -1)
12085       return -1;
12086   }
12087   {
12088     char device[] = "/dev/sda2";
12089     device[5] = devchar;
12090     int r;
12091     suppress_error = 0;
12092     r = guestfs_pvcreate (g, device);
12093     if (r == -1)
12094       return -1;
12095   }
12096   {
12097     char device[] = "/dev/sda3";
12098     device[5] = devchar;
12099     int r;
12100     suppress_error = 0;
12101     r = guestfs_pvcreate (g, device);
12102     if (r == -1)
12103       return -1;
12104   }
12105   {
12106     char volgroup[] = "VG1";
12107     char physvols_0[] = "/dev/sda1";
12108     physvols_0[5] = devchar;
12109     char physvols_1[] = "/dev/sda2";
12110     physvols_1[5] = devchar;
12111     char *physvols[] = {
12112       physvols_0,
12113       physvols_1,
12114       NULL
12115     };
12116     int r;
12117     suppress_error = 0;
12118     r = guestfs_vgcreate (g, volgroup, physvols);
12119     if (r == -1)
12120       return -1;
12121   }
12122   {
12123     char volgroup[] = "VG2";
12124     char physvols_0[] = "/dev/sda3";
12125     physvols_0[5] = devchar;
12126     char *physvols[] = {
12127       physvols_0,
12128       NULL
12129     };
12130     int r;
12131     suppress_error = 0;
12132     r = guestfs_vgcreate (g, volgroup, physvols);
12133     if (r == -1)
12134       return -1;
12135   }
12136   {
12137     char **r;
12138     int i;
12139     suppress_error = 0;
12140     r = guestfs_vgs (g);
12141     if (r == NULL)
12142       return -1;
12143     if (!r[0]) {
12144       fprintf (stderr, "test_vgs_1: short list returned from command\n");
12145       print_strings (r);
12146       return -1;
12147     }
12148     {
12149       char expected[] = "VG1";
12150       if (strcmp (r[0], expected) != 0) {
12151         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12152         return -1;
12153       }
12154     }
12155     if (!r[1]) {
12156       fprintf (stderr, "test_vgs_1: short list returned from command\n");
12157       print_strings (r);
12158       return -1;
12159     }
12160     {
12161       char expected[] = "VG2";
12162       if (strcmp (r[1], expected) != 0) {
12163         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12164         return -1;
12165       }
12166     }
12167     if (r[2] != NULL) {
12168       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
12169       print_strings (r);
12170       return -1;
12171     }
12172     for (i = 0; r[i] != NULL; ++i)
12173       free (r[i]);
12174     free (r);
12175   }
12176   return 0;
12177 }
12178
12179 static int test_pvs_0 (void)
12180 {
12181   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
12182   {
12183     char device[] = "/dev/sda";
12184     device[5] = devchar;
12185     int r;
12186     suppress_error = 0;
12187     r = guestfs_blockdev_setrw (g, device);
12188     if (r == -1)
12189       return -1;
12190   }
12191   {
12192     int r;
12193     suppress_error = 0;
12194     r = guestfs_umount_all (g);
12195     if (r == -1)
12196       return -1;
12197   }
12198   {
12199     int r;
12200     suppress_error = 0;
12201     r = guestfs_lvm_remove_all (g);
12202     if (r == -1)
12203       return -1;
12204   }
12205   {
12206     char device[] = "/dev/sda";
12207     device[5] = devchar;
12208     char lines_0[] = ",";
12209     char *lines[] = {
12210       lines_0,
12211       NULL
12212     };
12213     int r;
12214     suppress_error = 0;
12215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12216     if (r == -1)
12217       return -1;
12218   }
12219   {
12220     char device[] = "/dev/sda1";
12221     device[5] = devchar;
12222     int r;
12223     suppress_error = 0;
12224     r = guestfs_pvcreate (g, device);
12225     if (r == -1)
12226       return -1;
12227   }
12228   {
12229     char volgroup[] = "VG";
12230     char physvols_0[] = "/dev/sda1";
12231     physvols_0[5] = devchar;
12232     char *physvols[] = {
12233       physvols_0,
12234       NULL
12235     };
12236     int r;
12237     suppress_error = 0;
12238     r = guestfs_vgcreate (g, volgroup, physvols);
12239     if (r == -1)
12240       return -1;
12241   }
12242   {
12243     char logvol[] = "LV";
12244     char volgroup[] = "VG";
12245     int r;
12246     suppress_error = 0;
12247     r = guestfs_lvcreate (g, logvol, volgroup, 8);
12248     if (r == -1)
12249       return -1;
12250   }
12251   {
12252     char fstype[] = "ext2";
12253     char device[] = "/dev/VG/LV";
12254     int r;
12255     suppress_error = 0;
12256     r = guestfs_mkfs (g, fstype, device);
12257     if (r == -1)
12258       return -1;
12259   }
12260   {
12261     char device[] = "/dev/VG/LV";
12262     char mountpoint[] = "/";
12263     int r;
12264     suppress_error = 0;
12265     r = guestfs_mount (g, device, mountpoint);
12266     if (r == -1)
12267       return -1;
12268   }
12269   /* TestOutputList for pvs (0) */
12270   {
12271     char **r;
12272     int i;
12273     suppress_error = 0;
12274     r = guestfs_pvs (g);
12275     if (r == NULL)
12276       return -1;
12277     if (!r[0]) {
12278       fprintf (stderr, "test_pvs_0: short list returned from command\n");
12279       print_strings (r);
12280       return -1;
12281     }
12282     {
12283       char expected[] = "/dev/sda1";
12284       expected[5] = devchar;
12285       if (strcmp (r[0], expected) != 0) {
12286         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12287         return -1;
12288       }
12289     }
12290     if (r[1] != NULL) {
12291       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12292       print_strings (r);
12293       return -1;
12294     }
12295     for (i = 0; r[i] != NULL; ++i)
12296       free (r[i]);
12297     free (r);
12298   }
12299   return 0;
12300 }
12301
12302 static int test_pvs_1 (void)
12303 {
12304   /* InitNone|InitEmpty for test_pvs_1 */
12305   {
12306     char device[] = "/dev/sda";
12307     device[5] = devchar;
12308     int r;
12309     suppress_error = 0;
12310     r = guestfs_blockdev_setrw (g, device);
12311     if (r == -1)
12312       return -1;
12313   }
12314   {
12315     int r;
12316     suppress_error = 0;
12317     r = guestfs_umount_all (g);
12318     if (r == -1)
12319       return -1;
12320   }
12321   {
12322     int r;
12323     suppress_error = 0;
12324     r = guestfs_lvm_remove_all (g);
12325     if (r == -1)
12326       return -1;
12327   }
12328   /* TestOutputList for pvs (1) */
12329   {
12330     char device[] = "/dev/sda";
12331     device[5] = devchar;
12332     char lines_0[] = ",10";
12333     char lines_1[] = ",20";
12334     char lines_2[] = ",";
12335     char *lines[] = {
12336       lines_0,
12337       lines_1,
12338       lines_2,
12339       NULL
12340     };
12341     int r;
12342     suppress_error = 0;
12343     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12344     if (r == -1)
12345       return -1;
12346   }
12347   {
12348     char device[] = "/dev/sda1";
12349     device[5] = devchar;
12350     int r;
12351     suppress_error = 0;
12352     r = guestfs_pvcreate (g, device);
12353     if (r == -1)
12354       return -1;
12355   }
12356   {
12357     char device[] = "/dev/sda2";
12358     device[5] = devchar;
12359     int r;
12360     suppress_error = 0;
12361     r = guestfs_pvcreate (g, device);
12362     if (r == -1)
12363       return -1;
12364   }
12365   {
12366     char device[] = "/dev/sda3";
12367     device[5] = devchar;
12368     int r;
12369     suppress_error = 0;
12370     r = guestfs_pvcreate (g, device);
12371     if (r == -1)
12372       return -1;
12373   }
12374   {
12375     char **r;
12376     int i;
12377     suppress_error = 0;
12378     r = guestfs_pvs (g);
12379     if (r == NULL)
12380       return -1;
12381     if (!r[0]) {
12382       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12383       print_strings (r);
12384       return -1;
12385     }
12386     {
12387       char expected[] = "/dev/sda1";
12388       expected[5] = devchar;
12389       if (strcmp (r[0], expected) != 0) {
12390         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12391         return -1;
12392       }
12393     }
12394     if (!r[1]) {
12395       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12396       print_strings (r);
12397       return -1;
12398     }
12399     {
12400       char expected[] = "/dev/sda2";
12401       expected[5] = devchar;
12402       if (strcmp (r[1], expected) != 0) {
12403         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12404         return -1;
12405       }
12406     }
12407     if (!r[2]) {
12408       fprintf (stderr, "test_pvs_1: short list returned from command\n");
12409       print_strings (r);
12410       return -1;
12411     }
12412     {
12413       char expected[] = "/dev/sda3";
12414       expected[5] = devchar;
12415       if (strcmp (r[2], expected) != 0) {
12416         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12417         return -1;
12418       }
12419     }
12420     if (r[3] != NULL) {
12421       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12422       print_strings (r);
12423       return -1;
12424     }
12425     for (i = 0; r[i] != NULL; ++i)
12426       free (r[i]);
12427     free (r);
12428   }
12429   return 0;
12430 }
12431
12432 static int test_list_partitions_0 (void)
12433 {
12434   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
12435   {
12436     char device[] = "/dev/sda";
12437     device[5] = devchar;
12438     int r;
12439     suppress_error = 0;
12440     r = guestfs_blockdev_setrw (g, device);
12441     if (r == -1)
12442       return -1;
12443   }
12444   {
12445     int r;
12446     suppress_error = 0;
12447     r = guestfs_umount_all (g);
12448     if (r == -1)
12449       return -1;
12450   }
12451   {
12452     int r;
12453     suppress_error = 0;
12454     r = guestfs_lvm_remove_all (g);
12455     if (r == -1)
12456       return -1;
12457   }
12458   {
12459     char device[] = "/dev/sda";
12460     device[5] = devchar;
12461     char lines_0[] = ",";
12462     char *lines[] = {
12463       lines_0,
12464       NULL
12465     };
12466     int r;
12467     suppress_error = 0;
12468     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12469     if (r == -1)
12470       return -1;
12471   }
12472   {
12473     char fstype[] = "ext2";
12474     char device[] = "/dev/sda1";
12475     device[5] = devchar;
12476     int r;
12477     suppress_error = 0;
12478     r = guestfs_mkfs (g, fstype, device);
12479     if (r == -1)
12480       return -1;
12481   }
12482   {
12483     char device[] = "/dev/sda1";
12484     device[5] = devchar;
12485     char mountpoint[] = "/";
12486     int r;
12487     suppress_error = 0;
12488     r = guestfs_mount (g, device, mountpoint);
12489     if (r == -1)
12490       return -1;
12491   }
12492   /* TestOutputList for list_partitions (0) */
12493   {
12494     char **r;
12495     int i;
12496     suppress_error = 0;
12497     r = guestfs_list_partitions (g);
12498     if (r == NULL)
12499       return -1;
12500     if (!r[0]) {
12501       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12502       print_strings (r);
12503       return -1;
12504     }
12505     {
12506       char expected[] = "/dev/sda1";
12507       expected[5] = devchar;
12508       if (strcmp (r[0], expected) != 0) {
12509         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12510         return -1;
12511       }
12512     }
12513     if (r[1] != NULL) {
12514       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12515       print_strings (r);
12516       return -1;
12517     }
12518     for (i = 0; r[i] != NULL; ++i)
12519       free (r[i]);
12520     free (r);
12521   }
12522   return 0;
12523 }
12524
12525 static int test_list_partitions_1 (void)
12526 {
12527   /* InitNone|InitEmpty for test_list_partitions_1 */
12528   {
12529     char device[] = "/dev/sda";
12530     device[5] = devchar;
12531     int r;
12532     suppress_error = 0;
12533     r = guestfs_blockdev_setrw (g, device);
12534     if (r == -1)
12535       return -1;
12536   }
12537   {
12538     int r;
12539     suppress_error = 0;
12540     r = guestfs_umount_all (g);
12541     if (r == -1)
12542       return -1;
12543   }
12544   {
12545     int r;
12546     suppress_error = 0;
12547     r = guestfs_lvm_remove_all (g);
12548     if (r == -1)
12549       return -1;
12550   }
12551   /* TestOutputList for list_partitions (1) */
12552   {
12553     char device[] = "/dev/sda";
12554     device[5] = devchar;
12555     char lines_0[] = ",10";
12556     char lines_1[] = ",20";
12557     char lines_2[] = ",";
12558     char *lines[] = {
12559       lines_0,
12560       lines_1,
12561       lines_2,
12562       NULL
12563     };
12564     int r;
12565     suppress_error = 0;
12566     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12567     if (r == -1)
12568       return -1;
12569   }
12570   {
12571     char **r;
12572     int i;
12573     suppress_error = 0;
12574     r = guestfs_list_partitions (g);
12575     if (r == NULL)
12576       return -1;
12577     if (!r[0]) {
12578       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12579       print_strings (r);
12580       return -1;
12581     }
12582     {
12583       char expected[] = "/dev/sda1";
12584       expected[5] = devchar;
12585       if (strcmp (r[0], expected) != 0) {
12586         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12587         return -1;
12588       }
12589     }
12590     if (!r[1]) {
12591       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12592       print_strings (r);
12593       return -1;
12594     }
12595     {
12596       char expected[] = "/dev/sda2";
12597       expected[5] = devchar;
12598       if (strcmp (r[1], expected) != 0) {
12599         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12600         return -1;
12601       }
12602     }
12603     if (!r[2]) {
12604       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12605       print_strings (r);
12606       return -1;
12607     }
12608     {
12609       char expected[] = "/dev/sda3";
12610       expected[5] = devchar;
12611       if (strcmp (r[2], expected) != 0) {
12612         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12613         return -1;
12614       }
12615     }
12616     if (r[3] != NULL) {
12617       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12618       print_strings (r);
12619       return -1;
12620     }
12621     for (i = 0; r[i] != NULL; ++i)
12622       free (r[i]);
12623     free (r);
12624   }
12625   return 0;
12626 }
12627
12628 static int test_list_devices_0 (void)
12629 {
12630   /* InitNone|InitEmpty for test_list_devices_0 */
12631   {
12632     char device[] = "/dev/sda";
12633     device[5] = devchar;
12634     int r;
12635     suppress_error = 0;
12636     r = guestfs_blockdev_setrw (g, device);
12637     if (r == -1)
12638       return -1;
12639   }
12640   {
12641     int r;
12642     suppress_error = 0;
12643     r = guestfs_umount_all (g);
12644     if (r == -1)
12645       return -1;
12646   }
12647   {
12648     int r;
12649     suppress_error = 0;
12650     r = guestfs_lvm_remove_all (g);
12651     if (r == -1)
12652       return -1;
12653   }
12654   /* TestOutputList for list_devices (0) */
12655   {
12656     char **r;
12657     int i;
12658     suppress_error = 0;
12659     r = guestfs_list_devices (g);
12660     if (r == NULL)
12661       return -1;
12662     if (!r[0]) {
12663       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12664       print_strings (r);
12665       return -1;
12666     }
12667     {
12668       char expected[] = "/dev/sda";
12669       expected[5] = devchar;
12670       if (strcmp (r[0], expected) != 0) {
12671         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12672         return -1;
12673       }
12674     }
12675     if (!r[1]) {
12676       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12677       print_strings (r);
12678       return -1;
12679     }
12680     {
12681       char expected[] = "/dev/sdb";
12682       expected[5] = devchar;
12683       if (strcmp (r[1], expected) != 0) {
12684         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12685         return -1;
12686       }
12687     }
12688     if (!r[2]) {
12689       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12690       print_strings (r);
12691       return -1;
12692     }
12693     {
12694       char expected[] = "/dev/sdc";
12695       expected[5] = devchar;
12696       if (strcmp (r[2], expected) != 0) {
12697         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12698         return -1;
12699       }
12700     }
12701     if (r[3] != NULL) {
12702       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
12703       print_strings (r);
12704       return -1;
12705     }
12706     for (i = 0; r[i] != NULL; ++i)
12707       free (r[i]);
12708     free (r);
12709   }
12710   return 0;
12711 }
12712
12713 static int test_ls_0 (void)
12714 {
12715   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
12716   {
12717     char device[] = "/dev/sda";
12718     device[5] = devchar;
12719     int r;
12720     suppress_error = 0;
12721     r = guestfs_blockdev_setrw (g, device);
12722     if (r == -1)
12723       return -1;
12724   }
12725   {
12726     int r;
12727     suppress_error = 0;
12728     r = guestfs_umount_all (g);
12729     if (r == -1)
12730       return -1;
12731   }
12732   {
12733     int r;
12734     suppress_error = 0;
12735     r = guestfs_lvm_remove_all (g);
12736     if (r == -1)
12737       return -1;
12738   }
12739   {
12740     char device[] = "/dev/sda";
12741     device[5] = devchar;
12742     char lines_0[] = ",";
12743     char *lines[] = {
12744       lines_0,
12745       NULL
12746     };
12747     int r;
12748     suppress_error = 0;
12749     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12750     if (r == -1)
12751       return -1;
12752   }
12753   {
12754     char fstype[] = "ext2";
12755     char device[] = "/dev/sda1";
12756     device[5] = devchar;
12757     int r;
12758     suppress_error = 0;
12759     r = guestfs_mkfs (g, fstype, device);
12760     if (r == -1)
12761       return -1;
12762   }
12763   {
12764     char device[] = "/dev/sda1";
12765     device[5] = devchar;
12766     char mountpoint[] = "/";
12767     int r;
12768     suppress_error = 0;
12769     r = guestfs_mount (g, device, mountpoint);
12770     if (r == -1)
12771       return -1;
12772   }
12773   /* TestOutputList for ls (0) */
12774   {
12775     char path[] = "/new";
12776     int r;
12777     suppress_error = 0;
12778     r = guestfs_touch (g, path);
12779     if (r == -1)
12780       return -1;
12781   }
12782   {
12783     char path[] = "/newer";
12784     int r;
12785     suppress_error = 0;
12786     r = guestfs_touch (g, path);
12787     if (r == -1)
12788       return -1;
12789   }
12790   {
12791     char path[] = "/newest";
12792     int r;
12793     suppress_error = 0;
12794     r = guestfs_touch (g, path);
12795     if (r == -1)
12796       return -1;
12797   }
12798   {
12799     char directory[] = "/";
12800     char **r;
12801     int i;
12802     suppress_error = 0;
12803     r = guestfs_ls (g, directory);
12804     if (r == NULL)
12805       return -1;
12806     if (!r[0]) {
12807       fprintf (stderr, "test_ls_0: short list returned from command\n");
12808       print_strings (r);
12809       return -1;
12810     }
12811     {
12812       char expected[] = "lost+found";
12813       if (strcmp (r[0], expected) != 0) {
12814         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12815         return -1;
12816       }
12817     }
12818     if (!r[1]) {
12819       fprintf (stderr, "test_ls_0: short list returned from command\n");
12820       print_strings (r);
12821       return -1;
12822     }
12823     {
12824       char expected[] = "new";
12825       if (strcmp (r[1], expected) != 0) {
12826         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12827         return -1;
12828       }
12829     }
12830     if (!r[2]) {
12831       fprintf (stderr, "test_ls_0: short list returned from command\n");
12832       print_strings (r);
12833       return -1;
12834     }
12835     {
12836       char expected[] = "newer";
12837       if (strcmp (r[2], expected) != 0) {
12838         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12839         return -1;
12840       }
12841     }
12842     if (!r[3]) {
12843       fprintf (stderr, "test_ls_0: short list returned from command\n");
12844       print_strings (r);
12845       return -1;
12846     }
12847     {
12848       char expected[] = "newest";
12849       if (strcmp (r[3], expected) != 0) {
12850         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12851         return -1;
12852       }
12853     }
12854     if (r[4] != NULL) {
12855       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
12856       print_strings (r);
12857       return -1;
12858     }
12859     for (i = 0; r[i] != NULL; ++i)
12860       free (r[i]);
12861     free (r);
12862   }
12863   return 0;
12864 }
12865
12866 static int test_cat_0 (void)
12867 {
12868   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
12869   {
12870     char device[] = "/dev/sda";
12871     device[5] = devchar;
12872     int r;
12873     suppress_error = 0;
12874     r = guestfs_blockdev_setrw (g, device);
12875     if (r == -1)
12876       return -1;
12877   }
12878   {
12879     int r;
12880     suppress_error = 0;
12881     r = guestfs_umount_all (g);
12882     if (r == -1)
12883       return -1;
12884   }
12885   {
12886     int r;
12887     suppress_error = 0;
12888     r = guestfs_lvm_remove_all (g);
12889     if (r == -1)
12890       return -1;
12891   }
12892   {
12893     char device[] = "/dev/sda";
12894     device[5] = devchar;
12895     char lines_0[] = ",";
12896     char *lines[] = {
12897       lines_0,
12898       NULL
12899     };
12900     int r;
12901     suppress_error = 0;
12902     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12903     if (r == -1)
12904       return -1;
12905   }
12906   {
12907     char fstype[] = "ext2";
12908     char device[] = "/dev/sda1";
12909     device[5] = devchar;
12910     int r;
12911     suppress_error = 0;
12912     r = guestfs_mkfs (g, fstype, device);
12913     if (r == -1)
12914       return -1;
12915   }
12916   {
12917     char device[] = "/dev/sda1";
12918     device[5] = devchar;
12919     char mountpoint[] = "/";
12920     int r;
12921     suppress_error = 0;
12922     r = guestfs_mount (g, device, mountpoint);
12923     if (r == -1)
12924       return -1;
12925   }
12926   /* TestOutput for cat (0) */
12927   char expected[] = "new file contents";
12928   {
12929     char path[] = "/new";
12930     char content[] = "new file contents";
12931     int r;
12932     suppress_error = 0;
12933     r = guestfs_write_file (g, path, content, 0);
12934     if (r == -1)
12935       return -1;
12936   }
12937   {
12938     char path[] = "/new";
12939     char *r;
12940     suppress_error = 0;
12941     r = guestfs_cat (g, path);
12942     if (r == NULL)
12943       return -1;
12944     if (strcmp (r, expected) != 0) {
12945       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
12946       return -1;
12947     }
12948     free (r);
12949   }
12950   return 0;
12951 }
12952
12953 static int test_touch_0 (void)
12954 {
12955   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
12956   {
12957     char device[] = "/dev/sda";
12958     device[5] = devchar;
12959     int r;
12960     suppress_error = 0;
12961     r = guestfs_blockdev_setrw (g, device);
12962     if (r == -1)
12963       return -1;
12964   }
12965   {
12966     int r;
12967     suppress_error = 0;
12968     r = guestfs_umount_all (g);
12969     if (r == -1)
12970       return -1;
12971   }
12972   {
12973     int r;
12974     suppress_error = 0;
12975     r = guestfs_lvm_remove_all (g);
12976     if (r == -1)
12977       return -1;
12978   }
12979   {
12980     char device[] = "/dev/sda";
12981     device[5] = devchar;
12982     char lines_0[] = ",";
12983     char *lines[] = {
12984       lines_0,
12985       NULL
12986     };
12987     int r;
12988     suppress_error = 0;
12989     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12990     if (r == -1)
12991       return -1;
12992   }
12993   {
12994     char fstype[] = "ext2";
12995     char device[] = "/dev/sda1";
12996     device[5] = devchar;
12997     int r;
12998     suppress_error = 0;
12999     r = guestfs_mkfs (g, fstype, device);
13000     if (r == -1)
13001       return -1;
13002   }
13003   {
13004     char device[] = "/dev/sda1";
13005     device[5] = devchar;
13006     char mountpoint[] = "/";
13007     int r;
13008     suppress_error = 0;
13009     r = guestfs_mount (g, device, mountpoint);
13010     if (r == -1)
13011       return -1;
13012   }
13013   /* TestOutputTrue for touch (0) */
13014   {
13015     char path[] = "/new";
13016     int r;
13017     suppress_error = 0;
13018     r = guestfs_touch (g, path);
13019     if (r == -1)
13020       return -1;
13021   }
13022   {
13023     char path[] = "/new";
13024     int r;
13025     suppress_error = 0;
13026     r = guestfs_exists (g, path);
13027     if (r == -1)
13028       return -1;
13029     if (!r) {
13030       fprintf (stderr, "test_touch_0: expected true, got false\n");
13031       return -1;
13032     }
13033   }
13034   return 0;
13035 }
13036
13037 static int test_sync_0 (void)
13038 {
13039   /* InitNone|InitEmpty for test_sync_0 */
13040   {
13041     char device[] = "/dev/sda";
13042     device[5] = devchar;
13043     int r;
13044     suppress_error = 0;
13045     r = guestfs_blockdev_setrw (g, device);
13046     if (r == -1)
13047       return -1;
13048   }
13049   {
13050     int r;
13051     suppress_error = 0;
13052     r = guestfs_umount_all (g);
13053     if (r == -1)
13054       return -1;
13055   }
13056   {
13057     int r;
13058     suppress_error = 0;
13059     r = guestfs_lvm_remove_all (g);
13060     if (r == -1)
13061       return -1;
13062   }
13063   /* TestRun for sync (0) */
13064   {
13065     int r;
13066     suppress_error = 0;
13067     r = guestfs_sync (g);
13068     if (r == -1)
13069       return -1;
13070   }
13071   return 0;
13072 }
13073
13074 static int test_mount_0 (void)
13075 {
13076   /* InitNone|InitEmpty for test_mount_0 */
13077   {
13078     char device[] = "/dev/sda";
13079     device[5] = devchar;
13080     int r;
13081     suppress_error = 0;
13082     r = guestfs_blockdev_setrw (g, device);
13083     if (r == -1)
13084       return -1;
13085   }
13086   {
13087     int r;
13088     suppress_error = 0;
13089     r = guestfs_umount_all (g);
13090     if (r == -1)
13091       return -1;
13092   }
13093   {
13094     int r;
13095     suppress_error = 0;
13096     r = guestfs_lvm_remove_all (g);
13097     if (r == -1)
13098       return -1;
13099   }
13100   /* TestOutput for mount (0) */
13101   char expected[] = "new file contents";
13102   {
13103     char device[] = "/dev/sda";
13104     device[5] = devchar;
13105     char lines_0[] = ",";
13106     char *lines[] = {
13107       lines_0,
13108       NULL
13109     };
13110     int r;
13111     suppress_error = 0;
13112     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13113     if (r == -1)
13114       return -1;
13115   }
13116   {
13117     char fstype[] = "ext2";
13118     char device[] = "/dev/sda1";
13119     device[5] = devchar;
13120     int r;
13121     suppress_error = 0;
13122     r = guestfs_mkfs (g, fstype, device);
13123     if (r == -1)
13124       return -1;
13125   }
13126   {
13127     char device[] = "/dev/sda1";
13128     device[5] = devchar;
13129     char mountpoint[] = "/";
13130     int r;
13131     suppress_error = 0;
13132     r = guestfs_mount (g, device, mountpoint);
13133     if (r == -1)
13134       return -1;
13135   }
13136   {
13137     char path[] = "/new";
13138     char content[] = "new file contents";
13139     int r;
13140     suppress_error = 0;
13141     r = guestfs_write_file (g, path, content, 0);
13142     if (r == -1)
13143       return -1;
13144   }
13145   {
13146     char path[] = "/new";
13147     char *r;
13148     suppress_error = 0;
13149     r = guestfs_cat (g, path);
13150     if (r == NULL)
13151       return -1;
13152     if (strcmp (r, expected) != 0) {
13153       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
13154       return -1;
13155     }
13156     free (r);
13157   }
13158   return 0;
13159 }
13160
13161 int main (int argc, char *argv[])
13162 {
13163   char c = 0;
13164   int failed = 0;
13165   const char *srcdir;
13166   const char *filename;
13167   int fd, i;
13168   int nr_tests, test_num = 0;
13169   char **devs;
13170
13171   no_test_warnings ();
13172
13173   g = guestfs_create ();
13174   if (g == NULL) {
13175     printf ("guestfs_create FAILED\n");
13176     exit (1);
13177   }
13178
13179   guestfs_set_error_handler (g, print_error, NULL);
13180
13181   srcdir = getenv ("srcdir");
13182   if (!srcdir) srcdir = ".";
13183   chdir (srcdir);
13184   guestfs_set_path (g, ".");
13185
13186   filename = "test1.img";
13187   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13188   if (fd == -1) {
13189     perror (filename);
13190     exit (1);
13191   }
13192   if (lseek (fd, 524288000, SEEK_SET) == -1) {
13193     perror ("lseek");
13194     close (fd);
13195     unlink (filename);
13196     exit (1);
13197   }
13198   if (write (fd, &c, 1) == -1) {
13199     perror ("write");
13200     close (fd);
13201     unlink (filename);
13202     exit (1);
13203   }
13204   if (close (fd) == -1) {
13205     perror (filename);
13206     unlink (filename);
13207     exit (1);
13208   }
13209   if (guestfs_add_drive (g, filename) == -1) {
13210     printf ("guestfs_add_drive %s FAILED\n", filename);
13211     exit (1);
13212   }
13213
13214   filename = "test2.img";
13215   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13216   if (fd == -1) {
13217     perror (filename);
13218     exit (1);
13219   }
13220   if (lseek (fd, 52428800, SEEK_SET) == -1) {
13221     perror ("lseek");
13222     close (fd);
13223     unlink (filename);
13224     exit (1);
13225   }
13226   if (write (fd, &c, 1) == -1) {
13227     perror ("write");
13228     close (fd);
13229     unlink (filename);
13230     exit (1);
13231   }
13232   if (close (fd) == -1) {
13233     perror (filename);
13234     unlink (filename);
13235     exit (1);
13236   }
13237   if (guestfs_add_drive (g, filename) == -1) {
13238     printf ("guestfs_add_drive %s FAILED\n", filename);
13239     exit (1);
13240   }
13241
13242   filename = "test3.img";
13243   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13244   if (fd == -1) {
13245     perror (filename);
13246     exit (1);
13247   }
13248   if (lseek (fd, 10485760, SEEK_SET) == -1) {
13249     perror ("lseek");
13250     close (fd);
13251     unlink (filename);
13252     exit (1);
13253   }
13254   if (write (fd, &c, 1) == -1) {
13255     perror ("write");
13256     close (fd);
13257     unlink (filename);
13258     exit (1);
13259   }
13260   if (close (fd) == -1) {
13261     perror (filename);
13262     unlink (filename);
13263     exit (1);
13264   }
13265   if (guestfs_add_drive (g, filename) == -1) {
13266     printf ("guestfs_add_drive %s FAILED\n", filename);
13267     exit (1);
13268   }
13269
13270   if (guestfs_launch (g) == -1) {
13271     printf ("guestfs_launch FAILED\n");
13272     exit (1);
13273   }
13274   if (guestfs_wait_ready (g) == -1) {
13275     printf ("guestfs_wait_ready FAILED\n");
13276     exit (1);
13277   }
13278
13279   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13280    * names.  This changed between RHEL 5 and RHEL 6 so we have to
13281    * support both.
13282    */
13283   devs = guestfs_list_devices (g);
13284   if (devs == NULL || devs[0] == NULL) {
13285     printf ("guestfs_list_devices FAILED\n");
13286     exit (1);
13287   }
13288   if (strncmp (devs[0], "/dev/sd", 7) == 0)
13289     devchar = 's';
13290   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13291     devchar = 'h';
13292   else {
13293     printf ("guestfs_list_devices returned unexpected string '%s'\n",
13294             devs[0]);
13295     exit (1);
13296   }
13297   for (i = 0; devs[i] != NULL; ++i)
13298     free (devs[i]);
13299   free (devs);
13300
13301   nr_tests = 137;
13302
13303   test_num++;
13304   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
13305   if (test_lvresize_0 () == -1) {
13306     printf ("test_lvresize_0 FAILED\n");
13307     failed++;
13308   }
13309   test_num++;
13310   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13311   if (test_zerofree_0 () == -1) {
13312     printf ("test_zerofree_0 FAILED\n");
13313     failed++;
13314   }
13315   test_num++;
13316   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13317   if (test_hexdump_0 () == -1) {
13318     printf ("test_hexdump_0 FAILED\n");
13319     failed++;
13320   }
13321   test_num++;
13322   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13323   if (test_strings_e_0 () == -1) {
13324     printf ("test_strings_e_0 FAILED\n");
13325     failed++;
13326   }
13327   test_num++;
13328   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13329   if (test_strings_e_1 () == -1) {
13330     printf ("test_strings_e_1 FAILED\n");
13331     failed++;
13332   }
13333   test_num++;
13334   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13335   if (test_strings_0 () == -1) {
13336     printf ("test_strings_0 FAILED\n");
13337     failed++;
13338   }
13339   test_num++;
13340   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13341   if (test_strings_1 () == -1) {
13342     printf ("test_strings_1 FAILED\n");
13343     failed++;
13344   }
13345   test_num++;
13346   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13347   if (test_equal_0 () == -1) {
13348     printf ("test_equal_0 FAILED\n");
13349     failed++;
13350   }
13351   test_num++;
13352   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13353   if (test_equal_1 () == -1) {
13354     printf ("test_equal_1 FAILED\n");
13355     failed++;
13356   }
13357   test_num++;
13358   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13359   if (test_equal_2 () == -1) {
13360     printf ("test_equal_2 FAILED\n");
13361     failed++;
13362   }
13363   test_num++;
13364   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13365   if (test_ping_daemon_0 () == -1) {
13366     printf ("test_ping_daemon_0 FAILED\n");
13367     failed++;
13368   }
13369   test_num++;
13370   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13371   if (test_dmesg_0 () == -1) {
13372     printf ("test_dmesg_0 FAILED\n");
13373     failed++;
13374   }
13375   test_num++;
13376   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13377   if (test_drop_caches_0 () == -1) {
13378     printf ("test_drop_caches_0 FAILED\n");
13379     failed++;
13380   }
13381   test_num++;
13382   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13383   if (test_mv_0 () == -1) {
13384     printf ("test_mv_0 FAILED\n");
13385     failed++;
13386   }
13387   test_num++;
13388   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13389   if (test_mv_1 () == -1) {
13390     printf ("test_mv_1 FAILED\n");
13391     failed++;
13392   }
13393   test_num++;
13394   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13395   if (test_cp_a_0 () == -1) {
13396     printf ("test_cp_a_0 FAILED\n");
13397     failed++;
13398   }
13399   test_num++;
13400   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13401   if (test_cp_0 () == -1) {
13402     printf ("test_cp_0 FAILED\n");
13403     failed++;
13404   }
13405   test_num++;
13406   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13407   if (test_cp_1 () == -1) {
13408     printf ("test_cp_1 FAILED\n");
13409     failed++;
13410   }
13411   test_num++;
13412   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13413   if (test_cp_2 () == -1) {
13414     printf ("test_cp_2 FAILED\n");
13415     failed++;
13416   }
13417   test_num++;
13418   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13419   if (test_grub_install_0 () == -1) {
13420     printf ("test_grub_install_0 FAILED\n");
13421     failed++;
13422   }
13423   test_num++;
13424   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13425   if (test_zero_0 () == -1) {
13426     printf ("test_zero_0 FAILED\n");
13427     failed++;
13428   }
13429   test_num++;
13430   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13431   if (test_fsck_0 () == -1) {
13432     printf ("test_fsck_0 FAILED\n");
13433     failed++;
13434   }
13435   test_num++;
13436   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13437   if (test_fsck_1 () == -1) {
13438     printf ("test_fsck_1 FAILED\n");
13439     failed++;
13440   }
13441   test_num++;
13442   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13443   if (test_set_e2uuid_0 () == -1) {
13444     printf ("test_set_e2uuid_0 FAILED\n");
13445     failed++;
13446   }
13447   test_num++;
13448   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13449   if (test_set_e2uuid_1 () == -1) {
13450     printf ("test_set_e2uuid_1 FAILED\n");
13451     failed++;
13452   }
13453   test_num++;
13454   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13455   if (test_set_e2uuid_2 () == -1) {
13456     printf ("test_set_e2uuid_2 FAILED\n");
13457     failed++;
13458   }
13459   test_num++;
13460   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13461   if (test_set_e2uuid_3 () == -1) {
13462     printf ("test_set_e2uuid_3 FAILED\n");
13463     failed++;
13464   }
13465   test_num++;
13466   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13467   if (test_set_e2label_0 () == -1) {
13468     printf ("test_set_e2label_0 FAILED\n");
13469     failed++;
13470   }
13471   test_num++;
13472   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13473   if (test_pvremove_0 () == -1) {
13474     printf ("test_pvremove_0 FAILED\n");
13475     failed++;
13476   }
13477   test_num++;
13478   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13479   if (test_pvremove_1 () == -1) {
13480     printf ("test_pvremove_1 FAILED\n");
13481     failed++;
13482   }
13483   test_num++;
13484   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13485   if (test_pvremove_2 () == -1) {
13486     printf ("test_pvremove_2 FAILED\n");
13487     failed++;
13488   }
13489   test_num++;
13490   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13491   if (test_vgremove_0 () == -1) {
13492     printf ("test_vgremove_0 FAILED\n");
13493     failed++;
13494   }
13495   test_num++;
13496   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13497   if (test_vgremove_1 () == -1) {
13498     printf ("test_vgremove_1 FAILED\n");
13499     failed++;
13500   }
13501   test_num++;
13502   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13503   if (test_lvremove_0 () == -1) {
13504     printf ("test_lvremove_0 FAILED\n");
13505     failed++;
13506   }
13507   test_num++;
13508   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13509   if (test_lvremove_1 () == -1) {
13510     printf ("test_lvremove_1 FAILED\n");
13511     failed++;
13512   }
13513   test_num++;
13514   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13515   if (test_lvremove_2 () == -1) {
13516     printf ("test_lvremove_2 FAILED\n");
13517     failed++;
13518   }
13519   test_num++;
13520   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13521   if (test_mount_ro_0 () == -1) {
13522     printf ("test_mount_ro_0 FAILED\n");
13523     failed++;
13524   }
13525   test_num++;
13526   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13527   if (test_mount_ro_1 () == -1) {
13528     printf ("test_mount_ro_1 FAILED\n");
13529     failed++;
13530   }
13531   test_num++;
13532   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13533   if (test_tgz_in_0 () == -1) {
13534     printf ("test_tgz_in_0 FAILED\n");
13535     failed++;
13536   }
13537   test_num++;
13538   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13539   if (test_tar_in_0 () == -1) {
13540     printf ("test_tar_in_0 FAILED\n");
13541     failed++;
13542   }
13543   test_num++;
13544   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13545   if (test_checksum_0 () == -1) {
13546     printf ("test_checksum_0 FAILED\n");
13547     failed++;
13548   }
13549   test_num++;
13550   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13551   if (test_checksum_1 () == -1) {
13552     printf ("test_checksum_1 FAILED\n");
13553     failed++;
13554   }
13555   test_num++;
13556   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13557   if (test_checksum_2 () == -1) {
13558     printf ("test_checksum_2 FAILED\n");
13559     failed++;
13560   }
13561   test_num++;
13562   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13563   if (test_checksum_3 () == -1) {
13564     printf ("test_checksum_3 FAILED\n");
13565     failed++;
13566   }
13567   test_num++;
13568   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13569   if (test_checksum_4 () == -1) {
13570     printf ("test_checksum_4 FAILED\n");
13571     failed++;
13572   }
13573   test_num++;
13574   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13575   if (test_checksum_5 () == -1) {
13576     printf ("test_checksum_5 FAILED\n");
13577     failed++;
13578   }
13579   test_num++;
13580   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13581   if (test_checksum_6 () == -1) {
13582     printf ("test_checksum_6 FAILED\n");
13583     failed++;
13584   }
13585   test_num++;
13586   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13587   if (test_checksum_7 () == -1) {
13588     printf ("test_checksum_7 FAILED\n");
13589     failed++;
13590   }
13591   test_num++;
13592   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13593   if (test_download_0 () == -1) {
13594     printf ("test_download_0 FAILED\n");
13595     failed++;
13596   }
13597   test_num++;
13598   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13599   if (test_upload_0 () == -1) {
13600     printf ("test_upload_0 FAILED\n");
13601     failed++;
13602   }
13603   test_num++;
13604   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13605   if (test_blockdev_rereadpt_0 () == -1) {
13606     printf ("test_blockdev_rereadpt_0 FAILED\n");
13607     failed++;
13608   }
13609   test_num++;
13610   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
13611   if (test_blockdev_flushbufs_0 () == -1) {
13612     printf ("test_blockdev_flushbufs_0 FAILED\n");
13613     failed++;
13614   }
13615   test_num++;
13616   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
13617   if (test_blockdev_getsize64_0 () == -1) {
13618     printf ("test_blockdev_getsize64_0 FAILED\n");
13619     failed++;
13620   }
13621   test_num++;
13622   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
13623   if (test_blockdev_getsz_0 () == -1) {
13624     printf ("test_blockdev_getsz_0 FAILED\n");
13625     failed++;
13626   }
13627   test_num++;
13628   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
13629   if (test_blockdev_getbsz_0 () == -1) {
13630     printf ("test_blockdev_getbsz_0 FAILED\n");
13631     failed++;
13632   }
13633   test_num++;
13634   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
13635   if (test_blockdev_getss_0 () == -1) {
13636     printf ("test_blockdev_getss_0 FAILED\n");
13637     failed++;
13638   }
13639   test_num++;
13640   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
13641   if (test_blockdev_getro_0 () == -1) {
13642     printf ("test_blockdev_getro_0 FAILED\n");
13643     failed++;
13644   }
13645   test_num++;
13646   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
13647   if (test_blockdev_setrw_0 () == -1) {
13648     printf ("test_blockdev_setrw_0 FAILED\n");
13649     failed++;
13650   }
13651   test_num++;
13652   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
13653   if (test_blockdev_setro_0 () == -1) {
13654     printf ("test_blockdev_setro_0 FAILED\n");
13655     failed++;
13656   }
13657   test_num++;
13658   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
13659   if (test_statvfs_0 () == -1) {
13660     printf ("test_statvfs_0 FAILED\n");
13661     failed++;
13662   }
13663   test_num++;
13664   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
13665   if (test_lstat_0 () == -1) {
13666     printf ("test_lstat_0 FAILED\n");
13667     failed++;
13668   }
13669   test_num++;
13670   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
13671   if (test_stat_0 () == -1) {
13672     printf ("test_stat_0 FAILED\n");
13673     failed++;
13674   }
13675   test_num++;
13676   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
13677   if (test_command_lines_0 () == -1) {
13678     printf ("test_command_lines_0 FAILED\n");
13679     failed++;
13680   }
13681   test_num++;
13682   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
13683   if (test_command_lines_1 () == -1) {
13684     printf ("test_command_lines_1 FAILED\n");
13685     failed++;
13686   }
13687   test_num++;
13688   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
13689   if (test_command_lines_2 () == -1) {
13690     printf ("test_command_lines_2 FAILED\n");
13691     failed++;
13692   }
13693   test_num++;
13694   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
13695   if (test_command_lines_3 () == -1) {
13696     printf ("test_command_lines_3 FAILED\n");
13697     failed++;
13698   }
13699   test_num++;
13700   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
13701   if (test_command_lines_4 () == -1) {
13702     printf ("test_command_lines_4 FAILED\n");
13703     failed++;
13704   }
13705   test_num++;
13706   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
13707   if (test_command_lines_5 () == -1) {
13708     printf ("test_command_lines_5 FAILED\n");
13709     failed++;
13710   }
13711   test_num++;
13712   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
13713   if (test_command_lines_6 () == -1) {
13714     printf ("test_command_lines_6 FAILED\n");
13715     failed++;
13716   }
13717   test_num++;
13718   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
13719   if (test_command_lines_7 () == -1) {
13720     printf ("test_command_lines_7 FAILED\n");
13721     failed++;
13722   }
13723   test_num++;
13724   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
13725   if (test_command_lines_8 () == -1) {
13726     printf ("test_command_lines_8 FAILED\n");
13727     failed++;
13728   }
13729   test_num++;
13730   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
13731   if (test_command_lines_9 () == -1) {
13732     printf ("test_command_lines_9 FAILED\n");
13733     failed++;
13734   }
13735   test_num++;
13736   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
13737   if (test_command_lines_10 () == -1) {
13738     printf ("test_command_lines_10 FAILED\n");
13739     failed++;
13740   }
13741   test_num++;
13742   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
13743   if (test_command_0 () == -1) {
13744     printf ("test_command_0 FAILED\n");
13745     failed++;
13746   }
13747   test_num++;
13748   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
13749   if (test_command_1 () == -1) {
13750     printf ("test_command_1 FAILED\n");
13751     failed++;
13752   }
13753   test_num++;
13754   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
13755   if (test_command_2 () == -1) {
13756     printf ("test_command_2 FAILED\n");
13757     failed++;
13758   }
13759   test_num++;
13760   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
13761   if (test_command_3 () == -1) {
13762     printf ("test_command_3 FAILED\n");
13763     failed++;
13764   }
13765   test_num++;
13766   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
13767   if (test_command_4 () == -1) {
13768     printf ("test_command_4 FAILED\n");
13769     failed++;
13770   }
13771   test_num++;
13772   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
13773   if (test_command_5 () == -1) {
13774     printf ("test_command_5 FAILED\n");
13775     failed++;
13776   }
13777   test_num++;
13778   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
13779   if (test_command_6 () == -1) {
13780     printf ("test_command_6 FAILED\n");
13781     failed++;
13782   }
13783   test_num++;
13784   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
13785   if (test_command_7 () == -1) {
13786     printf ("test_command_7 FAILED\n");
13787     failed++;
13788   }
13789   test_num++;
13790   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
13791   if (test_command_8 () == -1) {
13792     printf ("test_command_8 FAILED\n");
13793     failed++;
13794   }
13795   test_num++;
13796   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
13797   if (test_command_9 () == -1) {
13798     printf ("test_command_9 FAILED\n");
13799     failed++;
13800   }
13801   test_num++;
13802   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
13803   if (test_command_10 () == -1) {
13804     printf ("test_command_10 FAILED\n");
13805     failed++;
13806   }
13807   test_num++;
13808   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
13809   if (test_command_11 () == -1) {
13810     printf ("test_command_11 FAILED\n");
13811     failed++;
13812   }
13813   test_num++;
13814   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
13815   if (test_file_0 () == -1) {
13816     printf ("test_file_0 FAILED\n");
13817     failed++;
13818   }
13819   test_num++;
13820   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
13821   if (test_file_1 () == -1) {
13822     printf ("test_file_1 FAILED\n");
13823     failed++;
13824   }
13825   test_num++;
13826   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
13827   if (test_file_2 () == -1) {
13828     printf ("test_file_2 FAILED\n");
13829     failed++;
13830   }
13831   test_num++;
13832   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
13833   if (test_umount_all_0 () == -1) {
13834     printf ("test_umount_all_0 FAILED\n");
13835     failed++;
13836   }
13837   test_num++;
13838   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
13839   if (test_umount_all_1 () == -1) {
13840     printf ("test_umount_all_1 FAILED\n");
13841     failed++;
13842   }
13843   test_num++;
13844   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
13845   if (test_mounts_0 () == -1) {
13846     printf ("test_mounts_0 FAILED\n");
13847     failed++;
13848   }
13849   test_num++;
13850   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
13851   if (test_umount_0 () == -1) {
13852     printf ("test_umount_0 FAILED\n");
13853     failed++;
13854   }
13855   test_num++;
13856   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
13857   if (test_umount_1 () == -1) {
13858     printf ("test_umount_1 FAILED\n");
13859     failed++;
13860   }
13861   test_num++;
13862   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
13863   if (test_write_file_0 () == -1) {
13864     printf ("test_write_file_0 FAILED\n");
13865     failed++;
13866   }
13867   test_num++;
13868   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
13869   if (test_write_file_1 () == -1) {
13870     printf ("test_write_file_1 FAILED\n");
13871     failed++;
13872   }
13873   test_num++;
13874   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
13875   if (test_write_file_2 () == -1) {
13876     printf ("test_write_file_2 FAILED\n");
13877     failed++;
13878   }
13879   test_num++;
13880   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
13881   if (test_write_file_3 () == -1) {
13882     printf ("test_write_file_3 FAILED\n");
13883     failed++;
13884   }
13885   test_num++;
13886   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
13887   if (test_write_file_4 () == -1) {
13888     printf ("test_write_file_4 FAILED\n");
13889     failed++;
13890   }
13891   test_num++;
13892   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
13893   if (test_write_file_5 () == -1) {
13894     printf ("test_write_file_5 FAILED\n");
13895     failed++;
13896   }
13897   test_num++;
13898   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
13899   if (test_mkfs_0 () == -1) {
13900     printf ("test_mkfs_0 FAILED\n");
13901     failed++;
13902   }
13903   test_num++;
13904   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
13905   if (test_lvcreate_0 () == -1) {
13906     printf ("test_lvcreate_0 FAILED\n");
13907     failed++;
13908   }
13909   test_num++;
13910   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
13911   if (test_vgcreate_0 () == -1) {
13912     printf ("test_vgcreate_0 FAILED\n");
13913     failed++;
13914   }
13915   test_num++;
13916   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
13917   if (test_pvcreate_0 () == -1) {
13918     printf ("test_pvcreate_0 FAILED\n");
13919     failed++;
13920   }
13921   test_num++;
13922   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
13923   if (test_is_dir_0 () == -1) {
13924     printf ("test_is_dir_0 FAILED\n");
13925     failed++;
13926   }
13927   test_num++;
13928   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
13929   if (test_is_dir_1 () == -1) {
13930     printf ("test_is_dir_1 FAILED\n");
13931     failed++;
13932   }
13933   test_num++;
13934   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
13935   if (test_is_file_0 () == -1) {
13936     printf ("test_is_file_0 FAILED\n");
13937     failed++;
13938   }
13939   test_num++;
13940   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
13941   if (test_is_file_1 () == -1) {
13942     printf ("test_is_file_1 FAILED\n");
13943     failed++;
13944   }
13945   test_num++;
13946   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
13947   if (test_exists_0 () == -1) {
13948     printf ("test_exists_0 FAILED\n");
13949     failed++;
13950   }
13951   test_num++;
13952   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
13953   if (test_exists_1 () == -1) {
13954     printf ("test_exists_1 FAILED\n");
13955     failed++;
13956   }
13957   test_num++;
13958   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
13959   if (test_mkdir_p_0 () == -1) {
13960     printf ("test_mkdir_p_0 FAILED\n");
13961     failed++;
13962   }
13963   test_num++;
13964   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
13965   if (test_mkdir_p_1 () == -1) {
13966     printf ("test_mkdir_p_1 FAILED\n");
13967     failed++;
13968   }
13969   test_num++;
13970   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
13971   if (test_mkdir_p_2 () == -1) {
13972     printf ("test_mkdir_p_2 FAILED\n");
13973     failed++;
13974   }
13975   test_num++;
13976   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
13977   if (test_mkdir_0 () == -1) {
13978     printf ("test_mkdir_0 FAILED\n");
13979     failed++;
13980   }
13981   test_num++;
13982   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
13983   if (test_mkdir_1 () == -1) {
13984     printf ("test_mkdir_1 FAILED\n");
13985     failed++;
13986   }
13987   test_num++;
13988   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
13989   if (test_rm_rf_0 () == -1) {
13990     printf ("test_rm_rf_0 FAILED\n");
13991     failed++;
13992   }
13993   test_num++;
13994   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
13995   if (test_rmdir_0 () == -1) {
13996     printf ("test_rmdir_0 FAILED\n");
13997     failed++;
13998   }
13999   test_num++;
14000   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
14001   if (test_rmdir_1 () == -1) {
14002     printf ("test_rmdir_1 FAILED\n");
14003     failed++;
14004   }
14005   test_num++;
14006   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
14007   if (test_rmdir_2 () == -1) {
14008     printf ("test_rmdir_2 FAILED\n");
14009     failed++;
14010   }
14011   test_num++;
14012   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
14013   if (test_rm_0 () == -1) {
14014     printf ("test_rm_0 FAILED\n");
14015     failed++;
14016   }
14017   test_num++;
14018   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
14019   if (test_rm_1 () == -1) {
14020     printf ("test_rm_1 FAILED\n");
14021     failed++;
14022   }
14023   test_num++;
14024   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
14025   if (test_rm_2 () == -1) {
14026     printf ("test_rm_2 FAILED\n");
14027     failed++;
14028   }
14029   test_num++;
14030   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
14031   if (test_read_lines_0 () == -1) {
14032     printf ("test_read_lines_0 FAILED\n");
14033     failed++;
14034   }
14035   test_num++;
14036   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
14037   if (test_read_lines_1 () == -1) {
14038     printf ("test_read_lines_1 FAILED\n");
14039     failed++;
14040   }
14041   test_num++;
14042   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
14043   if (test_lvs_0 () == -1) {
14044     printf ("test_lvs_0 FAILED\n");
14045     failed++;
14046   }
14047   test_num++;
14048   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
14049   if (test_lvs_1 () == -1) {
14050     printf ("test_lvs_1 FAILED\n");
14051     failed++;
14052   }
14053   test_num++;
14054   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
14055   if (test_vgs_0 () == -1) {
14056     printf ("test_vgs_0 FAILED\n");
14057     failed++;
14058   }
14059   test_num++;
14060   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
14061   if (test_vgs_1 () == -1) {
14062     printf ("test_vgs_1 FAILED\n");
14063     failed++;
14064   }
14065   test_num++;
14066   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
14067   if (test_pvs_0 () == -1) {
14068     printf ("test_pvs_0 FAILED\n");
14069     failed++;
14070   }
14071   test_num++;
14072   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
14073   if (test_pvs_1 () == -1) {
14074     printf ("test_pvs_1 FAILED\n");
14075     failed++;
14076   }
14077   test_num++;
14078   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
14079   if (test_list_partitions_0 () == -1) {
14080     printf ("test_list_partitions_0 FAILED\n");
14081     failed++;
14082   }
14083   test_num++;
14084   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
14085   if (test_list_partitions_1 () == -1) {
14086     printf ("test_list_partitions_1 FAILED\n");
14087     failed++;
14088   }
14089   test_num++;
14090   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
14091   if (test_list_devices_0 () == -1) {
14092     printf ("test_list_devices_0 FAILED\n");
14093     failed++;
14094   }
14095   test_num++;
14096   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
14097   if (test_ls_0 () == -1) {
14098     printf ("test_ls_0 FAILED\n");
14099     failed++;
14100   }
14101   test_num++;
14102   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
14103   if (test_cat_0 () == -1) {
14104     printf ("test_cat_0 FAILED\n");
14105     failed++;
14106   }
14107   test_num++;
14108   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
14109   if (test_touch_0 () == -1) {
14110     printf ("test_touch_0 FAILED\n");
14111     failed++;
14112   }
14113   test_num++;
14114   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
14115   if (test_sync_0 () == -1) {
14116     printf ("test_sync_0 FAILED\n");
14117     failed++;
14118   }
14119   test_num++;
14120   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
14121   if (test_mount_0 () == -1) {
14122     printf ("test_mount_0 FAILED\n");
14123     failed++;
14124   }
14125
14126   guestfs_close (g);
14127   unlink ("test1.img");
14128   unlink ("test2.img");
14129   unlink ("test3.img");
14130
14131   if (failed > 0) {
14132     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
14133     exit (1);
14134   }
14135
14136   exit (0);
14137 }