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