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