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