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