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 }
 120
 121 static int test_hexdump_0 (void)
 122 {
 123   /* InitBasicFS for hexdump (0): create ext2 on /dev/sda1 */
 124   {
 125     char device[] = "/dev/sda";
 126     device[5] = devchar;
 127     int r;
 128     suppress_error = 0;
 129     r = guestfs_blockdev_setrw (g, device);
 130     if (r == -1)
 131       return -1;
 132   }
 133   {
 134     int r;
 135     suppress_error = 0;
 136     r = guestfs_umount_all (g);
 137     if (r == -1)
 138       return -1;
 139   }
 140   {
 141     int r;
 142     suppress_error = 0;
 143     r = guestfs_lvm_remove_all (g);
 144     if (r == -1)
 145       return -1;
 146   }
 147   {
 148     char device[] = "/dev/sda";
 149     device[5] = devchar;
 150     char lines_0[] = ",";
 151     char *lines[] = {
 152       lines_0,
 153       NULL
 154     };
 155     int r;
 156     suppress_error = 0;
 157     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 158     if (r == -1)
 159       return -1;
 160   }
 161   {
 162     char fstype[] = "ext2";
 163     char device[] = "/dev/sda1";
 164     device[5] = devchar;
 165     int r;
 166     suppress_error = 0;
 167     r = guestfs_mkfs (g, fstype, device);
 168     if (r == -1)
 169       return -1;
 170   }
 171   {
 172     char device[] = "/dev/sda1";
 173     device[5] = devchar;
 174     char mountpoint[] = "/";
 175     int r;
 176     suppress_error = 0;
 177     r = guestfs_mount (g, device, mountpoint);
 178     if (r == -1)
 179       return -1;
 180   }
 181   /* TestOutput for hexdump (0) */
 182   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
 183   {
 184     char path[] = "/new";
 185     char content[] = "hello\nworld\n";
 186     int r;
 187     suppress_error = 0;
 188     r = guestfs_write_file (g, path, content, 12);
 189     if (r == -1)
 190       return -1;
 191   }
 192   {
 193     char path[] = "/new";
 194     char *r;
 195     suppress_error = 0;
 196     r = guestfs_hexdump (g, path);
 197     if (r == NULL)
 198       return -1;
 199     if (strcmp (r, expected) != 0) {
 200       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
 201       return -1;
 202     }
 203     free (r);
 204   }
 205   return 0;
 206 }
 207
 208 static int test_strings_e_0 (void)
 209 {
 210   /* InitBasicFS for strings_e (0): create ext2 on /dev/sda1 */
 211   {
 212     char device[] = "/dev/sda";
 213     device[5] = devchar;
 214     int r;
 215     suppress_error = 0;
 216     r = guestfs_blockdev_setrw (g, device);
 217     if (r == -1)
 218       return -1;
 219   }
 220   {
 221     int r;
 222     suppress_error = 0;
 223     r = guestfs_umount_all (g);
 224     if (r == -1)
 225       return -1;
 226   }
 227   {
 228     int r;
 229     suppress_error = 0;
 230     r = guestfs_lvm_remove_all (g);
 231     if (r == -1)
 232       return -1;
 233   }
 234   {
 235     char device[] = "/dev/sda";
 236     device[5] = devchar;
 237     char lines_0[] = ",";
 238     char *lines[] = {
 239       lines_0,
 240       NULL
 241     };
 242     int r;
 243     suppress_error = 0;
 244     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 245     if (r == -1)
 246       return -1;
 247   }
 248   {
 249     char fstype[] = "ext2";
 250     char device[] = "/dev/sda1";
 251     device[5] = devchar;
 252     int r;
 253     suppress_error = 0;
 254     r = guestfs_mkfs (g, fstype, device);
 255     if (r == -1)
 256       return -1;
 257   }
 258   {
 259     char device[] = "/dev/sda1";
 260     device[5] = devchar;
 261     char mountpoint[] = "/";
 262     int r;
 263     suppress_error = 0;
 264     r = guestfs_mount (g, device, mountpoint);
 265     if (r == -1)
 266       return -1;
 267   }
 268   /* TestOutputList for strings_e (0) */
 269   {
 270     char path[] = "/new";
 271     char content[] = "hello\nworld\n";
 272     int r;
 273     suppress_error = 0;
 274     r = guestfs_write_file (g, path, content, 0);
 275     if (r == -1)
 276       return -1;
 277   }
 278   {
 279     char encoding[] = "b";
 280     char path[] = "/new";
 281     char **r;
 282     int i;
 283     suppress_error = 0;
 284     r = guestfs_strings_e (g, encoding, path);
 285     if (r == NULL)
 286       return -1;
 287     if (r[0] != NULL) {
 288       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
 289       print_strings (r);
 290       return -1;
 291     }
 292     for (i = 0; r[i] != NULL; ++i)
 293       free (r[i]);
 294     free (r);
 295   }
 296   return 0;
 297 }
 298
 299 static int test_strings_e_1 (void)
 300 {
 301   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
 302   return 0;
 303 }
 304
 305 static int test_strings_0 (void)
 306 {
 307   /* InitBasicFS for strings (0): create ext2 on /dev/sda1 */
 308   {
 309     char device[] = "/dev/sda";
 310     device[5] = devchar;
 311     int r;
 312     suppress_error = 0;
 313     r = guestfs_blockdev_setrw (g, device);
 314     if (r == -1)
 315       return -1;
 316   }
 317   {
 318     int r;
 319     suppress_error = 0;
 320     r = guestfs_umount_all (g);
 321     if (r == -1)
 322       return -1;
 323   }
 324   {
 325     int r;
 326     suppress_error = 0;
 327     r = guestfs_lvm_remove_all (g);
 328     if (r == -1)
 329       return -1;
 330   }
 331   {
 332     char device[] = "/dev/sda";
 333     device[5] = devchar;
 334     char lines_0[] = ",";
 335     char *lines[] = {
 336       lines_0,
 337       NULL
 338     };
 339     int r;
 340     suppress_error = 0;
 341     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 342     if (r == -1)
 343       return -1;
 344   }
 345   {
 346     char fstype[] = "ext2";
 347     char device[] = "/dev/sda1";
 348     device[5] = devchar;
 349     int r;
 350     suppress_error = 0;
 351     r = guestfs_mkfs (g, fstype, device);
 352     if (r == -1)
 353       return -1;
 354   }
 355   {
 356     char device[] = "/dev/sda1";
 357     device[5] = devchar;
 358     char mountpoint[] = "/";
 359     int r;
 360     suppress_error = 0;
 361     r = guestfs_mount (g, device, mountpoint);
 362     if (r == -1)
 363       return -1;
 364   }
 365   /* TestOutputList for strings (0) */
 366   {
 367     char path[] = "/new";
 368     char content[] = "hello\nworld\n";
 369     int r;
 370     suppress_error = 0;
 371     r = guestfs_write_file (g, path, content, 0);
 372     if (r == -1)
 373       return -1;
 374   }
 375   {
 376     char path[] = "/new";
 377     char **r;
 378     int i;
 379     suppress_error = 0;
 380     r = guestfs_strings (g, path);
 381     if (r == NULL)
 382       return -1;
 383     if (!r[0]) {
 384       fprintf (stderr, "test_strings_0: short list returned from command\n");
 385       print_strings (r);
 386       return -1;
 387     }
 388     {
 389       char expected[] = "hello";
 390       if (strcmp (r[0], expected) != 0) {
 391         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 392         return -1;
 393       }
 394     }
 395     if (!r[1]) {
 396       fprintf (stderr, "test_strings_0: short list returned from command\n");
 397       print_strings (r);
 398       return -1;
 399     }
 400     {
 401       char expected[] = "world";
 402       if (strcmp (r[1], expected) != 0) {
 403         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 404         return -1;
 405       }
 406     }
 407     if (r[2] != NULL) {
 408       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
 409       print_strings (r);
 410       return -1;
 411     }
 412     for (i = 0; r[i] != NULL; ++i)
 413       free (r[i]);
 414     free (r);
 415   }
 416   return 0;
 417 }
 418
 419 static int test_strings_1 (void)
 420 {
 421   /* InitBasicFS for strings (1): create ext2 on /dev/sda1 */
 422   {
 423     char device[] = "/dev/sda";
 424     device[5] = devchar;
 425     int r;
 426     suppress_error = 0;
 427     r = guestfs_blockdev_setrw (g, device);
 428     if (r == -1)
 429       return -1;
 430   }
 431   {
 432     int r;
 433     suppress_error = 0;
 434     r = guestfs_umount_all (g);
 435     if (r == -1)
 436       return -1;
 437   }
 438   {
 439     int r;
 440     suppress_error = 0;
 441     r = guestfs_lvm_remove_all (g);
 442     if (r == -1)
 443       return -1;
 444   }
 445   {
 446     char device[] = "/dev/sda";
 447     device[5] = devchar;
 448     char lines_0[] = ",";
 449     char *lines[] = {
 450       lines_0,
 451       NULL
 452     };
 453     int r;
 454     suppress_error = 0;
 455     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 456     if (r == -1)
 457       return -1;
 458   }
 459   {
 460     char fstype[] = "ext2";
 461     char device[] = "/dev/sda1";
 462     device[5] = devchar;
 463     int r;
 464     suppress_error = 0;
 465     r = guestfs_mkfs (g, fstype, device);
 466     if (r == -1)
 467       return -1;
 468   }
 469   {
 470     char device[] = "/dev/sda1";
 471     device[5] = devchar;
 472     char mountpoint[] = "/";
 473     int r;
 474     suppress_error = 0;
 475     r = guestfs_mount (g, device, mountpoint);
 476     if (r == -1)
 477       return -1;
 478   }
 479   /* TestOutputList for strings (1) */
 480   {
 481     char path[] = "/new";
 482     int r;
 483     suppress_error = 0;
 484     r = guestfs_touch (g, path);
 485     if (r == -1)
 486       return -1;
 487   }
 488   {
 489     char path[] = "/new";
 490     char **r;
 491     int i;
 492     suppress_error = 0;
 493     r = guestfs_strings (g, path);
 494     if (r == NULL)
 495       return -1;
 496     if (r[0] != NULL) {
 497       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
 498       print_strings (r);
 499       return -1;
 500     }
 501     for (i = 0; r[i] != NULL; ++i)
 502       free (r[i]);
 503     free (r);
 504   }
 505   return 0;
 506 }
 507
 508 static int test_equal_0 (void)
 509 {
 510   /* InitBasicFS for equal (0): create ext2 on /dev/sda1 */
 511   {
 512     char device[] = "/dev/sda";
 513     device[5] = devchar;
 514     int r;
 515     suppress_error = 0;
 516     r = guestfs_blockdev_setrw (g, device);
 517     if (r == -1)
 518       return -1;
 519   }
 520   {
 521     int r;
 522     suppress_error = 0;
 523     r = guestfs_umount_all (g);
 524     if (r == -1)
 525       return -1;
 526   }
 527   {
 528     int r;
 529     suppress_error = 0;
 530     r = guestfs_lvm_remove_all (g);
 531     if (r == -1)
 532       return -1;
 533   }
 534   {
 535     char device[] = "/dev/sda";
 536     device[5] = devchar;
 537     char lines_0[] = ",";
 538     char *lines[] = {
 539       lines_0,
 540       NULL
 541     };
 542     int r;
 543     suppress_error = 0;
 544     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 545     if (r == -1)
 546       return -1;
 547   }
 548   {
 549     char fstype[] = "ext2";
 550     char device[] = "/dev/sda1";
 551     device[5] = devchar;
 552     int r;
 553     suppress_error = 0;
 554     r = guestfs_mkfs (g, fstype, device);
 555     if (r == -1)
 556       return -1;
 557   }
 558   {
 559     char device[] = "/dev/sda1";
 560     device[5] = devchar;
 561     char mountpoint[] = "/";
 562     int r;
 563     suppress_error = 0;
 564     r = guestfs_mount (g, device, mountpoint);
 565     if (r == -1)
 566       return -1;
 567   }
 568   /* TestOutputTrue for equal (0) */
 569   {
 570     char path[] = "/file1";
 571     char content[] = "contents of a file";
 572     int r;
 573     suppress_error = 0;
 574     r = guestfs_write_file (g, path, content, 0);
 575     if (r == -1)
 576       return -1;
 577   }
 578   {
 579     char src[] = "/file1";
 580     char dest[] = "/file2";
 581     int r;
 582     suppress_error = 0;
 583     r = guestfs_cp (g, src, dest);
 584     if (r == -1)
 585       return -1;
 586   }
 587   {
 588     char file1[] = "/file1";
 589     char file2[] = "/file2";
 590     int r;
 591     suppress_error = 0;
 592     r = guestfs_equal (g, file1, file2);
 593     if (r == -1)
 594       return -1;
 595     if (!r) {
 596       fprintf (stderr, "test_equal_0: expected true, got false\n");
 597       return -1;
 598     }
 599   }
 600   return 0;
 601 }
 602
 603 static int test_equal_1 (void)
 604 {
 605   /* InitBasicFS for equal (1): create ext2 on /dev/sda1 */
 606   {
 607     char device[] = "/dev/sda";
 608     device[5] = devchar;
 609     int r;
 610     suppress_error = 0;
 611     r = guestfs_blockdev_setrw (g, device);
 612     if (r == -1)
 613       return -1;
 614   }
 615   {
 616     int r;
 617     suppress_error = 0;
 618     r = guestfs_umount_all (g);
 619     if (r == -1)
 620       return -1;
 621   }
 622   {
 623     int r;
 624     suppress_error = 0;
 625     r = guestfs_lvm_remove_all (g);
 626     if (r == -1)
 627       return -1;
 628   }
 629   {
 630     char device[] = "/dev/sda";
 631     device[5] = devchar;
 632     char lines_0[] = ",";
 633     char *lines[] = {
 634       lines_0,
 635       NULL
 636     };
 637     int r;
 638     suppress_error = 0;
 639     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 640     if (r == -1)
 641       return -1;
 642   }
 643   {
 644     char fstype[] = "ext2";
 645     char device[] = "/dev/sda1";
 646     device[5] = devchar;
 647     int r;
 648     suppress_error = 0;
 649     r = guestfs_mkfs (g, fstype, device);
 650     if (r == -1)
 651       return -1;
 652   }
 653   {
 654     char device[] = "/dev/sda1";
 655     device[5] = devchar;
 656     char mountpoint[] = "/";
 657     int r;
 658     suppress_error = 0;
 659     r = guestfs_mount (g, device, mountpoint);
 660     if (r == -1)
 661       return -1;
 662   }
 663   /* TestOutputFalse for equal (1) */
 664   {
 665     char path[] = "/file1";
 666     char content[] = "contents of a file";
 667     int r;
 668     suppress_error = 0;
 669     r = guestfs_write_file (g, path, content, 0);
 670     if (r == -1)
 671       return -1;
 672   }
 673   {
 674     char path[] = "/file2";
 675     char content[] = "contents of another file";
 676     int r;
 677     suppress_error = 0;
 678     r = guestfs_write_file (g, path, content, 0);
 679     if (r == -1)
 680       return -1;
 681   }
 682   {
 683     char file1[] = "/file1";
 684     char file2[] = "/file2";
 685     int r;
 686     suppress_error = 0;
 687     r = guestfs_equal (g, file1, file2);
 688     if (r == -1)
 689       return -1;
 690     if (r) {
 691       fprintf (stderr, "test_equal_1: expected false, got true\n");
 692       return -1;
 693     }
 694   }
 695   return 0;
 696 }
 697
 698 static int test_equal_2 (void)
 699 {
 700   /* InitBasicFS for equal (2): create ext2 on /dev/sda1 */
 701   {
 702     char device[] = "/dev/sda";
 703     device[5] = devchar;
 704     int r;
 705     suppress_error = 0;
 706     r = guestfs_blockdev_setrw (g, device);
 707     if (r == -1)
 708       return -1;
 709   }
 710   {
 711     int r;
 712     suppress_error = 0;
 713     r = guestfs_umount_all (g);
 714     if (r == -1)
 715       return -1;
 716   }
 717   {
 718     int r;
 719     suppress_error = 0;
 720     r = guestfs_lvm_remove_all (g);
 721     if (r == -1)
 722       return -1;
 723   }
 724   {
 725     char device[] = "/dev/sda";
 726     device[5] = devchar;
 727     char lines_0[] = ",";
 728     char *lines[] = {
 729       lines_0,
 730       NULL
 731     };
 732     int r;
 733     suppress_error = 0;
 734     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 735     if (r == -1)
 736       return -1;
 737   }
 738   {
 739     char fstype[] = "ext2";
 740     char device[] = "/dev/sda1";
 741     device[5] = devchar;
 742     int r;
 743     suppress_error = 0;
 744     r = guestfs_mkfs (g, fstype, device);
 745     if (r == -1)
 746       return -1;
 747   }
 748   {
 749     char device[] = "/dev/sda1";
 750     device[5] = devchar;
 751     char mountpoint[] = "/";
 752     int r;
 753     suppress_error = 0;
 754     r = guestfs_mount (g, device, mountpoint);
 755     if (r == -1)
 756       return -1;
 757   }
 758   /* TestLastFail for equal (2) */
 759   {
 760     char file1[] = "/file1";
 761     char file2[] = "/file2";
 762     int r;
 763     suppress_error = 1;
 764     r = guestfs_equal (g, file1, file2);
 765     if (r != -1)
 766       return -1;
 767   }
 768   return 0;
 769 }
 770
 771 static int test_ping_daemon_0 (void)
 772 {
 773   /* InitEmpty for ping_daemon (0) */
 774   {
 775     char device[] = "/dev/sda";
 776     device[5] = devchar;
 777     int r;
 778     suppress_error = 0;
 779     r = guestfs_blockdev_setrw (g, device);
 780     if (r == -1)
 781       return -1;
 782   }
 783   {
 784     int r;
 785     suppress_error = 0;
 786     r = guestfs_umount_all (g);
 787     if (r == -1)
 788       return -1;
 789   }
 790   {
 791     int r;
 792     suppress_error = 0;
 793     r = guestfs_lvm_remove_all (g);
 794     if (r == -1)
 795       return -1;
 796   }
 797   /* TestRun for ping_daemon (0) */
 798   {
 799     int r;
 800     suppress_error = 0;
 801     r = guestfs_ping_daemon (g);
 802     if (r == -1)
 803       return -1;
 804   }
 805   return 0;
 806 }
 807
 808 static int test_dmesg_0 (void)
 809 {
 810   /* InitEmpty for dmesg (0) */
 811   {
 812     char device[] = "/dev/sda";
 813     device[5] = devchar;
 814     int r;
 815     suppress_error = 0;
 816     r = guestfs_blockdev_setrw (g, device);
 817     if (r == -1)
 818       return -1;
 819   }
 820   {
 821     int r;
 822     suppress_error = 0;
 823     r = guestfs_umount_all (g);
 824     if (r == -1)
 825       return -1;
 826   }
 827   {
 828     int r;
 829     suppress_error = 0;
 830     r = guestfs_lvm_remove_all (g);
 831     if (r == -1)
 832       return -1;
 833   }
 834   /* TestRun for dmesg (0) */
 835   {
 836     char *r;
 837     suppress_error = 0;
 838     r = guestfs_dmesg (g);
 839     if (r == NULL)
 840       return -1;
 841     free (r);
 842   }
 843   return 0;
 844 }
 845
 846 static int test_drop_caches_0 (void)
 847 {
 848   /* InitEmpty for drop_caches (0) */
 849   {
 850     char device[] = "/dev/sda";
 851     device[5] = devchar;
 852     int r;
 853     suppress_error = 0;
 854     r = guestfs_blockdev_setrw (g, device);
 855     if (r == -1)
 856       return -1;
 857   }
 858   {
 859     int r;
 860     suppress_error = 0;
 861     r = guestfs_umount_all (g);
 862     if (r == -1)
 863       return -1;
 864   }
 865   {
 866     int r;
 867     suppress_error = 0;
 868     r = guestfs_lvm_remove_all (g);
 869     if (r == -1)
 870       return -1;
 871   }
 872   /* TestRun for drop_caches (0) */
 873   {
 874     int r;
 875     suppress_error = 0;
 876     r = guestfs_drop_caches (g, 3);
 877     if (r == -1)
 878       return -1;
 879   }
 880   return 0;
 881 }
 882
 883 static int test_mv_0 (void)
 884 {
 885   /* InitBasicFS for mv (0): create ext2 on /dev/sda1 */
 886   {
 887     char device[] = "/dev/sda";
 888     device[5] = devchar;
 889     int r;
 890     suppress_error = 0;
 891     r = guestfs_blockdev_setrw (g, device);
 892     if (r == -1)
 893       return -1;
 894   }
 895   {
 896     int r;
 897     suppress_error = 0;
 898     r = guestfs_umount_all (g);
 899     if (r == -1)
 900       return -1;
 901   }
 902   {
 903     int r;
 904     suppress_error = 0;
 905     r = guestfs_lvm_remove_all (g);
 906     if (r == -1)
 907       return -1;
 908   }
 909   {
 910     char device[] = "/dev/sda";
 911     device[5] = devchar;
 912     char lines_0[] = ",";
 913     char *lines[] = {
 914       lines_0,
 915       NULL
 916     };
 917     int r;
 918     suppress_error = 0;
 919     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 920     if (r == -1)
 921       return -1;
 922   }
 923   {
 924     char fstype[] = "ext2";
 925     char device[] = "/dev/sda1";
 926     device[5] = devchar;
 927     int r;
 928     suppress_error = 0;
 929     r = guestfs_mkfs (g, fstype, device);
 930     if (r == -1)
 931       return -1;
 932   }
 933   {
 934     char device[] = "/dev/sda1";
 935     device[5] = devchar;
 936     char mountpoint[] = "/";
 937     int r;
 938     suppress_error = 0;
 939     r = guestfs_mount (g, device, mountpoint);
 940     if (r == -1)
 941       return -1;
 942   }
 943   /* TestOutput for mv (0) */
 944   char expected[] = "file content";
 945   {
 946     char path[] = "/old";
 947     char content[] = "file content";
 948     int r;
 949     suppress_error = 0;
 950     r = guestfs_write_file (g, path, content, 0);
 951     if (r == -1)
 952       return -1;
 953   }
 954   {
 955     char src[] = "/old";
 956     char dest[] = "/new";
 957     int r;
 958     suppress_error = 0;
 959     r = guestfs_mv (g, src, dest);
 960     if (r == -1)
 961       return -1;
 962   }
 963   {
 964     char path[] = "/new";
 965     char *r;
 966     suppress_error = 0;
 967     r = guestfs_cat (g, path);
 968     if (r == NULL)
 969       return -1;
 970     if (strcmp (r, expected) != 0) {
 971       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
 972       return -1;
 973     }
 974     free (r);
 975   }
 976   return 0;
 977 }
 978
 979 static int test_mv_1 (void)
 980 {
 981   /* InitBasicFS for mv (1): create ext2 on /dev/sda1 */
 982   {
 983     char device[] = "/dev/sda";
 984     device[5] = devchar;
 985     int r;
 986     suppress_error = 0;
 987     r = guestfs_blockdev_setrw (g, device);
 988     if (r == -1)
 989       return -1;
 990   }
 991   {
 992     int r;
 993     suppress_error = 0;
 994     r = guestfs_umount_all (g);
 995     if (r == -1)
 996       return -1;
 997   }
 998   {
 999     int r;
1000     suppress_error = 0;
1001     r = guestfs_lvm_remove_all (g);
1002     if (r == -1)
1003       return -1;
1004   }
1005   {
1006     char device[] = "/dev/sda";
1007     device[5] = devchar;
1008     char lines_0[] = ",";
1009     char *lines[] = {
1010       lines_0,
1011       NULL
1012     };
1013     int r;
1014     suppress_error = 0;
1015     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1016     if (r == -1)
1017       return -1;
1018   }
1019   {
1020     char fstype[] = "ext2";
1021     char device[] = "/dev/sda1";
1022     device[5] = devchar;
1023     int r;
1024     suppress_error = 0;
1025     r = guestfs_mkfs (g, fstype, device);
1026     if (r == -1)
1027       return -1;
1028   }
1029   {
1030     char device[] = "/dev/sda1";
1031     device[5] = devchar;
1032     char mountpoint[] = "/";
1033     int r;
1034     suppress_error = 0;
1035     r = guestfs_mount (g, device, mountpoint);
1036     if (r == -1)
1037       return -1;
1038   }
1039   /* TestOutputFalse for mv (1) */
1040   {
1041     char path[] = "/old";
1042     char content[] = "file content";
1043     int r;
1044     suppress_error = 0;
1045     r = guestfs_write_file (g, path, content, 0);
1046     if (r == -1)
1047       return -1;
1048   }
1049   {
1050     char src[] = "/old";
1051     char dest[] = "/new";
1052     int r;
1053     suppress_error = 0;
1054     r = guestfs_mv (g, src, dest);
1055     if (r == -1)
1056       return -1;
1057   }
1058   {
1059     char path[] = "/old";
1060     int r;
1061     suppress_error = 0;
1062     r = guestfs_is_file (g, path);
1063     if (r == -1)
1064       return -1;
1065     if (r) {
1066       fprintf (stderr, "test_mv_1: expected false, got true\n");
1067       return -1;
1068     }
1069   }
1070   return 0;
1071 }
1072
1073 static int test_cp_a_0 (void)
1074 {
1075   /* InitBasicFS for cp_a (0): create ext2 on /dev/sda1 */
1076   {
1077     char device[] = "/dev/sda";
1078     device[5] = devchar;
1079     int r;
1080     suppress_error = 0;
1081     r = guestfs_blockdev_setrw (g, device);
1082     if (r == -1)
1083       return -1;
1084   }
1085   {
1086     int r;
1087     suppress_error = 0;
1088     r = guestfs_umount_all (g);
1089     if (r == -1)
1090       return -1;
1091   }
1092   {
1093     int r;
1094     suppress_error = 0;
1095     r = guestfs_lvm_remove_all (g);
1096     if (r == -1)
1097       return -1;
1098   }
1099   {
1100     char device[] = "/dev/sda";
1101     device[5] = devchar;
1102     char lines_0[] = ",";
1103     char *lines[] = {
1104       lines_0,
1105       NULL
1106     };
1107     int r;
1108     suppress_error = 0;
1109     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1110     if (r == -1)
1111       return -1;
1112   }
1113   {
1114     char fstype[] = "ext2";
1115     char device[] = "/dev/sda1";
1116     device[5] = devchar;
1117     int r;
1118     suppress_error = 0;
1119     r = guestfs_mkfs (g, fstype, device);
1120     if (r == -1)
1121       return -1;
1122   }
1123   {
1124     char device[] = "/dev/sda1";
1125     device[5] = devchar;
1126     char mountpoint[] = "/";
1127     int r;
1128     suppress_error = 0;
1129     r = guestfs_mount (g, device, mountpoint);
1130     if (r == -1)
1131       return -1;
1132   }
1133   /* TestOutput for cp_a (0) */
1134   char expected[] = "file content";
1135   {
1136     char path[] = "/olddir";
1137     int r;
1138     suppress_error = 0;
1139     r = guestfs_mkdir (g, path);
1140     if (r == -1)
1141       return -1;
1142   }
1143   {
1144     char path[] = "/newdir";
1145     int r;
1146     suppress_error = 0;
1147     r = guestfs_mkdir (g, path);
1148     if (r == -1)
1149       return -1;
1150   }
1151   {
1152     char path[] = "/olddir/file";
1153     char content[] = "file content";
1154     int r;
1155     suppress_error = 0;
1156     r = guestfs_write_file (g, path, content, 0);
1157     if (r == -1)
1158       return -1;
1159   }
1160   {
1161     char src[] = "/olddir";
1162     char dest[] = "/newdir";
1163     int r;
1164     suppress_error = 0;
1165     r = guestfs_cp_a (g, src, dest);
1166     if (r == -1)
1167       return -1;
1168   }
1169   {
1170     char path[] = "/newdir/olddir/file";
1171     char *r;
1172     suppress_error = 0;
1173     r = guestfs_cat (g, path);
1174     if (r == NULL)
1175       return -1;
1176     if (strcmp (r, expected) != 0) {
1177       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1178       return -1;
1179     }
1180     free (r);
1181   }
1182   return 0;
1183 }
1184
1185 static int test_cp_0 (void)
1186 {
1187   /* InitBasicFS for cp (0): create ext2 on /dev/sda1 */
1188   {
1189     char device[] = "/dev/sda";
1190     device[5] = devchar;
1191     int r;
1192     suppress_error = 0;
1193     r = guestfs_blockdev_setrw (g, device);
1194     if (r == -1)
1195       return -1;
1196   }
1197   {
1198     int r;
1199     suppress_error = 0;
1200     r = guestfs_umount_all (g);
1201     if (r == -1)
1202       return -1;
1203   }
1204   {
1205     int r;
1206     suppress_error = 0;
1207     r = guestfs_lvm_remove_all (g);
1208     if (r == -1)
1209       return -1;
1210   }
1211   {
1212     char device[] = "/dev/sda";
1213     device[5] = devchar;
1214     char lines_0[] = ",";
1215     char *lines[] = {
1216       lines_0,
1217       NULL
1218     };
1219     int r;
1220     suppress_error = 0;
1221     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1222     if (r == -1)
1223       return -1;
1224   }
1225   {
1226     char fstype[] = "ext2";
1227     char device[] = "/dev/sda1";
1228     device[5] = devchar;
1229     int r;
1230     suppress_error = 0;
1231     r = guestfs_mkfs (g, fstype, device);
1232     if (r == -1)
1233       return -1;
1234   }
1235   {
1236     char device[] = "/dev/sda1";
1237     device[5] = devchar;
1238     char mountpoint[] = "/";
1239     int r;
1240     suppress_error = 0;
1241     r = guestfs_mount (g, device, mountpoint);
1242     if (r == -1)
1243       return -1;
1244   }
1245   /* TestOutput for cp (0) */
1246   char expected[] = "file content";
1247   {
1248     char path[] = "/old";
1249     char content[] = "file content";
1250     int r;
1251     suppress_error = 0;
1252     r = guestfs_write_file (g, path, content, 0);
1253     if (r == -1)
1254       return -1;
1255   }
1256   {
1257     char src[] = "/old";
1258     char dest[] = "/new";
1259     int r;
1260     suppress_error = 0;
1261     r = guestfs_cp (g, src, dest);
1262     if (r == -1)
1263       return -1;
1264   }
1265   {
1266     char path[] = "/new";
1267     char *r;
1268     suppress_error = 0;
1269     r = guestfs_cat (g, path);
1270     if (r == NULL)
1271       return -1;
1272     if (strcmp (r, expected) != 0) {
1273       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1274       return -1;
1275     }
1276     free (r);
1277   }
1278   return 0;
1279 }
1280
1281 static int test_cp_1 (void)
1282 {
1283   /* InitBasicFS for cp (1): create ext2 on /dev/sda1 */
1284   {
1285     char device[] = "/dev/sda";
1286     device[5] = devchar;
1287     int r;
1288     suppress_error = 0;
1289     r = guestfs_blockdev_setrw (g, device);
1290     if (r == -1)
1291       return -1;
1292   }
1293   {
1294     int r;
1295     suppress_error = 0;
1296     r = guestfs_umount_all (g);
1297     if (r == -1)
1298       return -1;
1299   }
1300   {
1301     int r;
1302     suppress_error = 0;
1303     r = guestfs_lvm_remove_all (g);
1304     if (r == -1)
1305       return -1;
1306   }
1307   {
1308     char device[] = "/dev/sda";
1309     device[5] = devchar;
1310     char lines_0[] = ",";
1311     char *lines[] = {
1312       lines_0,
1313       NULL
1314     };
1315     int r;
1316     suppress_error = 0;
1317     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1318     if (r == -1)
1319       return -1;
1320   }
1321   {
1322     char fstype[] = "ext2";
1323     char device[] = "/dev/sda1";
1324     device[5] = devchar;
1325     int r;
1326     suppress_error = 0;
1327     r = guestfs_mkfs (g, fstype, device);
1328     if (r == -1)
1329       return -1;
1330   }
1331   {
1332     char device[] = "/dev/sda1";
1333     device[5] = devchar;
1334     char mountpoint[] = "/";
1335     int r;
1336     suppress_error = 0;
1337     r = guestfs_mount (g, device, mountpoint);
1338     if (r == -1)
1339       return -1;
1340   }
1341   /* TestOutputTrue for cp (1) */
1342   {
1343     char path[] = "/old";
1344     char content[] = "file content";
1345     int r;
1346     suppress_error = 0;
1347     r = guestfs_write_file (g, path, content, 0);
1348     if (r == -1)
1349       return -1;
1350   }
1351   {
1352     char src[] = "/old";
1353     char dest[] = "/new";
1354     int r;
1355     suppress_error = 0;
1356     r = guestfs_cp (g, src, dest);
1357     if (r == -1)
1358       return -1;
1359   }
1360   {
1361     char path[] = "/old";
1362     int r;
1363     suppress_error = 0;
1364     r = guestfs_is_file (g, path);
1365     if (r == -1)
1366       return -1;
1367     if (!r) {
1368       fprintf (stderr, "test_cp_1: expected true, got false\n");
1369       return -1;
1370     }
1371   }
1372   return 0;
1373 }
1374
1375 static int test_cp_2 (void)
1376 {
1377   /* InitBasicFS for cp (2): create ext2 on /dev/sda1 */
1378   {
1379     char device[] = "/dev/sda";
1380     device[5] = devchar;
1381     int r;
1382     suppress_error = 0;
1383     r = guestfs_blockdev_setrw (g, device);
1384     if (r == -1)
1385       return -1;
1386   }
1387   {
1388     int r;
1389     suppress_error = 0;
1390     r = guestfs_umount_all (g);
1391     if (r == -1)
1392       return -1;
1393   }
1394   {
1395     int r;
1396     suppress_error = 0;
1397     r = guestfs_lvm_remove_all (g);
1398     if (r == -1)
1399       return -1;
1400   }
1401   {
1402     char device[] = "/dev/sda";
1403     device[5] = devchar;
1404     char lines_0[] = ",";
1405     char *lines[] = {
1406       lines_0,
1407       NULL
1408     };
1409     int r;
1410     suppress_error = 0;
1411     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1412     if (r == -1)
1413       return -1;
1414   }
1415   {
1416     char fstype[] = "ext2";
1417     char device[] = "/dev/sda1";
1418     device[5] = devchar;
1419     int r;
1420     suppress_error = 0;
1421     r = guestfs_mkfs (g, fstype, device);
1422     if (r == -1)
1423       return -1;
1424   }
1425   {
1426     char device[] = "/dev/sda1";
1427     device[5] = devchar;
1428     char mountpoint[] = "/";
1429     int r;
1430     suppress_error = 0;
1431     r = guestfs_mount (g, device, mountpoint);
1432     if (r == -1)
1433       return -1;
1434   }
1435   /* TestOutput for cp (2) */
1436   char expected[] = "file content";
1437   {
1438     char path[] = "/old";
1439     char content[] = "file content";
1440     int r;
1441     suppress_error = 0;
1442     r = guestfs_write_file (g, path, content, 0);
1443     if (r == -1)
1444       return -1;
1445   }
1446   {
1447     char path[] = "/dir";
1448     int r;
1449     suppress_error = 0;
1450     r = guestfs_mkdir (g, path);
1451     if (r == -1)
1452       return -1;
1453   }
1454   {
1455     char src[] = "/old";
1456     char dest[] = "/dir/new";
1457     int r;
1458     suppress_error = 0;
1459     r = guestfs_cp (g, src, dest);
1460     if (r == -1)
1461       return -1;
1462   }
1463   {
1464     char path[] = "/dir/new";
1465     char *r;
1466     suppress_error = 0;
1467     r = guestfs_cat (g, path);
1468     if (r == NULL)
1469       return -1;
1470     if (strcmp (r, expected) != 0) {
1471       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
1472       return -1;
1473     }
1474     free (r);
1475   }
1476   return 0;
1477 }
1478
1479 static int test_grub_install_0 (void)
1480 {
1481   /* InitBasicFS for grub_install (0): create ext2 on /dev/sda1 */
1482   {
1483     char device[] = "/dev/sda";
1484     device[5] = devchar;
1485     int r;
1486     suppress_error = 0;
1487     r = guestfs_blockdev_setrw (g, device);
1488     if (r == -1)
1489       return -1;
1490   }
1491   {
1492     int r;
1493     suppress_error = 0;
1494     r = guestfs_umount_all (g);
1495     if (r == -1)
1496       return -1;
1497   }
1498   {
1499     int r;
1500     suppress_error = 0;
1501     r = guestfs_lvm_remove_all (g);
1502     if (r == -1)
1503       return -1;
1504   }
1505   {
1506     char device[] = "/dev/sda";
1507     device[5] = devchar;
1508     char lines_0[] = ",";
1509     char *lines[] = {
1510       lines_0,
1511       NULL
1512     };
1513     int r;
1514     suppress_error = 0;
1515     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1516     if (r == -1)
1517       return -1;
1518   }
1519   {
1520     char fstype[] = "ext2";
1521     char device[] = "/dev/sda1";
1522     device[5] = devchar;
1523     int r;
1524     suppress_error = 0;
1525     r = guestfs_mkfs (g, fstype, device);
1526     if (r == -1)
1527       return -1;
1528   }
1529   {
1530     char device[] = "/dev/sda1";
1531     device[5] = devchar;
1532     char mountpoint[] = "/";
1533     int r;
1534     suppress_error = 0;
1535     r = guestfs_mount (g, device, mountpoint);
1536     if (r == -1)
1537       return -1;
1538   }
1539   /* TestOutputTrue for grub_install (0) */
1540   {
1541     char root[] = "/";
1542     char device[] = "/dev/sda1";
1543     device[5] = devchar;
1544     int r;
1545     suppress_error = 0;
1546     r = guestfs_grub_install (g, root, device);
1547     if (r == -1)
1548       return -1;
1549   }
1550   {
1551     char path[] = "/boot";
1552     int r;
1553     suppress_error = 0;
1554     r = guestfs_is_dir (g, path);
1555     if (r == -1)
1556       return -1;
1557     if (!r) {
1558       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
1559       return -1;
1560     }
1561   }
1562   return 0;
1563 }
1564
1565 static int test_zero_0 (void)
1566 {
1567   /* InitBasicFS for zero (0): create ext2 on /dev/sda1 */
1568   {
1569     char device[] = "/dev/sda";
1570     device[5] = devchar;
1571     int r;
1572     suppress_error = 0;
1573     r = guestfs_blockdev_setrw (g, device);
1574     if (r == -1)
1575       return -1;
1576   }
1577   {
1578     int r;
1579     suppress_error = 0;
1580     r = guestfs_umount_all (g);
1581     if (r == -1)
1582       return -1;
1583   }
1584   {
1585     int r;
1586     suppress_error = 0;
1587     r = guestfs_lvm_remove_all (g);
1588     if (r == -1)
1589       return -1;
1590   }
1591   {
1592     char device[] = "/dev/sda";
1593     device[5] = devchar;
1594     char lines_0[] = ",";
1595     char *lines[] = {
1596       lines_0,
1597       NULL
1598     };
1599     int r;
1600     suppress_error = 0;
1601     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1602     if (r == -1)
1603       return -1;
1604   }
1605   {
1606     char fstype[] = "ext2";
1607     char device[] = "/dev/sda1";
1608     device[5] = devchar;
1609     int r;
1610     suppress_error = 0;
1611     r = guestfs_mkfs (g, fstype, device);
1612     if (r == -1)
1613       return -1;
1614   }
1615   {
1616     char device[] = "/dev/sda1";
1617     device[5] = devchar;
1618     char mountpoint[] = "/";
1619     int r;
1620     suppress_error = 0;
1621     r = guestfs_mount (g, device, mountpoint);
1622     if (r == -1)
1623       return -1;
1624   }
1625   /* TestOutput for zero (0) */
1626   char expected[] = "data";
1627   {
1628     char pathordevice[] = "/dev/sda1";
1629     pathordevice[5] = devchar;
1630     int r;
1631     suppress_error = 0;
1632     r = guestfs_umount (g, pathordevice);
1633     if (r == -1)
1634       return -1;
1635   }
1636   {
1637     char device[] = "/dev/sda1";
1638     device[5] = devchar;
1639     int r;
1640     suppress_error = 0;
1641     r = guestfs_zero (g, device);
1642     if (r == -1)
1643       return -1;
1644   }
1645   {
1646     char path[] = "/dev/sda1";
1647     path[5] = devchar;
1648     char *r;
1649     suppress_error = 0;
1650     r = guestfs_file (g, path);
1651     if (r == NULL)
1652       return -1;
1653     if (strcmp (r, expected) != 0) {
1654       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
1655       return -1;
1656     }
1657     free (r);
1658   }
1659   return 0;
1660 }
1661
1662 static int test_fsck_0 (void)
1663 {
1664   /* InitBasicFS for fsck (0): create ext2 on /dev/sda1 */
1665   {
1666     char device[] = "/dev/sda";
1667     device[5] = devchar;
1668     int r;
1669     suppress_error = 0;
1670     r = guestfs_blockdev_setrw (g, device);
1671     if (r == -1)
1672       return -1;
1673   }
1674   {
1675     int r;
1676     suppress_error = 0;
1677     r = guestfs_umount_all (g);
1678     if (r == -1)
1679       return -1;
1680   }
1681   {
1682     int r;
1683     suppress_error = 0;
1684     r = guestfs_lvm_remove_all (g);
1685     if (r == -1)
1686       return -1;
1687   }
1688   {
1689     char device[] = "/dev/sda";
1690     device[5] = devchar;
1691     char lines_0[] = ",";
1692     char *lines[] = {
1693       lines_0,
1694       NULL
1695     };
1696     int r;
1697     suppress_error = 0;
1698     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1699     if (r == -1)
1700       return -1;
1701   }
1702   {
1703     char fstype[] = "ext2";
1704     char device[] = "/dev/sda1";
1705     device[5] = devchar;
1706     int r;
1707     suppress_error = 0;
1708     r = guestfs_mkfs (g, fstype, device);
1709     if (r == -1)
1710       return -1;
1711   }
1712   {
1713     char device[] = "/dev/sda1";
1714     device[5] = devchar;
1715     char mountpoint[] = "/";
1716     int r;
1717     suppress_error = 0;
1718     r = guestfs_mount (g, device, mountpoint);
1719     if (r == -1)
1720       return -1;
1721   }
1722   /* TestOutputInt for fsck (0) */
1723   {
1724     char pathordevice[] = "/dev/sda1";
1725     pathordevice[5] = devchar;
1726     int r;
1727     suppress_error = 0;
1728     r = guestfs_umount (g, pathordevice);
1729     if (r == -1)
1730       return -1;
1731   }
1732   {
1733     char fstype[] = "ext2";
1734     char device[] = "/dev/sda1";
1735     device[5] = devchar;
1736     int r;
1737     suppress_error = 0;
1738     r = guestfs_fsck (g, fstype, device);
1739     if (r == -1)
1740       return -1;
1741     if (r != 0) {
1742       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
1743       return -1;
1744     }
1745   }
1746   return 0;
1747 }
1748
1749 static int test_fsck_1 (void)
1750 {
1751   /* InitBasicFS for fsck (1): create ext2 on /dev/sda1 */
1752   {
1753     char device[] = "/dev/sda";
1754     device[5] = devchar;
1755     int r;
1756     suppress_error = 0;
1757     r = guestfs_blockdev_setrw (g, device);
1758     if (r == -1)
1759       return -1;
1760   }
1761   {
1762     int r;
1763     suppress_error = 0;
1764     r = guestfs_umount_all (g);
1765     if (r == -1)
1766       return -1;
1767   }
1768   {
1769     int r;
1770     suppress_error = 0;
1771     r = guestfs_lvm_remove_all (g);
1772     if (r == -1)
1773       return -1;
1774   }
1775   {
1776     char device[] = "/dev/sda";
1777     device[5] = devchar;
1778     char lines_0[] = ",";
1779     char *lines[] = {
1780       lines_0,
1781       NULL
1782     };
1783     int r;
1784     suppress_error = 0;
1785     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1786     if (r == -1)
1787       return -1;
1788   }
1789   {
1790     char fstype[] = "ext2";
1791     char device[] = "/dev/sda1";
1792     device[5] = devchar;
1793     int r;
1794     suppress_error = 0;
1795     r = guestfs_mkfs (g, fstype, device);
1796     if (r == -1)
1797       return -1;
1798   }
1799   {
1800     char device[] = "/dev/sda1";
1801     device[5] = devchar;
1802     char mountpoint[] = "/";
1803     int r;
1804     suppress_error = 0;
1805     r = guestfs_mount (g, device, mountpoint);
1806     if (r == -1)
1807       return -1;
1808   }
1809   /* TestOutputInt for fsck (1) */
1810   {
1811     char pathordevice[] = "/dev/sda1";
1812     pathordevice[5] = devchar;
1813     int r;
1814     suppress_error = 0;
1815     r = guestfs_umount (g, pathordevice);
1816     if (r == -1)
1817       return -1;
1818   }
1819   {
1820     char device[] = "/dev/sda1";
1821     device[5] = devchar;
1822     int r;
1823     suppress_error = 0;
1824     r = guestfs_zero (g, device);
1825     if (r == -1)
1826       return -1;
1827   }
1828   {
1829     char fstype[] = "ext2";
1830     char device[] = "/dev/sda1";
1831     device[5] = devchar;
1832     int r;
1833     suppress_error = 0;
1834     r = guestfs_fsck (g, fstype, device);
1835     if (r == -1)
1836       return -1;
1837     if (r != 8) {
1838       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
1839       return -1;
1840     }
1841   }
1842   return 0;
1843 }
1844
1845 static int test_set_e2uuid_0 (void)
1846 {
1847   /* InitBasicFS for set_e2uuid (0): create ext2 on /dev/sda1 */
1848   {
1849     char device[] = "/dev/sda";
1850     device[5] = devchar;
1851     int r;
1852     suppress_error = 0;
1853     r = guestfs_blockdev_setrw (g, device);
1854     if (r == -1)
1855       return -1;
1856   }
1857   {
1858     int r;
1859     suppress_error = 0;
1860     r = guestfs_umount_all (g);
1861     if (r == -1)
1862       return -1;
1863   }
1864   {
1865     int r;
1866     suppress_error = 0;
1867     r = guestfs_lvm_remove_all (g);
1868     if (r == -1)
1869       return -1;
1870   }
1871   {
1872     char device[] = "/dev/sda";
1873     device[5] = devchar;
1874     char lines_0[] = ",";
1875     char *lines[] = {
1876       lines_0,
1877       NULL
1878     };
1879     int r;
1880     suppress_error = 0;
1881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1882     if (r == -1)
1883       return -1;
1884   }
1885   {
1886     char fstype[] = "ext2";
1887     char device[] = "/dev/sda1";
1888     device[5] = devchar;
1889     int r;
1890     suppress_error = 0;
1891     r = guestfs_mkfs (g, fstype, device);
1892     if (r == -1)
1893       return -1;
1894   }
1895   {
1896     char device[] = "/dev/sda1";
1897     device[5] = devchar;
1898     char mountpoint[] = "/";
1899     int r;
1900     suppress_error = 0;
1901     r = guestfs_mount (g, device, mountpoint);
1902     if (r == -1)
1903       return -1;
1904   }
1905   /* TestOutput for set_e2uuid (0) */
1906   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
1907   {
1908     char device[] = "/dev/sda1";
1909     device[5] = devchar;
1910     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
1911     int r;
1912     suppress_error = 0;
1913     r = guestfs_set_e2uuid (g, device, uuid);
1914     if (r == -1)
1915       return -1;
1916   }
1917   {
1918     char device[] = "/dev/sda1";
1919     device[5] = devchar;
1920     char *r;
1921     suppress_error = 0;
1922     r = guestfs_get_e2uuid (g, device);
1923     if (r == NULL)
1924       return -1;
1925     if (strcmp (r, expected) != 0) {
1926       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
1927       return -1;
1928     }
1929     free (r);
1930   }
1931   return 0;
1932 }
1933
1934 static int test_set_e2uuid_1 (void)
1935 {
1936   /* InitBasicFS for set_e2uuid (1): create ext2 on /dev/sda1 */
1937   {
1938     char device[] = "/dev/sda";
1939     device[5] = devchar;
1940     int r;
1941     suppress_error = 0;
1942     r = guestfs_blockdev_setrw (g, device);
1943     if (r == -1)
1944       return -1;
1945   }
1946   {
1947     int r;
1948     suppress_error = 0;
1949     r = guestfs_umount_all (g);
1950     if (r == -1)
1951       return -1;
1952   }
1953   {
1954     int r;
1955     suppress_error = 0;
1956     r = guestfs_lvm_remove_all (g);
1957     if (r == -1)
1958       return -1;
1959   }
1960   {
1961     char device[] = "/dev/sda";
1962     device[5] = devchar;
1963     char lines_0[] = ",";
1964     char *lines[] = {
1965       lines_0,
1966       NULL
1967     };
1968     int r;
1969     suppress_error = 0;
1970     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1971     if (r == -1)
1972       return -1;
1973   }
1974   {
1975     char fstype[] = "ext2";
1976     char device[] = "/dev/sda1";
1977     device[5] = devchar;
1978     int r;
1979     suppress_error = 0;
1980     r = guestfs_mkfs (g, fstype, device);
1981     if (r == -1)
1982       return -1;
1983   }
1984   {
1985     char device[] = "/dev/sda1";
1986     device[5] = devchar;
1987     char mountpoint[] = "/";
1988     int r;
1989     suppress_error = 0;
1990     r = guestfs_mount (g, device, mountpoint);
1991     if (r == -1)
1992       return -1;
1993   }
1994   /* TestOutput for set_e2uuid (1) */
1995   char expected[] = "";
1996   {
1997     char device[] = "/dev/sda1";
1998     device[5] = devchar;
1999     char uuid[] = "clear";
2000     int r;
2001     suppress_error = 0;
2002     r = guestfs_set_e2uuid (g, device, uuid);
2003     if (r == -1)
2004       return -1;
2005   }
2006   {
2007     char device[] = "/dev/sda1";
2008     device[5] = devchar;
2009     char *r;
2010     suppress_error = 0;
2011     r = guestfs_get_e2uuid (g, device);
2012     if (r == NULL)
2013       return -1;
2014     if (strcmp (r, expected) != 0) {
2015       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2016       return -1;
2017     }
2018     free (r);
2019   }
2020   return 0;
2021 }
2022
2023 static int test_set_e2uuid_2 (void)
2024 {
2025   /* InitBasicFS for set_e2uuid (2): create ext2 on /dev/sda1 */
2026   {
2027     char device[] = "/dev/sda";
2028     device[5] = devchar;
2029     int r;
2030     suppress_error = 0;
2031     r = guestfs_blockdev_setrw (g, device);
2032     if (r == -1)
2033       return -1;
2034   }
2035   {
2036     int r;
2037     suppress_error = 0;
2038     r = guestfs_umount_all (g);
2039     if (r == -1)
2040       return -1;
2041   }
2042   {
2043     int r;
2044     suppress_error = 0;
2045     r = guestfs_lvm_remove_all (g);
2046     if (r == -1)
2047       return -1;
2048   }
2049   {
2050     char device[] = "/dev/sda";
2051     device[5] = devchar;
2052     char lines_0[] = ",";
2053     char *lines[] = {
2054       lines_0,
2055       NULL
2056     };
2057     int r;
2058     suppress_error = 0;
2059     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2060     if (r == -1)
2061       return -1;
2062   }
2063   {
2064     char fstype[] = "ext2";
2065     char device[] = "/dev/sda1";
2066     device[5] = devchar;
2067     int r;
2068     suppress_error = 0;
2069     r = guestfs_mkfs (g, fstype, device);
2070     if (r == -1)
2071       return -1;
2072   }
2073   {
2074     char device[] = "/dev/sda1";
2075     device[5] = devchar;
2076     char mountpoint[] = "/";
2077     int r;
2078     suppress_error = 0;
2079     r = guestfs_mount (g, device, mountpoint);
2080     if (r == -1)
2081       return -1;
2082   }
2083   /* TestRun for set_e2uuid (2) */
2084   {
2085     char device[] = "/dev/sda1";
2086     device[5] = devchar;
2087     char uuid[] = "random";
2088     int r;
2089     suppress_error = 0;
2090     r = guestfs_set_e2uuid (g, device, uuid);
2091     if (r == -1)
2092       return -1;
2093   }
2094   return 0;
2095 }
2096
2097 static int test_set_e2uuid_3 (void)
2098 {
2099   /* InitBasicFS for set_e2uuid (3): create ext2 on /dev/sda1 */
2100   {
2101     char device[] = "/dev/sda";
2102     device[5] = devchar;
2103     int r;
2104     suppress_error = 0;
2105     r = guestfs_blockdev_setrw (g, device);
2106     if (r == -1)
2107       return -1;
2108   }
2109   {
2110     int r;
2111     suppress_error = 0;
2112     r = guestfs_umount_all (g);
2113     if (r == -1)
2114       return -1;
2115   }
2116   {
2117     int r;
2118     suppress_error = 0;
2119     r = guestfs_lvm_remove_all (g);
2120     if (r == -1)
2121       return -1;
2122   }
2123   {
2124     char device[] = "/dev/sda";
2125     device[5] = devchar;
2126     char lines_0[] = ",";
2127     char *lines[] = {
2128       lines_0,
2129       NULL
2130     };
2131     int r;
2132     suppress_error = 0;
2133     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2134     if (r == -1)
2135       return -1;
2136   }
2137   {
2138     char fstype[] = "ext2";
2139     char device[] = "/dev/sda1";
2140     device[5] = devchar;
2141     int r;
2142     suppress_error = 0;
2143     r = guestfs_mkfs (g, fstype, device);
2144     if (r == -1)
2145       return -1;
2146   }
2147   {
2148     char device[] = "/dev/sda1";
2149     device[5] = devchar;
2150     char mountpoint[] = "/";
2151     int r;
2152     suppress_error = 0;
2153     r = guestfs_mount (g, device, mountpoint);
2154     if (r == -1)
2155       return -1;
2156   }
2157   /* TestRun for set_e2uuid (3) */
2158   {
2159     char device[] = "/dev/sda1";
2160     device[5] = devchar;
2161     char uuid[] = "time";
2162     int r;
2163     suppress_error = 0;
2164     r = guestfs_set_e2uuid (g, device, uuid);
2165     if (r == -1)
2166       return -1;
2167   }
2168   return 0;
2169 }
2170
2171 static int test_set_e2label_0 (void)
2172 {
2173   /* InitBasicFS for set_e2label (0): create ext2 on /dev/sda1 */
2174   {
2175     char device[] = "/dev/sda";
2176     device[5] = devchar;
2177     int r;
2178     suppress_error = 0;
2179     r = guestfs_blockdev_setrw (g, device);
2180     if (r == -1)
2181       return -1;
2182   }
2183   {
2184     int r;
2185     suppress_error = 0;
2186     r = guestfs_umount_all (g);
2187     if (r == -1)
2188       return -1;
2189   }
2190   {
2191     int r;
2192     suppress_error = 0;
2193     r = guestfs_lvm_remove_all (g);
2194     if (r == -1)
2195       return -1;
2196   }
2197   {
2198     char device[] = "/dev/sda";
2199     device[5] = devchar;
2200     char lines_0[] = ",";
2201     char *lines[] = {
2202       lines_0,
2203       NULL
2204     };
2205     int r;
2206     suppress_error = 0;
2207     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2208     if (r == -1)
2209       return -1;
2210   }
2211   {
2212     char fstype[] = "ext2";
2213     char device[] = "/dev/sda1";
2214     device[5] = devchar;
2215     int r;
2216     suppress_error = 0;
2217     r = guestfs_mkfs (g, fstype, device);
2218     if (r == -1)
2219       return -1;
2220   }
2221   {
2222     char device[] = "/dev/sda1";
2223     device[5] = devchar;
2224     char mountpoint[] = "/";
2225     int r;
2226     suppress_error = 0;
2227     r = guestfs_mount (g, device, mountpoint);
2228     if (r == -1)
2229       return -1;
2230   }
2231   /* TestOutput for set_e2label (0) */
2232   char expected[] = "testlabel";
2233   {
2234     char device[] = "/dev/sda1";
2235     device[5] = devchar;
2236     char label[] = "testlabel";
2237     int r;
2238     suppress_error = 0;
2239     r = guestfs_set_e2label (g, device, label);
2240     if (r == -1)
2241       return -1;
2242   }
2243   {
2244     char device[] = "/dev/sda1";
2245     device[5] = devchar;
2246     char *r;
2247     suppress_error = 0;
2248     r = guestfs_get_e2label (g, device);
2249     if (r == NULL)
2250       return -1;
2251     if (strcmp (r, expected) != 0) {
2252       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2253       return -1;
2254     }
2255     free (r);
2256   }
2257   return 0;
2258 }
2259
2260 static int test_pvremove_0 (void)
2261 {
2262   /* InitEmpty for pvremove (0) */
2263   {
2264     char device[] = "/dev/sda";
2265     device[5] = devchar;
2266     int r;
2267     suppress_error = 0;
2268     r = guestfs_blockdev_setrw (g, device);
2269     if (r == -1)
2270       return -1;
2271   }
2272   {
2273     int r;
2274     suppress_error = 0;
2275     r = guestfs_umount_all (g);
2276     if (r == -1)
2277       return -1;
2278   }
2279   {
2280     int r;
2281     suppress_error = 0;
2282     r = guestfs_lvm_remove_all (g);
2283     if (r == -1)
2284       return -1;
2285   }
2286   /* TestOutputList for pvremove (0) */
2287   {
2288     char device[] = "/dev/sda";
2289     device[5] = devchar;
2290     int r;
2291     suppress_error = 0;
2292     r = guestfs_pvcreate (g, device);
2293     if (r == -1)
2294       return -1;
2295   }
2296   {
2297     char volgroup[] = "VG";
2298     char physvols_0[] = "/dev/sda";
2299     physvols_0[5] = devchar;
2300     char *physvols[] = {
2301       physvols_0,
2302       NULL
2303     };
2304     int r;
2305     suppress_error = 0;
2306     r = guestfs_vgcreate (g, volgroup, physvols);
2307     if (r == -1)
2308       return -1;
2309   }
2310   {
2311     char logvol[] = "LV1";
2312     char volgroup[] = "VG";
2313     int r;
2314     suppress_error = 0;
2315     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2316     if (r == -1)
2317       return -1;
2318   }
2319   {
2320     char logvol[] = "LV2";
2321     char volgroup[] = "VG";
2322     int r;
2323     suppress_error = 0;
2324     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2325     if (r == -1)
2326       return -1;
2327   }
2328   {
2329     char vgname[] = "VG";
2330     int r;
2331     suppress_error = 0;
2332     r = guestfs_vgremove (g, vgname);
2333     if (r == -1)
2334       return -1;
2335   }
2336   {
2337     char device[] = "/dev/sda";
2338     device[5] = devchar;
2339     int r;
2340     suppress_error = 0;
2341     r = guestfs_pvremove (g, device);
2342     if (r == -1)
2343       return -1;
2344   }
2345   {
2346     char **r;
2347     int i;
2348     suppress_error = 0;
2349     r = guestfs_lvs (g);
2350     if (r == NULL)
2351       return -1;
2352     if (r[0] != NULL) {
2353       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
2354       print_strings (r);
2355       return -1;
2356     }
2357     for (i = 0; r[i] != NULL; ++i)
2358       free (r[i]);
2359     free (r);
2360   }
2361   return 0;
2362 }
2363
2364 static int test_pvremove_1 (void)
2365 {
2366   /* InitEmpty for pvremove (1) */
2367   {
2368     char device[] = "/dev/sda";
2369     device[5] = devchar;
2370     int r;
2371     suppress_error = 0;
2372     r = guestfs_blockdev_setrw (g, device);
2373     if (r == -1)
2374       return -1;
2375   }
2376   {
2377     int r;
2378     suppress_error = 0;
2379     r = guestfs_umount_all (g);
2380     if (r == -1)
2381       return -1;
2382   }
2383   {
2384     int r;
2385     suppress_error = 0;
2386     r = guestfs_lvm_remove_all (g);
2387     if (r == -1)
2388       return -1;
2389   }
2390   /* TestOutputList for pvremove (1) */
2391   {
2392     char device[] = "/dev/sda";
2393     device[5] = devchar;
2394     int r;
2395     suppress_error = 0;
2396     r = guestfs_pvcreate (g, device);
2397     if (r == -1)
2398       return -1;
2399   }
2400   {
2401     char volgroup[] = "VG";
2402     char physvols_0[] = "/dev/sda";
2403     physvols_0[5] = devchar;
2404     char *physvols[] = {
2405       physvols_0,
2406       NULL
2407     };
2408     int r;
2409     suppress_error = 0;
2410     r = guestfs_vgcreate (g, volgroup, physvols);
2411     if (r == -1)
2412       return -1;
2413   }
2414   {
2415     char logvol[] = "LV1";
2416     char volgroup[] = "VG";
2417     int r;
2418     suppress_error = 0;
2419     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2420     if (r == -1)
2421       return -1;
2422   }
2423   {
2424     char logvol[] = "LV2";
2425     char volgroup[] = "VG";
2426     int r;
2427     suppress_error = 0;
2428     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2429     if (r == -1)
2430       return -1;
2431   }
2432   {
2433     char vgname[] = "VG";
2434     int r;
2435     suppress_error = 0;
2436     r = guestfs_vgremove (g, vgname);
2437     if (r == -1)
2438       return -1;
2439   }
2440   {
2441     char device[] = "/dev/sda";
2442     device[5] = devchar;
2443     int r;
2444     suppress_error = 0;
2445     r = guestfs_pvremove (g, device);
2446     if (r == -1)
2447       return -1;
2448   }
2449   {
2450     char **r;
2451     int i;
2452     suppress_error = 0;
2453     r = guestfs_vgs (g);
2454     if (r == NULL)
2455       return -1;
2456     if (r[0] != NULL) {
2457       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
2458       print_strings (r);
2459       return -1;
2460     }
2461     for (i = 0; r[i] != NULL; ++i)
2462       free (r[i]);
2463     free (r);
2464   }
2465   return 0;
2466 }
2467
2468 static int test_pvremove_2 (void)
2469 {
2470   /* InitEmpty for pvremove (2) */
2471   {
2472     char device[] = "/dev/sda";
2473     device[5] = devchar;
2474     int r;
2475     suppress_error = 0;
2476     r = guestfs_blockdev_setrw (g, device);
2477     if (r == -1)
2478       return -1;
2479   }
2480   {
2481     int r;
2482     suppress_error = 0;
2483     r = guestfs_umount_all (g);
2484     if (r == -1)
2485       return -1;
2486   }
2487   {
2488     int r;
2489     suppress_error = 0;
2490     r = guestfs_lvm_remove_all (g);
2491     if (r == -1)
2492       return -1;
2493   }
2494   /* TestOutputList for pvremove (2) */
2495   {
2496     char device[] = "/dev/sda";
2497     device[5] = devchar;
2498     int r;
2499     suppress_error = 0;
2500     r = guestfs_pvcreate (g, device);
2501     if (r == -1)
2502       return -1;
2503   }
2504   {
2505     char volgroup[] = "VG";
2506     char physvols_0[] = "/dev/sda";
2507     physvols_0[5] = devchar;
2508     char *physvols[] = {
2509       physvols_0,
2510       NULL
2511     };
2512     int r;
2513     suppress_error = 0;
2514     r = guestfs_vgcreate (g, volgroup, physvols);
2515     if (r == -1)
2516       return -1;
2517   }
2518   {
2519     char logvol[] = "LV1";
2520     char volgroup[] = "VG";
2521     int r;
2522     suppress_error = 0;
2523     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2524     if (r == -1)
2525       return -1;
2526   }
2527   {
2528     char logvol[] = "LV2";
2529     char volgroup[] = "VG";
2530     int r;
2531     suppress_error = 0;
2532     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2533     if (r == -1)
2534       return -1;
2535   }
2536   {
2537     char vgname[] = "VG";
2538     int r;
2539     suppress_error = 0;
2540     r = guestfs_vgremove (g, vgname);
2541     if (r == -1)
2542       return -1;
2543   }
2544   {
2545     char device[] = "/dev/sda";
2546     device[5] = devchar;
2547     int r;
2548     suppress_error = 0;
2549     r = guestfs_pvremove (g, device);
2550     if (r == -1)
2551       return -1;
2552   }
2553   {
2554     char **r;
2555     int i;
2556     suppress_error = 0;
2557     r = guestfs_pvs (g);
2558     if (r == NULL)
2559       return -1;
2560     if (r[0] != NULL) {
2561       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
2562       print_strings (r);
2563       return -1;
2564     }
2565     for (i = 0; r[i] != NULL; ++i)
2566       free (r[i]);
2567     free (r);
2568   }
2569   return 0;
2570 }
2571
2572 static int test_vgremove_0 (void)
2573 {
2574   /* InitEmpty for vgremove (0) */
2575   {
2576     char device[] = "/dev/sda";
2577     device[5] = devchar;
2578     int r;
2579     suppress_error = 0;
2580     r = guestfs_blockdev_setrw (g, device);
2581     if (r == -1)
2582       return -1;
2583   }
2584   {
2585     int r;
2586     suppress_error = 0;
2587     r = guestfs_umount_all (g);
2588     if (r == -1)
2589       return -1;
2590   }
2591   {
2592     int r;
2593     suppress_error = 0;
2594     r = guestfs_lvm_remove_all (g);
2595     if (r == -1)
2596       return -1;
2597   }
2598   /* TestOutputList for vgremove (0) */
2599   {
2600     char device[] = "/dev/sda";
2601     device[5] = devchar;
2602     int r;
2603     suppress_error = 0;
2604     r = guestfs_pvcreate (g, device);
2605     if (r == -1)
2606       return -1;
2607   }
2608   {
2609     char volgroup[] = "VG";
2610     char physvols_0[] = "/dev/sda";
2611     physvols_0[5] = devchar;
2612     char *physvols[] = {
2613       physvols_0,
2614       NULL
2615     };
2616     int r;
2617     suppress_error = 0;
2618     r = guestfs_vgcreate (g, volgroup, physvols);
2619     if (r == -1)
2620       return -1;
2621   }
2622   {
2623     char logvol[] = "LV1";
2624     char volgroup[] = "VG";
2625     int r;
2626     suppress_error = 0;
2627     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2628     if (r == -1)
2629       return -1;
2630   }
2631   {
2632     char logvol[] = "LV2";
2633     char volgroup[] = "VG";
2634     int r;
2635     suppress_error = 0;
2636     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2637     if (r == -1)
2638       return -1;
2639   }
2640   {
2641     char vgname[] = "VG";
2642     int r;
2643     suppress_error = 0;
2644     r = guestfs_vgremove (g, vgname);
2645     if (r == -1)
2646       return -1;
2647   }
2648   {
2649     char **r;
2650     int i;
2651     suppress_error = 0;
2652     r = guestfs_lvs (g);
2653     if (r == NULL)
2654       return -1;
2655     if (r[0] != NULL) {
2656       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
2657       print_strings (r);
2658       return -1;
2659     }
2660     for (i = 0; r[i] != NULL; ++i)
2661       free (r[i]);
2662     free (r);
2663   }
2664   return 0;
2665 }
2666
2667 static int test_vgremove_1 (void)
2668 {
2669   /* InitEmpty for vgremove (1) */
2670   {
2671     char device[] = "/dev/sda";
2672     device[5] = devchar;
2673     int r;
2674     suppress_error = 0;
2675     r = guestfs_blockdev_setrw (g, device);
2676     if (r == -1)
2677       return -1;
2678   }
2679   {
2680     int r;
2681     suppress_error = 0;
2682     r = guestfs_umount_all (g);
2683     if (r == -1)
2684       return -1;
2685   }
2686   {
2687     int r;
2688     suppress_error = 0;
2689     r = guestfs_lvm_remove_all (g);
2690     if (r == -1)
2691       return -1;
2692   }
2693   /* TestOutputList for vgremove (1) */
2694   {
2695     char device[] = "/dev/sda";
2696     device[5] = devchar;
2697     int r;
2698     suppress_error = 0;
2699     r = guestfs_pvcreate (g, device);
2700     if (r == -1)
2701       return -1;
2702   }
2703   {
2704     char volgroup[] = "VG";
2705     char physvols_0[] = "/dev/sda";
2706     physvols_0[5] = devchar;
2707     char *physvols[] = {
2708       physvols_0,
2709       NULL
2710     };
2711     int r;
2712     suppress_error = 0;
2713     r = guestfs_vgcreate (g, volgroup, physvols);
2714     if (r == -1)
2715       return -1;
2716   }
2717   {
2718     char logvol[] = "LV1";
2719     char volgroup[] = "VG";
2720     int r;
2721     suppress_error = 0;
2722     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2723     if (r == -1)
2724       return -1;
2725   }
2726   {
2727     char logvol[] = "LV2";
2728     char volgroup[] = "VG";
2729     int r;
2730     suppress_error = 0;
2731     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2732     if (r == -1)
2733       return -1;
2734   }
2735   {
2736     char vgname[] = "VG";
2737     int r;
2738     suppress_error = 0;
2739     r = guestfs_vgremove (g, vgname);
2740     if (r == -1)
2741       return -1;
2742   }
2743   {
2744     char **r;
2745     int i;
2746     suppress_error = 0;
2747     r = guestfs_vgs (g);
2748     if (r == NULL)
2749       return -1;
2750     if (r[0] != NULL) {
2751       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
2752       print_strings (r);
2753       return -1;
2754     }
2755     for (i = 0; r[i] != NULL; ++i)
2756       free (r[i]);
2757     free (r);
2758   }
2759   return 0;
2760 }
2761
2762 static int test_lvremove_0 (void)
2763 {
2764   /* InitEmpty for lvremove (0) */
2765   {
2766     char device[] = "/dev/sda";
2767     device[5] = devchar;
2768     int r;
2769     suppress_error = 0;
2770     r = guestfs_blockdev_setrw (g, device);
2771     if (r == -1)
2772       return -1;
2773   }
2774   {
2775     int r;
2776     suppress_error = 0;
2777     r = guestfs_umount_all (g);
2778     if (r == -1)
2779       return -1;
2780   }
2781   {
2782     int r;
2783     suppress_error = 0;
2784     r = guestfs_lvm_remove_all (g);
2785     if (r == -1)
2786       return -1;
2787   }
2788   /* TestOutputList for lvremove (0) */
2789   {
2790     char device[] = "/dev/sda";
2791     device[5] = devchar;
2792     int r;
2793     suppress_error = 0;
2794     r = guestfs_pvcreate (g, device);
2795     if (r == -1)
2796       return -1;
2797   }
2798   {
2799     char volgroup[] = "VG";
2800     char physvols_0[] = "/dev/sda";
2801     physvols_0[5] = devchar;
2802     char *physvols[] = {
2803       physvols_0,
2804       NULL
2805     };
2806     int r;
2807     suppress_error = 0;
2808     r = guestfs_vgcreate (g, volgroup, physvols);
2809     if (r == -1)
2810       return -1;
2811   }
2812   {
2813     char logvol[] = "LV1";
2814     char volgroup[] = "VG";
2815     int r;
2816     suppress_error = 0;
2817     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2818     if (r == -1)
2819       return -1;
2820   }
2821   {
2822     char logvol[] = "LV2";
2823     char volgroup[] = "VG";
2824     int r;
2825     suppress_error = 0;
2826     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2827     if (r == -1)
2828       return -1;
2829   }
2830   {
2831     char device[] = "/dev/VG/LV1";
2832     int r;
2833     suppress_error = 0;
2834     r = guestfs_lvremove (g, device);
2835     if (r == -1)
2836       return -1;
2837   }
2838   {
2839     char **r;
2840     int i;
2841     suppress_error = 0;
2842     r = guestfs_lvs (g);
2843     if (r == NULL)
2844       return -1;
2845     if (!r[0]) {
2846       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
2847       print_strings (r);
2848       return -1;
2849     }
2850     {
2851       char expected[] = "/dev/VG/LV2";
2852       if (strcmp (r[0], expected) != 0) {
2853         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2854         return -1;
2855       }
2856     }
2857     if (r[1] != NULL) {
2858       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
2859       print_strings (r);
2860       return -1;
2861     }
2862     for (i = 0; r[i] != NULL; ++i)
2863       free (r[i]);
2864     free (r);
2865   }
2866   return 0;
2867 }
2868
2869 static int test_lvremove_1 (void)
2870 {
2871   /* InitEmpty for lvremove (1) */
2872   {
2873     char device[] = "/dev/sda";
2874     device[5] = devchar;
2875     int r;
2876     suppress_error = 0;
2877     r = guestfs_blockdev_setrw (g, device);
2878     if (r == -1)
2879       return -1;
2880   }
2881   {
2882     int r;
2883     suppress_error = 0;
2884     r = guestfs_umount_all (g);
2885     if (r == -1)
2886       return -1;
2887   }
2888   {
2889     int r;
2890     suppress_error = 0;
2891     r = guestfs_lvm_remove_all (g);
2892     if (r == -1)
2893       return -1;
2894   }
2895   /* TestOutputList for lvremove (1) */
2896   {
2897     char device[] = "/dev/sda";
2898     device[5] = devchar;
2899     int r;
2900     suppress_error = 0;
2901     r = guestfs_pvcreate (g, device);
2902     if (r == -1)
2903       return -1;
2904   }
2905   {
2906     char volgroup[] = "VG";
2907     char physvols_0[] = "/dev/sda";
2908     physvols_0[5] = devchar;
2909     char *physvols[] = {
2910       physvols_0,
2911       NULL
2912     };
2913     int r;
2914     suppress_error = 0;
2915     r = guestfs_vgcreate (g, volgroup, physvols);
2916     if (r == -1)
2917       return -1;
2918   }
2919   {
2920     char logvol[] = "LV1";
2921     char volgroup[] = "VG";
2922     int r;
2923     suppress_error = 0;
2924     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2925     if (r == -1)
2926       return -1;
2927   }
2928   {
2929     char logvol[] = "LV2";
2930     char volgroup[] = "VG";
2931     int r;
2932     suppress_error = 0;
2933     r = guestfs_lvcreate (g, logvol, volgroup, 50);
2934     if (r == -1)
2935       return -1;
2936   }
2937   {
2938     char device[] = "/dev/VG";
2939     int r;
2940     suppress_error = 0;
2941     r = guestfs_lvremove (g, device);
2942     if (r == -1)
2943       return -1;
2944   }
2945   {
2946     char **r;
2947     int i;
2948     suppress_error = 0;
2949     r = guestfs_lvs (g);
2950     if (r == NULL)
2951       return -1;
2952     if (r[0] != NULL) {
2953       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
2954       print_strings (r);
2955       return -1;
2956     }
2957     for (i = 0; r[i] != NULL; ++i)
2958       free (r[i]);
2959     free (r);
2960   }
2961   return 0;
2962 }
2963
2964 static int test_lvremove_2 (void)
2965 {
2966   /* InitEmpty for lvremove (2) */
2967   {
2968     char device[] = "/dev/sda";
2969     device[5] = devchar;
2970     int r;
2971     suppress_error = 0;
2972     r = guestfs_blockdev_setrw (g, device);
2973     if (r == -1)
2974       return -1;
2975   }
2976   {
2977     int r;
2978     suppress_error = 0;
2979     r = guestfs_umount_all (g);
2980     if (r == -1)
2981       return -1;
2982   }
2983   {
2984     int r;
2985     suppress_error = 0;
2986     r = guestfs_lvm_remove_all (g);
2987     if (r == -1)
2988       return -1;
2989   }
2990   /* TestOutputList for lvremove (2) */
2991   {
2992     char device[] = "/dev/sda";
2993     device[5] = devchar;
2994     int r;
2995     suppress_error = 0;
2996     r = guestfs_pvcreate (g, device);
2997     if (r == -1)
2998       return -1;
2999   }
3000   {
3001     char volgroup[] = "VG";
3002     char physvols_0[] = "/dev/sda";
3003     physvols_0[5] = devchar;
3004     char *physvols[] = {
3005       physvols_0,
3006       NULL
3007     };
3008     int r;
3009     suppress_error = 0;
3010     r = guestfs_vgcreate (g, volgroup, physvols);
3011     if (r == -1)
3012       return -1;
3013   }
3014   {
3015     char logvol[] = "LV1";
3016     char volgroup[] = "VG";
3017     int r;
3018     suppress_error = 0;
3019     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3020     if (r == -1)
3021       return -1;
3022   }
3023   {
3024     char logvol[] = "LV2";
3025     char volgroup[] = "VG";
3026     int r;
3027     suppress_error = 0;
3028     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3029     if (r == -1)
3030       return -1;
3031   }
3032   {
3033     char device[] = "/dev/VG";
3034     int r;
3035     suppress_error = 0;
3036     r = guestfs_lvremove (g, device);
3037     if (r == -1)
3038       return -1;
3039   }
3040   {
3041     char **r;
3042     int i;
3043     suppress_error = 0;
3044     r = guestfs_vgs (g);
3045     if (r == NULL)
3046       return -1;
3047     if (!r[0]) {
3048       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3049       print_strings (r);
3050       return -1;
3051     }
3052     {
3053       char expected[] = "VG";
3054       if (strcmp (r[0], expected) != 0) {
3055         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3056         return -1;
3057       }
3058     }
3059     if (r[1] != NULL) {
3060       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3061       print_strings (r);
3062       return -1;
3063     }
3064     for (i = 0; r[i] != NULL; ++i)
3065       free (r[i]);
3066     free (r);
3067   }
3068   return 0;
3069 }
3070
3071 static int test_mount_ro_0 (void)
3072 {
3073   /* InitBasicFS for mount_ro (0): create ext2 on /dev/sda1 */
3074   {
3075     char device[] = "/dev/sda";
3076     device[5] = devchar;
3077     int r;
3078     suppress_error = 0;
3079     r = guestfs_blockdev_setrw (g, device);
3080     if (r == -1)
3081       return -1;
3082   }
3083   {
3084     int r;
3085     suppress_error = 0;
3086     r = guestfs_umount_all (g);
3087     if (r == -1)
3088       return -1;
3089   }
3090   {
3091     int r;
3092     suppress_error = 0;
3093     r = guestfs_lvm_remove_all (g);
3094     if (r == -1)
3095       return -1;
3096   }
3097   {
3098     char device[] = "/dev/sda";
3099     device[5] = devchar;
3100     char lines_0[] = ",";
3101     char *lines[] = {
3102       lines_0,
3103       NULL
3104     };
3105     int r;
3106     suppress_error = 0;
3107     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3108     if (r == -1)
3109       return -1;
3110   }
3111   {
3112     char fstype[] = "ext2";
3113     char device[] = "/dev/sda1";
3114     device[5] = devchar;
3115     int r;
3116     suppress_error = 0;
3117     r = guestfs_mkfs (g, fstype, device);
3118     if (r == -1)
3119       return -1;
3120   }
3121   {
3122     char device[] = "/dev/sda1";
3123     device[5] = devchar;
3124     char mountpoint[] = "/";
3125     int r;
3126     suppress_error = 0;
3127     r = guestfs_mount (g, device, mountpoint);
3128     if (r == -1)
3129       return -1;
3130   }
3131   /* TestLastFail for mount_ro (0) */
3132   {
3133     char pathordevice[] = "/";
3134     int r;
3135     suppress_error = 0;
3136     r = guestfs_umount (g, pathordevice);
3137     if (r == -1)
3138       return -1;
3139   }
3140   {
3141     char device[] = "/dev/sda1";
3142     device[5] = devchar;
3143     char mountpoint[] = "/";
3144     int r;
3145     suppress_error = 0;
3146     r = guestfs_mount_ro (g, device, mountpoint);
3147     if (r == -1)
3148       return -1;
3149   }
3150   {
3151     char path[] = "/new";
3152     int r;
3153     suppress_error = 1;
3154     r = guestfs_touch (g, path);
3155     if (r != -1)
3156       return -1;
3157   }
3158   return 0;
3159 }
3160
3161 static int test_mount_ro_1 (void)
3162 {
3163   /* InitBasicFS for mount_ro (1): create ext2 on /dev/sda1 */
3164   {
3165     char device[] = "/dev/sda";
3166     device[5] = devchar;
3167     int r;
3168     suppress_error = 0;
3169     r = guestfs_blockdev_setrw (g, device);
3170     if (r == -1)
3171       return -1;
3172   }
3173   {
3174     int r;
3175     suppress_error = 0;
3176     r = guestfs_umount_all (g);
3177     if (r == -1)
3178       return -1;
3179   }
3180   {
3181     int r;
3182     suppress_error = 0;
3183     r = guestfs_lvm_remove_all (g);
3184     if (r == -1)
3185       return -1;
3186   }
3187   {
3188     char device[] = "/dev/sda";
3189     device[5] = devchar;
3190     char lines_0[] = ",";
3191     char *lines[] = {
3192       lines_0,
3193       NULL
3194     };
3195     int r;
3196     suppress_error = 0;
3197     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3198     if (r == -1)
3199       return -1;
3200   }
3201   {
3202     char fstype[] = "ext2";
3203     char device[] = "/dev/sda1";
3204     device[5] = devchar;
3205     int r;
3206     suppress_error = 0;
3207     r = guestfs_mkfs (g, fstype, device);
3208     if (r == -1)
3209       return -1;
3210   }
3211   {
3212     char device[] = "/dev/sda1";
3213     device[5] = devchar;
3214     char mountpoint[] = "/";
3215     int r;
3216     suppress_error = 0;
3217     r = guestfs_mount (g, device, mountpoint);
3218     if (r == -1)
3219       return -1;
3220   }
3221   /* TestOutput for mount_ro (1) */
3222   char expected[] = "data";
3223   {
3224     char path[] = "/new";
3225     char content[] = "data";
3226     int r;
3227     suppress_error = 0;
3228     r = guestfs_write_file (g, path, content, 0);
3229     if (r == -1)
3230       return -1;
3231   }
3232   {
3233     char pathordevice[] = "/";
3234     int r;
3235     suppress_error = 0;
3236     r = guestfs_umount (g, pathordevice);
3237     if (r == -1)
3238       return -1;
3239   }
3240   {
3241     char device[] = "/dev/sda1";
3242     device[5] = devchar;
3243     char mountpoint[] = "/";
3244     int r;
3245     suppress_error = 0;
3246     r = guestfs_mount_ro (g, device, mountpoint);
3247     if (r == -1)
3248       return -1;
3249   }
3250   {
3251     char path[] = "/new";
3252     char *r;
3253     suppress_error = 0;
3254     r = guestfs_cat (g, path);
3255     if (r == NULL)
3256       return -1;
3257     if (strcmp (r, expected) != 0) {
3258       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3259       return -1;
3260     }
3261     free (r);
3262   }
3263   return 0;
3264 }
3265
3266 static int test_tgz_in_0 (void)
3267 {
3268   /* InitBasicFS for tgz_in (0): create ext2 on /dev/sda1 */
3269   {
3270     char device[] = "/dev/sda";
3271     device[5] = devchar;
3272     int r;
3273     suppress_error = 0;
3274     r = guestfs_blockdev_setrw (g, device);
3275     if (r == -1)
3276       return -1;
3277   }
3278   {
3279     int r;
3280     suppress_error = 0;
3281     r = guestfs_umount_all (g);
3282     if (r == -1)
3283       return -1;
3284   }
3285   {
3286     int r;
3287     suppress_error = 0;
3288     r = guestfs_lvm_remove_all (g);
3289     if (r == -1)
3290       return -1;
3291   }
3292   {
3293     char device[] = "/dev/sda";
3294     device[5] = devchar;
3295     char lines_0[] = ",";
3296     char *lines[] = {
3297       lines_0,
3298       NULL
3299     };
3300     int r;
3301     suppress_error = 0;
3302     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3303     if (r == -1)
3304       return -1;
3305   }
3306   {
3307     char fstype[] = "ext2";
3308     char device[] = "/dev/sda1";
3309     device[5] = devchar;
3310     int r;
3311     suppress_error = 0;
3312     r = guestfs_mkfs (g, fstype, device);
3313     if (r == -1)
3314       return -1;
3315   }
3316   {
3317     char device[] = "/dev/sda1";
3318     device[5] = devchar;
3319     char mountpoint[] = "/";
3320     int r;
3321     suppress_error = 0;
3322     r = guestfs_mount (g, device, mountpoint);
3323     if (r == -1)
3324       return -1;
3325   }
3326   /* TestOutput for tgz_in (0) */
3327   char expected[] = "hello\n";
3328   {
3329     char directory[] = "/";
3330     int r;
3331     suppress_error = 0;
3332     r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3333     if (r == -1)
3334       return -1;
3335   }
3336   {
3337     char path[] = "/hello";
3338     char *r;
3339     suppress_error = 0;
3340     r = guestfs_cat (g, path);
3341     if (r == NULL)
3342       return -1;
3343     if (strcmp (r, expected) != 0) {
3344       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3345       return -1;
3346     }
3347     free (r);
3348   }
3349   return 0;
3350 }
3351
3352 static int test_tar_in_0 (void)
3353 {
3354   /* InitBasicFS for tar_in (0): create ext2 on /dev/sda1 */
3355   {
3356     char device[] = "/dev/sda";
3357     device[5] = devchar;
3358     int r;
3359     suppress_error = 0;
3360     r = guestfs_blockdev_setrw (g, device);
3361     if (r == -1)
3362       return -1;
3363   }
3364   {
3365     int r;
3366     suppress_error = 0;
3367     r = guestfs_umount_all (g);
3368     if (r == -1)
3369       return -1;
3370   }
3371   {
3372     int r;
3373     suppress_error = 0;
3374     r = guestfs_lvm_remove_all (g);
3375     if (r == -1)
3376       return -1;
3377   }
3378   {
3379     char device[] = "/dev/sda";
3380     device[5] = devchar;
3381     char lines_0[] = ",";
3382     char *lines[] = {
3383       lines_0,
3384       NULL
3385     };
3386     int r;
3387     suppress_error = 0;
3388     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3389     if (r == -1)
3390       return -1;
3391   }
3392   {
3393     char fstype[] = "ext2";
3394     char device[] = "/dev/sda1";
3395     device[5] = devchar;
3396     int r;
3397     suppress_error = 0;
3398     r = guestfs_mkfs (g, fstype, device);
3399     if (r == -1)
3400       return -1;
3401   }
3402   {
3403     char device[] = "/dev/sda1";
3404     device[5] = devchar;
3405     char mountpoint[] = "/";
3406     int r;
3407     suppress_error = 0;
3408     r = guestfs_mount (g, device, mountpoint);
3409     if (r == -1)
3410       return -1;
3411   }
3412   /* TestOutput for tar_in (0) */
3413   char expected[] = "hello\n";
3414   {
3415     char directory[] = "/";
3416     int r;
3417     suppress_error = 0;
3418     r = guestfs_tar_in (g, "images/helloworld.tar", directory);
3419     if (r == -1)
3420       return -1;
3421   }
3422   {
3423     char path[] = "/hello";
3424     char *r;
3425     suppress_error = 0;
3426     r = guestfs_cat (g, path);
3427     if (r == NULL)
3428       return -1;
3429     if (strcmp (r, expected) != 0) {
3430       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3431       return -1;
3432     }
3433     free (r);
3434   }
3435   return 0;
3436 }
3437
3438 static int test_checksum_0 (void)
3439 {
3440   /* InitBasicFS for checksum (0): create ext2 on /dev/sda1 */
3441   {
3442     char device[] = "/dev/sda";
3443     device[5] = devchar;
3444     int r;
3445     suppress_error = 0;
3446     r = guestfs_blockdev_setrw (g, device);
3447     if (r == -1)
3448       return -1;
3449   }
3450   {
3451     int r;
3452     suppress_error = 0;
3453     r = guestfs_umount_all (g);
3454     if (r == -1)
3455       return -1;
3456   }
3457   {
3458     int r;
3459     suppress_error = 0;
3460     r = guestfs_lvm_remove_all (g);
3461     if (r == -1)
3462       return -1;
3463   }
3464   {
3465     char device[] = "/dev/sda";
3466     device[5] = devchar;
3467     char lines_0[] = ",";
3468     char *lines[] = {
3469       lines_0,
3470       NULL
3471     };
3472     int r;
3473     suppress_error = 0;
3474     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3475     if (r == -1)
3476       return -1;
3477   }
3478   {
3479     char fstype[] = "ext2";
3480     char device[] = "/dev/sda1";
3481     device[5] = devchar;
3482     int r;
3483     suppress_error = 0;
3484     r = guestfs_mkfs (g, fstype, device);
3485     if (r == -1)
3486       return -1;
3487   }
3488   {
3489     char device[] = "/dev/sda1";
3490     device[5] = devchar;
3491     char mountpoint[] = "/";
3492     int r;
3493     suppress_error = 0;
3494     r = guestfs_mount (g, device, mountpoint);
3495     if (r == -1)
3496       return -1;
3497   }
3498   /* TestOutput for checksum (0) */
3499   char expected[] = "935282863";
3500   {
3501     char path[] = "/new";
3502     char content[] = "test\n";
3503     int r;
3504     suppress_error = 0;
3505     r = guestfs_write_file (g, path, content, 0);
3506     if (r == -1)
3507       return -1;
3508   }
3509   {
3510     char csumtype[] = "crc";
3511     char path[] = "/new";
3512     char *r;
3513     suppress_error = 0;
3514     r = guestfs_checksum (g, csumtype, path);
3515     if (r == NULL)
3516       return -1;
3517     if (strcmp (r, expected) != 0) {
3518       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
3519       return -1;
3520     }
3521     free (r);
3522   }
3523   return 0;
3524 }
3525
3526 static int test_checksum_1 (void)
3527 {
3528   /* InitBasicFS for checksum (1): create ext2 on /dev/sda1 */
3529   {
3530     char device[] = "/dev/sda";
3531     device[5] = devchar;
3532     int r;
3533     suppress_error = 0;
3534     r = guestfs_blockdev_setrw (g, device);
3535     if (r == -1)
3536       return -1;
3537   }
3538   {
3539     int r;
3540     suppress_error = 0;
3541     r = guestfs_umount_all (g);
3542     if (r == -1)
3543       return -1;
3544   }
3545   {
3546     int r;
3547     suppress_error = 0;
3548     r = guestfs_lvm_remove_all (g);
3549     if (r == -1)
3550       return -1;
3551   }
3552   {
3553     char device[] = "/dev/sda";
3554     device[5] = devchar;
3555     char lines_0[] = ",";
3556     char *lines[] = {
3557       lines_0,
3558       NULL
3559     };
3560     int r;
3561     suppress_error = 0;
3562     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3563     if (r == -1)
3564       return -1;
3565   }
3566   {
3567     char fstype[] = "ext2";
3568     char device[] = "/dev/sda1";
3569     device[5] = devchar;
3570     int r;
3571     suppress_error = 0;
3572     r = guestfs_mkfs (g, fstype, device);
3573     if (r == -1)
3574       return -1;
3575   }
3576   {
3577     char device[] = "/dev/sda1";
3578     device[5] = devchar;
3579     char mountpoint[] = "/";
3580     int r;
3581     suppress_error = 0;
3582     r = guestfs_mount (g, device, mountpoint);
3583     if (r == -1)
3584       return -1;
3585   }
3586   /* TestLastFail for checksum (1) */
3587   {
3588     char csumtype[] = "crc";
3589     char path[] = "/new";
3590     char *r;
3591     suppress_error = 1;
3592     r = guestfs_checksum (g, csumtype, path);
3593     if (r != NULL)
3594       return -1;
3595     free (r);
3596   }
3597   return 0;
3598 }
3599
3600 static int test_checksum_2 (void)
3601 {
3602   /* InitBasicFS for checksum (2): create ext2 on /dev/sda1 */
3603   {
3604     char device[] = "/dev/sda";
3605     device[5] = devchar;
3606     int r;
3607     suppress_error = 0;
3608     r = guestfs_blockdev_setrw (g, device);
3609     if (r == -1)
3610       return -1;
3611   }
3612   {
3613     int r;
3614     suppress_error = 0;
3615     r = guestfs_umount_all (g);
3616     if (r == -1)
3617       return -1;
3618   }
3619   {
3620     int r;
3621     suppress_error = 0;
3622     r = guestfs_lvm_remove_all (g);
3623     if (r == -1)
3624       return -1;
3625   }
3626   {
3627     char device[] = "/dev/sda";
3628     device[5] = devchar;
3629     char lines_0[] = ",";
3630     char *lines[] = {
3631       lines_0,
3632       NULL
3633     };
3634     int r;
3635     suppress_error = 0;
3636     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3637     if (r == -1)
3638       return -1;
3639   }
3640   {
3641     char fstype[] = "ext2";
3642     char device[] = "/dev/sda1";
3643     device[5] = devchar;
3644     int r;
3645     suppress_error = 0;
3646     r = guestfs_mkfs (g, fstype, device);
3647     if (r == -1)
3648       return -1;
3649   }
3650   {
3651     char device[] = "/dev/sda1";
3652     device[5] = devchar;
3653     char mountpoint[] = "/";
3654     int r;
3655     suppress_error = 0;
3656     r = guestfs_mount (g, device, mountpoint);
3657     if (r == -1)
3658       return -1;
3659   }
3660   /* TestOutput for checksum (2) */
3661   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
3662   {
3663     char path[] = "/new";
3664     char content[] = "test\n";
3665     int r;
3666     suppress_error = 0;
3667     r = guestfs_write_file (g, path, content, 0);
3668     if (r == -1)
3669       return -1;
3670   }
3671   {
3672     char csumtype[] = "md5";
3673     char path[] = "/new";
3674     char *r;
3675     suppress_error = 0;
3676     r = guestfs_checksum (g, csumtype, path);
3677     if (r == NULL)
3678       return -1;
3679     if (strcmp (r, expected) != 0) {
3680       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
3681       return -1;
3682     }
3683     free (r);
3684   }
3685   return 0;
3686 }
3687
3688 static int test_checksum_3 (void)
3689 {
3690   /* InitBasicFS for checksum (3): create ext2 on /dev/sda1 */
3691   {
3692     char device[] = "/dev/sda";
3693     device[5] = devchar;
3694     int r;
3695     suppress_error = 0;
3696     r = guestfs_blockdev_setrw (g, device);
3697     if (r == -1)
3698       return -1;
3699   }
3700   {
3701     int r;
3702     suppress_error = 0;
3703     r = guestfs_umount_all (g);
3704     if (r == -1)
3705       return -1;
3706   }
3707   {
3708     int r;
3709     suppress_error = 0;
3710     r = guestfs_lvm_remove_all (g);
3711     if (r == -1)
3712       return -1;
3713   }
3714   {
3715     char device[] = "/dev/sda";
3716     device[5] = devchar;
3717     char lines_0[] = ",";
3718     char *lines[] = {
3719       lines_0,
3720       NULL
3721     };
3722     int r;
3723     suppress_error = 0;
3724     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3725     if (r == -1)
3726       return -1;
3727   }
3728   {
3729     char fstype[] = "ext2";
3730     char device[] = "/dev/sda1";
3731     device[5] = devchar;
3732     int r;
3733     suppress_error = 0;
3734     r = guestfs_mkfs (g, fstype, device);
3735     if (r == -1)
3736       return -1;
3737   }
3738   {
3739     char device[] = "/dev/sda1";
3740     device[5] = devchar;
3741     char mountpoint[] = "/";
3742     int r;
3743     suppress_error = 0;
3744     r = guestfs_mount (g, device, mountpoint);
3745     if (r == -1)
3746       return -1;
3747   }
3748   /* TestOutput for checksum (3) */
3749   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
3750   {
3751     char path[] = "/new";
3752     char content[] = "test\n";
3753     int r;
3754     suppress_error = 0;
3755     r = guestfs_write_file (g, path, content, 0);
3756     if (r == -1)
3757       return -1;
3758   }
3759   {
3760     char csumtype[] = "sha1";
3761     char path[] = "/new";
3762     char *r;
3763     suppress_error = 0;
3764     r = guestfs_checksum (g, csumtype, path);
3765     if (r == NULL)
3766       return -1;
3767     if (strcmp (r, expected) != 0) {
3768       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
3769       return -1;
3770     }
3771     free (r);
3772   }
3773   return 0;
3774 }
3775
3776 static int test_checksum_4 (void)
3777 {
3778   /* InitBasicFS for checksum (4): create ext2 on /dev/sda1 */
3779   {
3780     char device[] = "/dev/sda";
3781     device[5] = devchar;
3782     int r;
3783     suppress_error = 0;
3784     r = guestfs_blockdev_setrw (g, device);
3785     if (r == -1)
3786       return -1;
3787   }
3788   {
3789     int r;
3790     suppress_error = 0;
3791     r = guestfs_umount_all (g);
3792     if (r == -1)
3793       return -1;
3794   }
3795   {
3796     int r;
3797     suppress_error = 0;
3798     r = guestfs_lvm_remove_all (g);
3799     if (r == -1)
3800       return -1;
3801   }
3802   {
3803     char device[] = "/dev/sda";
3804     device[5] = devchar;
3805     char lines_0[] = ",";
3806     char *lines[] = {
3807       lines_0,
3808       NULL
3809     };
3810     int r;
3811     suppress_error = 0;
3812     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3813     if (r == -1)
3814       return -1;
3815   }
3816   {
3817     char fstype[] = "ext2";
3818     char device[] = "/dev/sda1";
3819     device[5] = devchar;
3820     int r;
3821     suppress_error = 0;
3822     r = guestfs_mkfs (g, fstype, device);
3823     if (r == -1)
3824       return -1;
3825   }
3826   {
3827     char device[] = "/dev/sda1";
3828     device[5] = devchar;
3829     char mountpoint[] = "/";
3830     int r;
3831     suppress_error = 0;
3832     r = guestfs_mount (g, device, mountpoint);
3833     if (r == -1)
3834       return -1;
3835   }
3836   /* TestOutput for checksum (4) */
3837   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
3838   {
3839     char path[] = "/new";
3840     char content[] = "test\n";
3841     int r;
3842     suppress_error = 0;
3843     r = guestfs_write_file (g, path, content, 0);
3844     if (r == -1)
3845       return -1;
3846   }
3847   {
3848     char csumtype[] = "sha224";
3849     char path[] = "/new";
3850     char *r;
3851     suppress_error = 0;
3852     r = guestfs_checksum (g, csumtype, path);
3853     if (r == NULL)
3854       return -1;
3855     if (strcmp (r, expected) != 0) {
3856       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
3857       return -1;
3858     }
3859     free (r);
3860   }
3861   return 0;
3862 }
3863
3864 static int test_checksum_5 (void)
3865 {
3866   /* InitBasicFS for checksum (5): create ext2 on /dev/sda1 */
3867   {
3868     char device[] = "/dev/sda";
3869     device[5] = devchar;
3870     int r;
3871     suppress_error = 0;
3872     r = guestfs_blockdev_setrw (g, device);
3873     if (r == -1)
3874       return -1;
3875   }
3876   {
3877     int r;
3878     suppress_error = 0;
3879     r = guestfs_umount_all (g);
3880     if (r == -1)
3881       return -1;
3882   }
3883   {
3884     int r;
3885     suppress_error = 0;
3886     r = guestfs_lvm_remove_all (g);
3887     if (r == -1)
3888       return -1;
3889   }
3890   {
3891     char device[] = "/dev/sda";
3892     device[5] = devchar;
3893     char lines_0[] = ",";
3894     char *lines[] = {
3895       lines_0,
3896       NULL
3897     };
3898     int r;
3899     suppress_error = 0;
3900     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3901     if (r == -1)
3902       return -1;
3903   }
3904   {
3905     char fstype[] = "ext2";
3906     char device[] = "/dev/sda1";
3907     device[5] = devchar;
3908     int r;
3909     suppress_error = 0;
3910     r = guestfs_mkfs (g, fstype, device);
3911     if (r == -1)
3912       return -1;
3913   }
3914   {
3915     char device[] = "/dev/sda1";
3916     device[5] = devchar;
3917     char mountpoint[] = "/";
3918     int r;
3919     suppress_error = 0;
3920     r = guestfs_mount (g, device, mountpoint);
3921     if (r == -1)
3922       return -1;
3923   }
3924   /* TestOutput for checksum (5) */
3925   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
3926   {
3927     char path[] = "/new";
3928     char content[] = "test\n";
3929     int r;
3930     suppress_error = 0;
3931     r = guestfs_write_file (g, path, content, 0);
3932     if (r == -1)
3933       return -1;
3934   }
3935   {
3936     char csumtype[] = "sha256";
3937     char path[] = "/new";
3938     char *r;
3939     suppress_error = 0;
3940     r = guestfs_checksum (g, csumtype, path);
3941     if (r == NULL)
3942       return -1;
3943     if (strcmp (r, expected) != 0) {
3944       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
3945       return -1;
3946     }
3947     free (r);
3948   }
3949   return 0;
3950 }
3951
3952 static int test_checksum_6 (void)
3953 {
3954   /* InitBasicFS for checksum (6): create ext2 on /dev/sda1 */
3955   {
3956     char device[] = "/dev/sda";
3957     device[5] = devchar;
3958     int r;
3959     suppress_error = 0;
3960     r = guestfs_blockdev_setrw (g, device);
3961     if (r == -1)
3962       return -1;
3963   }
3964   {
3965     int r;
3966     suppress_error = 0;
3967     r = guestfs_umount_all (g);
3968     if (r == -1)
3969       return -1;
3970   }
3971   {
3972     int r;
3973     suppress_error = 0;
3974     r = guestfs_lvm_remove_all (g);
3975     if (r == -1)
3976       return -1;
3977   }
3978   {
3979     char device[] = "/dev/sda";
3980     device[5] = devchar;
3981     char lines_0[] = ",";
3982     char *lines[] = {
3983       lines_0,
3984       NULL
3985     };
3986     int r;
3987     suppress_error = 0;
3988     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3989     if (r == -1)
3990       return -1;
3991   }
3992   {
3993     char fstype[] = "ext2";
3994     char device[] = "/dev/sda1";
3995     device[5] = devchar;
3996     int r;
3997     suppress_error = 0;
3998     r = guestfs_mkfs (g, fstype, device);
3999     if (r == -1)
4000       return -1;
4001   }
4002   {
4003     char device[] = "/dev/sda1";
4004     device[5] = devchar;
4005     char mountpoint[] = "/";
4006     int r;
4007     suppress_error = 0;
4008     r = guestfs_mount (g, device, mountpoint);
4009     if (r == -1)
4010       return -1;
4011   }
4012   /* TestOutput for checksum (6) */
4013   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4014   {
4015     char path[] = "/new";
4016     char content[] = "test\n";
4017     int r;
4018     suppress_error = 0;
4019     r = guestfs_write_file (g, path, content, 0);
4020     if (r == -1)
4021       return -1;
4022   }
4023   {
4024     char csumtype[] = "sha384";
4025     char path[] = "/new";
4026     char *r;
4027     suppress_error = 0;
4028     r = guestfs_checksum (g, csumtype, path);
4029     if (r == NULL)
4030       return -1;
4031     if (strcmp (r, expected) != 0) {
4032       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4033       return -1;
4034     }
4035     free (r);
4036   }
4037   return 0;
4038 }
4039
4040 static int test_checksum_7 (void)
4041 {
4042   /* InitBasicFS for checksum (7): create ext2 on /dev/sda1 */
4043   {
4044     char device[] = "/dev/sda";
4045     device[5] = devchar;
4046     int r;
4047     suppress_error = 0;
4048     r = guestfs_blockdev_setrw (g, device);
4049     if (r == -1)
4050       return -1;
4051   }
4052   {
4053     int r;
4054     suppress_error = 0;
4055     r = guestfs_umount_all (g);
4056     if (r == -1)
4057       return -1;
4058   }
4059   {
4060     int r;
4061     suppress_error = 0;
4062     r = guestfs_lvm_remove_all (g);
4063     if (r == -1)
4064       return -1;
4065   }
4066   {
4067     char device[] = "/dev/sda";
4068     device[5] = devchar;
4069     char lines_0[] = ",";
4070     char *lines[] = {
4071       lines_0,
4072       NULL
4073     };
4074     int r;
4075     suppress_error = 0;
4076     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4077     if (r == -1)
4078       return -1;
4079   }
4080   {
4081     char fstype[] = "ext2";
4082     char device[] = "/dev/sda1";
4083     device[5] = devchar;
4084     int r;
4085     suppress_error = 0;
4086     r = guestfs_mkfs (g, fstype, device);
4087     if (r == -1)
4088       return -1;
4089   }
4090   {
4091     char device[] = "/dev/sda1";
4092     device[5] = devchar;
4093     char mountpoint[] = "/";
4094     int r;
4095     suppress_error = 0;
4096     r = guestfs_mount (g, device, mountpoint);
4097     if (r == -1)
4098       return -1;
4099   }
4100   /* TestOutput for checksum (7) */
4101   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4102   {
4103     char path[] = "/new";
4104     char content[] = "test\n";
4105     int r;
4106     suppress_error = 0;
4107     r = guestfs_write_file (g, path, content, 0);
4108     if (r == -1)
4109       return -1;
4110   }
4111   {
4112     char csumtype[] = "sha512";
4113     char path[] = "/new";
4114     char *r;
4115     suppress_error = 0;
4116     r = guestfs_checksum (g, csumtype, path);
4117     if (r == NULL)
4118       return -1;
4119     if (strcmp (r, expected) != 0) {
4120       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4121       return -1;
4122     }
4123     free (r);
4124   }
4125   return 0;
4126 }
4127
4128 static int test_download_0 (void)
4129 {
4130   /* InitBasicFS for download (0): create ext2 on /dev/sda1 */
4131   {
4132     char device[] = "/dev/sda";
4133     device[5] = devchar;
4134     int r;
4135     suppress_error = 0;
4136     r = guestfs_blockdev_setrw (g, device);
4137     if (r == -1)
4138       return -1;
4139   }
4140   {
4141     int r;
4142     suppress_error = 0;
4143     r = guestfs_umount_all (g);
4144     if (r == -1)
4145       return -1;
4146   }
4147   {
4148     int r;
4149     suppress_error = 0;
4150     r = guestfs_lvm_remove_all (g);
4151     if (r == -1)
4152       return -1;
4153   }
4154   {
4155     char device[] = "/dev/sda";
4156     device[5] = devchar;
4157     char lines_0[] = ",";
4158     char *lines[] = {
4159       lines_0,
4160       NULL
4161     };
4162     int r;
4163     suppress_error = 0;
4164     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4165     if (r == -1)
4166       return -1;
4167   }
4168   {
4169     char fstype[] = "ext2";
4170     char device[] = "/dev/sda1";
4171     device[5] = devchar;
4172     int r;
4173     suppress_error = 0;
4174     r = guestfs_mkfs (g, fstype, device);
4175     if (r == -1)
4176       return -1;
4177   }
4178   {
4179     char device[] = "/dev/sda1";
4180     device[5] = devchar;
4181     char mountpoint[] = "/";
4182     int r;
4183     suppress_error = 0;
4184     r = guestfs_mount (g, device, mountpoint);
4185     if (r == -1)
4186       return -1;
4187   }
4188   /* TestOutput for download (0) */
4189   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4190   {
4191     char remotefilename[] = "/COPYING.LIB";
4192     int r;
4193     suppress_error = 0;
4194     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4195     if (r == -1)
4196       return -1;
4197   }
4198   {
4199     char remotefilename[] = "/COPYING.LIB";
4200     int r;
4201     suppress_error = 0;
4202     r = guestfs_download (g, remotefilename, "testdownload.tmp");
4203     if (r == -1)
4204       return -1;
4205   }
4206   {
4207     char remotefilename[] = "/upload";
4208     int r;
4209     suppress_error = 0;
4210     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4211     if (r == -1)
4212       return -1;
4213   }
4214   {
4215     char csumtype[] = "md5";
4216     char path[] = "/upload";
4217     char *r;
4218     suppress_error = 0;
4219     r = guestfs_checksum (g, csumtype, path);
4220     if (r == NULL)
4221       return -1;
4222     if (strcmp (r, expected) != 0) {
4223       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4224       return -1;
4225     }
4226     free (r);
4227   }
4228   return 0;
4229 }
4230
4231 static int test_upload_0 (void)
4232 {
4233   /* InitBasicFS for upload (0): create ext2 on /dev/sda1 */
4234   {
4235     char device[] = "/dev/sda";
4236     device[5] = devchar;
4237     int r;
4238     suppress_error = 0;
4239     r = guestfs_blockdev_setrw (g, device);
4240     if (r == -1)
4241       return -1;
4242   }
4243   {
4244     int r;
4245     suppress_error = 0;
4246     r = guestfs_umount_all (g);
4247     if (r == -1)
4248       return -1;
4249   }
4250   {
4251     int r;
4252     suppress_error = 0;
4253     r = guestfs_lvm_remove_all (g);
4254     if (r == -1)
4255       return -1;
4256   }
4257   {
4258     char device[] = "/dev/sda";
4259     device[5] = devchar;
4260     char lines_0[] = ",";
4261     char *lines[] = {
4262       lines_0,
4263       NULL
4264     };
4265     int r;
4266     suppress_error = 0;
4267     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4268     if (r == -1)
4269       return -1;
4270   }
4271   {
4272     char fstype[] = "ext2";
4273     char device[] = "/dev/sda1";
4274     device[5] = devchar;
4275     int r;
4276     suppress_error = 0;
4277     r = guestfs_mkfs (g, fstype, device);
4278     if (r == -1)
4279       return -1;
4280   }
4281   {
4282     char device[] = "/dev/sda1";
4283     device[5] = devchar;
4284     char mountpoint[] = "/";
4285     int r;
4286     suppress_error = 0;
4287     r = guestfs_mount (g, device, mountpoint);
4288     if (r == -1)
4289       return -1;
4290   }
4291   /* TestOutput for upload (0) */
4292   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4293   {
4294     char remotefilename[] = "/COPYING.LIB";
4295     int r;
4296     suppress_error = 0;
4297     r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4298     if (r == -1)
4299       return -1;
4300   }
4301   {
4302     char csumtype[] = "md5";
4303     char path[] = "/COPYING.LIB";
4304     char *r;
4305     suppress_error = 0;
4306     r = guestfs_checksum (g, csumtype, path);
4307     if (r == NULL)
4308       return -1;
4309     if (strcmp (r, expected) != 0) {
4310       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4311       return -1;
4312     }
4313     free (r);
4314   }
4315   return 0;
4316 }
4317
4318 static int test_blockdev_rereadpt_0 (void)
4319 {
4320   /* InitEmpty for blockdev_rereadpt (0) */
4321   {
4322     char device[] = "/dev/sda";
4323     device[5] = devchar;
4324     int r;
4325     suppress_error = 0;
4326     r = guestfs_blockdev_setrw (g, device);
4327     if (r == -1)
4328       return -1;
4329   }
4330   {
4331     int r;
4332     suppress_error = 0;
4333     r = guestfs_umount_all (g);
4334     if (r == -1)
4335       return -1;
4336   }
4337   {
4338     int r;
4339     suppress_error = 0;
4340     r = guestfs_lvm_remove_all (g);
4341     if (r == -1)
4342       return -1;
4343   }
4344   /* TestRun for blockdev_rereadpt (0) */
4345   {
4346     char device[] = "/dev/sda";
4347     device[5] = devchar;
4348     int r;
4349     suppress_error = 0;
4350     r = guestfs_blockdev_rereadpt (g, device);
4351     if (r == -1)
4352       return -1;
4353   }
4354   return 0;
4355 }
4356
4357 static int test_blockdev_flushbufs_0 (void)
4358 {
4359   /* InitEmpty for blockdev_flushbufs (0) */
4360   {
4361     char device[] = "/dev/sda";
4362     device[5] = devchar;
4363     int r;
4364     suppress_error = 0;
4365     r = guestfs_blockdev_setrw (g, device);
4366     if (r == -1)
4367       return -1;
4368   }
4369   {
4370     int r;
4371     suppress_error = 0;
4372     r = guestfs_umount_all (g);
4373     if (r == -1)
4374       return -1;
4375   }
4376   {
4377     int r;
4378     suppress_error = 0;
4379     r = guestfs_lvm_remove_all (g);
4380     if (r == -1)
4381       return -1;
4382   }
4383   /* TestRun for blockdev_flushbufs (0) */
4384   {
4385     char device[] = "/dev/sda";
4386     device[5] = devchar;
4387     int r;
4388     suppress_error = 0;
4389     r = guestfs_blockdev_flushbufs (g, device);
4390     if (r == -1)
4391       return -1;
4392   }
4393   return 0;
4394 }
4395
4396 static int test_blockdev_getsize64_0 (void)
4397 {
4398   /* InitEmpty for blockdev_getsize64 (0) */
4399   {
4400     char device[] = "/dev/sda";
4401     device[5] = devchar;
4402     int r;
4403     suppress_error = 0;
4404     r = guestfs_blockdev_setrw (g, device);
4405     if (r == -1)
4406       return -1;
4407   }
4408   {
4409     int r;
4410     suppress_error = 0;
4411     r = guestfs_umount_all (g);
4412     if (r == -1)
4413       return -1;
4414   }
4415   {
4416     int r;
4417     suppress_error = 0;
4418     r = guestfs_lvm_remove_all (g);
4419     if (r == -1)
4420       return -1;
4421   }
4422   /* TestOutputInt for blockdev_getsize64 (0) */
4423   {
4424     char device[] = "/dev/sda";
4425     device[5] = devchar;
4426     int64_t r;
4427     suppress_error = 0;
4428     r = guestfs_blockdev_getsize64 (g, device);
4429     if (r == -1)
4430       return -1;
4431     if (r != 524288000) {
4432       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
4433       return -1;
4434     }
4435   }
4436   return 0;
4437 }
4438
4439 static int test_blockdev_getsz_0 (void)
4440 {
4441   /* InitEmpty for blockdev_getsz (0) */
4442   {
4443     char device[] = "/dev/sda";
4444     device[5] = devchar;
4445     int r;
4446     suppress_error = 0;
4447     r = guestfs_blockdev_setrw (g, device);
4448     if (r == -1)
4449       return -1;
4450   }
4451   {
4452     int r;
4453     suppress_error = 0;
4454     r = guestfs_umount_all (g);
4455     if (r == -1)
4456       return -1;
4457   }
4458   {
4459     int r;
4460     suppress_error = 0;
4461     r = guestfs_lvm_remove_all (g);
4462     if (r == -1)
4463       return -1;
4464   }
4465   /* TestOutputInt for blockdev_getsz (0) */
4466   {
4467     char device[] = "/dev/sda";
4468     device[5] = devchar;
4469     int64_t r;
4470     suppress_error = 0;
4471     r = guestfs_blockdev_getsz (g, device);
4472     if (r == -1)
4473       return -1;
4474     if (r != 1024000) {
4475       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
4476       return -1;
4477     }
4478   }
4479   return 0;
4480 }
4481
4482 static int test_blockdev_getbsz_0 (void)
4483 {
4484   /* InitEmpty for blockdev_getbsz (0) */
4485   {
4486     char device[] = "/dev/sda";
4487     device[5] = devchar;
4488     int r;
4489     suppress_error = 0;
4490     r = guestfs_blockdev_setrw (g, device);
4491     if (r == -1)
4492       return -1;
4493   }
4494   {
4495     int r;
4496     suppress_error = 0;
4497     r = guestfs_umount_all (g);
4498     if (r == -1)
4499       return -1;
4500   }
4501   {
4502     int r;
4503     suppress_error = 0;
4504     r = guestfs_lvm_remove_all (g);
4505     if (r == -1)
4506       return -1;
4507   }
4508   /* TestOutputInt for blockdev_getbsz (0) */
4509   {
4510     char device[] = "/dev/sda";
4511     device[5] = devchar;
4512     int r;
4513     suppress_error = 0;
4514     r = guestfs_blockdev_getbsz (g, device);
4515     if (r == -1)
4516       return -1;
4517     if (r != 4096) {
4518       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
4519       return -1;
4520     }
4521   }
4522   return 0;
4523 }
4524
4525 static int test_blockdev_getss_0 (void)
4526 {
4527   /* InitEmpty for blockdev_getss (0) */
4528   {
4529     char device[] = "/dev/sda";
4530     device[5] = devchar;
4531     int r;
4532     suppress_error = 0;
4533     r = guestfs_blockdev_setrw (g, device);
4534     if (r == -1)
4535       return -1;
4536   }
4537   {
4538     int r;
4539     suppress_error = 0;
4540     r = guestfs_umount_all (g);
4541     if (r == -1)
4542       return -1;
4543   }
4544   {
4545     int r;
4546     suppress_error = 0;
4547     r = guestfs_lvm_remove_all (g);
4548     if (r == -1)
4549       return -1;
4550   }
4551   /* TestOutputInt for blockdev_getss (0) */
4552   {
4553     char device[] = "/dev/sda";
4554     device[5] = devchar;
4555     int r;
4556     suppress_error = 0;
4557     r = guestfs_blockdev_getss (g, device);
4558     if (r == -1)
4559       return -1;
4560     if (r != 512) {
4561       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
4562       return -1;
4563     }
4564   }
4565   return 0;
4566 }
4567
4568 static int test_blockdev_getro_0 (void)
4569 {
4570   /* InitEmpty for blockdev_getro (0) */
4571   {
4572     char device[] = "/dev/sda";
4573     device[5] = devchar;
4574     int r;
4575     suppress_error = 0;
4576     r = guestfs_blockdev_setrw (g, device);
4577     if (r == -1)
4578       return -1;
4579   }
4580   {
4581     int r;
4582     suppress_error = 0;
4583     r = guestfs_umount_all (g);
4584     if (r == -1)
4585       return -1;
4586   }
4587   {
4588     int r;
4589     suppress_error = 0;
4590     r = guestfs_lvm_remove_all (g);
4591     if (r == -1)
4592       return -1;
4593   }
4594   /* TestOutputTrue for blockdev_getro (0) */
4595   {
4596     char device[] = "/dev/sda";
4597     device[5] = devchar;
4598     int r;
4599     suppress_error = 0;
4600     r = guestfs_blockdev_setro (g, device);
4601     if (r == -1)
4602       return -1;
4603   }
4604   {
4605     char device[] = "/dev/sda";
4606     device[5] = devchar;
4607     int r;
4608     suppress_error = 0;
4609     r = guestfs_blockdev_getro (g, device);
4610     if (r == -1)
4611       return -1;
4612     if (!r) {
4613       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
4614       return -1;
4615     }
4616   }
4617   return 0;
4618 }
4619
4620 static int test_blockdev_setrw_0 (void)
4621 {
4622   /* InitEmpty for blockdev_setrw (0) */
4623   {
4624     char device[] = "/dev/sda";
4625     device[5] = devchar;
4626     int r;
4627     suppress_error = 0;
4628     r = guestfs_blockdev_setrw (g, device);
4629     if (r == -1)
4630       return -1;
4631   }
4632   {
4633     int r;
4634     suppress_error = 0;
4635     r = guestfs_umount_all (g);
4636     if (r == -1)
4637       return -1;
4638   }
4639   {
4640     int r;
4641     suppress_error = 0;
4642     r = guestfs_lvm_remove_all (g);
4643     if (r == -1)
4644       return -1;
4645   }
4646   /* TestOutputFalse for blockdev_setrw (0) */
4647   {
4648     char device[] = "/dev/sda";
4649     device[5] = devchar;
4650     int r;
4651     suppress_error = 0;
4652     r = guestfs_blockdev_setrw (g, device);
4653     if (r == -1)
4654       return -1;
4655   }
4656   {
4657     char device[] = "/dev/sda";
4658     device[5] = devchar;
4659     int r;
4660     suppress_error = 0;
4661     r = guestfs_blockdev_getro (g, device);
4662     if (r == -1)
4663       return -1;
4664     if (r) {
4665       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
4666       return -1;
4667     }
4668   }
4669   return 0;
4670 }
4671
4672 static int test_blockdev_setro_0 (void)
4673 {
4674   /* InitEmpty for blockdev_setro (0) */
4675   {
4676     char device[] = "/dev/sda";
4677     device[5] = devchar;
4678     int r;
4679     suppress_error = 0;
4680     r = guestfs_blockdev_setrw (g, device);
4681     if (r == -1)
4682       return -1;
4683   }
4684   {
4685     int r;
4686     suppress_error = 0;
4687     r = guestfs_umount_all (g);
4688     if (r == -1)
4689       return -1;
4690   }
4691   {
4692     int r;
4693     suppress_error = 0;
4694     r = guestfs_lvm_remove_all (g);
4695     if (r == -1)
4696       return -1;
4697   }
4698   /* TestOutputTrue for blockdev_setro (0) */
4699   {
4700     char device[] = "/dev/sda";
4701     device[5] = devchar;
4702     int r;
4703     suppress_error = 0;
4704     r = guestfs_blockdev_setro (g, device);
4705     if (r == -1)
4706       return -1;
4707   }
4708   {
4709     char device[] = "/dev/sda";
4710     device[5] = devchar;
4711     int r;
4712     suppress_error = 0;
4713     r = guestfs_blockdev_getro (g, device);
4714     if (r == -1)
4715       return -1;
4716     if (!r) {
4717       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
4718       return -1;
4719     }
4720   }
4721   return 0;
4722 }
4723
4724 static int test_statvfs_0 (void)
4725 {
4726   /* InitBasicFS for statvfs (0): create ext2 on /dev/sda1 */
4727   {
4728     char device[] = "/dev/sda";
4729     device[5] = devchar;
4730     int r;
4731     suppress_error = 0;
4732     r = guestfs_blockdev_setrw (g, device);
4733     if (r == -1)
4734       return -1;
4735   }
4736   {
4737     int r;
4738     suppress_error = 0;
4739     r = guestfs_umount_all (g);
4740     if (r == -1)
4741       return -1;
4742   }
4743   {
4744     int r;
4745     suppress_error = 0;
4746     r = guestfs_lvm_remove_all (g);
4747     if (r == -1)
4748       return -1;
4749   }
4750   {
4751     char device[] = "/dev/sda";
4752     device[5] = devchar;
4753     char lines_0[] = ",";
4754     char *lines[] = {
4755       lines_0,
4756       NULL
4757     };
4758     int r;
4759     suppress_error = 0;
4760     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4761     if (r == -1)
4762       return -1;
4763   }
4764   {
4765     char fstype[] = "ext2";
4766     char device[] = "/dev/sda1";
4767     device[5] = devchar;
4768     int r;
4769     suppress_error = 0;
4770     r = guestfs_mkfs (g, fstype, device);
4771     if (r == -1)
4772       return -1;
4773   }
4774   {
4775     char device[] = "/dev/sda1";
4776     device[5] = devchar;
4777     char mountpoint[] = "/";
4778     int r;
4779     suppress_error = 0;
4780     r = guestfs_mount (g, device, mountpoint);
4781     if (r == -1)
4782       return -1;
4783   }
4784   /* TestOutputStruct for statvfs (0) */
4785   {
4786     char path[] = "/";
4787     struct guestfs_statvfs *r;
4788     suppress_error = 0;
4789     r = guestfs_statvfs (g, path);
4790     if (r == NULL)
4791       return -1;
4792     if (r->bfree != 487702) {
4793       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
4794                (int) r->bfree);
4795       return -1;
4796     }
4797     if (r->blocks != 490020) {
4798       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
4799                (int) r->blocks);
4800       return -1;
4801     }
4802     if (r->bsize != 1024) {
4803       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
4804                (int) r->bsize);
4805       return -1;
4806     }
4807     free (r);
4808   }
4809   return 0;
4810 }
4811
4812 static int test_lstat_0 (void)
4813 {
4814   /* InitBasicFS for lstat (0): create ext2 on /dev/sda1 */
4815   {
4816     char device[] = "/dev/sda";
4817     device[5] = devchar;
4818     int r;
4819     suppress_error = 0;
4820     r = guestfs_blockdev_setrw (g, device);
4821     if (r == -1)
4822       return -1;
4823   }
4824   {
4825     int r;
4826     suppress_error = 0;
4827     r = guestfs_umount_all (g);
4828     if (r == -1)
4829       return -1;
4830   }
4831   {
4832     int r;
4833     suppress_error = 0;
4834     r = guestfs_lvm_remove_all (g);
4835     if (r == -1)
4836       return -1;
4837   }
4838   {
4839     char device[] = "/dev/sda";
4840     device[5] = devchar;
4841     char lines_0[] = ",";
4842     char *lines[] = {
4843       lines_0,
4844       NULL
4845     };
4846     int r;
4847     suppress_error = 0;
4848     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4849     if (r == -1)
4850       return -1;
4851   }
4852   {
4853     char fstype[] = "ext2";
4854     char device[] = "/dev/sda1";
4855     device[5] = devchar;
4856     int r;
4857     suppress_error = 0;
4858     r = guestfs_mkfs (g, fstype, device);
4859     if (r == -1)
4860       return -1;
4861   }
4862   {
4863     char device[] = "/dev/sda1";
4864     device[5] = devchar;
4865     char mountpoint[] = "/";
4866     int r;
4867     suppress_error = 0;
4868     r = guestfs_mount (g, device, mountpoint);
4869     if (r == -1)
4870       return -1;
4871   }
4872   /* TestOutputStruct for lstat (0) */
4873   {
4874     char path[] = "/new";
4875     int r;
4876     suppress_error = 0;
4877     r = guestfs_touch (g, path);
4878     if (r == -1)
4879       return -1;
4880   }
4881   {
4882     char path[] = "/new";
4883     struct guestfs_stat *r;
4884     suppress_error = 0;
4885     r = guestfs_lstat (g, path);
4886     if (r == NULL)
4887       return -1;
4888     if (r->size != 0) {
4889       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
4890                (int) r->size);
4891       return -1;
4892     }
4893     free (r);
4894   }
4895   return 0;
4896 }
4897
4898 static int test_stat_0 (void)
4899 {
4900   /* InitBasicFS for stat (0): create ext2 on /dev/sda1 */
4901   {
4902     char device[] = "/dev/sda";
4903     device[5] = devchar;
4904     int r;
4905     suppress_error = 0;
4906     r = guestfs_blockdev_setrw (g, device);
4907     if (r == -1)
4908       return -1;
4909   }
4910   {
4911     int r;
4912     suppress_error = 0;
4913     r = guestfs_umount_all (g);
4914     if (r == -1)
4915       return -1;
4916   }
4917   {
4918     int r;
4919     suppress_error = 0;
4920     r = guestfs_lvm_remove_all (g);
4921     if (r == -1)
4922       return -1;
4923   }
4924   {
4925     char device[] = "/dev/sda";
4926     device[5] = devchar;
4927     char lines_0[] = ",";
4928     char *lines[] = {
4929       lines_0,
4930       NULL
4931     };
4932     int r;
4933     suppress_error = 0;
4934     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4935     if (r == -1)
4936       return -1;
4937   }
4938   {
4939     char fstype[] = "ext2";
4940     char device[] = "/dev/sda1";
4941     device[5] = devchar;
4942     int r;
4943     suppress_error = 0;
4944     r = guestfs_mkfs (g, fstype, device);
4945     if (r == -1)
4946       return -1;
4947   }
4948   {
4949     char device[] = "/dev/sda1";
4950     device[5] = devchar;
4951     char mountpoint[] = "/";
4952     int r;
4953     suppress_error = 0;
4954     r = guestfs_mount (g, device, mountpoint);
4955     if (r == -1)
4956       return -1;
4957   }
4958   /* TestOutputStruct for stat (0) */
4959   {
4960     char path[] = "/new";
4961     int r;
4962     suppress_error = 0;
4963     r = guestfs_touch (g, path);
4964     if (r == -1)
4965       return -1;
4966   }
4967   {
4968     char path[] = "/new";
4969     struct guestfs_stat *r;
4970     suppress_error = 0;
4971     r = guestfs_stat (g, path);
4972     if (r == NULL)
4973       return -1;
4974     if (r->size != 0) {
4975       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
4976                (int) r->size);
4977       return -1;
4978     }
4979     free (r);
4980   }
4981   return 0;
4982 }
4983
4984 static int test_command_lines_0_prereq (void)
4985 {
4986   const char *str = getenv ("SKIP_TEST_COMMAND");
4987   return str && strcmp (str, "1") == 0;
4988 }
4989
4990 static int test_command_lines_0 (void)
4991 {
4992   if (! test_command_lines_0_prereq ()) {
4993   /* InitBasicFS for command_lines (0): create ext2 on /dev/sda1 */
4994   {
4995     char device[] = "/dev/sda";
4996     device[5] = devchar;
4997     int r;
4998     suppress_error = 0;
4999     r = guestfs_blockdev_setrw (g, device);
5000     if (r == -1)
5001       return -1;
5002   }
5003   {
5004     int r;
5005     suppress_error = 0;
5006     r = guestfs_umount_all (g);
5007     if (r == -1)
5008       return -1;
5009   }
5010   {
5011     int r;
5012     suppress_error = 0;
5013     r = guestfs_lvm_remove_all (g);
5014     if (r == -1)
5015       return -1;
5016   }
5017   {
5018     char device[] = "/dev/sda";
5019     device[5] = devchar;
5020     char lines_0[] = ",";
5021     char *lines[] = {
5022       lines_0,
5023       NULL
5024     };
5025     int r;
5026     suppress_error = 0;
5027     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5028     if (r == -1)
5029       return -1;
5030   }
5031   {
5032     char fstype[] = "ext2";
5033     char device[] = "/dev/sda1";
5034     device[5] = devchar;
5035     int r;
5036     suppress_error = 0;
5037     r = guestfs_mkfs (g, fstype, device);
5038     if (r == -1)
5039       return -1;
5040   }
5041   {
5042     char device[] = "/dev/sda1";
5043     device[5] = devchar;
5044     char mountpoint[] = "/";
5045     int r;
5046     suppress_error = 0;
5047     r = guestfs_mount (g, device, mountpoint);
5048     if (r == -1)
5049       return -1;
5050   }
5051   /* TestOutputList for command_lines (0) */
5052   {
5053     char remotefilename[] = "/test-command";
5054     int r;
5055     suppress_error = 0;
5056     r = guestfs_upload (g, "test-command", remotefilename);
5057     if (r == -1)
5058       return -1;
5059   }
5060   {
5061     char path[] = "/test-command";
5062     int r;
5063     suppress_error = 0;
5064     r = guestfs_chmod (g, 493, path);
5065     if (r == -1)
5066       return -1;
5067   }
5068   {
5069     char arguments_0[] = "/test-command";
5070     char arguments_1[] = "1";
5071     char *arguments[] = {
5072       arguments_0,
5073       arguments_1,
5074       NULL
5075     };
5076     char **r;
5077     int i;
5078     suppress_error = 0;
5079     r = guestfs_command_lines (g, arguments);
5080     if (r == NULL)
5081       return -1;
5082     if (!r[0]) {
5083       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5084       print_strings (r);
5085       return -1;
5086     }
5087     {
5088       char expected[] = "Result1";
5089       if (strcmp (r[0], expected) != 0) {
5090         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5091         return -1;
5092       }
5093     }
5094     if (r[1] != NULL) {
5095       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5096       print_strings (r);
5097       return -1;
5098     }
5099     for (i = 0; r[i] != NULL; ++i)
5100       free (r[i]);
5101     free (r);
5102   }
5103   } else
5104     printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_0");
5105   return 0;
5106 }
5107
5108 static int test_command_lines_1_prereq (void)
5109 {
5110   const char *str = getenv ("SKIP_TEST_COMMAND");
5111   return str && strcmp (str, "1") == 0;
5112 }
5113
5114 static int test_command_lines_1 (void)
5115 {
5116   if (! test_command_lines_1_prereq ()) {
5117   /* InitBasicFS for command_lines (1): create ext2 on /dev/sda1 */
5118   {
5119     char device[] = "/dev/sda";
5120     device[5] = devchar;
5121     int r;
5122     suppress_error = 0;
5123     r = guestfs_blockdev_setrw (g, device);
5124     if (r == -1)
5125       return -1;
5126   }
5127   {
5128     int r;
5129     suppress_error = 0;
5130     r = guestfs_umount_all (g);
5131     if (r == -1)
5132       return -1;
5133   }
5134   {
5135     int r;
5136     suppress_error = 0;
5137     r = guestfs_lvm_remove_all (g);
5138     if (r == -1)
5139       return -1;
5140   }
5141   {
5142     char device[] = "/dev/sda";
5143     device[5] = devchar;
5144     char lines_0[] = ",";
5145     char *lines[] = {
5146       lines_0,
5147       NULL
5148     };
5149     int r;
5150     suppress_error = 0;
5151     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5152     if (r == -1)
5153       return -1;
5154   }
5155   {
5156     char fstype[] =&nbs