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