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 {
4889   const char *str;
4890
4891   str = getenv ("TEST_ONLY");
4892   if (str)
4893     return strstr (str, "vgremove") == NULL;
4894   str = getenv ("SKIP_TEST_VGREMOVE_1");
4895   if (str && strcmp (str, "1") == 0) return 1;
4896   str = getenv ("SKIP_TEST_VGREMOVE");
4897   if (str && strcmp (str, "1") == 0) return 1;
4898   return 0;
4899 }
4900
4901 static int test_vgremove_1 (void)
4902 {
4903   if (test_vgremove_1_skip ()) {
4904     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4905     return 0;
4906   }
4907
4908   /* InitNone|InitEmpty for test_vgremove_1 */
4909   {
4910     char device[] = "/dev/sda";
4911     int r;
4912     suppress_error = 0;
4913     r = guestfs_blockdev_setrw (g, device);
4914     if (r == -1)
4915       return -1;
4916   }
4917   {
4918     int r;
4919     suppress_error = 0;
4920     r = guestfs_umount_all (g);
4921     if (r == -1)
4922       return -1;
4923   }
4924   {
4925     int r;
4926     suppress_error = 0;
4927     r = guestfs_lvm_remove_all (g);
4928     if (r == -1)
4929       return -1;
4930   }
4931   /* TestOutputList for vgremove (1) */
4932   {
4933     char device[] = "/dev/sda";
4934     char lines_0[] = ",";
4935     char *lines[] = {
4936       lines_0,
4937       NULL
4938     };
4939     int r;
4940     suppress_error = 0;
4941     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4942     if (r == -1)
4943       return -1;
4944   }
4945   {
4946     char device[] = "/dev/sda1";
4947     int r;
4948     suppress_error = 0;
4949     r = guestfs_pvcreate (g, device);
4950     if (r == -1)
4951       return -1;
4952   }
4953   {
4954     char volgroup[] = "VG";
4955     char physvols_0[] = "/dev/sda1";
4956     char *physvols[] = {
4957       physvols_0,
4958       NULL
4959     };
4960     int r;
4961     suppress_error = 0;
4962     r = guestfs_vgcreate (g, volgroup, physvols);
4963     if (r == -1)
4964       return -1;
4965   }
4966   {
4967     char logvol[] = "LV1";
4968     char volgroup[] = "VG";
4969     int r;
4970     suppress_error = 0;
4971     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4972     if (r == -1)
4973       return -1;
4974   }
4975   {
4976     char logvol[] = "LV2";
4977     char volgroup[] = "VG";
4978     int r;
4979     suppress_error = 0;
4980     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4981     if (r == -1)
4982       return -1;
4983   }
4984   {
4985     char vgname[] = "VG";
4986     int r;
4987     suppress_error = 0;
4988     r = guestfs_vgremove (g, vgname);
4989     if (r == -1)
4990       return -1;
4991   }
4992   {
4993     char **r;
4994     int i;
4995     suppress_error = 0;
4996     r = guestfs_vgs (g);
4997     if (r == NULL)
4998       return -1;
4999     if (r[0] != NULL) {
5000       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
5001       print_strings (r);
5002       return -1;
5003     }
5004     for (i = 0; r[i] != NULL; ++i)
5005       free (r[i]);
5006     free (r);
5007   }
5008   return 0;
5009 }
5010
5011 static int test_lvremove_0_skip (void)
5012 {
5013   const char *str;
5014
5015   str = getenv ("TEST_ONLY");
5016   if (str)
5017     return strstr (str, "lvremove") == NULL;
5018   str = getenv ("SKIP_TEST_LVREMOVE_0");
5019   if (str && strcmp (str, "1") == 0) return 1;
5020   str = getenv ("SKIP_TEST_LVREMOVE");
5021   if (str && strcmp (str, "1") == 0) return 1;
5022   return 0;
5023 }
5024
5025 static int test_lvremove_0 (void)
5026 {
5027   if (test_lvremove_0_skip ()) {
5028     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
5029     return 0;
5030   }
5031
5032   /* InitNone|InitEmpty for test_lvremove_0 */
5033   {
5034     char device[] = "/dev/sda";
5035     int r;
5036     suppress_error = 0;
5037     r = guestfs_blockdev_setrw (g, device);
5038     if (r == -1)
5039       return -1;
5040   }
5041   {
5042     int r;
5043     suppress_error = 0;
5044     r = guestfs_umount_all (g);
5045     if (r == -1)
5046       return -1;
5047   }
5048   {
5049     int r;
5050     suppress_error = 0;
5051     r = guestfs_lvm_remove_all (g);
5052     if (r == -1)
5053       return -1;
5054   }
5055   /* TestOutputList for lvremove (0) */
5056   {
5057     char device[] = "/dev/sda";
5058     char lines_0[] = ",";
5059     char *lines[] = {
5060       lines_0,
5061       NULL
5062     };
5063     int r;
5064     suppress_error = 0;
5065     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5066     if (r == -1)
5067       return -1;
5068   }
5069   {
5070     char device[] = "/dev/sda1";
5071     int r;
5072     suppress_error = 0;
5073     r = guestfs_pvcreate (g, device);
5074     if (r == -1)
5075       return -1;
5076   }
5077   {
5078     char volgroup[] = "VG";
5079     char physvols_0[] = "/dev/sda1";
5080     char *physvols[] = {
5081       physvols_0,
5082       NULL
5083     };
5084     int r;
5085     suppress_error = 0;
5086     r = guestfs_vgcreate (g, volgroup, physvols);
5087     if (r == -1)
5088       return -1;
5089   }
5090   {
5091     char logvol[] = "LV1";
5092     char volgroup[] = "VG";
5093     int r;
5094     suppress_error = 0;
5095     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5096     if (r == -1)
5097       return -1;
5098   }
5099   {
5100     char logvol[] = "LV2";
5101     char volgroup[] = "VG";
5102     int r;
5103     suppress_error = 0;
5104     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5105     if (r == -1)
5106       return -1;
5107   }
5108   {
5109     char device[] = "/dev/VG/LV1";
5110     int r;
5111     suppress_error = 0;
5112     r = guestfs_lvremove (g, device);
5113     if (r == -1)
5114       return -1;
5115   }
5116   {
5117     char **r;
5118     int i;
5119     suppress_error = 0;
5120     r = guestfs_lvs (g);
5121     if (r == NULL)
5122       return -1;
5123     if (!r[0]) {
5124       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
5125       print_strings (r);
5126       return -1;
5127     }
5128     {
5129       char expected[] = "/dev/VG/LV2";
5130       if (strcmp (r[0], expected) != 0) {
5131         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5132         return -1;
5133       }
5134     }
5135     if (r[1] != NULL) {
5136       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
5137       print_strings (r);
5138       return -1;
5139     }
5140     for (i = 0; r[i] != NULL; ++i)
5141       free (r[i]);
5142     free (r);
5143   }
5144   return 0;
5145 }
5146
5147 static int test_lvremove_1_skip (void)
5148 {
5149   const char *str;
5150
5151   str = getenv ("TEST_ONLY");
5152   if (str)
5153     return strstr (str, "lvremove") == NULL;
5154   str = getenv ("SKIP_TEST_LVREMOVE_1");
5155   if (str && strcmp (str, "1") == 0) return 1;
5156   str = getenv ("SKIP_TEST_LVREMOVE");
5157   if (str && strcmp (str, "1") == 0) return 1;
5158   return 0;
5159 }
5160
5161 static int test_lvremove_1 (void)
5162 {
5163   if (test_lvremove_1_skip ()) {
5164     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
5165     return 0;
5166   }
5167
5168   /* InitNone|InitEmpty for test_lvremove_1 */
5169   {
5170     char device[] = "/dev/sda";
5171     int r;
5172     suppress_error = 0;
5173     r = guestfs_blockdev_setrw (g, device);
5174     if (r == -1)
5175       return -1;
5176   }
5177   {
5178     int r;
5179     suppress_error = 0;
5180     r = guestfs_umount_all (g);
5181     if (r == -1)
5182       return -1;
5183   }
5184   {
5185     int r;
5186     suppress_error = 0;
5187     r = guestfs_lvm_remove_all (g);
5188     if (r == -1)
5189       return -1;
5190   }
5191   /* TestOutputList for lvremove (1) */
5192   {
5193     char device[] = "/dev/sda";
5194     char lines_0[] = ",";
5195     char *lines[] = {
5196       lines_0,
5197       NULL
5198     };
5199     int r;
5200     suppress_error = 0;
5201     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5202     if (r == -1)
5203       return -1;
5204   }
5205   {
5206     char device[] = "/dev/sda1";
5207     int r;
5208     suppress_error = 0;
5209     r = guestfs_pvcreate (g, device);
5210     if (r == -1)
5211       return -1;
5212   }
5213   {
5214     char volgroup[] = "VG";
5215     char physvols_0[] = "/dev/sda1";
5216     char *physvols[] = {
5217       physvols_0,
5218       NULL
5219     };
5220     int r;
5221     suppress_error = 0;
5222     r = guestfs_vgcreate (g, volgroup, physvols);
5223     if (r == -1)
5224       return -1;
5225   }
5226   {
5227     char logvol[] = "LV1";
5228     char volgroup[] = "VG";
5229     int r;
5230     suppress_error = 0;
5231     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5232     if (r == -1)
5233       return -1;
5234   }
5235   {
5236     char logvol[] = "LV2";
5237     char volgroup[] = "VG";
5238     int r;
5239     suppress_error = 0;
5240     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5241     if (r == -1)
5242       return -1;
5243   }
5244   {
5245     char device[] = "/dev/VG";
5246     int r;
5247     suppress_error = 0;
5248     r = guestfs_lvremove (g, device);
5249     if (r == -1)
5250       return -1;
5251   }
5252   {
5253     char **r;
5254     int i;
5255     suppress_error = 0;
5256     r = guestfs_lvs (g);
5257     if (r == NULL)
5258       return -1;
5259     if (r[0] != NULL) {
5260       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
5261       print_strings (r);
5262       return -1;
5263     }
5264     for (i = 0; r[i] != NULL; ++i)
5265       free (r[i]);
5266     free (r);
5267   }
5268   return 0;
5269 }
5270
5271 static int test_lvremove_2_skip (void)
5272 {
5273   const char *str;
5274
5275   str = getenv ("TEST_ONLY");
5276   if (str)
5277     return strstr (str, "lvremove") == NULL;
5278   str = getenv ("SKIP_TEST_LVREMOVE_2");
5279   if (str && strcmp (str, "1") == 0) return 1;
5280   str = getenv ("SKIP_TEST_LVREMOVE");
5281   if (str && strcmp (str, "1") == 0) return 1;
5282   return 0;
5283 }
5284
5285 static int test_lvremove_2 (void)
5286 {
5287   if (test_lvremove_2_skip ()) {
5288     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
5289     return 0;
5290   }
5291
5292   /* InitNone|InitEmpty for test_lvremove_2 */
5293   {
5294     char device[] = "/dev/sda";
5295     int r;
5296     suppress_error = 0;
5297     r = guestfs_blockdev_setrw (g, device);
5298     if (r == -1)
5299       return -1;
5300   }
5301   {
5302     int r;
5303     suppress_error = 0;
5304     r = guestfs_umount_all (g);
5305     if (r == -1)
5306       return -1;
5307   }
5308   {
5309     int r;
5310     suppress_error = 0;
5311     r = guestfs_lvm_remove_all (g);
5312     if (r == -1)
5313       return -1;
5314   }
5315   /* TestOutputList for lvremove (2) */
5316   {
5317     char device[] = "/dev/sda";
5318     char lines_0[] = ",";
5319     char *lines[] = {
5320       lines_0,
5321       NULL
5322     };
5323     int r;
5324     suppress_error = 0;
5325     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5326     if (r == -1)
5327       return -1;
5328   }
5329   {
5330     char device[] = "/dev/sda1";
5331     int r;
5332     suppress_error = 0;
5333     r = guestfs_pvcreate (g, device);
5334     if (r == -1)
5335       return -1;
5336   }
5337   {
5338     char volgroup[] = "VG";
5339     char physvols_0[] = "/dev/sda1";
5340     char *physvols[] = {
5341       physvols_0,
5342       NULL
5343     };
5344     int r;
5345     suppress_error = 0;
5346     r = guestfs_vgcreate (g, volgroup, physvols);
5347     if (r == -1)
5348       return -1;
5349   }
5350   {
5351     char logvol[] = "LV1";
5352     char volgroup[] = "VG";
5353     int r;
5354     suppress_error = 0;
5355     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5356     if (r == -1)
5357       return -1;
5358   }
5359   {
5360     char logvol[] = "LV2";
5361     char volgroup[] = "VG";
5362     int r;
5363     suppress_error = 0;
5364     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5365     if (r == -1)
5366       return -1;
5367   }
5368   {
5369     char device[] = "/dev/VG";
5370     int r;
5371     suppress_error = 0;
5372     r = guestfs_lvremove (g, device);
5373     if (r == -1)
5374       return -1;
5375   }
5376   {
5377     char **r;
5378     int i;
5379     suppress_error = 0;
5380     r = guestfs_vgs (g);
5381     if (r == NULL)
5382       return -1;
5383     if (!r[0]) {
5384       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
5385       print_strings (r);
5386       return -1;
5387     }
5388     {
5389       char expected[] = "VG";
5390       if (strcmp (r[0], expected) != 0) {
5391         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5392         return -1;
5393       }
5394     }
5395     if (r[1] != NULL) {
5396       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
5397       print_strings (r);
5398       return -1;
5399     }
5400     for (i = 0; r[i] != NULL; ++i)
5401       free (r[i]);
5402     free (r);
5403   }
5404   return 0;
5405 }
5406
5407 static int test_mount_ro_0_skip (void)
5408 {
5409   const char *str;
5410
5411   str = getenv ("TEST_ONLY");
5412   if (str)
5413     return strstr (str, "mount_ro") == NULL;
5414   str = getenv ("SKIP_TEST_MOUNT_RO_0");
5415   if (str && strcmp (str, "1") == 0) return 1;
5416   str = getenv ("SKIP_TEST_MOUNT_RO");
5417   if (str && strcmp (str, "1") == 0) return 1;
5418   return 0;
5419 }
5420
5421 static int test_mount_ro_0 (void)
5422 {
5423   if (test_mount_ro_0_skip ()) {
5424     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
5425     return 0;
5426   }
5427
5428   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
5429   {
5430     char device[] = "/dev/sda";
5431     int r;
5432     suppress_error = 0;
5433     r = guestfs_blockdev_setrw (g, device);
5434     if (r == -1)
5435       return -1;
5436   }
5437   {
5438     int r;
5439     suppress_error = 0;
5440     r = guestfs_umount_all (g);
5441     if (r == -1)
5442       return -1;
5443   }
5444   {
5445     int r;
5446     suppress_error = 0;
5447     r = guestfs_lvm_remove_all (g);
5448     if (r == -1)
5449       return -1;
5450   }
5451   {
5452     char device[] = "/dev/sda";
5453     char lines_0[] = ",";
5454     char *lines[] = {
5455       lines_0,
5456       NULL
5457     };
5458     int r;
5459     suppress_error = 0;
5460     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5461     if (r == -1)
5462       return -1;
5463   }
5464   {
5465     char fstype[] = "ext2";
5466     char device[] = "/dev/sda1";
5467     int r;
5468     suppress_error = 0;
5469     r = guestfs_mkfs (g, fstype, device);
5470     if (r == -1)
5471       return -1;
5472   }
5473   {
5474     char device[] = "/dev/sda1";
5475     char mountpoint[] = "/";
5476     int r;
5477     suppress_error = 0;
5478     r = guestfs_mount (g, device, mountpoint);
5479     if (r == -1)
5480       return -1;
5481   }
5482   /* TestLastFail for mount_ro (0) */
5483   {
5484     char pathordevice[] = "/";
5485     int r;
5486     suppress_error = 0;
5487     r = guestfs_umount (g, pathordevice);
5488     if (r == -1)
5489       return -1;
5490   }
5491   {
5492     char device[] = "/dev/sda1";
5493     char mountpoint[] = "/";
5494     int r;
5495     suppress_error = 0;
5496     r = guestfs_mount_ro (g, device, mountpoint);
5497     if (r == -1)
5498       return -1;
5499   }
5500   {
5501     char path[] = "/new";
5502     int r;
5503     suppress_error = 1;
5504     r = guestfs_touch (g, path);
5505     if (r != -1)
5506       return -1;
5507   }
5508   return 0;
5509 }
5510
5511 static int test_mount_ro_1_skip (void)
5512 {
5513   const char *str;
5514
5515   str = getenv ("TEST_ONLY");
5516   if (str)
5517     return strstr (str, "mount_ro") == NULL;
5518   str = getenv ("SKIP_TEST_MOUNT_RO_1");
5519   if (str && strcmp (str, "1") == 0) return 1;
5520   str = getenv ("SKIP_TEST_MOUNT_RO");
5521   if (str && strcmp (str, "1") == 0) return 1;
5522   return 0;
5523 }
5524
5525 static int test_mount_ro_1 (void)
5526 {
5527   if (test_mount_ro_1_skip ()) {
5528     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
5529     return 0;
5530   }
5531
5532   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5533   {
5534     char device[] = "/dev/sda";
5535     int r;
5536     suppress_error = 0;
5537     r = guestfs_blockdev_setrw (g, device);
5538     if (r == -1)
5539       return -1;
5540   }
5541   {
5542     int r;
5543     suppress_error = 0;
5544     r = guestfs_umount_all (g);
5545     if (r == -1)
5546       return -1;
5547   }
5548   {
5549     int r;
5550     suppress_error = 0;
5551     r = guestfs_lvm_remove_all (g);
5552     if (r == -1)
5553       return -1;
5554   }
5555   {
5556     char device[] = "/dev/sda";
5557     char lines_0[] = ",";
5558     char *lines[] = {
5559       lines_0,
5560       NULL
5561     };
5562     int r;
5563     suppress_error = 0;
5564     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5565     if (r == -1)
5566       return -1;
5567   }
5568   {
5569     char fstype[] = "ext2";
5570     char device[] = "/dev/sda1";
5571     int r;
5572     suppress_error = 0;
5573     r = guestfs_mkfs (g, fstype, device);
5574     if (r == -1)
5575       return -1;
5576   }
5577   {
5578     char device[] = "/dev/sda1";
5579     char mountpoint[] = "/";
5580     int r;
5581     suppress_error = 0;
5582     r = guestfs_mount (g, device, mountpoint);
5583     if (r == -1)
5584       return -1;
5585   }
5586   /* TestOutput for mount_ro (1) */
5587   char expected[] = "data";
5588   {
5589     char path[] = "/new";
5590     char content[] = "data";
5591     int r;
5592     suppress_error = 0;
5593     r = guestfs_write_file (g, path, content, 0);
5594     if (r == -1)
5595       return -1;
5596   }
5597   {
5598     char pathordevice[] = "/";
5599     int r;
5600     suppress_error = 0;
5601     r = guestfs_umount (g, pathordevice);
5602     if (r == -1)
5603       return -1;
5604   }
5605   {
5606     char device[] = "/dev/sda1";
5607     char mountpoint[] = "/";
5608     int r;
5609     suppress_error = 0;
5610     r = guestfs_mount_ro (g, device, mountpoint);
5611     if (r == -1)
5612       return -1;
5613   }
5614   {
5615     char path[] = "/new";
5616     char *r;
5617     suppress_error = 0;
5618     r = guestfs_cat (g, path);
5619     if (r == NULL)
5620       return -1;
5621     if (strcmp (r, expected) != 0) {
5622       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5623       return -1;
5624     }
5625     free (r);
5626   }
5627   return 0;
5628 }
5629
5630 static int test_tgz_in_0_skip (void)
5631 {
5632   const char *str;
5633
5634   str = getenv ("TEST_ONLY");
5635   if (str)
5636     return strstr (str, "tgz_in") == NULL;
5637   str = getenv ("SKIP_TEST_TGZ_IN_0");
5638   if (str && strcmp (str, "1") == 0) return 1;
5639   str = getenv ("SKIP_TEST_TGZ_IN");
5640   if (str && strcmp (str, "1") == 0) return 1;
5641   return 0;
5642 }
5643
5644 static int test_tgz_in_0 (void)
5645 {
5646   if (test_tgz_in_0_skip ()) {
5647     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
5648     return 0;
5649   }
5650
5651   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5652   {
5653     char device[] = "/dev/sda";
5654     int r;
5655     suppress_error = 0;
5656     r = guestfs_blockdev_setrw (g, device);
5657     if (r == -1)
5658       return -1;
5659   }
5660   {
5661     int r;
5662     suppress_error = 0;
5663     r = guestfs_umount_all (g);
5664     if (r == -1)
5665       return -1;
5666   }
5667   {
5668     int r;
5669     suppress_error = 0;
5670     r = guestfs_lvm_remove_all (g);
5671     if (r == -1)
5672       return -1;
5673   }
5674   {
5675     char device[] = "/dev/sda";
5676     char lines_0[] = ",";
5677     char *lines[] = {
5678       lines_0,
5679       NULL
5680     };
5681     int r;
5682     suppress_error = 0;
5683     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5684     if (r == -1)
5685       return -1;
5686   }
5687   {
5688     char fstype[] = "ext2";
5689     char device[] = "/dev/sda1";
5690     int r;
5691     suppress_error = 0;
5692     r = guestfs_mkfs (g, fstype, device);
5693     if (r == -1)
5694       return -1;
5695   }
5696   {
5697     char device[] = "/dev/sda1";
5698     char mountpoint[] = "/";
5699     int r;
5700     suppress_error = 0;
5701     r = guestfs_mount (g, device, mountpoint);
5702     if (r == -1)
5703       return -1;
5704   }
5705   /* TestOutput for tgz_in (0) */
5706   char expected[] = "hello\n";
5707   {
5708     char directory[] = "/";
5709     int r;
5710     suppress_error = 0;
5711     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5712     if (r == -1)
5713       return -1;
5714   }
5715   {
5716     char path[] = "/hello";
5717     char *r;
5718     suppress_error = 0;
5719     r = guestfs_cat (g, path);
5720     if (r == NULL)
5721       return -1;
5722     if (strcmp (r, expected) != 0) {
5723       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5724       return -1;
5725     }
5726     free (r);
5727   }
5728   return 0;
5729 }
5730
5731 static int test_tar_in_0_skip (void)
5732 {
5733   const char *str;
5734
5735   str = getenv ("TEST_ONLY");
5736   if (str)
5737     return strstr (str, "tar_in") == NULL;
5738   str = getenv ("SKIP_TEST_TAR_IN_0");
5739   if (str && strcmp (str, "1") == 0) return 1;
5740   str = getenv ("SKIP_TEST_TAR_IN");
5741   if (str && strcmp (str, "1") == 0) return 1;
5742   return 0;
5743 }
5744
5745 static int test_tar_in_0 (void)
5746 {
5747   if (test_tar_in_0_skip ()) {
5748     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5749     return 0;
5750   }
5751
5752   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5753   {
5754     char device[] = "/dev/sda";
5755     int r;
5756     suppress_error = 0;
5757     r = guestfs_blockdev_setrw (g, device);
5758     if (r == -1)
5759       return -1;
5760   }
5761   {
5762     int r;
5763     suppress_error = 0;
5764     r = guestfs_umount_all (g);
5765     if (r == -1)
5766       return -1;
5767   }
5768   {
5769     int r;
5770     suppress_error = 0;
5771     r = guestfs_lvm_remove_all (g);
5772     if (r == -1)
5773       return -1;
5774   }
5775   {
5776     char device[] = "/dev/sda";
5777     char lines_0[] = ",";
5778     char *lines[] = {
5779       lines_0,
5780       NULL
5781     };
5782     int r;
5783     suppress_error = 0;
5784     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5785     if (r == -1)
5786       return -1;
5787   }
5788   {
5789     char fstype[] = "ext2";
5790     char device[] = "/dev/sda1";
5791     int r;
5792     suppress_error = 0;
5793     r = guestfs_mkfs (g, fstype, device);
5794     if (r == -1)
5795       return -1;
5796   }
5797   {
5798     char device[] = "/dev/sda1";
5799     char mountpoint[] = "/";
5800     int r;
5801     suppress_error = 0;
5802     r = guestfs_mount (g, device, mountpoint);
5803     if (r == -1)
5804       return -1;
5805   }
5806   /* TestOutput for tar_in (0) */
5807   char expected[] = "hello\n";
5808   {
5809     char directory[] = "/";
5810     int r;
5811     suppress_error = 0;
5812     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5813     if (r == -1)
5814       return -1;
5815   }
5816   {
5817     char path[] = "/hello";
5818     char *r;
5819     suppress_error = 0;
5820     r = guestfs_cat (g, path);
5821     if (r == NULL)
5822       return -1;
5823     if (strcmp (r, expected) != 0) {
5824       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5825       return -1;
5826     }
5827     free (r);
5828   }
5829   return 0;
5830 }
5831
5832 static int test_checksum_0_skip (void)
5833 {
5834   const char *str;
5835
5836   str = getenv ("TEST_ONLY");
5837   if (str)
5838     return strstr (str, "checksum") == NULL;
5839   str = getenv ("SKIP_TEST_CHECKSUM_0");
5840   if (str && strcmp (str, "1") == 0) return 1;
5841   str = getenv ("SKIP_TEST_CHECKSUM");
5842   if (str && strcmp (str, "1") == 0) return 1;
5843   return 0;
5844 }
5845
5846 static int test_checksum_0 (void)
5847 {
5848   if (test_checksum_0_skip ()) {
5849     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5850     return 0;
5851   }
5852
5853   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5854   {
5855     char device[] = "/dev/sda";
5856     int r;
5857     suppress_error = 0;
5858     r = guestfs_blockdev_setrw (g, device);
5859     if (r == -1)
5860       return -1;
5861   }
5862   {
5863     int r;
5864     suppress_error = 0;
5865     r = guestfs_umount_all (g);
5866     if (r == -1)
5867       return -1;
5868   }
5869   {
5870     int r;
5871     suppress_error = 0;
5872     r = guestfs_lvm_remove_all (g);
5873     if (r == -1)
5874       return -1;
5875   }
5876   {
5877     char device[] = "/dev/sda";
5878     char lines_0[] = ",";
5879     char *lines[] = {
5880       lines_0,
5881       NULL
5882     };
5883     int r;
5884     suppress_error = 0;
5885     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5886     if (r == -1)
5887       return -1;
5888   }
5889   {
5890     char fstype[] = "ext2";
5891     char device[] = "/dev/sda1";
5892     int r;
5893     suppress_error = 0;
5894     r = guestfs_mkfs (g, fstype, device);
5895     if (r == -1)
5896       return -1;
5897   }
5898   {
5899     char device[] = "/dev/sda1";
5900     char mountpoint[] = "/";
5901     int r;
5902     suppress_error = 0;
5903     r = guestfs_mount (g, device, mountpoint);
5904     if (r == -1)
5905       return -1;
5906   }
5907   /* TestOutput for checksum (0) */
5908   char expected[] = "935282863";
5909   {
5910     char path[] = "/new";
5911     char content[] = "test\n";
5912     int r;
5913     suppress_error = 0;
5914     r = guestfs_write_file (g, path, content, 0);
5915     if (r == -1)
5916       return -1;
5917   }
5918   {
5919     char csumtype[] = "crc";
5920     char path[] = "/new";
5921     char *r;
5922     suppress_error = 0;
5923     r = guestfs_checksum (g, csumtype, path);
5924     if (r == NULL)
5925       return -1;
5926     if (strcmp (r, expected) != 0) {
5927       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5928       return -1;
5929     }
5930     free (r);
5931   }
5932   return 0;
5933 }
5934
5935 static int test_checksum_1_skip (void)
5936 {
5937   const char *str;
5938
5939   str = getenv ("TEST_ONLY");
5940   if (str)
5941     return strstr (str, "checksum") == NULL;
5942   str = getenv ("SKIP_TEST_CHECKSUM_1");
5943   if (str && strcmp (str, "1") == 0) return 1;
5944   str = getenv ("SKIP_TEST_CHECKSUM");
5945   if (str && strcmp (str, "1") == 0) return 1;
5946   return 0;
5947 }
5948
5949 static int test_checksum_1 (void)
5950 {
5951   if (test_checksum_1_skip ()) {
5952     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5953     return 0;
5954   }
5955
5956   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5957   {
5958     char device[] = "/dev/sda";
5959     int r;
5960     suppress_error = 0;
5961     r = guestfs_blockdev_setrw (g, device);
5962     if (r == -1)
5963       return -1;
5964   }
5965   {
5966     int r;
5967     suppress_error = 0;
5968     r = guestfs_umount_all (g);
5969     if (r == -1)
5970       return -1;
5971   }
5972   {
5973     int r;
5974     suppress_error = 0;
5975     r = guestfs_lvm_remove_all (g);
5976     if (r == -1)
5977       return -1;
5978   }
5979   {
5980     char device[] = "/dev/sda";
5981     char lines_0[] = ",";
5982     char *lines[] = {
5983       lines_0,
5984       NULL
5985     };
5986     int r;
5987     suppress_error = 0;
5988     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5989     if (r == -1)
5990       return -1;
5991   }
5992   {
5993     char fstype[] = "ext2";
5994     char device[] = "/dev/sda1";
5995     int r;
5996     suppress_error = 0;
5997     r = guestfs_mkfs (g, fstype, device);
5998     if (r == -1)
5999       return -1;
6000   }
6001   {
6002     char device[] = "/dev/sda1";
6003     char mountpoint[] = "/";
6004     int r;
6005     suppress_error = 0;
6006     r = guestfs_mount (g, device, mountpoint);
6007     if (r == -1)
6008       return -1;
6009   }
6010   /* TestLastFail for checksum (1) */
6011   {
6012     char csumtype[] = "crc";
6013     char path[] = "/new";
6014     char *r;
6015     suppress_error = 1;
6016     r = guestfs_checksum (g, csumtype, path);
6017     if (r != NULL)
6018       return -1;
6019     free (r);
6020   }
6021   return 0;
6022 }
6023
6024 static int test_checksum_2_skip (void)
6025 {
6026   const char *str;
6027
6028   str = getenv ("TEST_ONLY");
6029   if (str)
6030     return strstr (str, "checksum") == NULL;
6031   str = getenv ("SKIP_TEST_CHECKSUM_2");
6032   if (str && strcmp (str, "1") == 0) return 1;
6033   str = getenv ("SKIP_TEST_CHECKSUM");
6034   if (str && strcmp (str, "1") == 0) return 1;
6035   return 0;
6036 }
6037
6038 static int test_checksum_2 (void)
6039 {
6040   if (test_checksum_2_skip ()) {
6041     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
6042     return 0;
6043   }
6044
6045   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
6046   {
6047     char device[] = "/dev/sda";
6048     int r;
6049     suppress_error = 0;
6050     r = guestfs_blockdev_setrw (g, device);
6051     if (r == -1)
6052       return -1;
6053   }
6054   {
6055     int r;
6056     suppress_error = 0;
6057     r = guestfs_umount_all (g);
6058     if (r == -1)
6059       return -1;
6060   }
6061   {
6062     int r;
6063     suppress_error = 0;
6064     r = guestfs_lvm_remove_all (g);
6065     if (r == -1)
6066       return -1;
6067   }
6068   {
6069     char device[] = "/dev/sda";
6070     char lines_0[] = ",";
6071     char *lines[] = {
6072       lines_0,
6073       NULL
6074     };
6075     int r;
6076     suppress_error = 0;
6077     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6078     if (r == -1)
6079       return -1;
6080   }
6081   {
6082     char fstype[] = "ext2";
6083     char device[] = "/dev/sda1";
6084     int r;
6085     suppress_error = 0;
6086     r = guestfs_mkfs (g, fstype, device);
6087     if (r == -1)
6088       return -1;
6089   }
6090   {
6091     char device[] = "/dev/sda1";
6092     char mountpoint[] = "/";
6093     int r;
6094     suppress_error = 0;
6095     r = guestfs_mount (g, device, mountpoint);
6096     if (r == -1)
6097       return -1;
6098   }
6099   /* TestOutput for checksum (2) */
6100   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
6101   {
6102     char path[] = "/new";
6103     char content[] = "test\n";
6104     int r;
6105     suppress_error = 0;
6106     r = guestfs_write_file (g, path, content, 0);
6107     if (r == -1)
6108       return -1;
6109   }
6110   {
6111     char csumtype[] = "md5";
6112     char path[] = "/new";
6113     char *r;
6114     suppress_error = 0;
6115     r = guestfs_checksum (g, csumtype, path);
6116     if (r == NULL)
6117       return -1;
6118     if (strcmp (r, expected) != 0) {
6119       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
6120       return -1;
6121     }
6122     free (r);
6123   }
6124   return 0;
6125 }
6126
6127 static int test_checksum_3_skip (void)
6128 {
6129   const char *str;
6130
6131   str = getenv ("TEST_ONLY");
6132   if (str)
6133     return strstr (str, "checksum") == NULL;
6134   str = getenv ("SKIP_TEST_CHECKSUM_3");
6135   if (str && strcmp (str, "1") == 0) return 1;
6136   str = getenv ("SKIP_TEST_CHECKSUM");
6137   if (str && strcmp (str, "1") == 0) return 1;
6138   return 0;
6139 }
6140
6141 static int test_checksum_3 (void)
6142 {
6143   if (test_checksum_3_skip ()) {
6144     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
6145     return 0;
6146   }
6147
6148   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
6149   {
6150     char device[] = "/dev/sda";
6151     int r;
6152     suppress_error = 0;
6153     r = guestfs_blockdev_setrw (g, device);
6154     if (r == -1)
6155       return -1;
6156   }
6157   {
6158     int r;
6159     suppress_error = 0;
6160     r = guestfs_umount_all (g);
6161     if (r == -1)
6162       return -1;
6163   }
6164   {
6165     int r;
6166     suppress_error = 0;
6167     r = guestfs_lvm_remove_all (g);
6168     if (r == -1)
6169       return -1;
6170   }
6171   {
6172     char device[] = "/dev/sda";
6173     char lines_0[] = ",";
6174     char *lines[] = {
6175       lines_0,
6176       NULL
6177     };
6178     int r;
6179     suppress_error = 0;
6180     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6181     if (r == -1)
6182       return -1;
6183   }
6184   {
6185     char fstype[] = "ext2";
6186     char device[] = "/dev/sda1";
6187     int r;
6188     suppress_error = 0;
6189     r = guestfs_mkfs (g, fstype, device);
6190     if (r == -1)
6191       return -1;
6192   }
6193   {
6194     char device[] = "/dev/sda1";
6195     char mountpoint[] = "/";
6196     int r;
6197     suppress_error = 0;
6198     r = guestfs_mount (g, device, mountpoint);
6199     if (r == -1)
6200       return -1;
6201   }
6202   /* TestOutput for checksum (3) */
6203   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
6204   {
6205     char path[] = "/new";
6206     char content[] = "test\n";
6207     int r;
6208     suppress_error = 0;
6209     r = guestfs_write_file (g, path, content, 0);
6210     if (r == -1)
6211       return -1;
6212   }
6213   {
6214     char csumtype[] = "sha1";
6215     char path[] = "/new";
6216     char *r;
6217     suppress_error = 0;
6218     r = guestfs_checksum (g, csumtype, path);
6219     if (r == NULL)
6220       return -1;
6221     if (strcmp (r, expected) != 0) {
6222       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
6223       return -1;
6224     }
6225     free (r);
6226   }
6227   return 0;
6228 }
6229
6230 static int test_checksum_4_skip (void)
6231 {
6232   const char *str;
6233
6234   str = getenv ("TEST_ONLY");
6235   if (str)
6236     return strstr (str, "checksum") == NULL;
6237   str = getenv ("SKIP_TEST_CHECKSUM_4");
6238   if (str && strcmp (str, "1") == 0) return 1;
6239   str = getenv ("SKIP_TEST_CHECKSUM");
6240   if (str && strcmp (str, "1") == 0) return 1;
6241   return 0;
6242 }
6243
6244 static int test_checksum_4 (void)
6245 {
6246   if (test_checksum_4_skip ()) {
6247     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
6248     return 0;
6249   }
6250
6251   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
6252   {
6253     char device[] = "/dev/sda";
6254     int r;
6255     suppress_error = 0;
6256     r = guestfs_blockdev_setrw (g, device);
6257     if (r == -1)
6258       return -1;
6259   }
6260   {
6261     int r;
6262     suppress_error = 0;
6263     r = guestfs_umount_all (g);
6264     if (r == -1)
6265       return -1;
6266   }
6267   {
6268     int r;
6269     suppress_error = 0;
6270     r = guestfs_lvm_remove_all (g);
6271     if (r == -1)
6272       return -1;
6273   }
6274   {
6275     char device[] = "/dev/sda";
6276     char lines_0[] = ",";
6277     char *lines[] = {
6278       lines_0,
6279       NULL
6280     };
6281     int r;
6282     suppress_error = 0;
6283     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6284     if (r == -1)
6285       return -1;
6286   }
6287   {
6288     char fstype[] = "ext2";
6289     char device[] = "/dev/sda1";
6290     int r;
6291     suppress_error = 0;
6292     r = guestfs_mkfs (g, fstype, device);
6293     if (r == -1)
6294       return -1;
6295   }
6296   {
6297     char device[] = "/dev/sda1";
6298     char mountpoint[] = "/";
6299     int r;
6300     suppress_error = 0;
6301     r = guestfs_mount (g, device, mountpoint);
6302     if (r == -1)
6303       return -1;
6304   }
6305   /* TestOutput for checksum (4) */
6306   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
6307   {
6308     char path[] = "/new";
6309     char content[] = "test\n";
6310     int r;
6311     suppress_error = 0;
6312     r = guestfs_write_file (g, path, content, 0);
6313     if (r == -1)
6314       return -1;
6315   }
6316   {
6317     char csumtype[] = "sha224";
6318     char path[] = "/new";
6319     char *r;
6320     suppress_error = 0;
6321     r = guestfs_checksum (g, csumtype, path);
6322     if (r == NULL)
6323       return -1;
6324     if (strcmp (r, expected) != 0) {
6325       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
6326       return -1;
6327     }
6328     free (r);
6329   }
6330   return 0;
6331 }
6332
6333 static int test_checksum_5_skip (void)
6334 {
6335   const char *str;
6336
6337   str = getenv ("TEST_ONLY");
6338   if (str)
6339     return strstr (str, "checksum") == NULL;
6340   str = getenv ("SKIP_TEST_CHECKSUM_5");
6341   if (str && strcmp (str, "1") == 0) return 1;
6342   str = getenv ("SKIP_TEST_CHECKSUM");
6343   if (str && strcmp (str, "1") == 0) return 1;
6344   return 0;
6345 }
6346
6347 static int test_checksum_5 (void)
6348 {
6349   if (test_checksum_5_skip ()) {
6350     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
6351     return 0;
6352   }
6353
6354   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
6355   {
6356     char device[] = "/dev/sda";
6357     int r;
6358     suppress_error = 0;
6359     r = guestfs_blockdev_setrw (g, device);
6360     if (r == -1)
6361       return -1;
6362   }
6363   {
6364     int r;
6365     suppress_error = 0;
6366     r = guestfs_umount_all (g);
6367     if (r == -1)
6368       return -1;
6369   }
6370   {
6371     int r;
6372     suppress_error = 0;
6373     r = guestfs_lvm_remove_all (g);
6374     if (r == -1)
6375       return -1;
6376   }
6377   {
6378     char device[] = "/dev/sda";
6379     char lines_0[] = ",";
6380     char *lines[] = {
6381       lines_0,
6382       NULL
6383     };
6384     int r;
6385     suppress_error = 0;
6386     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6387     if (r == -1)
6388       return -1;
6389   }
6390   {
6391     char fstype[] = "ext2";
6392     char device[] = "/dev/sda1";
6393     int r;
6394     suppress_error = 0;
6395     r = guestfs_mkfs (g, fstype, device);
6396     if (r == -1)
6397       return -1;
6398   }
6399   {
6400     char device[] = "/dev/sda1";
6401     char mountpoint[] = "/";
6402     int r;
6403     suppress_error = 0;
6404     r = guestfs_mount (g, device, mountpoint);
6405     if (r == -1)
6406       return -1;
6407   }
6408   /* TestOutput for checksum (5) */
6409   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
6410   {
6411     char path[] = "/new";
6412     char content[] = "test\n";
6413     int r;
6414     suppress_error = 0;
6415     r = guestfs_write_file (g, path, content, 0);
6416     if (r == -1)
6417       return -1;
6418   }
6419   {
6420     char csumtype[] = "sha256";
6421     char path[] = "/new";
6422     char *r;
6423     suppress_error = 0;
6424     r = guestfs_checksum (g, csumtype, path);
6425     if (r == NULL)
6426       return -1;
6427     if (strcmp (r, expected) != 0) {
6428       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
6429       return -1;
6430     }
6431     free (r);
6432   }
6433   return 0;
6434 }
6435
6436 static int test_checksum_6_skip (void)
6437 {
6438   const char *str;
6439
6440   str = getenv ("TEST_ONLY");
6441   if (str)
6442     return strstr (str, "checksum") == NULL;
6443   str = getenv ("SKIP_TEST_CHECKSUM_6");
6444   if (str && strcmp (str, "1") == 0) return 1;
6445   str = getenv ("SKIP_TEST_CHECKSUM");
6446   if (str && strcmp (str, "1") == 0) return 1;
6447   return 0;
6448 }
6449
6450 static int test_checksum_6 (void)
6451 {
6452   if (test_checksum_6_skip ()) {
6453     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
6454     return 0;
6455   }
6456
6457   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
6458   {
6459     char device[] = "/dev/sda";
6460     int r;
6461     suppress_error = 0;
6462     r = guestfs_blockdev_setrw (g, device);
6463     if (r == -1)
6464       return -1;
6465   }
6466   {
6467     int r;
6468     suppress_error = 0;
6469     r = guestfs_umount_all (g);
6470     if (r == -1)
6471       return -1;
6472   }
6473   {
6474     int r;
6475     suppress_error = 0;
6476     r = guestfs_lvm_remove_all (g);
6477     if (r == -1)
6478       return -1;
6479   }
6480   {
6481     char device[] = "/dev/sda";
6482     char lines_0[] = ",";
6483     char *lines[] = {
6484       lines_0,
6485       NULL
6486     };
6487     int r;
6488     suppress_error = 0;
6489     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6490     if (r == -1)
6491       return -1;
6492   }
6493   {
6494     char fstype[] = "ext2";
6495     char device[] = "/dev/sda1";
6496     int r;
6497     suppress_error = 0;
6498     r = guestfs_mkfs (g, fstype, device);
6499     if (r == -1)
6500       return -1;
6501   }
6502   {
6503     char device[] = "/dev/sda1";
6504     char mountpoint[] = "/";
6505     int r;
6506     suppress_error = 0;
6507     r = guestfs_mount (g, device, mountpoint);
6508     if (r == -1)
6509       return -1;
6510   }
6511   /* TestOutput for checksum (6) */
6512   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
6513   {
6514     char path[] = "/new";
6515     char content[] = "test\n";
6516     int r;
6517     suppress_error = 0;
6518     r = guestfs_write_file (g, path, content, 0);
6519     if (r == -1)
6520       return -1;
6521   }
6522   {
6523     char csumtype[] = "sha384";
6524     char path[] = "/new";
6525     char *r;
6526     suppress_error = 0;
6527     r = guestfs_checksum (g, csumtype, path);
6528     if (r == NULL)
6529       return -1;
6530     if (strcmp (r, expected) != 0) {
6531       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6532       return -1;
6533     }
6534     free (r);
6535   }
6536   return 0;
6537 }
6538
6539 static int test_checksum_7_skip (void)
6540 {
6541   const char *str;
6542
6543   str = getenv ("TEST_ONLY");
6544   if (str)
6545     return strstr (str, "checksum") == NULL;
6546   str = getenv ("SKIP_TEST_CHECKSUM_7");
6547   if (str && strcmp (str, "1") == 0) return 1;
6548   str = getenv ("SKIP_TEST_CHECKSUM");
6549   if (str && strcmp (str, "1") == 0) return 1;
6550   return 0;
6551 }
6552
6553 static int test_checksum_7 (void)
6554 {
6555   if (test_checksum_7_skip ()) {
6556     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
6557     return 0;
6558   }
6559
6560   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6561   {
6562     char device[] = "/dev/sda";
6563     int r;
6564     suppress_error = 0;
6565     r = guestfs_blockdev_setrw (g, device);
6566     if (r == -1)
6567       return -1;
6568   }
6569   {
6570     int r;
6571     suppress_error = 0;
6572     r = guestfs_umount_all (g);
6573     if (r == -1)
6574       return -1;
6575   }
6576   {
6577     int r;
6578     suppress_error = 0;
6579     r = guestfs_lvm_remove_all (g);
6580     if (r == -1)
6581       return -1;
6582   }
6583   {
6584     char device[] = "/dev/sda";
6585     char lines_0[] = ",";
6586     char *lines[] = {
6587       lines_0,
6588       NULL
6589     };
6590     int r;
6591     suppress_error = 0;
6592     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6593     if (r == -1)
6594       return -1;
6595   }
6596   {
6597     char fstype[] = "ext2";
6598     char device[] = "/dev/sda1";
6599     int r;
6600     suppress_error = 0;
6601     r = guestfs_mkfs (g, fstype, device);
6602     if (r == -1)
6603       return -1;
6604   }
6605   {
6606     char device[] = "/dev/sda1";
6607     char mountpoint[] = "/";
6608     int r;
6609     suppress_error = 0;
6610     r = guestfs_mount (g, device, mountpoint);
6611     if (r == -1)
6612       return -1;
6613   }
6614   /* TestOutput for checksum (7) */
6615   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6616   {
6617     char path[] = "/new";
6618     char content[] = "test\n";
6619     int r;
6620     suppress_error = 0;
6621     r = guestfs_write_file (g, path, content, 0);
6622     if (r == -1)
6623       return -1;
6624   }
6625   {
6626     char csumtype[] = "sha512";
6627     char path[] = "/new";
6628     char *r;
6629     suppress_error = 0;
6630     r = guestfs_checksum (g, csumtype, path);
6631     if (r == NULL)
6632       return -1;
6633     if (strcmp (r, expected) != 0) {
6634       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6635       return -1;
6636     }
6637     free (r);
6638   }
6639   return 0;
6640 }
6641
6642 static int test_checksum_8_skip (void)
6643 {
6644   const char *str;
6645
6646   str = getenv ("TEST_ONLY");
6647   if (str)
6648     return strstr (str, "checksum") == NULL;
6649   str = getenv ("SKIP_TEST_CHECKSUM_8");
6650   if (str && strcmp (str, "1") == 0) return 1;
6651   str = getenv ("SKIP_TEST_CHECKSUM");
6652   if (str && strcmp (str, "1") == 0) return 1;
6653   return 0;
6654 }
6655
6656 static int test_checksum_8 (void)
6657 {
6658   if (test_checksum_8_skip ()) {
6659     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
6660     return 0;
6661   }
6662
6663   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6664   {
6665     char device[] = "/dev/sda";
6666     int r;
6667     suppress_error = 0;
6668     r = guestfs_blockdev_setrw (g, device);
6669     if (r == -1)
6670       return -1;
6671   }
6672   {
6673     int r;
6674     suppress_error = 0;
6675     r = guestfs_umount_all (g);
6676     if (r == -1)
6677       return -1;
6678   }
6679   {
6680     int r;
6681     suppress_error = 0;
6682     r = guestfs_lvm_remove_all (g);
6683     if (r == -1)
6684       return -1;
6685   }
6686   {
6687     char device[] = "/dev/sda";
6688     char lines_0[] = ",";
6689     char *lines[] = {
6690       lines_0,
6691       NULL
6692     };
6693     int r;
6694     suppress_error = 0;
6695     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6696     if (r == -1)
6697       return -1;
6698   }
6699   {
6700     char fstype[] = "ext2";
6701     char device[] = "/dev/sda1";
6702     int r;
6703     suppress_error = 0;
6704     r = guestfs_mkfs (g, fstype, device);
6705     if (r == -1)
6706       return -1;
6707   }
6708   {
6709     char device[] = "/dev/sda1";
6710     char mountpoint[] = "/";
6711     int r;
6712     suppress_error = 0;
6713     r = guestfs_mount (g, device, mountpoint);
6714     if (r == -1)
6715       return -1;
6716   }
6717   /* TestOutput for checksum (8) */
6718   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6719   {
6720     char options[] = "ro";
6721     char vfstype[] = "squashfs";
6722     char device[] = "/dev/sdd";
6723     char mountpoint[] = "/";
6724     int r;
6725     suppress_error = 0;
6726     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
6727     if (r == -1)
6728       return -1;
6729   }
6730   {
6731     char csumtype[] = "md5";
6732     char path[] = "/known-3";
6733     char *r;
6734     suppress_error = 0;
6735     r = guestfs_checksum (g, csumtype, path);
6736     if (r == NULL)
6737       return -1;
6738     if (strcmp (r, expected) != 0) {
6739       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6740       return -1;
6741     }
6742     free (r);
6743   }
6744   return 0;
6745 }
6746
6747 static int test_download_0_skip (void)
6748 {
6749   const char *str;
6750
6751   str = getenv ("TEST_ONLY");
6752   if (str)
6753     return strstr (str, "download") == NULL;
6754   str = getenv ("SKIP_TEST_DOWNLOAD_0");
6755   if (str && strcmp (str, "1") == 0) return 1;
6756   str = getenv ("SKIP_TEST_DOWNLOAD");
6757   if (str && strcmp (str, "1") == 0) return 1;
6758   return 0;
6759 }
6760
6761 static int test_download_0 (void)
6762 {
6763   if (test_download_0_skip ()) {
6764     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6765     return 0;
6766   }
6767
6768   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
6769   {
6770     char device[] = "/dev/sda";
6771     int r;
6772     suppress_error = 0;
6773     r = guestfs_blockdev_setrw (g, device);
6774     if (r == -1)
6775       return -1;
6776   }
6777   {
6778     int r;
6779     suppress_error = 0;
6780     r = guestfs_umount_all (g);
6781     if (r == -1)
6782       return -1;
6783   }
6784   {
6785     int r;
6786     suppress_error = 0;
6787     r = guestfs_lvm_remove_all (g);
6788     if (r == -1)
6789       return -1;
6790   }
6791   {
6792     char device[] = "/dev/sda";
6793     char lines_0[] = ",";
6794     char *lines[] = {
6795       lines_0,
6796       NULL
6797     };
6798     int r;
6799     suppress_error = 0;
6800     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6801     if (r == -1)
6802       return -1;
6803   }
6804   {
6805     char fstype[] = "ext2";
6806     char device[] = "/dev/sda1";
6807     int r;
6808     suppress_error = 0;
6809     r = guestfs_mkfs (g, fstype, device);
6810     if (r == -1)
6811       return -1;
6812   }
6813   {
6814     char device[] = "/dev/sda1";
6815     char mountpoint[] = "/";
6816     int r;
6817     suppress_error = 0;
6818     r = guestfs_mount (g, device, mountpoint);
6819     if (r == -1)
6820       return -1;
6821   }
6822   /* TestOutput for download (0) */
6823   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6824   {
6825     char remotefilename[] = "/COPYING.LIB";
6826     int r;
6827     suppress_error = 0;
6828     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6829     if (r == -1)
6830       return -1;
6831   }
6832   {
6833     char remotefilename[] = "/COPYING.LIB";
6834     int r;
6835     suppress_error = 0;
6836     r = guestfs_download (g, remotefilename, "testdownload.tmp");
6837     if (r == -1)
6838       return -1;
6839   }
6840   {
6841     char remotefilename[] = "/upload";
6842     int r;
6843     suppress_error = 0;
6844     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6845     if (r == -1)
6846       return -1;
6847   }
6848   {
6849     char csumtype[] = "md5";
6850     char path[] = "/upload";
6851     char *r;
6852     suppress_error = 0;
6853     r = guestfs_checksum (g, csumtype, path);
6854     if (r == NULL)
6855       return -1;
6856     if (strcmp (r, expected) != 0) {
6857       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6858       return -1;
6859     }
6860     free (r);
6861   }
6862   return 0;
6863 }
6864
6865 static int test_upload_0_skip (void)
6866 {
6867   const char *str;
6868
6869   str = getenv ("TEST_ONLY");
6870   if (str)
6871     return strstr (str, "upload") == NULL;
6872   str = getenv ("SKIP_TEST_UPLOAD_0");
6873   if (str && strcmp (str, "1") == 0) return 1;
6874   str = getenv ("SKIP_TEST_UPLOAD");
6875   if (str && strcmp (str, "1") == 0) return 1;
6876   return 0;
6877 }
6878
6879 static int test_upload_0 (void)
6880 {
6881   if (test_upload_0_skip ()) {
6882     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6883     return 0;
6884   }
6885
6886   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6887   {
6888     char device[] = "/dev/sda";
6889     int r;
6890     suppress_error = 0;
6891     r = guestfs_blockdev_setrw (g, device);
6892     if (r == -1)
6893       return -1;
6894   }
6895   {
6896     int r;
6897     suppress_error = 0;
6898     r = guestfs_umount_all (g);
6899     if (r == -1)
6900       return -1;
6901   }
6902   {
6903     int r;
6904     suppress_error = 0;
6905     r = guestfs_lvm_remove_all (g);
6906     if (r == -1)
6907       return -1;
6908   }
6909   {
6910     char device[] = "/dev/sda";
6911     char lines_0[] = ",";
6912     char *lines[] = {
6913       lines_0,
6914       NULL
6915     };
6916     int r;
6917     suppress_error = 0;
6918     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6919     if (r == -1)
6920       return -1;
6921   }
6922   {
6923     char fstype[] = "ext2";
6924     char device[] = "/dev/sda1";
6925     int r;
6926     suppress_error = 0;
6927     r = guestfs_mkfs (g, fstype, device);
6928     if (r == -1)
6929       return -1;
6930   }
6931   {
6932     char device[] = "/dev/sda1";
6933     char mountpoint[] = "/";
6934     int r;
6935     suppress_error = 0;
6936     r = guestfs_mount (g, device, mountpoint);
6937     if (r == -1)
6938       return -1;
6939   }
6940   /* TestOutput for upload (0) */
6941   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6942   {
6943     char remotefilename[] = "/COPYING.LIB";
6944     int r;
6945     suppress_error = 0;
6946     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6947     if (r == -1)
6948       return -1;
6949   }
6950   {
6951     char csumtype[] = "md5";
6952     char path[] = "/COPYING.LIB";
6953     char *r;
6954     suppress_error = 0;
6955     r = guestfs_checksum (g, csumtype, path);
6956     if (r == NULL)
6957       return -1;
6958     if (strcmp (r, expected) != 0) {
6959       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6960       return -1;
6961     }
6962     free (r);
6963   }
6964   return 0;
6965 }
6966
6967 static int test_blockdev_rereadpt_0_skip (void)
6968 {
6969   const char *str;
6970
6971   str = getenv ("TEST_ONLY");
6972   if (str)
6973     return strstr (str, "blockdev_rereadpt") == NULL;
6974   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6975   if (str && strcmp (str, "1") == 0) return 1;
6976   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6977   if (str && strcmp (str, "1") == 0) return 1;
6978   return 0;
6979 }
6980
6981 static int test_blockdev_rereadpt_0 (void)
6982 {
6983   if (test_blockdev_rereadpt_0_skip ()) {
6984     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6985     return 0;
6986   }
6987
6988   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6989   {
6990     char device[] = "/dev/sda";
6991     int r;
6992     suppress_error = 0;
6993     r = guestfs_blockdev_setrw (g, device);
6994     if (r == -1)
6995       return -1;
6996   }
6997   {
6998     int r;
6999     suppress_error = 0;
7000     r = guestfs_umount_all (g);
7001     if (r == -1)
7002       return -1;
7003   }
7004   {
7005     int r;
7006     suppress_error = 0;
7007     r = guestfs_lvm_remove_all (g);
7008     if (r == -1)
7009       return -1;
7010   }
7011   /* TestRun for blockdev_rereadpt (0) */
7012   {
7013     char device[] = "/dev/sda";
7014     int r;
7015     suppress_error = 0;
7016     r = guestfs_blockdev_rereadpt (g, device);
7017     if (r == -1)
7018       return -1;
7019   }
7020   return 0;
7021 }
7022
7023 static int test_blockdev_flushbufs_0_skip (void)
7024 {
7025   const char *str;
7026
7027   str = getenv ("TEST_ONLY");
7028   if (str)
7029     return strstr (str, "blockdev_flushbufs") == NULL;
7030   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
7031   if (str && strcmp (str, "1") == 0) return 1;
7032   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
7033   if (str && strcmp (str, "1") == 0) return 1;
7034   return 0;
7035 }
7036
7037 static int test_blockdev_flushbufs_0 (void)
7038 {
7039   if (test_blockdev_flushbufs_0_skip ()) {
7040     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
7041     return 0;
7042   }
7043
7044   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
7045   {
7046     char device[] = "/dev/sda";
7047     int r;
7048     suppress_error = 0;
7049     r = guestfs_blockdev_setrw (g, device);
7050     if (r == -1)
7051       return -1;
7052   }
7053   {
7054     int r;
7055     suppress_error = 0;
7056     r = guestfs_umount_all (g);
7057     if (r == -1)
7058       return -1;
7059   }
7060   {
7061     int r;
7062     suppress_error = 0;
7063     r = guestfs_lvm_remove_all (g);
7064     if (r == -1)
7065       return -1;
7066   }
7067   /* TestRun for blockdev_flushbufs (0) */
7068   {
7069     char device[] = "/dev/sda";
7070     int r;
7071     suppress_error = 0;
7072     r = guestfs_blockdev_flushbufs (g, device);
7073     if (r == -1)
7074       return -1;
7075   }
7076   return 0;
7077 }
7078
7079 static int test_blockdev_getsize64_0_skip (void)
7080 {
7081   const char *str;
7082
7083   str = getenv ("TEST_ONLY");
7084   if (str)
7085     return strstr (str, "blockdev_getsize64") == NULL;
7086   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
7087   if (str && strcmp (str, "1") == 0) return 1;
7088   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
7089   if (str && strcmp (str, "1") == 0) return 1;
7090   return 0;
7091 }
7092
7093 static int test_blockdev_getsize64_0 (void)
7094 {
7095   if (test_blockdev_getsize64_0_skip ()) {
7096     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
7097     return 0;
7098   }
7099
7100   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
7101   {
7102     char device[] = "/dev/sda";
7103     int r;
7104     suppress_error = 0;
7105     r = guestfs_blockdev_setrw (g, device);
7106     if (r == -1)
7107       return -1;
7108   }
7109   {
7110     int r;
7111     suppress_error = 0;
7112     r = guestfs_umount_all (g);
7113     if (r == -1)
7114       return -1;
7115   }
7116   {
7117     int r;
7118     suppress_error = 0;
7119     r = guestfs_lvm_remove_all (g);
7120     if (r == -1)
7121       return -1;
7122   }
7123   /* TestOutputInt for blockdev_getsize64 (0) */
7124   {
7125     char device[] = "/dev/sda";
7126     int64_t r;
7127     suppress_error = 0;
7128     r = guestfs_blockdev_getsize64 (g, device);
7129     if (r == -1)
7130       return -1;
7131     if (r != 524288000) {
7132       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
7133       return -1;
7134     }
7135   }
7136   return 0;
7137 }
7138
7139 static int test_blockdev_getsz_0_skip (void)
7140 {
7141   const char *str;
7142
7143   str = getenv ("TEST_ONLY");
7144   if (str)
7145     return strstr (str, "blockdev_getsz") == NULL;
7146   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
7147   if (str && strcmp (str, "1") == 0) return 1;
7148   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
7149   if (str && strcmp (str, "1") == 0) return 1;
7150   return 0;
7151 }
7152
7153 static int test_blockdev_getsz_0 (void)
7154 {
7155   if (test_blockdev_getsz_0_skip ()) {
7156     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
7157     return 0;
7158   }
7159
7160   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
7161   {
7162     char device[] = "/dev/sda";
7163     int r;
7164     suppress_error = 0;
7165     r = guestfs_blockdev_setrw (g, device);
7166     if (r == -1)
7167       return -1;
7168   }
7169   {
7170     int r;
7171     suppress_error = 0;
7172     r = guestfs_umount_all (g);
7173     if (r == -1)
7174       return -1;
7175   }
7176   {
7177     int r;
7178     suppress_error = 0;
7179     r = guestfs_lvm_remove_all (g);
7180     if (r == -1)
7181       return -1;
7182   }
7183   /* TestOutputInt for blockdev_getsz (0) */
7184   {
7185     char device[] = "/dev/sda";
7186     int64_t r;
7187     suppress_error = 0;
7188     r = guestfs_blockdev_getsz (g, device);
7189     if (r == -1)
7190       return -1;
7191     if (r != 1024000) {
7192       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
7193       return -1;
7194     }
7195   }
7196   return 0;
7197 }
7198
7199 static int test_blockdev_getbsz_0_skip (void)
7200 {
7201   const char *str;
7202
7203   str = getenv ("TEST_ONLY");
7204   if (str)
7205     return strstr (str, "blockdev_getbsz") == NULL;
7206   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
7207   if (str && strcmp (str, "1") == 0) return 1;
7208   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
7209   if (str && strcmp (str, "1") == 0) return 1;
7210   return 0;
7211 }
7212
7213 static int test_blockdev_getbsz_0 (void)
7214 {
7215   if (test_blockdev_getbsz_0_skip ()) {
7216     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
7217     return 0;
7218   }
7219
7220   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
7221   {
7222     char device[] = "/dev/sda";
7223     int r;
7224     suppress_error = 0;
7225     r = guestfs_blockdev_setrw (g, device);
7226     if (r == -1)
7227       return -1;
7228   }
7229   {
7230     int r;
7231     suppress_error = 0;
7232     r = guestfs_umount_all (g);
7233     if (r == -1)
7234       return -1;
7235   }
7236   {
7237     int r;
7238     suppress_error = 0;
7239     r = guestfs_lvm_remove_all (g);
7240     if (r == -1)
7241       return -1;
7242   }
7243   /* TestOutputInt for blockdev_getbsz (0) */
7244   {
7245     char device[] = "/dev/sda";
7246     int r;
7247     suppress_error = 0;
7248     r = guestfs_blockdev_getbsz (g, device);
7249     if (r == -1)
7250       return -1;
7251     if (r != 4096) {
7252       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
7253       return -1;
7254     }
7255   }
7256   return 0;
7257 }
7258
7259 static int test_blockdev_getss_0_skip (void)
7260 {
7261   const char *str;
7262
7263   str = getenv ("TEST_ONLY");
7264   if (str)
7265     return strstr (str, "blockdev_getss") == NULL;
7266   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
7267   if (str && strcmp (str, "1") == 0) return 1;
7268   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
7269   if (str && strcmp (str, "1") == 0) return 1;
7270   return 0;
7271 }
7272
7273 static int test_blockdev_getss_0 (void)
7274 {
7275   if (test_blockdev_getss_0_skip ()) {
7276     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
7277     return 0;
7278   }
7279
7280   /* InitNone|InitEmpty for test_blockdev_getss_0 */
7281   {
7282     char device[] = "/dev/sda";
7283     int r;
7284     suppress_error = 0;
7285     r = guestfs_blockdev_setrw (g, device);
7286     if (r == -1)
7287       return -1;
7288   }
7289   {
7290     int r;
7291     suppress_error = 0;
7292     r = guestfs_umount_all (g);
7293     if (r == -1)
7294       return -1;
7295   }
7296   {
7297     int r;
7298     suppress_error = 0;
7299     r = guestfs_lvm_remove_all (g);
7300     if (r == -1)
7301       return -1;
7302   }
7303   /* TestOutputInt for blockdev_getss (0) */
7304   {
7305     char device[] = "/dev/sda";
7306     int r;
7307     suppress_error = 0;
7308     r = guestfs_blockdev_getss (g, device);
7309     if (r == -1)
7310       return -1;
7311     if (r != 512) {
7312       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
7313       return -1;
7314     }
7315   }
7316   return 0;
7317 }
7318
7319 static int test_blockdev_getro_0_skip (void)
7320 {
7321   const char *str;
7322
7323   str = getenv ("TEST_ONLY");
7324   if (str)
7325     return strstr (str, "blockdev_getro") == NULL;
7326   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
7327   if (str && strcmp (str, "1") == 0) return 1;
7328   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
7329   if (str && strcmp (str, "1") == 0) return 1;
7330   return 0;
7331 }
7332
7333 static int test_blockdev_getro_0 (void)
7334 {
7335   if (test_blockdev_getro_0_skip ()) {
7336     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
7337     return 0;
7338   }
7339
7340   /* InitNone|InitEmpty for test_blockdev_getro_0 */
7341   {
7342     char device[] = "/dev/sda";
7343     int r;
7344     suppress_error = 0;
7345     r = guestfs_blockdev_setrw (g, device);
7346     if (r == -1)
7347       return -1;
7348   }
7349   {
7350     int r;
7351     suppress_error = 0;
7352     r = guestfs_umount_all (g);
7353     if (r == -1)
7354       return -1;
7355   }
7356   {
7357     int r;
7358     suppress_error = 0;
7359     r = guestfs_lvm_remove_all (g);
7360     if (r == -1)
7361       return -1;
7362   }
7363   /* TestOutputTrue for blockdev_getro (0) */
7364   {
7365     char device[] = "/dev/sda";
7366     int r;
7367     suppress_error = 0;
7368     r = guestfs_blockdev_setro (g, device);
7369     if (r == -1)
7370       return -1;
7371   }
7372   {
7373     char device[] = "/dev/sda";
7374     int r;
7375     suppress_error = 0;
7376     r = guestfs_blockdev_getro (g, device);
7377     if (r == -1)
7378       return -1;
7379     if (!r) {
7380       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
7381       return -1;
7382     }
7383   }
7384   return 0;
7385 }
7386
7387 static int test_blockdev_setrw_0_skip (void)
7388 {
7389   const char *str;
7390
7391   str = getenv ("TEST_ONLY");
7392   if (str)
7393     return strstr (str, "blockdev_setrw") == NULL;
7394   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
7395   if (str && strcmp (str, "1") == 0) return 1;
7396   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
7397   if (str && strcmp (str, "1") == 0) return 1;
7398   return 0;
7399 }
7400
7401 static int test_blockdev_setrw_0 (void)
7402 {
7403   if (test_blockdev_setrw_0_skip ()) {
7404     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
7405     return 0;
7406   }
7407
7408   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
7409   {
7410     char device[] = "/dev/sda";
7411     int r;
7412     suppress_error = 0;
7413     r = guestfs_blockdev_setrw (g, device);
7414     if (r == -1)
7415       return -1;
7416   }
7417   {
7418     int r;
7419     suppress_error = 0;
7420     r = guestfs_umount_all (g);
7421     if (r == -1)
7422       return -1;
7423   }
7424   {
7425     int r;
7426     suppress_error = 0;
7427     r = guestfs_lvm_remove_all (g);
7428     if (r == -1)
7429       return -1;
7430   }
7431   /* TestOutputFalse for blockdev_setrw (0) */
7432   {
7433     char device[] = "/dev/sda";
7434     int r;
7435     suppress_error = 0;
7436     r = guestfs_blockdev_setrw (g, device);
7437     if (r == -1)
7438       return -1;
7439   }
7440   {
7441     char device[] = "/dev/sda";
7442     int r;
7443     suppress_error = 0;
7444     r = guestfs_blockdev_getro (g, device);
7445     if (r == -1)
7446       return -1;
7447     if (r) {
7448       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
7449       return -1;
7450     }
7451   }
7452   return 0;
7453 }
7454
7455 static int test_blockdev_setro_0_skip (void)
7456 {
7457   const char *str;
7458
7459   str = getenv ("TEST_ONLY");
7460   if (str)
7461     return strstr (str, "blockdev_setro") == NULL;
7462   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
7463   if (str && strcmp (str, "1") == 0) return 1;
7464   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
7465   if (str && strcmp (str, "1") == 0) return 1;
7466   return 0;
7467 }
7468
7469 static int test_blockdev_setro_0 (void)
7470 {
7471   if (test_blockdev_setro_0_skip ()) {
7472     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
7473     return 0;
7474   }
7475
7476   /* InitNone|InitEmpty for test_blockdev_setro_0 */
7477   {
7478     char device[] = "/dev/sda";
7479     int r;
7480     suppress_error = 0;
7481     r = guestfs_blockdev_setrw (g, device);
7482     if (r == -1)
7483       return -1;
7484   }
7485   {
7486     int r;
7487     suppress_error = 0;
7488     r = guestfs_umount_all (g);
7489     if (r == -1)
7490       return -1;
7491   }
7492   {
7493     int r;
7494     suppress_error = 0;
7495     r = guestfs_lvm_remove_all (g);
7496     if (r == -1)
7497       return -1;
7498   }
7499   /* TestOutputTrue for blockdev_setro (0) */
7500   {
7501     char device[] = "/dev/sda";
7502     int r;
7503     suppress_error = 0;
7504     r = guestfs_blockdev_setro (g, device);
7505     if (r == -1)
7506       return -1;
7507   }
7508   {
7509     char device[] = "/dev/sda";
7510     int r;
7511     suppress_error = 0;
7512     r = guestfs_blockdev_getro (g, device);
7513     if (r == -1)
7514       return -1;
7515     if (!r) {
7516       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
7517       return -1;
7518     }
7519   }
7520   return 0;
7521 }
7522
7523 static int test_statvfs_0_skip (void)
7524 {
7525   const char *str;
7526
7527   str = getenv ("TEST_ONLY");
7528   if (str)
7529     return strstr (str, "statvfs") == NULL;
7530   str = getenv ("SKIP_TEST_STATVFS_0");
7531   if (str && strcmp (str, "1") == 0) return 1;
7532   str = getenv ("SKIP_TEST_STATVFS");
7533   if (str && strcmp (str, "1") == 0) return 1;
7534   return 0;
7535 }
7536
7537 static int test_statvfs_0 (void)
7538 {
7539   if (test_statvfs_0_skip ()) {
7540     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
7541     return 0;
7542   }
7543
7544   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
7545   {
7546     char device[] = "/dev/sda";
7547     int r;
7548     suppress_error = 0;
7549     r = guestfs_blockdev_setrw (g, device);
7550     if (r == -1)
7551       return -1;
7552   }
7553   {
7554     int r;
7555     suppress_error = 0;
7556     r = guestfs_umount_all (g);
7557     if (r == -1)
7558       return -1;
7559   }
7560   {
7561     int r;
7562     suppress_error = 0;
7563     r = guestfs_lvm_remove_all (g);
7564     if (r == -1)
7565       return -1;
7566   }
7567   {
7568     char device[] = "/dev/sda";
7569     char lines_0[] = ",";
7570     char *lines[] = {
7571       lines_0,
7572       NULL
7573     };
7574     int r;
7575     suppress_error = 0;
7576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7577     if (r == -1)
7578       return -1;
7579   }
7580   {
7581     char fstype[] = "ext2";
7582     char device[] = "/dev/sda1";
7583     int r;
7584     suppress_error = 0;
7585     r = guestfs_mkfs (g, fstype, device);
7586     if (r == -1)
7587       return -1;
7588   }
7589   {
7590     char device[] = "/dev/sda1";
7591     char mountpoint[] = "/";
7592     int r;
7593     suppress_error = 0;
7594     r = guestfs_mount (g, device, mountpoint);
7595     if (r == -1)
7596       return -1;
7597   }
7598   /* TestOutputStruct for statvfs (0) */
7599   {
7600     char path[] = "/";
7601     struct guestfs_statvfs *r;
7602     suppress_error = 0;
7603     r = guestfs_statvfs (g, path);
7604     if (r == NULL)
7605       return -1;
7606     if (r->bfree != 487702) {
7607       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7608                (int) r->bfree);
7609       return -1;
7610     }
7611     if (r->blocks != 490020) {
7612       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7613                (int) r->blocks);
7614       return -1;
7615     }
7616     if (r->bsize != 1024) {
7617       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7618                (int) r->bsize);
7619       return -1;
7620     }
7621     free (r);
7622   }
7623   return 0;
7624 }
7625
7626 static int test_lstat_0_skip (void)
7627 {
7628   const char *str;
7629
7630   str = getenv ("TEST_ONLY");
7631   if (str)
7632     return strstr (str, "lstat") == NULL;
7633   str = getenv ("SKIP_TEST_LSTAT_0");
7634   if (str && strcmp (str, "1") == 0) return 1;
7635   str = getenv ("SKIP_TEST_LSTAT");
7636   if (str && strcmp (str, "1") == 0) return 1;
7637   return 0;
7638 }
7639
7640 static int test_lstat_0 (void)
7641 {
7642   if (test_lstat_0_skip ()) {
7643     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
7644     return 0;
7645   }
7646
7647   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7648   {
7649     char device[] = "/dev/sda";
7650     int r;
7651     suppress_error = 0;
7652     r = guestfs_blockdev_setrw (g, device);
7653     if (r == -1)
7654       return -1;
7655   }
7656   {
7657     int r;
7658     suppress_error = 0;
7659     r = guestfs_umount_all (g);
7660     if (r == -1)
7661       return -1;
7662   }
7663   {
7664     int r;
7665     suppress_error = 0;
7666     r = guestfs_lvm_remove_all (g);
7667     if (r == -1)
7668       return -1;
7669   }
7670   {
7671     char device[] = "/dev/sda";
7672     char lines_0[] = ",";
7673     char *lines[] = {
7674       lines_0,
7675       NULL
7676     };
7677     int r;
7678     suppress_error = 0;
7679     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7680     if (r == -1)
7681       return -1;
7682   }
7683   {
7684     char fstype[] = "ext2";
7685     char device[] = "/dev/sda1";
7686     int r;
7687     suppress_error = 0;
7688     r = guestfs_mkfs (g, fstype, device);
7689     if (r == -1)
7690       return -1;
7691   }
7692   {
7693     char device[] = "/dev/sda1";
7694     char mountpoint[] = "/";
7695     int r;
7696     suppress_error = 0;
7697     r = guestfs_mount (g, device, mountpoint);
7698     if (r == -1)
7699       return -1;
7700   }
7701   /* TestOutputStruct for lstat (0) */
7702   {
7703     char path[] = "/new";
7704     int r;
7705     suppress_error = 0;
7706     r = guestfs_touch (g, path);
7707     if (r == -1)
7708       return -1;
7709   }
7710   {
7711     char path[] = "/new";
7712     struct guestfs_stat *r;
7713     suppress_error = 0;
7714     r = guestfs_lstat (g, path);
7715     if (r == NULL)
7716       return -1;
7717     if (r->size != 0) {
7718       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7719                (int) r->size);
7720       return -1;
7721     }
7722     free (r);
7723   }
7724   return 0;
7725 }
7726
7727 static int test_stat_0_skip (void)
7728 {
7729   const char *str;
7730
7731   str = getenv ("TEST_ONLY");
7732   if (str)
7733     return strstr (str, "stat") == NULL;
7734   str = getenv ("SKIP_TEST_STAT_0");
7735   if (str && strcmp (str, "1") == 0) return 1;
7736   str = getenv ("SKIP_TEST_STAT");
7737   if (str && strcmp (str, "1") == 0) return 1;
7738   return 0;
7739 }
7740
7741 static int test_stat_0 (void)
7742 {
7743   if (test_stat_0_skip ()) {
7744     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7745     return 0;
7746   }
7747
7748   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7749   {
7750     char device[] = "/dev/sda";
7751     int r;
7752     suppress_error = 0;
7753     r = guestfs_blockdev_setrw (g, device);
7754     if (r == -1)
7755       return -1;
7756   }
7757   {
7758     int r;
7759     suppress_error = 0;
7760     r = guestfs_umount_all (g);
7761     if (r == -1)
7762       return -1;
7763   }
7764   {
7765     int r;
7766     suppress_error = 0;
7767     r = guestfs_lvm_remove_all (g);
7768     if (r == -1)
7769       return -1;
7770   }
7771   {
7772     char device[] = "/dev/sda";
7773     char lines_0[] = ",";
7774     char *lines[] = {
7775       lines_0,
7776       NULL
7777     };
7778     int r;
7779     suppress_error = 0;
7780     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7781     if (r == -1)
7782       return -1;
7783   }
7784   {
7785     char fstype[] = "ext2";
7786     char device[] = "/dev/sda1";
7787     int r;
7788     suppress_error = 0;
7789     r = guestfs_mkfs (g, fstype, device);
7790     if (r == -1)
7791       return -1;
7792   }
7793   {
7794     char device[] = "/dev/sda1";
7795     char mountpoint[] = "/";
7796     int r;
7797     suppress_error = 0;
7798     r = guestfs_mount (g, device, mountpoint);
7799     if (r == -1)
7800       return -1;
7801   }
7802   /* TestOutputStruct for stat (0) */
7803   {
7804     char path[] = "/new";
7805     int r;
7806     suppress_error = 0;
7807     r = guestfs_touch (g, path);
7808     if (r == -1)
7809       return -1;
7810   }
7811   {
7812     char path[] = "/new";
7813     struct guestfs_stat *r;
7814     suppress_error = 0;
7815     r = guestfs_stat (g, path);
7816     if (r == NULL)
7817       return -1;
7818     if (r->size != 0) {
7819       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7820                (int) r->size);
7821       return -1;
7822     }
7823     free (r);
7824   }
7825   return 0;
7826 }
7827
7828 static int test_command_lines_0_skip (void)
7829 {
7830   const char *str;
7831
7832   str = getenv ("TEST_ONLY");
7833   if (str)
7834     return strstr (str, "command_lines") == NULL;
7835   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7836   if (str && strcmp (str, "1") == 0) return 1;
7837   str = getenv ("SKIP_TEST_COMMAND_LINES");
7838   if (str && strcmp (str, "1") == 0) return 1;
7839   return 0;
7840 }
7841
7842 static int test_command_lines_0 (void)
7843 {
7844   if (test_command_lines_0_skip ()) {
7845     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7846     return 0;
7847   }
7848
7849   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7850   {
7851     char device[] = "/dev/sda";
7852     int r;
7853     suppress_error = 0;
7854     r = guestfs_blockdev_setrw (g, device);
7855     if (r == -1)
7856       return -1;
7857   }
7858   {
7859     int r;
7860     suppress_error = 0;
7861     r = guestfs_umount_all (g);
7862     if (r == -1)
7863       return -1;
7864   }
7865   {
7866     int r;
7867     suppress_error = 0;
7868     r = guestfs_lvm_remove_all (g);
7869     if (r == -1)
7870       return -1;
7871   }
7872   {
7873     char device[] = "/dev/sda";
7874     char lines_0[] = ",";
7875     char *lines[] = {
7876       lines_0,
7877       NULL
7878     };
7879     int r;
7880     suppress_error = 0;
7881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7882     if (r == -1)
7883       return -1;
7884   }
7885   {
7886     char fstype[] = "ext2";
7887     char device[] = "/dev/sda1";
7888     int r;
7889     suppress_error = 0;
7890     r = guestfs_mkfs (g, fstype, device);
7891     if (r == -1)
7892       return -1;
7893   }
7894   {
7895     char device[] = "/dev/sda1";
7896     char mountpoint[] = "/";
7897     int r;
7898     suppress_error = 0;
7899     r = guestfs_mount (g, device, mountpoint);
7900     if (r == -1)
7901       return -1;
7902   }
7903   /* TestOutputList for command_lines (0) */
7904   {
7905     char remotefilename[] = "/test-command";
7906     int r;
7907     suppress_error = 0;
7908     r = guestfs_upload (g, "test-command", remotefilename);
7909     if (r == -1)
7910       return -1;
7911   }
7912   {
7913     char path[] = "/test-command";
7914     int r;
7915     suppress_error = 0;
7916     r = guestfs_chmod (g, 493, path);
7917     if (r == -1)
7918       return -1;
7919   }
7920   {
7921     char arguments_0[] = "/test-command";
7922     char arguments_1[] = "1";
7923     char *arguments[] = {
7924       arguments_0,
7925       arguments_1,
7926       NULL
7927     };
7928     char **r;
7929     int i;
7930     suppress_error = 0;
7931     r = guestfs_command_lines (g, arguments);
7932     if (r == NULL)
7933       return -1;
7934     if (!r[0]) {
7935       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7936       print_strings (r);
7937       return -1;
7938     }
7939     {
7940       char expected[] = "Result1";
7941       if (strcmp (r[0], expected) != 0) {
7942         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7943         return -1;
7944       }
7945     }
7946     if (r[1] != NULL) {
7947       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7948       print_strings (r);
7949       return -1;
7950     }
7951     for (i = 0; r[i] != NULL; ++i)
7952       free (r[i]);
7953     free (r);
7954   }
7955   return 0;
7956 }
7957
7958 static int test_command_lines_1_skip (void)
7959 {
7960   const char *str;
7961
7962   str = getenv ("TEST_ONLY");
7963   if (str)
7964     return strstr (str, "command_lines") == NULL;
7965   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7966   if (str && strcmp (str, "1") == 0) return 1;
7967   str = getenv ("SKIP_TEST_COMMAND_LINES");
7968   if (str && strcmp (str, "1") == 0) return 1;
7969   return 0;
7970 }
7971
7972 static int test_command_lines_1 (void)
7973 {
7974   if (test_command_lines_1_skip ()) {
7975     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7976     return 0;
7977   }
7978
7979   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7980   {
7981     char device[] = "/dev/sda";
7982     int r;
7983     suppress_error = 0;
7984     r = guestfs_blockdev_setrw (g, device);
7985     if (r == -1)
7986       return -1;
7987   }
7988   {
7989     int r;
7990     suppress_error = 0;
7991     r = guestfs_umount_all (g);
7992     if (r == -1)
7993       return -1;
7994   }
7995   {
7996     int r;
7997     suppress_error = 0;
7998     r = guestfs_lvm_remove_all (g);
7999     if (r == -1)
8000       return -1;
8001   }
8002   {
8003     char device[] = "/dev/sda";
8004     char lines_0[] = ",";
8005     char *lines[] = {
8006       lines_0,
8007       NULL
8008     };
8009     int r;
8010     suppress_error = 0;
8011     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8012     if (r == -1)
8013       return -1;
8014   }
8015   {
8016     char fstype[] = "ext2";
8017     char device[] = "/dev/sda1";
8018     int r;
8019     suppress_error = 0;
8020     r = guestfs_mkfs (g, fstype, device);
8021     if (r == -1)
8022       return -1;
8023   }
8024   {
8025     char device[] = "/dev/sda1";
8026     char mountpoint[] = "/";
8027     int r;
8028     suppress_error = 0;
8029     r = guestfs_mount (g, device, mountpoint);
8030     if (r == -1)
8031       return -1;
8032   }
8033   /* TestOutputList for command_lines (1) */
8034   {
8035     char remotefilename[] = "/test-command";
8036     int r;
8037     suppress_error = 0;
8038     r = guestfs_upload (g, "test-command", remotefilename);
8039     if (r == -1)
8040       return -1;
8041   }
8042   {
8043     char path[] = "/test-command";
8044     int r;
8045     suppress_error = 0;
8046     r = guestfs_chmod (g, 493, path);
8047     if (r == -1)
8048       return -1;
8049   }
8050   {
8051     char arguments_0[] = "/test-command";
8052     char arguments_1[] = "2";
8053     char *arguments[] = {
8054       arguments_0,
8055       arguments_1,
8056       NULL
8057     };
8058     char **r;
8059     int i;
8060     suppress_error = 0;
8061     r = guestfs_command_lines (g, arguments);
8062     if (r == NULL)
8063       return -1;
8064     if (!r[0]) {
8065       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
8066       print_strings (r);
8067       return -1;
8068     }
8069     {
8070       char expected[] = "Result2";
8071       if (strcmp (r[0], expected) != 0) {
8072         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8073         return -1;
8074       }
8075     }
8076     if (r[1] != NULL) {
8077       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
8078       print_strings (r);
8079       return -1;
8080     }
8081     for (i = 0; r[i] != NULL; ++i)
8082       free (r[i]);
8083     free (r);
8084   }
8085   return 0;
8086 }
8087
8088 static int test_command_lines_2_skip (void)
8089 {
8090   const char *str;
8091
8092   str = getenv ("TEST_ONLY");
8093   if (str)
8094     return strstr (str, "command_lines") == NULL;
8095   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
8096   if (str && strcmp (str, "1") == 0) return 1;
8097   str = getenv ("SKIP_TEST_COMMAND_LINES");
8098   if (str && strcmp (str, "1") == 0) return 1;
8099   return 0;
8100 }
8101
8102 static int test_command_lines_2 (void)
8103 {
8104   if (test_command_lines_2_skip ()) {
8105     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
8106     return 0;
8107   }
8108
8109   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
8110   {
8111     char device[] = "/dev/sda";
8112     int r;
8113     suppress_error = 0;
8114     r = guestfs_blockdev_setrw (g, device);
8115     if (r == -1)
8116       return -1;
8117   }
8118   {
8119     int r;
8120     suppress_error = 0;
8121     r = guestfs_umount_all (g);
8122     if (r == -1)
8123       return -1;
8124   }
8125   {
8126     int r;
8127     suppress_error = 0;
8128     r = guestfs_lvm_remove_all (g);
8129     if (r == -1)
8130       return -1;
8131   }
8132   {
8133     char device[] = "/dev/sda";
8134     char lines_0[] = ",";
8135     char *lines[] = {
8136       lines_0,
8137       NULL
8138     };
8139     int r;
8140     suppress_error = 0;
8141     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8142     if (r == -1)
8143       return -1;
8144   }
8145   {
8146     char fstype[] = "ext2";
8147     char device[] = "/dev/sda1";
8148     int r;
8149     suppress_error = 0;
8150     r = guestfs_mkfs (g, fstype, device);
8151     if (r == -1)
8152       return -1;
8153   }
8154   {
8155     char device[] = "/dev/sda1";
8156     char mountpoint[] = "/";
8157     int r;
8158     suppress_error = 0;
8159     r = guestfs_mount (g, device, mountpoint);
8160     if (r == -1)
8161       return -1;
8162   }
8163   /* TestOutputList for command_lines (2) */
8164   {
8165     char remotefilename[] = "/test-command";
8166     int r;
8167     suppress_error = 0;
8168     r = guestfs_upload (g, "test-command", remotefilename);
8169     if (r == -1)
8170       return -1;
8171   }
8172   {
8173     char path[] = "/test-command";
8174     int r;
8175     suppress_error = 0;
8176     r = guestfs_chmod (g, 493, path);
8177     if (r == -1)
8178       return -1;
8179   }
8180   {
8181     char arguments_0[] = "/test-command";
8182     char arguments_1[] = "3";
8183     char *arguments[] = {
8184       arguments_0,
8185       arguments_1,
8186       NULL
8187     };
8188     char **r;
8189     int i;
8190     suppress_error = 0;
8191     r = guestfs_command_lines (g, arguments);
8192     if (r == NULL)
8193       return -1;
8194     if (!r[0]) {
8195       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
8196       print_strings (r);
8197       return -1;
8198     }
8199     {
8200       char expected[] = "";
8201       if (strcmp (r[0], expected) != 0) {
8202         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8203         return -1;
8204       }
8205     }
8206     if (!r[1]) {
8207       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
8208       print_strings (r);
8209       return -1;
8210     }
8211     {
8212       char expected[] = "Result3";
8213       if (strcmp (r[1], expected) != 0) {
8214         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8215         return -1;
8216       }
8217     }
8218     if (r[2] != NULL) {
8219       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
8220       print_strings (r);
8221       return -1;
8222     }
8223     for (i = 0; r[i] != NULL; ++i)
8224       free (r[i]);
8225     free (r);
8226   }
8227   return 0;
8228 }
8229
8230 static int test_command_lines_3_skip (void)
8231 {
8232   const char *str;
8233
8234   str = getenv ("TEST_ONLY");
8235   if (str)
8236     return strstr (str, "command_lines") == NULL;
8237   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
8238   if (str && strcmp (str, "1") == 0) return 1;
8239   str = getenv ("SKIP_TEST_COMMAND_LINES");
8240   if (str && strcmp (str, "1") == 0) return 1;
8241   return 0;
8242 }
8243
8244 static int test_command_lines_3 (void)
8245 {
8246   if (test_command_lines_3_skip ()) {
8247     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
8248     return 0;
8249   }
8250
8251   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
8252   {
8253     char device[] = "/dev/sda";
8254     int r;
8255     suppress_error = 0;
8256     r = guestfs_blockdev_setrw (g, device);
8257     if (r == -1)
8258       return -1;
8259   }
8260   {
8261     int r;
8262     suppress_error = 0;
8263     r = guestfs_umount_all (g);
8264     if (r == -1)
8265       return -1;
8266   }
8267   {
8268     int r;
8269     suppress_error = 0;
8270     r = guestfs_lvm_remove_all (g);
8271     if (r == -1)
8272       return -1;
8273   }
8274   {
8275     char device[] = "/dev/sda";
8276     char lines_0[] = ",";
8277     char *lines[] = {
8278       lines_0,
8279       NULL
8280     };
8281     int r;
8282     suppress_error = 0;
8283     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8284     if (r == -1)
8285       return -1;
8286   }
8287   {
8288     char fstype[] = "ext2";
8289     char device[] = "/dev/sda1";
8290     int r;
8291     suppress_error = 0;
8292     r = guestfs_mkfs (g, fstype, device);
8293     if (r == -1)
8294       return -1;
8295   }
8296   {
8297     char device[] = "/dev/sda1";
8298     char mountpoint[] = "/";
8299     int r;
8300     suppress_error = 0;
8301     r = guestfs_mount (g, device, mountpoint);
8302     if (r == -1)
8303       return -1;
8304   }
8305   /* TestOutputList for command_lines (3) */
8306   {
8307     char remotefilename[] = "/test-command";
8308     int r;
8309     suppress_error = 0;
8310     r = guestfs_upload (g, "test-command", remotefilename);
8311     if (r == -1)
8312       return -1;
8313   }
8314   {
8315     char path[] = "/test-command";
8316     int r;
8317     suppress_error = 0;
8318     r = guestfs_chmod (g, 493, path);
8319     if (r == -1)
8320       return -1;
8321   }
8322   {
8323     char arguments_0[] = "/test-command";
8324     char arguments_1[] = "4";
8325     char *arguments[] = {
8326       arguments_0,
8327       arguments_1,
8328       NULL
8329     };
8330     char **r;
8331     int i;
8332     suppress_error = 0;
8333     r = guestfs_command_lines (g, arguments);
8334     if (r == NULL)
8335       return -1;
8336     if (!r[0]) {
8337       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8338       print_strings (r);
8339       return -1;
8340     }
8341     {
8342       char expected[] = "";
8343       if (strcmp (r[0], expected) != 0) {
8344         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8345         return -1;
8346       }
8347     }
8348     if (!r[1]) {
8349       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8350       print_strings (r);
8351       return -1;
8352     }
8353     {
8354       char expected[] = "Result4";
8355       if (strcmp (r[1], expected) != 0) {
8356         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8357         return -1;
8358       }
8359     }
8360     if (r[2] != NULL) {
8361       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
8362       print_strings (r);
8363       return -1;
8364     }
8365     for (i = 0; r[i] != NULL; ++i)
8366       free (r[i]);
8367     free (r);
8368   }
8369   return 0;
8370 }
8371
8372 static int test_command_lines_4_skip (void)
8373 {
8374   const char *str;
8375
8376   str = getenv ("TEST_ONLY");
8377   if (str)
8378     return strstr (str, "command_lines") == NULL;
8379   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
8380   if (str && strcmp (str, "1") == 0) return 1;
8381   str = getenv ("SKIP_TEST_COMMAND_LINES");
8382   if (str && strcmp (str, "1") == 0) return 1;
8383   return 0;
8384 }
8385
8386 static int test_command_lines_4 (void)
8387 {
8388   if (test_command_lines_4_skip ()) {
8389     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
8390     return 0;
8391   }
8392
8393   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
8394   {
8395     char device[] = "/dev/sda";
8396     int r;
8397     suppress_error = 0;
8398     r = guestfs_blockdev_setrw (g, device);
8399     if (r == -1)
8400       return -1;
8401   }
8402   {
8403     int r;
8404     suppress_error = 0;
8405     r = guestfs_umount_all (g);
8406     if (r == -1)
8407       return -1;
8408   }
8409   {
8410     int r;
8411     suppress_error = 0;
8412     r = guestfs_lvm_remove_all (g);
8413     if (r == -1)
8414       return -1;
8415   }
8416   {
8417     char device[] = "/dev/sda";
8418     char lines_0[] = ",";
8419     char *lines[] = {
8420       lines_0,
8421       NULL
8422     };
8423     int r;
8424     suppress_error = 0;
8425     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8426     if (r == -1)
8427       return -1;
8428   }
8429   {
8430     char fstype[] = "ext2";
8431     char device[] = "/dev/sda1";
8432     int r;
8433     suppress_error = 0;
8434     r = guestfs_mkfs (g, fstype, device);
8435     if (r == -1)
8436       return -1;
8437   }
8438   {
8439     char device[] = "/dev/sda1";
8440     char mountpoint[] = "/";
8441     int r;
8442     suppress_error = 0;
8443     r = guestfs_mount (g, device, mountpoint);
8444     if (r == -1)
8445       return -1;
8446   }
8447   /* TestOutputList for command_lines (4) */
8448   {
8449     char remotefilename[] = "/test-command";
8450     int r;
8451     suppress_error = 0;
8452     r = guestfs_upload (g, "test-command", remotefilename);
8453     if (r == -1)
8454       return -1;
8455   }
8456   {
8457     char path[] = "/test-command";
8458     int r;
8459     suppress_error = 0;
8460     r = guestfs_chmod (g, 493, path);
8461     if (r == -1)
8462       return -1;
8463   }
8464   {
8465     char arguments_0[] = "/test-command";
8466     char arguments_1[] = "5";
8467     char *arguments[] = {
8468       arguments_0,
8469       arguments_1,
8470       NULL
8471     };
8472     char **r;
8473     int i;
8474     suppress_error = 0;
8475     r = guestfs_command_lines (g, arguments);
8476     if (r == NULL)
8477       return -1;
8478     if (!r[0]) {
8479       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8480       print_strings (r);
8481       return -1;
8482     }
8483     {
8484       char expected[] = "";
8485       if (strcmp (r[0], expected) != 0) {
8486         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8487         return -1;
8488       }
8489     }
8490     if (!r[1]) {
8491       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8492       print_strings (r);
8493       return -1;
8494     }
8495     {
8496       char expected[] = "Result5";
8497       if (strcmp (r[1], expected) != 0) {
8498         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8499         return -1;
8500       }
8501     }
8502     if (!r[2]) {
8503       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8504       print_strings (r);
8505       return -1;
8506     }
8507     {
8508       char expected[] = "";
8509       if (strcmp (r[2], expected) != 0) {
8510         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8511         return -1;
8512       }
8513     }
8514     if (r[3] != NULL) {
8515       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
8516       print_strings (r);
8517       return -1;
8518     }
8519     for (i = 0; r[i] != NULL; ++i)
8520       free (r[i]);
8521     free (r);
8522   }
8523   return 0;
8524 }
8525
8526 static int test_command_lines_5_skip (void)
8527 {
8528   const char *str;
8529
8530   str = getenv ("TEST_ONLY");
8531   if (str)
8532     return strstr (str, "command_lines") == NULL;
8533   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
8534   if (str && strcmp (str, "1") == 0) return 1;
8535   str = getenv ("SKIP_TEST_COMMAND_LINES");
8536   if (str && strcmp (str, "1") == 0) return 1;
8537   return 0;
8538 }
8539
8540 static int test_command_lines_5 (void)
8541 {
8542   if (test_command_lines_5_skip ()) {
8543     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
8544     return 0;
8545   }
8546
8547   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
8548   {
8549     char device[] = "/dev/sda";
8550     int r;
8551     suppress_error = 0;
8552     r = guestfs_blockdev_setrw (g, device);
8553     if (r == -1)
8554       return -1;
8555   }
8556   {
8557     int r;
8558     suppress_error = 0;
8559     r = guestfs_umount_all (g);
8560     if (r == -1)
8561       return -1;
8562   }
8563   {
8564     int r;
8565     suppress_error = 0;
8566     r = guestfs_lvm_remove_all (g);
8567     if (r == -1)
8568       return -1;
8569   }
8570   {
8571     char device[] = "/dev/sda";
8572     char lines_0[] = ",";
8573     char *lines[] = {
8574       lines_0,
8575       NULL
8576     };
8577     int r;
8578     suppress_error = 0;
8579     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8580     if (r == -1)
8581       return -1;
8582   }
8583   {
8584     char fstype[] = "ext2";
8585     char device[] = "/dev/sda1";
8586     int r;
8587     suppress_error = 0;
8588     r = guestfs_mkfs (g, fstype, device);
8589     if (r == -1)
8590       return -1;
8591   }
8592   {
8593     char device[] = "/dev/sda1";
8594     char mountpoint[] = "/";
8595     int r;
8596     suppress_error = 0;
8597     r = guestfs_mount (g, device, mountpoint);
8598     if (r == -1)
8599       return -1;
8600   }
8601   /* TestOutputList for command_lines (5) */
8602   {
8603     char remotefilename[] = "/test-command";
8604     int r;
8605     suppress_error = 0;
8606     r = guestfs_upload (g, "test-command", remotefilename);
8607     if (r == -1)
8608       return -1;
8609   }
8610   {
8611     char path[] = "/test-command";
8612     int r;
8613     suppress_error = 0;
8614     r = guestfs_chmod (g, 493, path);
8615     if (r == -1)
8616       return -1;
8617   }
8618   {
8619     char arguments_0[] = "/test-command";
8620     char arguments_1[] = "6";
8621     char *arguments[] = {
8622       arguments_0,
8623       arguments_1,
8624       NULL
8625     };
8626     char **r;
8627     int i;
8628     suppress_error = 0;
8629     r = guestfs_command_lines (g, arguments);
8630     if (r == NULL)
8631       return -1;
8632     if (!r[0]) {
8633       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8634       print_strings (r);
8635       return -1;
8636     }
8637     {
8638       char expected[] = "";
8639       if (strcmp (r[0], expected) != 0) {
8640         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8641         return -1;
8642       }
8643     }
8644     if (!r[1]) {
8645       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8646       print_strings (r);
8647       return -1;
8648     }
8649     {
8650       char expected[] = "";
8651       if (strcmp (r[1], expected) != 0) {
8652         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8653         return -1;
8654       }
8655     }
8656     if (!r[2]) {
8657       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8658       print_strings (r);
8659       return -1;
8660     }
8661     {
8662       char expected[] = "Result6";
8663       if (strcmp (r[2], expected) != 0) {
8664         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8665         return -1;
8666       }
8667     }
8668     if (!r[3]) {
8669       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8670       print_strings (r);
8671       return -1;
8672     }
8673     {
8674       char expected[] = "";
8675       if (strcmp (r[3], expected) != 0) {
8676         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8677         return -1;
8678       }
8679     }
8680     if (r[4] != NULL) {
8681       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8682       print_strings (r);
8683       return -1;
8684     }
8685     for (i = 0; r[i] != NULL; ++i)
8686       free (r[i]);
8687     free (r);
8688   }
8689   return 0;
8690 }
8691
8692 static int test_command_lines_6_skip (void)
8693 {
8694   const char *str;
8695
8696   str = getenv ("TEST_ONLY");
8697   if (str)
8698     return strstr (str, "command_lines") == NULL;
8699   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8700   if (str && strcmp (str, "1") == 0) return 1;
8701   str = getenv ("SKIP_TEST_COMMAND_LINES");
8702   if (str && strcmp (str, "1") == 0) return 1;
8703   return 0;
8704 }
8705
8706 static int test_command_lines_6 (void)
8707 {
8708   if (test_command_lines_6_skip ()) {
8709     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8710     return 0;
8711   }
8712
8713   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8714   {
8715     char device[] = "/dev/sda";
8716     int r;
8717     suppress_error = 0;
8718     r = guestfs_blockdev_setrw (g, device);
8719     if (r == -1)
8720       return -1;
8721   }
8722   {
8723     int r;
8724     suppress_error = 0;
8725     r = guestfs_umount_all (g);
8726     if (r == -1)
8727       return -1;
8728   }
8729   {
8730     int r;
8731     suppress_error = 0;
8732     r = guestfs_lvm_remove_all (g);
8733     if (r == -1)
8734       return -1;
8735   }
8736   {
8737     char device[] = "/dev/sda";
8738     char lines_0[] = ",";
8739     char *lines[] = {
8740       lines_0,
8741       NULL
8742     };
8743     int r;
8744     suppress_error = 0;
8745     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8746     if (r == -1)
8747       return -1;
8748   }
8749   {
8750     char fstype[] = "ext2";
8751     char device[] = "/dev/sda1";
8752     int r;
8753     suppress_error = 0;
8754     r = guestfs_mkfs (g, fstype, device);
8755     if (r == -1)
8756       return -1;
8757   }
8758   {
8759     char device[] = "/dev/sda1";
8760     char mountpoint[] = "/";
8761     int r;
8762     suppress_error = 0;
8763     r = guestfs_mount (g, device, mountpoint);
8764     if (r == -1)
8765       return -1;
8766   }
8767   /* TestOutputList for command_lines (6) */
8768   {
8769     char remotefilename[] = "/test-command";
8770     int r;
8771     suppress_error = 0;
8772     r = guestfs_upload (g, "test-command", remotefilename);
8773     if (r == -1)
8774       return -1;
8775   }
8776   {
8777     char path[] = "/test-command";
8778     int r;
8779     suppress_error = 0;
8780     r = guestfs_chmod (g, 493, path);
8781     if (r == -1)
8782       return -1;
8783   }
8784   {
8785     char arguments_0[] = "/test-command";
8786     char arguments_1[] = "7";
8787     char *arguments[] = {
8788       arguments_0,
8789       arguments_1,
8790       NULL
8791     };
8792     char **r;
8793     int i;
8794     suppress_error = 0;
8795     r = guestfs_command_lines (g, arguments);
8796     if (r == NULL)
8797       return -1;
8798     if (r[0] != NULL) {
8799       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8800       print_strings (r);
8801       return -1;
8802     }
8803     for (i = 0; r[i] != NULL; ++i)
8804       free (r[i]);
8805     free (r);
8806   }
8807   return 0;
8808 }
8809
8810 static int test_command_lines_7_skip (void)
8811 {
8812   const char *str;
8813
8814   str = getenv ("TEST_ONLY");
8815   if (str)
8816     return strstr (str, "command_lines") == NULL;
8817   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8818   if (str && strcmp (str, "1") == 0) return 1;
8819   str = getenv ("SKIP_TEST_COMMAND_LINES");
8820   if (str && strcmp (str, "1") == 0) return 1;
8821   return 0;
8822 }
8823
8824 static int test_command_lines_7 (void)
8825 {
8826   if (test_command_lines_7_skip ()) {
8827     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8828     return 0;
8829   }
8830
8831   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8832   {
8833     char device[] = "/dev/sda";
8834     int r;
8835     suppress_error = 0;
8836     r = guestfs_blockdev_setrw (g, device);
8837     if (r == -1)
8838       return -1;
8839   }
8840   {
8841     int r;
8842     suppress_error = 0;
8843     r = guestfs_umount_all (g);
8844     if (r == -1)
8845       return -1;
8846   }
8847   {
8848     int r;
8849     suppress_error = 0;
8850     r = guestfs_lvm_remove_all (g);
8851     if (r == -1)
8852       return -1;
8853   }
8854   {
8855     char device[] = "/dev/sda";
8856     char lines_0[] = ",";
8857     char *lines[] = {
8858       lines_0,
8859       NULL
8860     };
8861     int r;
8862     suppress_error = 0;
8863     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8864     if (r == -1)
8865       return -1;
8866   }
8867   {
8868     char fstype[] = "ext2";
8869     char device[] = "/dev/sda1";
8870     int r;
8871     suppress_error = 0;
8872     r = guestfs_mkfs (g, fstype, device);
8873     if (r == -1)
8874       return -1;
8875   }
8876   {
8877     char device[] = "/dev/sda1";
8878     char mountpoint[] = "/";
8879     int r;
8880     suppress_error = 0;
8881     r = guestfs_mount (g, device, mountpoint);
8882     if (r == -1)
8883       return -1;
8884   }
8885   /* TestOutputList for command_lines (7) */
8886   {
8887     char remotefilename[] = "/test-command";
8888     int r;
8889     suppress_error = 0;
8890     r = guestfs_upload (g, "test-command", remotefilename);
8891     if (r == -1)
8892       return -1;
8893   }
8894   {
8895     char path[] = "/test-command";
8896     int r;
8897     suppress_error = 0;
8898     r = guestfs_chmod (g, 493, path);
8899     if (r == -1)
8900       return -1;
8901   }
8902   {
8903     char arguments_0[] = "/test-command";
8904     char arguments_1[] = "8";
8905     char *arguments[] = {
8906       arguments_0,
8907       arguments_1,
8908       NULL
8909     };
8910     char **r;
8911     int i;
8912     suppress_error = 0;
8913     r = guestfs_command_lines (g, arguments);
8914     if (r == NULL)
8915       return -1;
8916     if (!r[0]) {
8917       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8918       print_strings (r);
8919       return -1;
8920     }
8921     {
8922       char expected[] = "";
8923       if (strcmp (r[0], expected) != 0) {
8924         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8925         return -1;
8926       }
8927     }
8928     if (r[1] != NULL) {
8929       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8930       print_strings (r);
8931       return -1;
8932     }
8933     for (i = 0; r[i] != NULL; ++i)
8934       free (r[i]);
8935     free (r);
8936   }
8937   return 0;
8938 }
8939
8940 static int test_command_lines_8_skip (void)
8941 {
8942   const char *str;
8943
8944   str = getenv ("TEST_ONLY");
8945   if (str)
8946     return strstr (str, "command_lines") == NULL;
8947   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8948   if (str && strcmp (str, "1") == 0) return 1;
8949   str = getenv ("SKIP_TEST_COMMAND_LINES");
8950   if (str && strcmp (str, "1") == 0) return 1;
8951   return 0;
8952 }
8953
8954 static int test_command_lines_8 (void)
8955 {
8956   if (test_command_lines_8_skip ()) {
8957     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8958     return 0;
8959   }
8960
8961   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8962   {
8963     char device[] = "/dev/sda";
8964     int r;
8965     suppress_error = 0;
8966     r = guestfs_blockdev_setrw (g, device);
8967     if (r == -1)
8968       return -1;
8969   }
8970   {
8971     int r;
8972     suppress_error = 0;
8973     r = guestfs_umount_all (g);
8974     if (r == -1)
8975       return -1;
8976   }
8977   {
8978     int r;
8979     suppress_error = 0;
8980     r = guestfs_lvm_remove_all (g);
8981     if (r == -1)
8982       return -1;
8983   }
8984   {
8985     char device[] = "/dev/sda";
8986     char lines_0[] = ",";
8987     char *lines[] = {
8988       lines_0,
8989       NULL
8990     };
8991     int r;
8992     suppress_error = 0;
8993     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8994     if (r == -1)
8995       return -1;
8996   }
8997   {
8998     char fstype[] = "ext2";
8999     char device[] = "/dev/sda1";
9000     int r;
9001     suppress_error = 0;
9002     r = guestfs_mkfs (g, fstype, device);
9003     if (r == -1)
9004       return -1;
9005   }
9006   {
9007     char device[] = "/dev/sda1";
9008     char mountpoint[] = "/";
9009     int r;
9010     suppress_error = 0;
9011     r = guestfs_mount (g, device, mountpoint);
9012     if (r == -1)
9013       return -1;
9014   }
9015   /* TestOutputList for command_lines (8) */
9016   {
9017     char remotefilename[] = "/test-command";
9018     int r;
9019     suppress_error = 0;
9020     r = guestfs_upload (g, "test-command", remotefilename);
9021     if (r == -1)
9022       return -1;
9023   }
9024   {
9025     char path[] = "/test-command";
9026     int r;
9027     suppress_error = 0;
9028     r = guestfs_chmod (g, 493, path);
9029     if (r == -1)
9030       return -1;
9031   }
9032   {
9033     char arguments_0[] = "/test-command";
9034     char arguments_1[] = "9";
9035     char *arguments[] = {
9036       arguments_0,
9037       arguments_1,
9038       NULL
9039     };
9040     char **r;
9041     int i;
9042     suppress_error = 0;
9043     r = guestfs_command_lines (g, arguments);
9044     if (r == NULL)
9045       return -1;
9046     if (!r[0]) {
9047       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
9048       print_strings (r);
9049       return -1;
9050     }
9051     {
9052       char expected[] = "";
9053       if (strcmp (r[0], expected) != 0) {
9054         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9055         return -1;
9056       }
9057     }
9058     if (!r[1]) {
9059       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
9060       print_strings (r);
9061       return -1;
9062     }
9063     {
9064       char expected[] = "";
9065       if (strcmp (r[1], expected) != 0) {
9066         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9067         return -1;
9068       }
9069     }
9070     if (r[2] != NULL) {
9071       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
9072       print_strings (r);
9073       return -1;
9074     }
9075     for (i = 0; r[i] != NULL; ++i)
9076       free (r[i]);
9077     free (r);
9078   }
9079   return 0;
9080 }
9081
9082 static int test_command_lines_9_skip (void)
9083 {
9084   const char *str;
9085
9086   str = getenv ("TEST_ONLY");
9087   if (str)
9088     return strstr (str, "command_lines") == NULL;
9089   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
9090   if (str && strcmp (str, "1") == 0) return 1;
9091   str = getenv ("SKIP_TEST_COMMAND_LINES");
9092   if (str && strcmp (str, "1") == 0) return 1;
9093   return 0;
9094 }
9095
9096 static int test_command_lines_9 (void)
9097 {
9098   if (test_command_lines_9_skip ()) {
9099     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
9100     return 0;
9101   }
9102
9103   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
9104   {
9105     char device[] = "/dev/sda";
9106     int r;
9107     suppress_error = 0;
9108     r = guestfs_blockdev_setrw (g, device);
9109     if (r == -1)
9110       return -1;
9111   }
9112   {
9113     int r;
9114     suppress_error = 0;
9115     r = guestfs_umount_all (g);
9116     if (r == -1)
9117       return -1;
9118   }
9119   {
9120     int r;
9121     suppress_error = 0;
9122     r = guestfs_lvm_remove_all (g);
9123     if (r == -1)
9124       return -1;
9125   }
9126   {
9127     char device[] = "/dev/sda";
9128     char lines_0[] = ",";
9129     char *lines[] = {
9130       lines_0,
9131       NULL
9132     };
9133     int r;
9134     suppress_error = 0;
9135     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9136     if (r == -1)
9137       return -1;
9138   }
9139   {
9140     char fstype[] = "ext2";
9141     char device[] = "/dev/sda1";
9142     int r;
9143     suppress_error = 0;
9144     r = guestfs_mkfs (g, fstype, device);
9145     if (r == -1)
9146       return -1;
9147   }
9148   {
9149     char device[] = "/dev/sda1";
9150     char mountpoint[] = "/";
9151     int r;
9152     suppress_error = 0;
9153     r = guestfs_mount (g, device, mountpoint);
9154     if (r == -1)
9155       return -1;
9156   }
9157   /* TestOutputList for command_lines (9) */
9158   {
9159     char remotefilename[] = "/test-command";
9160     int r;
9161     suppress_error = 0;
9162     r = guestfs_upload (g, "test-command", remotefilename);
9163     if (r == -1)
9164       return -1;
9165   }
9166   {
9167     char path[] = "/test-command";
9168     int r;
9169     suppress_error = 0;
9170     r = guestfs_chmod (g, 493, path);
9171     if (r == -1)
9172       return -1;
9173   }
9174   {
9175     char arguments_0[] = "/test-command";
9176     char arguments_1[] = "10";
9177     char *arguments[] = {
9178       arguments_0,
9179       arguments_1,
9180       NULL
9181     };
9182     char **r;
9183     int i;
9184     suppress_error = 0;
9185     r = guestfs_command_lines (g, arguments);
9186     if (r == NULL)
9187       return -1;
9188     if (!r[0]) {
9189       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
9190       print_strings (r);
9191       return -1;
9192     }
9193     {
9194       char expected[] = "Result10-1";
9195       if (strcmp (r[0], expected) != 0) {
9196         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9197         return -1;
9198       }
9199     }
9200     if (!r[1]) {
9201       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
9202       print_strings (r);
9203       return -1;
9204     }
9205     {
9206       char expected[] = "Result10-2";
9207       if (strcmp (r[1], expected) != 0) {
9208         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9209         return -1;
9210       }
9211     }
9212     if (r[2] != NULL) {
9213       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
9214       print_strings (r);
9215       return -1;
9216     }
9217     for (i = 0; r[i] != NULL; ++i)
9218       free (r[i]);
9219     free (r);
9220   }
9221   return 0;
9222 }
9223
9224 static int test_command_lines_10_skip (void)
9225 {
9226   const char *str;
9227
9228   str = getenv ("TEST_ONLY");
9229   if (str)
9230     return strstr (str, "command_lines") == NULL;
9231   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
9232   if (str && strcmp (str, "1") == 0) return 1;
9233   str = getenv ("SKIP_TEST_COMMAND_LINES");
9234   if (str && strcmp (str, "1") == 0) return 1;
9235   return 0;
9236 }
9237
9238 static int test_command_lines_10 (void)
9239 {
9240   if (test_command_lines_10_skip ()) {
9241     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
9242     return 0;
9243   }
9244
9245   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
9246   {
9247     char device[] = "/dev/sda";
9248     int r;
9249     suppress_error = 0;
9250     r = guestfs_blockdev_setrw (g, device);
9251     if (r == -1)
9252       return -1;
9253   }
9254   {
9255     int r;
9256     suppress_error = 0;
9257     r = guestfs_umount_all (g);
9258     if (r == -1)
9259       return -1;
9260   }
9261   {
9262     int r;
9263     suppress_error = 0;
9264     r = guestfs_lvm_remove_all (g);
9265     if (r == -1)
9266       return -1;
9267   }
9268   {
9269     char device[] = "/dev/sda";
9270     char lines_0[] = ",";
9271     char *lines[] = {
9272       lines_0,
9273       NULL
9274     };
9275     int r;
9276     suppress_error = 0;
9277     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9278     if (r == -1)
9279       return -1;
9280   }
9281   {
9282     char fstype[] = "ext2";
9283     char device[] = "/dev/sda1";
9284     int r;
9285     suppress_error = 0;
9286     r = guestfs_mkfs (g, fstype, device);
9287     if (r == -1)
9288       return -1;
9289   }
9290   {
9291     char device[] = "/dev/sda1";
9292     char mountpoint[] = "/";
9293     int r;
9294     suppress_error = 0;
9295     r = guestfs_mount (g, device, mountpoint);
9296     if (r == -1)
9297       return -1;
9298   }
9299   /* TestOutputList for command_lines (10) */
9300   {
9301     char remotefilename[] = "/test-command";
9302     int r;
9303     suppress_error = 0;
9304     r = guestfs_upload (g, "test-command", remotefilename);
9305     if (r == -1)
9306       return -1;
9307   }
9308   {
9309     char path[] = "/test-command";
9310     int r;
9311     suppress_error = 0;
9312     r = guestfs_chmod (g, 493, path);
9313     if (r == -1)
9314       return -1;
9315   }
9316   {
9317     char arguments_0[] = "/test-command";
9318     char arguments_1[] = "11";
9319     char *arguments[] = {
9320       arguments_0,
9321       arguments_1,
9322       NULL
9323     };
9324     char **r;
9325     int i;
9326     suppress_error = 0;
9327     r = guestfs_command_lines (g, arguments);
9328     if (r == NULL)
9329       return -1;
9330     if (!r[0]) {
9331       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
9332       print_strings (r);
9333       return -1;
9334     }
9335     {
9336       char expected[] = "Result11-1";
9337       if (strcmp (r[0], expected) != 0) {
9338         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9339         return -1;
9340       }
9341     }
9342     if (!r[1]) {
9343       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
9344       print_strings (r);
9345       return -1;
9346     }
9347     {
9348       char expected[] = "Result11-2";
9349       if (strcmp (r[1], expected) != 0) {
9350         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9351         return -1;
9352       }
9353     }
9354     if (r[2] != NULL) {
9355       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
9356       print_strings (r);
9357       return -1;
9358     }
9359     for (i = 0; r[i] != NULL; ++i)
9360       free (r[i]);
9361     free (r);
9362   }
9363   return 0;
9364 }
9365
9366 static int test_command_0_skip (void)
9367 {
9368   const char *str;
9369
9370   str = getenv ("TEST_ONLY");
9371   if (str)
9372     return strstr (str, "command") == NULL;
9373   str = getenv ("SKIP_TEST_COMMAND_0");
9374   if (str && strcmp (str, "1") == 0) return 1;
9375   str = getenv ("SKIP_TEST_COMMAND");
9376   if (str && strcmp (str, "1") == 0) return 1;
9377   return 0;
9378 }
9379
9380 static int test_command_0 (void)
9381 {
9382   if (test_command_0_skip ()) {
9383     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
9384     return 0;
9385   }
9386
9387   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
9388   {
9389     char device[] = "/dev/sda";
9390     int r;
9391     suppress_error = 0;
9392     r = guestfs_blockdev_setrw (g, device);
9393     if (r == -1)
9394       return -1;
9395   }
9396   {
9397     int r;
9398     suppress_error = 0;
9399     r = guestfs_umount_all (g);
9400     if (r == -1)
9401       return -1;
9402   }
9403   {
9404     int r;
9405     suppress_error = 0;
9406     r = guestfs_lvm_remove_all (g);
9407     if (r == -1)
9408       return -1;
9409   }
9410   {
9411     char device[] = "/dev/sda";
9412     char lines_0[] = ",";
9413     char *lines[] = {
9414       lines_0,
9415       NULL
9416     };
9417     int r;
9418     suppress_error = 0;
9419     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9420     if (r == -1)
9421       return -1;
9422   }
9423   {
9424     char fstype[] = "ext2";
9425     char device[] = "/dev/sda1";
9426     int r;
9427     suppress_error = 0;
9428     r = guestfs_mkfs (g, fstype, device);
9429     if (r == -1)
9430       return -1;
9431   }
9432   {
9433     char device[] = "/dev/sda1";
9434     char mountpoint[] = "/";
9435     int r;
9436     suppress_error = 0;
9437     r = guestfs_mount (g, device, mountpoint);
9438     if (r == -1)
9439       return -1;
9440   }
9441   /* TestOutput for command (0) */
9442   char expected[] = "Result1";
9443   {
9444     char remotefilename[] = "/test-command";
9445     int r;
9446     suppress_error = 0;
9447     r = guestfs_upload (g, "test-command", remotefilename);
9448     if (r == -1)
9449       return -1;
9450   }
9451   {
9452     char path[] = "/test-command";
9453     int r;
9454     suppress_error = 0;
9455     r = guestfs_chmod (g, 493, path);
9456     if (r == -1)
9457       return -1;
9458   }
9459   {
9460     char arguments_0[] = "/test-command";
9461     char arguments_1[] = "1";
9462     char *arguments[] = {
9463       arguments_0,
9464       arguments_1,
9465       NULL
9466     };
9467     char *r;
9468     suppress_error = 0;
9469     r = guestfs_command (g, arguments);
9470     if (r == NULL)
9471       return -1;
9472     if (strcmp (r, expected) != 0) {
9473       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
9474       return -1;
9475     }
9476     free (r);
9477   }
9478   return 0;
9479 }
9480
9481 static int test_command_1_skip (void)
9482 {
9483   const char *str;
9484
9485   str = getenv ("TEST_ONLY");
9486   if (str)
9487     return strstr (str, "command") == NULL;
9488   str = getenv ("SKIP_TEST_COMMAND_1");
9489   if (str && strcmp (str, "1") == 0) return 1;
9490   str = getenv ("SKIP_TEST_COMMAND");
9491   if (str && strcmp (str, "1") == 0) return 1;
9492   return 0;
9493 }
9494
9495 static int test_command_1 (void)
9496 {
9497   if (test_command_1_skip ()) {
9498     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
9499     return 0;
9500   }
9501
9502   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
9503   {
9504     char device[] = "/dev/sda";
9505     int r;
9506     suppress_error = 0;
9507     r = guestfs_blockdev_setrw (g, device);
9508     if (r == -1)
9509       return -1;
9510   }
9511   {
9512     int r;
9513     suppress_error = 0;
9514     r = guestfs_umount_all (g);
9515     if (r == -1)
9516       return -1;
9517   }
9518   {
9519     int r;
9520     suppress_error = 0;
9521     r = guestfs_lvm_remove_all (g);
9522     if (r == -1)
9523       return -1;
9524   }
9525   {
9526     char device[] = "/dev/sda";
9527     char lines_0[] = ",";
9528     char *lines[] = {
9529       lines_0,
9530       NULL
9531     };
9532     int r;
9533     suppress_error = 0;
9534     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9535     if (r == -1)
9536       return -1;
9537   }
9538   {
9539     char fstype[] = "ext2";
9540     char device[] = "/dev/sda1";
9541     int r;
9542     suppress_error = 0;
9543     r = guestfs_mkfs (g, fstype, device);
9544     if (r == -1)
9545       return -1;
9546   }
9547   {
9548     char device[] = "/dev/sda1";
9549     char mountpoint[] = "/";
9550     int r;
9551     suppress_error = 0;
9552     r = guestfs_mount (g, device, mountpoint);
9553     if (r == -1)
9554       return -1;
9555   }
9556   /* TestOutput for command (1) */
9557   char expected[] = "Result2\n";
9558   {
9559     char remotefilename[] = "/test-command";
9560     int r;
9561     suppress_error = 0;
9562     r = guestfs_upload (g, "test-command", remotefilename);
9563     if (r == -1)
9564       return -1;
9565   }
9566   {
9567     char path[] = "/test-command";
9568     int r;
9569     suppress_error = 0;
9570     r = guestfs_chmod (g, 493, path);
9571     if (r == -1)
9572       return -1;
9573   }
9574   {
9575     char arguments_0[] = "/test-command";
9576     char arguments_1[] = "2";
9577     char *arguments[] = {
9578       arguments_0,
9579       arguments_1,
9580       NULL
9581     };
9582     char *r;
9583     suppress_error = 0;
9584     r = guestfs_command (g, arguments);
9585     if (r == NULL)
9586       return -1;
9587     if (strcmp (r, expected) != 0) {
9588       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
9589       return -1;
9590     }
9591     free (r);
9592   }
9593   return 0;
9594 }
9595
9596 static int test_command_2_skip (void)
9597 {
9598   const char *str;
9599
9600   str = getenv ("TEST_ONLY");
9601   if (str)
9602     return strstr (str, "command") == NULL;
9603   str = getenv ("SKIP_TEST_COMMAND_2");
9604   if (str && strcmp (str, "1") == 0) return 1;
9605   str = getenv ("SKIP_TEST_COMMAND");
9606   if (str && strcmp (str, "1") == 0) return 1;
9607   return 0;
9608 }
9609
9610 static int test_command_2 (void)
9611 {
9612   if (test_command_2_skip ()) {
9613     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
9614     return 0;
9615   }
9616
9617   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9618   {
9619     char device[] = "/dev/sda";
9620     int r;
9621     suppress_error = 0;
9622     r = guestfs_blockdev_setrw (g, device);
9623     if (r == -1)
9624       return -1;
9625   }
9626   {
9627     int r;
9628     suppress_error = 0;
9629     r = guestfs_umount_all (g);
9630     if (r == -1)
9631       return -1;
9632   }
9633   {
9634     int r;
9635     suppress_error = 0;
9636     r = guestfs_lvm_remove_all (g);
9637     if (r == -1)
9638       return -1;
9639   }
9640   {
9641     char device[] = "/dev/sda";
9642     char lines_0[] = ",";
9643     char *lines[] = {
9644       lines_0,
9645       NULL
9646     };
9647     int r;
9648     suppress_error = 0;
9649     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9650     if (r == -1)
9651       return -1;
9652   }
9653   {
9654     char fstype[] = "ext2";
9655     char device[] = "/dev/sda1";
9656     int r;
9657     suppress_error = 0;
9658     r = guestfs_mkfs (g, fstype, device);
9659     if (r == -1)
9660       return -1;
9661   }
9662   {
9663     char device[] = "/dev/sda1";
9664     char mountpoint[] = "/";
9665     int r;
9666     suppress_error = 0;
9667     r = guestfs_mount (g, device, mountpoint);
9668     if (r == -1)
9669       return -1;
9670   }
9671   /* TestOutput for command (2) */
9672   char expected[] = "\nResult3";
9673   {
9674     char remotefilename[] = "/test-command";
9675     int r;
9676     suppress_error = 0;
9677     r = guestfs_upload (g, "test-command", remotefilename);
9678     if (r == -1)
9679       return -1;
9680   }
9681   {
9682     char path[] = "/test-command";
9683     int r;
9684     suppress_error = 0;
9685     r = guestfs_chmod (g, 493, path);
9686     if (r == -1)
9687       return -1;
9688   }
9689   {
9690     char arguments_0[] = "/test-command";
9691     char arguments_1[] = "3";
9692     char *arguments[] = {
9693       arguments_0,
9694       arguments_1,
9695       NULL
9696     };
9697     char *r;
9698     suppress_error = 0;
9699     r = guestfs_command (g, arguments);
9700     if (r == NULL)
9701       return -1;
9702     if (strcmp (r, expected) != 0) {
9703       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9704       return -1;
9705     }
9706     free (r);
9707   }
9708   return 0;
9709 }
9710
9711 static int test_command_3_skip (void)
9712 {
9713   const char *str;
9714
9715   str = getenv ("TEST_ONLY");
9716   if (str)
9717     return strstr (str, "command") == NULL;
9718   str = getenv ("SKIP_TEST_COMMAND_3");
9719   if (str && strcmp (str, "1") == 0) return 1;
9720   str = getenv ("SKIP_TEST_COMMAND");
9721   if (str && strcmp (str, "1") == 0) return 1;
9722   return 0;
9723 }
9724
9725 static int test_command_3 (void)
9726 {
9727   if (test_command_3_skip ()) {
9728     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9729     return 0;
9730   }
9731
9732   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9733   {
9734     char device[] = "/dev/sda";
9735     int r;
9736     suppress_error = 0;
9737     r = guestfs_blockdev_setrw (g, device);
9738     if (r == -1)
9739       return -1;
9740   }
9741   {
9742     int r;
9743     suppress_error = 0;
9744     r = guestfs_umount_all (g);
9745     if (r == -1)
9746       return -1;
9747   }
9748   {
9749     int r;
9750     suppress_error = 0;
9751     r = guestfs_lvm_remove_all (g);
9752     if (r == -1)
9753       return -1;
9754   }
9755   {
9756     char device[] = "/dev/sda";
9757     char lines_0[] = ",";
9758     char *lines[] = {
9759       lines_0,
9760       NULL
9761     };
9762     int r;
9763     suppress_error = 0;
9764     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9765     if (r == -1)
9766       return -1;
9767   }
9768   {
9769     char fstype[] = "ext2";
9770     char device[] = "/dev/sda1";
9771     int r;
9772     suppress_error = 0;
9773     r = guestfs_mkfs (g, fstype, device);
9774     if (r == -1)
9775       return -1;
9776   }
9777   {
9778     char device[] = "/dev/sda1";
9779     char mountpoint[] = "/";
9780     int r;
9781     suppress_error = 0;
9782     r = guestfs_mount (g, device, mountpoint);
9783     if (r == -1)
9784       return -1;
9785   }
9786   /* TestOutput for command (3) */
9787   char expected[] = "\nResult4\n";
9788   {
9789     char remotefilename[] = "/test-command";
9790     int r;
9791     suppress_error = 0;
9792     r = guestfs_upload (g, "test-command", remotefilename);
9793     if (r == -1)
9794       return -1;
9795   }
9796   {
9797     char path[] = "/test-command";
9798     int r;
9799     suppress_error = 0;
9800     r = guestfs_chmod (g, 493, path);
9801     if (r == -1)
9802       return -1;
9803   }
9804   {
9805     char arguments_0[] = "/test-command";
9806     char arguments_1[] = "4";
9807     char *arguments[] = {
9808       arguments_0,
9809       arguments_1,
9810       NULL
9811     };
9812     char *r;
9813     suppress_error = 0;
9814     r = guestfs_command (g, arguments);
9815     if (r == NULL)
9816       return -1;
9817     if (strcmp (r, expected) != 0) {
9818       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9819       return -1;
9820     }
9821     free (r);
9822   }
9823   return 0;
9824 }
9825
9826 static int test_command_4_skip (void)
9827 {
9828   const char *str;
9829
9830   str = getenv ("TEST_ONLY");
9831   if (str)
9832     return strstr (str, "command") == NULL;
9833   str = getenv ("SKIP_TEST_COMMAND_4");
9834   if (str && strcmp (str, "1") == 0) return 1;
9835   str = getenv ("SKIP_TEST_COMMAND");
9836   if (str && strcmp (str, "1") == 0) return 1;
9837   return 0;
9838 }
9839
9840 static int test_command_4 (void)
9841 {
9842   if (test_command_4_skip ()) {
9843     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9844     return 0;
9845   }
9846
9847   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9848   {
9849     char device[] = "/dev/sda";
9850     int r;
9851     suppress_error = 0;
9852     r = guestfs_blockdev_setrw (g, device);
9853     if (r == -1)
9854       return -1;
9855   }
9856   {
9857     int r;
9858     suppress_error = 0;
9859     r = guestfs_umount_all (g);
9860     if (r == -1)
9861       return -1;
9862   }
9863   {
9864     int r;
9865     suppress_error = 0;
9866     r = guestfs_lvm_remove_all (g);
9867     if (r == -1)
9868       return -1;
9869   }
9870   {
9871     char device[] = "/dev/sda";
9872     char lines_0[] = ",";
9873     char *lines[] = {
9874       lines_0,
9875       NULL
9876     };
9877     int r;
9878     suppress_error = 0;
9879     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9880     if (r == -1)
9881       return -1;
9882   }
9883   {
9884     char fstype[] = "ext2";
9885     char device[] = "/dev/sda1";
9886     int r;
9887     suppress_error = 0;
9888     r = guestfs_mkfs (g, fstype, device);
9889     if (r == -1)
9890       return -1;
9891   }
9892   {
9893     char device[] = "/dev/sda1";
9894     char mountpoint[] = "/";
9895     int r;
9896     suppress_error = 0;
9897     r = guestfs_mount (g, device, mountpoint);
9898     if (r == -1)
9899       return -1;
9900   }
9901   /* TestOutput for command (4) */
9902   char expected[] = "\nResult5\n\n";
9903   {
9904     char remotefilename[] = "/test-command";
9905     int r;
9906     suppress_error = 0;
9907     r = guestfs_upload (g, "test-command", remotefilename);
9908     if (r == -1)
9909       return -1;
9910   }
9911   {
9912     char path[] = "/test-command";
9913     int r;
9914     suppress_error = 0;
9915     r = guestfs_chmod (g, 493, path);
9916     if (r == -1)
9917       return -1;
9918   }
9919   {
9920     char arguments_0[] = "/test-command";
9921     char arguments_1[] = "5";
9922     char *arguments[] = {
9923       arguments_0,
9924       arguments_1,
9925       NULL
9926     };
9927     char *r;
9928     suppress_error = 0;
9929     r = guestfs_command (g, arguments);
9930     if (r == NULL)
9931       return -1;
9932     if (strcmp (r, expected) != 0) {
9933       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9934       return -1;
9935     }
9936     free (r);
9937   }
9938   return 0;
9939 }
9940
9941 static int test_command_5_skip (void)
9942 {
9943   const char *str;
9944
9945   str = getenv ("TEST_ONLY");
9946   if (str)
9947     return strstr (str, "command") == NULL;
9948   str = getenv ("SKIP_TEST_COMMAND_5");
9949   if (str && strcmp (str, "1") == 0) return 1;
9950   str = getenv ("SKIP_TEST_COMMAND");
9951   if (str && strcmp (str, "1") == 0) return 1;
9952   return 0;
9953 }
9954
9955 static int test_command_5 (void)
9956 {
9957   if (test_command_5_skip ()) {
9958     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9959     return 0;
9960   }
9961
9962   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9963   {
9964     char device[] = "/dev/sda";
9965     int r;
9966     suppress_error = 0;
9967     r = guestfs_blockdev_setrw (g, device);
9968     if (r == -1)
9969       return -1;
9970   }
9971   {
9972     int r;
9973     suppress_error = 0;
9974     r = guestfs_umount_all (g);
9975     if (r == -1)
9976       return -1;
9977   }
9978   {
9979     int r;
9980     suppress_error = 0;
9981     r = guestfs_lvm_remove_all (g);
9982     if (r == -1)
9983       return -1;
9984   }
9985   {
9986     char device[] = "/dev/sda";
9987     char lines_0[] = ",";
9988     char *lines[] = {
9989       lines_0,
9990       NULL
9991     };
9992     int r;
9993     suppress_error = 0;
9994     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9995     if (r == -1)
9996       return -1;
9997   }
9998   {
9999     char fstype[] = "ext2";
10000     char device[] = "/dev/sda1";
10001     int r;
10002     suppress_error = 0;
10003     r = guestfs_mkfs (g, fstype, device);
10004     if (r == -1)
10005       return -1;
10006   }
10007   {
10008     char device[] = "/dev/sda1";
10009     char mountpoint[] = "/";
10010     int r;
10011     suppress_error = 0;
10012     r = guestfs_mount (g, device, mountpoint);
10013     if (r == -1)
10014       return -1;
10015   }
10016   /* TestOutput for command (5) */
10017   char expected[] = "\n\nResult6\n\n";
10018   {
10019     char remotefilename[] = "/test-command";
10020     int r;
10021     suppress_error = 0;
10022     r = guestfs_upload (g, "test-command", remotefilename);
10023     if (r == -1)
10024       return -1;
10025   }
10026   {
10027     char path[] = "/test-command";
10028     int r;
10029     suppress_error = 0;
10030     r = guestfs_chmod (g, 493, path);
10031     if (r == -1)
10032       return -1;
10033   }
10034   {
10035     char arguments_0[] = "/test-command";
10036     char arguments_1[] = "6";
10037     char *arguments[] = {
10038       arguments_0,
10039       arguments_1,
10040       NULL
10041     };
10042     char *r;
10043     suppress_error = 0;
10044     r = guestfs_command (g, arguments);
10045     if (r == NULL)
10046       return -1;
10047     if (strcmp (r, expected) != 0) {
10048       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
10049       return -1;
10050     }
10051     free (r);
10052   }
10053   return 0;
10054 }
10055
10056 static int test_command_6_skip (void)
10057 {
10058   const char *str;
10059
10060   str = getenv ("TEST_ONLY");
10061   if (str)
10062     return strstr (str, "command") == NULL;
10063   str = getenv ("SKIP_TEST_COMMAND_6");
10064   if (str && strcmp (str, "1") == 0) return 1;
10065   str = getenv ("SKIP_TEST_COMMAND");
10066   if (str && strcmp (str, "1") == 0) return 1;
10067   return 0;
10068 }
10069
10070 static int test_command_6 (void)
10071 {
10072   if (test_command_6_skip ()) {
10073     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
10074     return 0;
10075   }
10076
10077   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
10078   {
10079     char device[] = "/dev/sda";
10080     int r;
10081     suppress_error = 0;
10082     r = guestfs_blockdev_setrw (g, device);
10083     if (r == -1)
10084       return -1;
10085   }
10086   {
10087     int r;
10088     suppress_error = 0;
10089     r = guestfs_umount_all (g);
10090     if (r == -1)
10091       return -1;
10092   }
10093   {
10094     int r;
10095     suppress_error = 0;
10096     r = guestfs_lvm_remove_all (g);
10097     if (r == -1)
10098       return -1;
10099   }
10100   {
10101     char device[] = "/dev/sda";
10102     char lines_0[] = ",";
10103     char *lines[] = {
10104       lines_0,
10105       NULL
10106     };
10107     int r;
10108     suppress_error = 0;
10109     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10110     if (r == -1)
10111       return -1;
10112   }
10113   {
10114     char fstype[] = "ext2";
10115     char device[] = "/dev/sda1";
10116     int r;
10117     suppress_error = 0;
10118     r = guestfs_mkfs (g, fstype, device);
10119     if (r == -1)
10120       return -1;
10121   }
10122   {
10123     char device[] = "/dev/sda1";
10124     char mountpoint[] = "/";
10125     int r;
10126     suppress_error = 0;
10127     r = guestfs_mount (g, device, mountpoint);
10128     if (r == -1)
10129       return -1;
10130   }
10131   /* TestOutput for command (6) */
10132   char expected[] = "";
10133   {
10134     char remotefilename[] = "/test-command";
10135     int r;
10136     suppress_error = 0;
10137     r = guestfs_upload (g, "test-command", remotefilename);
10138     if (r == -1)
10139       return -1;
10140   }
10141   {
10142     char path[] = "/test-command";
10143     int r;
10144     suppress_error = 0;
10145     r = guestfs_chmod (g, 493, path);
10146     if (r == -1)
10147       return -1;
10148   }
10149   {
10150     char arguments_0[] = "/test-command";
10151     char arguments_1[] = "7";
10152     char *arguments[] = {
10153       arguments_0,
10154       arguments_1,
10155       NULL
10156     };
10157     char *r;
10158     suppress_error = 0;
10159     r = guestfs_command (g, arguments);
10160     if (r == NULL)
10161       return -1;
10162     if (strcmp (r, expected) != 0) {
10163       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
10164       return -1;
10165     }
10166     free (r);
10167   }
10168   return 0;
10169 }
10170
10171 static int test_command_7_skip (void)
10172 {
10173   const char *str;
10174
10175   str = getenv ("TEST_ONLY");
10176   if (str)
10177     return strstr (str, "command") == NULL;
10178   str = getenv ("SKIP_TEST_COMMAND_7");
10179   if (str && strcmp (str, "1") == 0) return 1;
10180   str = getenv ("SKIP_TEST_COMMAND");
10181   if (str && strcmp (str, "1") == 0) return 1;
10182   return 0;
10183 }
10184
10185 static int test_command_7 (void)
10186 {
10187   if (test_command_7_skip ()) {
10188     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
10189     return 0;
10190   }
10191
10192   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
10193   {
10194     char device[] = "/dev/sda";
10195     int r;
10196     suppress_error = 0;
10197     r = guestfs_blockdev_setrw (g, device);
10198     if (r == -1)
10199       return -1;
10200   }
10201   {
10202     int r;
10203     suppress_error = 0;
10204     r = guestfs_umount_all (g);
10205     if (r == -1)
10206       return -1;
10207   }
10208   {
10209     int r;
10210     suppress_error = 0;
10211     r = guestfs_lvm_remove_all (g);
10212     if (r == -1)
10213       return -1;
10214   }
10215   {
10216     char device[] = "/dev/sda";
10217     char lines_0[] = ",";
10218     char *lines[] = {
10219       lines_0,
10220       NULL
10221     };
10222     int r;
10223     suppress_error = 0;
10224     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10225     if (r == -1)
10226       return -1;
10227   }
10228   {
10229     char fstype[] = "ext2";
10230     char device[] = "/dev/sda1";
10231     int r;
10232     suppress_error = 0;
10233     r = guestfs_mkfs (g, fstype, device);
10234     if (r == -1)
10235       return -1;
10236   }
10237   {
10238     char device[] = "/dev/sda1";
10239     char mountpoint[] = "/";
10240     int r;
10241     suppress_error = 0;
10242     r = guestfs_mount (g, device, mountpoint);
10243     if (r == -1)
10244       return -1;
10245   }
10246   /* TestOutput for command (7) */
10247   char expected[] = "\n";
10248   {
10249     char remotefilename[] = "/test-command";
10250     int r;
10251     suppress_error = 0;
10252     r = guestfs_upload (g, "test-command", remotefilename);
10253     if (r == -1)
10254       return -1;
10255   }
10256   {
10257     char path[] = "/test-command";
10258     int r;
10259     suppress_error = 0;
10260     r = guestfs_chmod (g, 493, path);
10261     if (r == -1)
10262       return -1;
10263   }
10264   {
10265     char arguments_0[] = "/test-command";
10266     char arguments_1[] = "8";
10267     char *arguments[] = {
10268       arguments_0,
10269       arguments_1,
10270       NULL
10271     };
10272     char *r;
10273     suppress_error = 0;
10274     r = guestfs_command (g, arguments);
10275     if (r == NULL)
10276       return -1;
10277     if (strcmp (r, expected) != 0) {
10278       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
10279       return -1;
10280     }
10281     free (r);
10282   }
10283   return 0;
10284 }
10285
10286 static int test_command_8_skip (void)
10287 {
10288   const char *str;
10289
10290   str = getenv ("TEST_ONLY");
10291   if (str)
10292     return strstr (str, "command") == NULL;
10293   str = getenv ("SKIP_TEST_COMMAND_8");
10294   if (str && strcmp (str, "1") == 0) return 1;
10295   str = getenv ("SKIP_TEST_COMMAND");
10296   if (str && strcmp (str, "1") == 0) return 1;
10297   return 0;
10298 }
10299
10300 static int test_command_8 (void)
10301 {
10302   if (test_command_8_skip ()) {
10303     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
10304     return 0;
10305   }
10306
10307   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
10308   {
10309     char device[] = "/dev/sda";
10310     int r;
10311     suppress_error = 0;
10312     r = guestfs_blockdev_setrw (g, device);
10313     if (r == -1)
10314       return -1;
10315   }
10316   {
10317     int r;
10318     suppress_error = 0;
10319     r = guestfs_umount_all (g);
10320     if (r == -1)
10321       return -1;
10322   }
10323   {
10324     int r;
10325     suppress_error = 0;
10326     r = guestfs_lvm_remove_all (g);
10327     if (r == -1)
10328       return -1;
10329   }
10330   {
10331     char device[] = "/dev/sda";
10332     char lines_0[] = ",";
10333     char *lines[] = {
10334       lines_0,
10335       NULL
10336     };
10337     int r;
10338     suppress_error = 0;
10339     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10340     if (r == -1)
10341       return -1;
10342   }
10343   {
10344     char fstype[] = "ext2";
10345     char device[] = "/dev/sda1";
10346     int r;
10347     suppress_error = 0;
10348     r = guestfs_mkfs (g, fstype, device);
10349     if (r == -1)
10350       return -1;
10351   }
10352   {
10353     char device[] = "/dev/sda1";
10354     char mountpoint[] = "/";
10355     int r;
10356     suppress_error = 0;
10357     r = guestfs_mount (g, device, mountpoint);
10358     if (r == -1)
10359       return -1;
10360   }
10361   /* TestOutput for command (8) */
10362   char expected[] = "\n\n";
10363   {
10364     char remotefilename[] = "/test-command";
10365     int r;
10366     suppress_error = 0;
10367     r = guestfs_upload (g, "test-command", remotefilename);
10368     if (r == -1)
10369       return -1;
10370   }
10371   {
10372     char path[] = "/test-command";
10373     int r;
10374     suppress_error = 0;
10375     r = guestfs_chmod (g, 493, path);
10376     if (r == -1)
10377       return -1;
10378   }
10379   {
10380     char arguments_0[] = "/test-command";
10381     char arguments_1[] = "9";
10382     char *arguments[] = {
10383       arguments_0,
10384       arguments_1,
10385       NULL
10386     };
10387     char *r;
10388     suppress_error = 0;
10389     r = guestfs_command (g, arguments);
10390     if (r == NULL)
10391       return -1;
10392     if (strcmp (r, expected) != 0) {
10393       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
10394       return -1;
10395     }
10396     free (r);
10397   }
10398   return 0;
10399 }
10400
10401 static int test_command_9_skip (void)
10402 {
10403   const char *str;
10404
10405   str = getenv ("TEST_ONLY");
10406   if (str)
10407     return strstr (str, "command") == NULL;
10408   str = getenv ("SKIP_TEST_COMMAND_9");
10409   if (str && strcmp (str, "1") == 0) return 1;
10410   str = getenv ("SKIP_TEST_COMMAND");
10411   if (str && strcmp (str, "1") == 0) return 1;
10412   return 0;
10413 }
10414
10415 static int test_command_9 (void)
10416 {
10417   if (test_command_9_skip ()) {
10418     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
10419     return 0;
10420   }
10421
10422   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
10423   {
10424     char device[] = "/dev/sda";
10425     int r;
10426     suppress_error = 0;
10427     r = guestfs_blockdev_setrw (g, device);
10428     if (r == -1)
10429       return -1;
10430   }
10431   {
10432     int r;
10433     suppress_error = 0;
10434     r = guestfs_umount_all (g);
10435     if (r == -1)
10436       return -1;
10437   }
10438   {
10439     int r;
10440     suppress_error = 0;
10441     r = guestfs_lvm_remove_all (g);
10442     if (r == -1)
10443       return -1;
10444   }
10445   {
10446     char device[] = "/dev/sda";
10447     char lines_0[] = ",";
10448     char *lines[] = {
10449       lines_0,
10450       NULL
10451     };
10452     int r;
10453     suppress_error = 0;
10454     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10455     if (r == -1)
10456       return -1;
10457   }
10458   {
10459     char fstype[] = "ext2";
10460     char device[] = "/dev/sda1";
10461     int r;
10462     suppress_error = 0;
10463     r = guestfs_mkfs (g, fstype, device);
10464     if (r == -1)
10465       return -1;
10466   }
10467   {
10468     char device[] = "/dev/sda1";
10469     char mountpoint[] = "/";
10470     int r;
10471     suppress_error = 0;
10472     r = guestfs_mount (g, device, mountpoint);
10473     if (r == -1)
10474       return -1;
10475   }
10476   /* TestOutput for command (9) */
10477   char expected[] = "Result10-1\nResult10-2\n";
10478   {
10479     char remotefilename[] = "/test-command";
10480     int r;
10481     suppress_error = 0;
10482     r = guestfs_upload (g, "test-command", remotefilename);
10483     if (r == -1)
10484       return -1;
10485   }
10486   {
10487     char path[] = "/test-command";
10488     int r;
10489     suppress_error = 0;
10490     r = guestfs_chmod (g, 493, path);
10491     if (r == -1)
10492       return -1;
10493   }
10494   {
10495     char arguments_0[] = "/test-command";
10496     char arguments_1[] = "10";
10497     char *arguments[] = {
10498       arguments_0,
10499       arguments_1,
10500       NULL
10501     };
10502     char *r;
10503     suppress_error = 0;
10504     r = guestfs_command (g, arguments);
10505     if (r == NULL)
10506       return -1;
10507     if (strcmp (r, expected) != 0) {
10508       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
10509       return -1;
10510     }
10511     free (r);
10512   }
10513   return 0;
10514 }
10515
10516 static int test_command_10_skip (void)
10517 {
10518   const char *str;
10519
10520   str = getenv ("TEST_ONLY");
10521   if (str)
10522     return strstr (str, "command") == NULL;
10523   str = getenv ("SKIP_TEST_COMMAND_10");
10524   if (str && strcmp (str, "1") == 0) return 1;
10525   str = getenv ("SKIP_TEST_COMMAND");
10526   if (str && strcmp (str, "1") == 0) return 1;
10527   return 0;
10528 }
10529
10530 static int test_command_10 (void)
10531 {
10532   if (test_command_10_skip ()) {
10533     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
10534     return 0;
10535   }
10536
10537   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
10538   {
10539     char device[] = "/dev/sda";
10540     int r;
10541     suppress_error = 0;
10542     r = guestfs_blockdev_setrw (g, device);
10543     if (r == -1)
10544       return -1;
10545   }
10546   {
10547     int r;
10548     suppress_error = 0;
10549     r = guestfs_umount_all (g);
10550     if (r == -1)
10551       return -1;
10552   }
10553   {
10554     int r;
10555     suppress_error = 0;
10556     r = guestfs_lvm_remove_all (g);
10557     if (r == -1)
10558       return -1;
10559   }
10560   {
10561     char device[] = "/dev/sda";
10562     char lines_0[] = ",";
10563     char *lines[] = {
10564       lines_0,
10565       NULL
10566     };
10567     int r;
10568     suppress_error = 0;
10569     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10570     if (r == -1)
10571       return -1;
10572   }
10573   {
10574     char fstype[] = "ext2";
10575     char device[] = "/dev/sda1";
10576     int r;
10577     suppress_error = 0;
10578     r = guestfs_mkfs (g, fstype, device);
10579     if (r == -1)
10580       return -1;
10581   }
10582   {
10583     char device[] = "/dev/sda1";
10584     char mountpoint[] = "/";
10585     int r;
10586     suppress_error = 0;
10587     r = guestfs_mount (g, device, mountpoint);
10588     if (r == -1)
10589       return -1;
10590   }
10591   /* TestOutput for command (10) */
10592   char expected[] = "Result11-1\nResult11-2";
10593   {
10594     char remotefilename[] = "/test-command";
10595     int r;
10596     suppress_error = 0;
10597     r = guestfs_upload (g, "test-command", remotefilename);
10598     if (r == -1)
10599       return -1;
10600   }
10601   {
10602     char path[] = "/test-command";
10603     int r;
10604     suppress_error = 0;
10605     r = guestfs_chmod (g, 493, path);
10606     if (r == -1)
10607       return -1;
10608   }
10609   {
10610     char arguments_0[] = "/test-command";
10611     char arguments_1[] = "11";
10612     char *arguments[] = {
10613       arguments_0,
10614       arguments_1,
10615       NULL
10616     };
10617     char *r;
10618     suppress_error = 0;
10619     r = guestfs_command (g, arguments);
10620     if (r == NULL)
10621       return -1;
10622     if (strcmp (r, expected) != 0) {
10623       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
10624       return -1;
10625     }
10626     free (r);
10627   }
10628   return 0;
10629 }
10630
10631 static int test_command_11_skip (void)
10632 {
10633   const char *str;
10634
10635   str = getenv ("TEST_ONLY");
10636   if (str)
10637     return strstr (str, "command") == NULL;
10638   str = getenv ("SKIP_TEST_COMMAND_11");
10639   if (str && strcmp (str, "1") == 0) return 1;
10640   str = getenv ("SKIP_TEST_COMMAND");
10641   if (str && strcmp (str, "1") == 0) return 1;
10642   return 0;
10643 }
10644
10645 static int test_command_11 (void)
10646 {
10647   if (test_command_11_skip ()) {
10648     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
10649     return 0;
10650   }
10651
10652   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10653   {
10654     char device[] = "/dev/sda";
10655     int r;
10656     suppress_error = 0;
10657     r = guestfs_blockdev_setrw (g, device);
10658     if (r == -1)
10659       return -1;
10660   }
10661   {
10662     int r;
10663     suppress_error = 0;
10664     r = guestfs_umount_all (g);
10665     if (r == -1)
10666       return -1;
10667   }
10668   {
10669     int r;
10670     suppress_error = 0;
10671     r = guestfs_lvm_remove_all (g);
10672     if (r == -1)
10673       return -1;
10674   }
10675   {
10676     char device[] = "/dev/sda";
10677     char lines_0[] = ",";
10678     char *lines[] = {
10679       lines_0,
10680       NULL
10681     };
10682     int r;
10683     suppress_error = 0;
10684     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10685     if (r == -1)
10686       return -1;
10687   }
10688   {
10689     char fstype[] = "ext2";
10690     char device[] = "/dev/sda1";
10691     int r;
10692     suppress_error = 0;
10693     r = guestfs_mkfs (g, fstype, device);
10694     if (r == -1)
10695       return -1;
10696   }
10697   {
10698     char device[] = "/dev/sda1";
10699     char mountpoint[] = "/";
10700     int r;
10701     suppress_error = 0;
10702     r = guestfs_mount (g, device, mountpoint);
10703     if (r == -1)
10704       return -1;
10705   }
10706   /* TestLastFail for command (11) */
10707   {
10708     char remotefilename[] = "/test-command";
10709     int r;
10710     suppress_error = 0;
10711     r = guestfs_upload (g, "test-command", remotefilename);
10712     if (r == -1)
10713       return -1;
10714   }
10715   {
10716     char path[] = "/test-command";
10717     int r;
10718     suppress_error = 0;
10719     r = guestfs_chmod (g, 493, path);
10720     if (r == -1)
10721       return -1;
10722   }
10723   {
10724     char arguments_0[] = "/test-command";
10725     char *arguments[] = {
10726       arguments_0,
10727       NULL
10728     };
10729     char *r;
10730     suppress_error = 1;
10731     r = guestfs_command (g, arguments);
10732     if (r != NULL)
10733       return -1;
10734     free (r);
10735   }
10736   return 0;
10737 }
10738
10739 static int test_file_0_skip (void)
10740 {
10741   const char *str;
10742
10743   str = getenv ("TEST_ONLY");
10744   if (str)
10745     return strstr (str, "file") == NULL;
10746   str = getenv ("SKIP_TEST_FILE_0");
10747   if (str && strcmp (str, "1") == 0) return 1;
10748   str = getenv ("SKIP_TEST_FILE");
10749   if (str && strcmp (str, "1") == 0) return 1;
10750   return 0;
10751 }
10752
10753 static int test_file_0 (void)
10754 {
10755   if (test_file_0_skip ()) {
10756     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10757     return 0;
10758   }
10759
10760   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10761   {
10762     char device[] = "/dev/sda";
10763     int r;
10764     suppress_error = 0;
10765     r = guestfs_blockdev_setrw (g, device);
10766     if (r == -1)
10767       return -1;
10768   }
10769   {
10770     int r;
10771     suppress_error = 0;
10772     r = guestfs_umount_all (g);
10773     if (r == -1)
10774       return -1;
10775   }
10776   {
10777     int r;
10778     suppress_error = 0;
10779     r = guestfs_lvm_remove_all (g);
10780     if (r == -1)
10781       return -1;
10782   }
10783   {
10784     char device[] = "/dev/sda";
10785     char lines_0[] = ",";
10786     char *lines[] = {
10787       lines_0,
10788       NULL
10789     };
10790     int r;
10791     suppress_error = 0;
10792     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10793     if (r == -1)
10794       return -1;
10795   }
10796   {
10797     char fstype[] = "ext2";
10798     char device[] = "/dev/sda1";
10799     int r;
10800     suppress_error = 0;
10801     r = guestfs_mkfs (g, fstype, device);
10802     if (r == -1)
10803       return -1;
10804   }
10805   {
10806     char device[] = "/dev/sda1";
10807     char mountpoint[] = "/";
10808     int r;
10809     suppress_error = 0;
10810     r = guestfs_mount (g, device, mountpoint);
10811     if (r == -1)
10812       return -1;
10813   }
10814   /* TestOutput for file (0) */
10815   char expected[] = "empty";
10816   {
10817     char path[] = "/new";
10818     int r;
10819     suppress_error = 0;
10820     r = guestfs_touch (g, path);
10821     if (r == -1)
10822       return -1;
10823   }
10824   {
10825     char path[] = "/new";
10826     char *r;
10827     suppress_error = 0;
10828     r = guestfs_file (g, path);
10829     if (r == NULL)
10830       return -1;
10831     if (strcmp (r, expected) != 0) {
10832       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10833       return -1;
10834     }
10835     free (r);
10836   }
10837   return 0;
10838 }
10839
10840 static int test_file_1_skip (void)
10841 {
10842   const char *str;
10843
10844   str = getenv ("TEST_ONLY");
10845   if (str)
10846     return strstr (str, "file") == NULL;
10847   str = getenv ("SKIP_TEST_FILE_1");
10848   if (str && strcmp (str, "1") == 0) return 1;
10849   str = getenv ("SKIP_TEST_FILE");
10850   if (str && strcmp (str, "1") == 0) return 1;
10851   return 0;
10852 }
10853
10854 static int test_file_1 (void)
10855 {
10856   if (test_file_1_skip ()) {
10857     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10858     return 0;
10859   }
10860
10861   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10862   {
10863     char device[] = "/dev/sda";
10864     int r;
10865     suppress_error = 0;
10866     r = guestfs_blockdev_setrw (g, device);
10867     if (r == -1)
10868       return -1;
10869   }
10870   {
10871     int r;
10872     suppress_error = 0;
10873     r = guestfs_umount_all (g);
10874     if (r == -1)
10875       return -1;
10876   }
10877   {
10878     int r;
10879     suppress_error = 0;
10880     r = guestfs_lvm_remove_all (g);
10881     if (r == -1)
10882       return -1;
10883   }
10884   {
10885     char device[] = "/dev/sda";
10886     char lines_0[] = ",";
10887     char *lines[] = {
10888       lines_0,
10889       NULL
10890     };
10891     int r;
10892     suppress_error = 0;
10893     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10894     if (r == -1)
10895       return -1;
10896   }
10897   {
10898     char fstype[] = "ext2";
10899     char device[] = "/dev/sda1";
10900     int r;
10901     suppress_error = 0;
10902     r = guestfs_mkfs (g, fstype, device);
10903     if (r == -1)
10904       return -1;
10905   }
10906   {
10907     char device[] = "/dev/sda1";
10908     char mountpoint[] = "/";
10909     int r;
10910     suppress_error = 0;
10911     r = guestfs_mount (g, device, mountpoint);
10912     if (r == -1)
10913       return -1;
10914   }
10915   /* TestOutput for file (1) */
10916   char expected[] = "ASCII text";
10917   {
10918     char path[] = "/new";
10919     char content[] = "some content\n";
10920     int r;
10921     suppress_error = 0;
10922     r = guestfs_write_file (g, path, content, 0);
10923     if (r == -1)
10924       return -1;
10925   }
10926   {
10927     char path[] = "/new";
10928     char *r;
10929     suppress_error = 0;
10930     r = guestfs_file (g, path);
10931     if (r == NULL)
10932       return -1;
10933     if (strcmp (r, expected) != 0) {
10934       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10935       return -1;
10936     }
10937     free (r);
10938   }
10939   return 0;
10940 }
10941
10942 static int test_file_2_skip (void)
10943 {
10944   const char *str;
10945
10946   str = getenv ("TEST_ONLY");
10947   if (str)
10948     return strstr (str, "file") == NULL;
10949   str = getenv ("SKIP_TEST_FILE_2");
10950   if (str && strcmp (str, "1") == 0) return 1;
10951   str = getenv ("SKIP_TEST_FILE");
10952   if (str && strcmp (str, "1") == 0) return 1;
10953   return 0;
10954 }
10955
10956 static int test_file_2 (void)
10957 {
10958   if (test_file_2_skip ()) {
10959     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10960     return 0;
10961   }
10962
10963   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10964   {
10965     char device[] = "/dev/sda";
10966     int r;
10967     suppress_error = 0;
10968     r = guestfs_blockdev_setrw (g, device);
10969     if (r == -1)
10970       return -1;
10971   }
10972   {
10973     int r;
10974     suppress_error = 0;
10975     r = guestfs_umount_all (g);
10976     if (r == -1)
10977       return -1;
10978   }
10979   {
10980     int r;
10981     suppress_error = 0;
10982     r = guestfs_lvm_remove_all (g);
10983     if (r == -1)
10984       return -1;
10985   }
10986   {
10987     char device[] = "/dev/sda";
10988     char lines_0[] = ",";
10989     char *lines[] = {
10990       lines_0,
10991       NULL
10992     };
10993     int r;
10994     suppress_error = 0;
10995     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10996     if (r == -1)
10997       return -1;
10998   }
10999   {
11000     char fstype[] = "ext2";
11001     char device[] = "/dev/sda1";
11002     int r;
11003     suppress_error = 0;
11004     r = guestfs_mkfs (g, fstype, device);
11005     if (r == -1)
11006       return -1;
11007   }
11008   {
11009     char device[] = "/dev/sda1";
11010     char mountpoint[] = "/";
11011     int r;
11012     suppress_error = 0;
11013     r = guestfs_mount (g, device, mountpoint);
11014     if (r == -1)
11015       return -1;
11016   }
11017   /* TestLastFail for file (2) */
11018   {
11019     char path[] = "/nofile";
11020     char *r;
11021     suppress_error = 1;
11022     r = guestfs_file (g, path);
11023     if (r != NULL)
11024       return -1;
11025     free (r);
11026   }
11027   return 0;
11028 }
11029
11030 static int test_umount_all_0_skip (void)
11031 {
11032   const char *str;
11033
11034   str = getenv ("TEST_ONLY");
11035   if (str)
11036     return strstr (str, "umount_all") == NULL;
11037   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
11038   if (str && strcmp (str, "1") == 0) return 1;
11039   str = getenv ("SKIP_TEST_UMOUNT_ALL");
11040   if (str && strcmp (str, "1") == 0) return 1;
11041   return 0;
11042 }
11043
11044 static int test_umount_all_0 (void)
11045 {
11046   if (test_umount_all_0_skip ()) {
11047     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
11048     return 0;
11049   }
11050
11051   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
11052   {
11053     char device[] = "/dev/sda";
11054     int r;
11055     suppress_error = 0;
11056     r = guestfs_blockdev_setrw (g, device);
11057     if (r == -1)
11058       return -1;
11059   }
11060   {
11061     int r;
11062     suppress_error = 0;
11063     r = guestfs_umount_all (g);
11064     if (r == -1)
11065       return -1;
11066   }
11067   {
11068     int r;
11069     suppress_error = 0;
11070     r = guestfs_lvm_remove_all (g);
11071     if (r == -1)
11072       return -1;
11073   }
11074   {
11075     char device[] = "/dev/sda";
11076     char lines_0[] = ",";
11077     char *lines[] = {
11078       lines_0,
11079       NULL
11080     };
11081     int r;
11082     suppress_error = 0;
11083     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11084     if (r == -1)
11085       return -1;
11086   }
11087   {
11088     char fstype[] = "ext2";
11089     char device[] = "/dev/sda1";
11090     int r;
11091     suppress_error = 0;
11092     r = guestfs_mkfs (g, fstype, device);
11093     if (r == -1)
11094       return -1;
11095   }
11096   {
11097     char device[] = "/dev/sda1";
11098     char mountpoint[] = "/";
11099     int r;
11100     suppress_error = 0;
11101     r = guestfs_mount (g, device, mountpoint);
11102     if (r == -1)
11103       return -1;
11104   }
11105   /* TestOutputList for umount_all (0) */
11106   {
11107     int r;
11108     suppress_error = 0;
11109     r = guestfs_umount_all (g);
11110     if (r == -1)
11111       return -1;
11112   }
11113   {
11114     char **r;
11115     int i;
11116     suppress_error = 0;
11117     r = guestfs_mounts (g);
11118     if (r == NULL)
11119       return -1;
11120     if (r[0] != NULL) {
11121       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
11122       print_strings (r);
11123       return -1;
11124     }
11125     for (i = 0; r[i] != NULL; ++i)
11126       free (r[i]);
11127     free (r);
11128   }
11129   return 0;
11130 }
11131
11132 static int test_umount_all_1_skip (void)
11133 {
11134   const char *str;
11135
11136   str = getenv ("TEST_ONLY");
11137   if (str)
11138     return strstr (str, "umount_all") == NULL;
11139   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
11140   if (str && strcmp (str, "1") == 0) return 1;
11141   str = getenv ("SKIP_TEST_UMOUNT_ALL");
11142   if (str && strcmp (str, "1") == 0) return 1;
11143   return 0;
11144 }
11145
11146 static int test_umount_all_1 (void)
11147 {
11148   if (test_umount_all_1_skip ()) {
11149     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
11150     return 0;
11151   }
11152
11153   /* InitNone|InitEmpty for test_umount_all_1 */
11154   {
11155     char device[] = "/dev/sda";
11156     int r;
11157     suppress_error = 0;
11158     r = guestfs_blockdev_setrw (g, device);
11159     if (r == -1)
11160       return -1;
11161   }
11162   {
11163     int r;
11164     suppress_error = 0;
11165     r = guestfs_umount_all (g);
11166     if (r == -1)
11167       return -1;
11168   }
11169   {
11170     int r;
11171     suppress_error = 0;
11172     r = guestfs_lvm_remove_all (g);
11173     if (r == -1)
11174       return -1;
11175   }
11176   /* TestOutputList for umount_all (1) */
11177   {
11178     char device[] = "/dev/sda";
11179     char lines_0[] = ",10";
11180     char lines_1[] = ",20";
11181     char lines_2[] = ",";
11182     char *lines[] = {
11183       lines_0,
11184       lines_1,
11185       lines_2,
11186       NULL
11187     };
11188     int r;
11189     suppress_error = 0;
11190     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11191     if (r == -1)
11192       return -1;
11193   }
11194   {
11195     char fstype[] = "ext2";
11196     char device[] = "/dev/sda1";
11197     int r;
11198     suppress_error = 0;
11199     r = guestfs_mkfs (g, fstype, device);
11200     if (r == -1)
11201       return -1;
11202   }
11203   {
11204     char fstype[] = "ext2";
11205     char device[] = "/dev/sda2";
11206     int r;
11207     suppress_error = 0;
11208     r = guestfs_mkfs (g, fstype, device);
11209     if (r == -1)
11210       return -1;
11211   }
11212   {
11213     char fstype[] = "ext2";
11214     char device[] = "/dev/sda3";
11215     int r;
11216     suppress_error = 0;
11217     r = guestfs_mkfs (g, fstype, device);
11218     if (r == -1)
11219       return -1;
11220   }
11221   {
11222     char device[] = "/dev/sda1";
11223     char mountpoint[] = "/";
11224     int r;
11225     suppress_error = 0;
11226     r = guestfs_mount (g, device, mountpoint);
11227     if (r == -1)
11228       return -1;
11229   }
11230   {
11231     char path[] = "/mp1";
11232     int r;
11233     suppress_error = 0;
11234     r = guestfs_mkdir (g, path);
11235     if (r == -1)
11236       return -1;
11237   }
11238   {
11239     char device[] = "/dev/sda2";
11240     char mountpoint[] = "/mp1";
11241     int r;
11242     suppress_error = 0;
11243     r = guestfs_mount (g, device, mountpoint);
11244     if (r == -1)
11245       return -1;
11246   }
11247   {
11248     char path[] = "/mp1/mp2";
11249     int r;
11250     suppress_error = 0;
11251     r = guestfs_mkdir (g, path);
11252     if (r == -1)
11253       return -1;
11254   }
11255   {
11256     char device[] = "/dev/sda3";
11257     char mountpoint[] = "/mp1/mp2";
11258     int r;
11259     suppress_error = 0;
11260     r = guestfs_mount (g, device, mountpoint);
11261     if (r == -1)
11262       return -1;
11263   }
11264   {
11265     char path[] = "/mp1/mp2/mp3";
11266     int r;
11267     suppress_error = 0;
11268     r = guestfs_mkdir (g, path);
11269     if (r == -1)
11270       return -1;
11271   }
11272   {
11273     int r;
11274     suppress_error = 0;
11275     r = guestfs_umount_all (g);
11276     if (r == -1)
11277       return -1;
11278   }
11279   {
11280     char **r;
11281     int i;
11282     suppress_error = 0;
11283     r = guestfs_mounts (g);
11284     if (r == NULL)
11285       return -1;
11286     if (r[0] != NULL) {
11287       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
11288       print_strings (r);
11289       return -1;
11290     }
11291     for (i = 0; r[i] != NULL; ++i)
11292       free (r[i]);
11293     free (r);
11294   }
11295   return 0;
11296 }
11297
11298 static int test_mounts_0_skip (void)
11299 {
11300   const char *str;
11301
11302   str = getenv ("TEST_ONLY");
11303   if (str)
11304     return strstr (str, "mounts") == NULL;
11305   str = getenv ("SKIP_TEST_MOUNTS_0");
11306   if (str && strcmp (str, "1") == 0) return 1;
11307   str = getenv ("SKIP_TEST_MOUNTS");
11308   if (str && strcmp (str, "1") == 0) return 1;
11309   return 0;
11310 }
11311
11312 static int test_mounts_0 (void)
11313 {
11314   if (test_mounts_0_skip ()) {
11315     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
11316     return 0;
11317   }
11318
11319   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
11320   {
11321     char device[] = "/dev/sda";
11322     int r;
11323     suppress_error = 0;
11324     r = guestfs_blockdev_setrw (g, device);
11325     if (r == -1)
11326       return -1;
11327   }
11328   {
11329     int r;
11330     suppress_error = 0;
11331     r = guestfs_umount_all (g);
11332     if (r == -1)
11333       return -1;
11334   }
11335   {
11336     int r;
11337     suppress_error = 0;
11338     r = guestfs_lvm_remove_all (g);
11339     if (r == -1)
11340       return -1;
11341   }
11342   {
11343     char device[] = "/dev/sda";
11344     char lines_0[] = ",";
11345     char *lines[] = {
11346       lines_0,
11347       NULL
11348     };
11349     int r;
11350     suppress_error = 0;
11351     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11352     if (r == -1)
11353       return -1;
11354   }
11355   {
11356     char fstype[] = "ext2";
11357     char device[] = "/dev/sda1";
11358     int r;
11359     suppress_error = 0;
11360     r = guestfs_mkfs (g, fstype, device);
11361     if (r == -1)
11362       return -1;
11363   }
11364   {
11365     char device[] = "/dev/sda1";
11366     char mountpoint[] = "/";
11367     int r;
11368     suppress_error = 0;
11369     r = guestfs_mount (g, device, mountpoint);
11370     if (r == -1)
11371       return -1;
11372   }
11373   /* TestOutputListOfDevices for mounts (0) */
11374   {
11375     char **r;
11376     int i;
11377     suppress_error = 0;
11378     r = guestfs_mounts (g);
11379     if (r == NULL)
11380       return -1;
11381     if (!r[0]) {
11382       fprintf (stderr, "test_mounts_0: short list returned from command\n");
11383       print_strings (r);
11384       return -1;
11385     }
11386     {
11387       char expected[] = "/dev/sda1";
11388       r[0][5] = 's';
11389       if (strcmp (r[0], expected) != 0) {
11390         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11391         return -1;
11392       }
11393     }
11394     if (r[1] != NULL) {
11395       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
11396       print_strings (r);
11397       return -1;
11398     }
11399     for (i = 0; r[i] != NULL; ++i)
11400       free (r[i]);
11401     free (r);
11402   }
11403   return 0;
11404 }
11405
11406 static int test_umount_0_skip (void)
11407 {
11408   const char *str;
11409
11410   str = getenv ("TEST_ONLY");
11411   if (str)
11412     return strstr (str, "umount") == NULL;
11413   str = getenv ("SKIP_TEST_UMOUNT_0");
11414   if (str && strcmp (str, "1") == 0) return 1;
11415   str = getenv ("SKIP_TEST_UMOUNT");
11416   if (str && strcmp (str, "1") == 0) return 1;
11417   return 0;
11418 }
11419
11420 static int test_umount_0 (void)
11421 {
11422   if (test_umount_0_skip ()) {
11423     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
11424     return 0;
11425   }
11426
11427   /* InitNone|InitEmpty for test_umount_0 */
11428   {
11429     char device[] = "/dev/sda";
11430     int r;
11431     suppress_error = 0;
11432     r = guestfs_blockdev_setrw (g, device);
11433     if (r == -1)
11434       return -1;
11435   }
11436   {
11437     int r;
11438     suppress_error = 0;
11439     r = guestfs_umount_all (g);
11440     if (r == -1)
11441       return -1;
11442   }
11443   {
11444     int r;
11445     suppress_error = 0;
11446     r = guestfs_lvm_remove_all (g);
11447     if (r == -1)
11448       return -1;
11449   }
11450   /* TestOutputListOfDevices for umount (0) */
11451   {
11452     char device[] = "/dev/sda";
11453     char lines_0[] = ",";
11454     char *lines[] = {
11455       lines_0,
11456       NULL
11457     };
11458     int r;
11459     suppress_error = 0;
11460     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11461     if (r == -1)
11462       return -1;
11463   }
11464   {
11465     char fstype[] = "ext2";
11466     char device[] = "/dev/sda1";
11467     int r;
11468     suppress_error = 0;
11469     r = guestfs_mkfs (g, fstype, device);
11470     if (r == -1)
11471       return -1;
11472   }
11473   {
11474     char device[] = "/dev/sda1";
11475     char mountpoint[] = "/";
11476     int r;
11477     suppress_error = 0;
11478     r = guestfs_mount (g, device, mountpoint);
11479     if (r == -1)
11480       return -1;
11481   }
11482   {
11483     char **r;
11484     int i;
11485     suppress_error = 0;
11486     r = guestfs_mounts (g);
11487     if (r == NULL)
11488       return -1;
11489     if (!r[0]) {
11490       fprintf (stderr, "test_umount_0: short list returned from command\n");
11491       print_strings (r);
11492       return -1;
11493     }
11494     {
11495       char expected[] = "/dev/sda1";
11496       r[0][5] = 's';
11497       if (strcmp (r[0], expected) != 0) {
11498         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11499         return -1;
11500       }
11501     }
11502     if (r[1] != NULL) {
11503       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
11504       print_strings (r);
11505       return -1;
11506     }
11507     for (i = 0; r[i] != NULL; ++i)
11508       free (r[i]);
11509     free (r);
11510   }
11511   return 0;
11512 }
11513
11514 static int test_umount_1_skip (void)
11515 {
11516   const char *str;
11517
11518   str = getenv ("TEST_ONLY");
11519   if (str)
11520     return strstr (str, "umount") == NULL;
11521   str = getenv ("SKIP_TEST_UMOUNT_1");
11522   if (str && strcmp (str, "1") == 0) return 1;
11523   str = getenv ("SKIP_TEST_UMOUNT");
11524   if (str && strcmp (str, "1") == 0) return 1;
11525   return 0;
11526 }
11527
11528 static int test_umount_1 (void)
11529 {
11530   if (test_umount_1_skip ()) {
11531     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
11532     return 0;
11533   }
11534
11535   /* InitNone|InitEmpty for test_umount_1 */
11536   {
11537     char device[] = "/dev/sda";
11538     int r;
11539     suppress_error = 0;
11540     r = guestfs_blockdev_setrw (g, device);
11541     if (r == -1)
11542       return -1;
11543   }
11544   {
11545     int r;
11546     suppress_error = 0;
11547     r = guestfs_umount_all (g);
11548     if (r == -1)
11549       return -1;
11550   }
11551   {
11552     int r;
11553     suppress_error = 0;
11554     r = guestfs_lvm_remove_all (g);
11555     if (r == -1)
11556       return -1;
11557   }
11558   /* TestOutputList for umount (1) */
11559   {
11560     char device[] = "/dev/sda";
11561     char lines_0[] = ",";
11562     char *lines[] = {
11563       lines_0,
11564       NULL
11565     };
11566     int r;
11567     suppress_error = 0;
11568     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11569     if (r == -1)
11570       return -1;
11571   }
11572   {
11573     char fstype[] = "ext2";
11574     char device[] = "/dev/sda1";
11575     int r;
11576     suppress_error = 0;
11577     r = guestfs_mkfs (g, fstype, device);
11578     if (r == -1)
11579       return -1;
11580   }
11581   {
11582     char device[] = "/dev/sda1";
11583     char mountpoint[] = "/";
11584     int r;
11585     suppress_error = 0;
11586     r = guestfs_mount (g, device, mountpoint);
11587     if (r == -1)
11588       return -1;
11589   }
11590   {
11591     char pathordevice[] = "/";
11592     int r;
11593     suppress_error = 0;
11594     r = guestfs_umount (g, pathordevice);
11595     if (r == -1)
11596       return -1;
11597   }
11598   {
11599     char **r;
11600     int i;
11601     suppress_error = 0;
11602     r = guestfs_mounts (g);
11603     if (r == NULL)
11604       return -1;
11605     if (r[0] != NULL) {
11606       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
11607       print_strings (r);
11608       return -1;
11609     }
11610     for (i = 0; r[i] != NULL; ++i)
11611       free (r[i]);
11612     free (r);
11613   }
11614   return 0;
11615 }
11616
11617 static int test_write_file_0_skip (void)
11618 {
11619   const char *str;
11620
11621   str = getenv ("TEST_ONLY");
11622   if (str)
11623     return strstr (str, "write_file") == NULL;
11624   str = getenv ("SKIP_TEST_WRITE_FILE_0");
11625   if (str && strcmp (str, "1") == 0) return 1;
11626   str = getenv ("SKIP_TEST_WRITE_FILE");
11627   if (str && strcmp (str, "1") == 0) return 1;
11628   return 0;
11629 }
11630
11631 static int test_write_file_0 (void)
11632 {
11633   if (test_write_file_0_skip ()) {
11634     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
11635     return 0;
11636   }
11637
11638   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
11639   {
11640     char device[] = "/dev/sda";
11641     int r;
11642     suppress_error = 0;
11643     r = guestfs_blockdev_setrw (g, device);
11644     if (r == -1)
11645       return -1;
11646   }
11647   {
11648     int r;
11649     suppress_error = 0;
11650     r = guestfs_umount_all (g);
11651     if (r == -1)
11652       return -1;
11653   }
11654   {
11655     int r;
11656     suppress_error = 0;
11657     r = guestfs_lvm_remove_all (g);
11658     if (r == -1)
11659       return -1;
11660   }
11661   {
11662     char device[] = "/dev/sda";
11663     char lines_0[] = ",";
11664     char *lines[] = {
11665       lines_0,
11666       NULL
11667     };
11668     int r;
11669     suppress_error = 0;
11670     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11671     if (r == -1)
11672       return -1;
11673   }
11674   {
11675     char fstype[] = "ext2";
11676     char device[] = "/dev/sda1";
11677     int r;
11678     suppress_error = 0;
11679     r = guestfs_mkfs (g, fstype, device);
11680     if (r == -1)
11681       return -1;
11682   }
11683   {
11684     char device[] = "/dev/sda1";
11685     char mountpoint[] = "/";
11686     int r;
11687     suppress_error = 0;
11688     r = guestfs_mount (g, device, mountpoint);
11689     if (r == -1)
11690       return -1;
11691   }
11692   /* TestOutput for write_file (0) */
11693   char expected[] = "new file contents";
11694   {
11695     char path[] = "/new";
11696     char content[] = "new file contents";
11697     int r;
11698     suppress_error = 0;
11699     r = guestfs_write_file (g, path, content, 0);
11700     if (r == -1)
11701       return -1;
11702   }
11703   {
11704     char path[] = "/new";
11705     char *r;
11706     suppress_error = 0;
11707     r = guestfs_cat (g, path);
11708     if (r == NULL)
11709       return -1;
11710     if (strcmp (r, expected) != 0) {
11711       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11712       return -1;
11713     }
11714     free (r);
11715   }
11716   return 0;
11717 }
11718
11719 static int test_write_file_1_skip (void)
11720 {
11721   const char *str;
11722
11723   str = getenv ("TEST_ONLY");
11724   if (str)
11725     return strstr (str, "write_file") == NULL;
11726   str = getenv ("SKIP_TEST_WRITE_FILE_1");
11727   if (str && strcmp (str, "1") == 0) return 1;
11728   str = getenv ("SKIP_TEST_WRITE_FILE");
11729   if (str && strcmp (str, "1") == 0) return 1;
11730   return 0;
11731 }
11732
11733 static int test_write_file_1 (void)
11734 {
11735   if (test_write_file_1_skip ()) {
11736     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11737     return 0;
11738   }
11739
11740   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11741   {
11742     char device[] = "/dev/sda";
11743     int r;
11744     suppress_error = 0;
11745     r = guestfs_blockdev_setrw (g, device);
11746     if (r == -1)
11747       return -1;
11748   }
11749   {
11750     int r;
11751     suppress_error = 0;
11752     r = guestfs_umount_all (g);
11753     if (r == -1)
11754       return -1;
11755   }
11756   {
11757     int r;
11758     suppress_error = 0;
11759     r = guestfs_lvm_remove_all (g);
11760     if (r == -1)
11761       return -1;
11762   }
11763   {
11764     char device[] = "/dev/sda";
11765     char lines_0[] = ",";
11766     char *lines[] = {
11767       lines_0,
11768       NULL
11769     };
11770     int r;
11771     suppress_error = 0;
11772     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11773     if (r == -1)
11774       return -1;
11775   }
11776   {
11777     char fstype[] = "ext2";
11778     char device[] = "/dev/sda1";
11779     int r;
11780     suppress_error = 0;
11781     r = guestfs_mkfs (g, fstype, device);
11782     if (r == -1)
11783       return -1;
11784   }
11785   {
11786     char device[] = "/dev/sda1";
11787     char mountpoint[] = "/";
11788     int r;
11789     suppress_error = 0;
11790     r = guestfs_mount (g, device, mountpoint);
11791     if (r == -1)
11792       return -1;
11793   }
11794   /* TestOutput for write_file (1) */
11795   char expected[] = "\nnew file contents\n";
11796   {
11797     char path[] = "/new";
11798     char content[] = "\nnew file contents\n";
11799     int r;
11800     suppress_error = 0;
11801     r = guestfs_write_file (g, path, content, 0);
11802     if (r == -1)
11803       return -1;
11804   }
11805   {
11806     char path[] = "/new";
11807     char *r;
11808     suppress_error = 0;
11809     r = guestfs_cat (g, path);
11810     if (r == NULL)
11811       return -1;
11812     if (strcmp (r, expected) != 0) {
11813       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11814       return -1;
11815     }
11816     free (r);
11817   }
11818   return 0;
11819 }
11820
11821 static int test_write_file_2_skip (void)
11822 {
11823   const char *str;
11824
11825   str = getenv ("TEST_ONLY");
11826   if (str)
11827     return strstr (str, "write_file") == NULL;
11828   str = getenv ("SKIP_TEST_WRITE_FILE_2");
11829   if (str && strcmp (str, "1") == 0) return 1;
11830   str = getenv ("SKIP_TEST_WRITE_FILE");
11831   if (str && strcmp (str, "1") == 0) return 1;
11832   return 0;
11833 }
11834
11835 static int test_write_file_2 (void)
11836 {
11837   if (test_write_file_2_skip ()) {
11838     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11839     return 0;
11840   }
11841
11842   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11843   {
11844     char device[] = "/dev/sda";
11845     int r;
11846     suppress_error = 0;
11847     r = guestfs_blockdev_setrw (g, device);
11848     if (r == -1)
11849       return -1;
11850   }
11851   {
11852     int r;
11853     suppress_error = 0;
11854     r = guestfs_umount_all (g);
11855     if (r == -1)
11856       return -1;
11857   }
11858   {
11859     int r;
11860     suppress_error = 0;
11861     r = guestfs_lvm_remove_all (g);
11862     if (r == -1)
11863       return -1;
11864   }
11865   {
11866     char device[] = "/dev/sda";
11867     char lines_0[] = ",";
11868     char *lines[] = {
11869       lines_0,
11870       NULL
11871     };
11872     int r;
11873     suppress_error = 0;
11874     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11875     if (r == -1)
11876       return -1;
11877   }
11878   {
11879     char fstype[] = "ext2";
11880     char device[] = "/dev/sda1";
11881     int r;
11882     suppress_error = 0;
11883     r = guestfs_mkfs (g, fstype, device);
11884     if (r == -1)
11885       return -1;
11886   }
11887   {
11888     char device[] = "/dev/sda1";
11889     char mountpoint[] = "/";
11890     int r;
11891     suppress_error = 0;
11892     r = guestfs_mount (g, device, mountpoint);
11893     if (r == -1)
11894       return -1;
11895   }
11896   /* TestOutput for write_file (2) */
11897   char expected[] = "\n\n";
11898   {
11899     char path[] = "/new";
11900     char content[] = "\n\n";
11901     int r;
11902     suppress_error = 0;
11903     r = guestfs_write_file (g, path, content, 0);
11904     if (r == -1)
11905       return -1;
11906   }
11907   {
11908     char path[] = "/new";
11909     char *r;
11910     suppress_error = 0;
11911     r = guestfs_cat (g, path);
11912     if (r == NULL)
11913       return -1;
11914     if (strcmp (r, expected) != 0) {
11915       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11916       return -1;
11917     }
11918     free (r);
11919   }
11920   return 0;
11921 }
11922
11923 static int test_write_file_3_skip (void)
11924 {
11925   const char *str;
11926
11927   str = getenv ("TEST_ONLY");
11928   if (str)
11929     return strstr (str, "write_file") == NULL;
11930   str = getenv ("SKIP_TEST_WRITE_FILE_3");
11931   if (str && strcmp (str, "1") == 0) return 1;
11932   str = getenv ("SKIP_TEST_WRITE_FILE");
11933   if (str && strcmp (str, "1") == 0) return 1;
11934   return 0;
11935 }
11936
11937 static int test_write_file_3 (void)
11938 {
11939   if (test_write_file_3_skip ()) {
11940     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11941     return 0;
11942   }
11943
11944   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11945   {
11946     char device[] = "/dev/sda";
11947     int r;
11948     suppress_error = 0;
11949     r = guestfs_blockdev_setrw (g, device);
11950     if (r == -1)
11951       return -1;
11952   }
11953   {
11954     int r;
11955     suppress_error = 0;
11956     r = guestfs_umount_all (g);
11957     if (r == -1)
11958       return -1;
11959   }
11960   {
11961     int r;
11962     suppress_error = 0;
11963     r = guestfs_lvm_remove_all (g);
11964     if (r == -1)
11965       return -1;
11966   }
11967   {
11968     char device[] = "/dev/sda";
11969     char lines_0[] = ",";
11970     char *lines[] = {
11971       lines_0,
11972       NULL
11973     };
11974     int r;
11975     suppress_error = 0;
11976     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11977     if (r == -1)
11978       return -1;
11979   }
11980   {
11981     char fstype[] = "ext2";
11982     char device[] = "/dev/sda1";
11983     int r;
11984     suppress_error = 0;
11985     r = guestfs_mkfs (g, fstype, device);
11986     if (r == -1)
11987       return -1;
11988   }
11989   {
11990     char device[] = "/dev/sda1";
11991     char mountpoint[] = "/";
11992     int r;
11993     suppress_error = 0;
11994     r = guestfs_mount (g, device, mountpoint);
11995     if (r == -1)
11996       return -1;
11997   }
11998   /* TestOutput for write_file (3) */
11999   char expected[] = "";
12000   {
12001     char path[] = "/new";
12002     char content[] = "";
12003     int r;
12004     suppress_error = 0;
12005     r = guestfs_write_file (g, path, content, 0);
12006     if (r == -1)
12007       return -1;
12008   }
12009   {
12010     char path[] = "/new";
12011     char *r;
12012     suppress_error = 0;
12013     r = guestfs_cat (g, path);
12014     if (r == NULL)
12015       return -1;
12016     if (strcmp (r, expected) != 0) {
12017       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
12018       return -1;
12019     }
12020     free (r);
12021   }
12022   return 0;
12023 }
12024
12025 static int test_write_file_4_skip (void)
12026 {
12027   const char *str;
12028
12029   str = getenv ("TEST_ONLY");
12030   if (str)
12031     return strstr (str, "write_file") == NULL;
12032   str = getenv ("SKIP_TEST_WRITE_FILE_4");
12033   if (str && strcmp (str, "1") == 0) return 1;
12034   str = getenv ("SKIP_TEST_WRITE_FILE");
12035   if (str && strcmp (str, "1") == 0) return 1;
12036   return 0;
12037 }
12038
12039 static int test_write_file_4 (void)
12040 {
12041   if (test_write_file_4_skip ()) {
12042     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
12043     return 0;
12044   }
12045
12046   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
12047   {
12048     char device[] = "/dev/sda";
12049     int r;
12050     suppress_error = 0;
12051     r = guestfs_blockdev_setrw (g, device);
12052     if (r == -1)
12053       return -1;
12054   }
12055   {
12056     int r;
12057     suppress_error = 0;
12058     r = guestfs_umount_all (g);
12059     if (r == -1)
12060       return -1;
12061   }
12062   {
12063     int r;
12064     suppress_error = 0;
12065     r = guestfs_lvm_remove_all (g);
12066     if (r == -1)
12067       return -1;
12068   }
12069   {
12070     char device[] = "/dev/sda";
12071     char lines_0[] = ",";
12072     char *lines[] = {
12073       lines_0,
12074       NULL
12075     };
12076     int r;
12077     suppress_error = 0;
12078     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12079     if (r == -1)
12080       return -1;
12081   }
12082   {
12083     char fstype[] = "ext2";
12084     char device[] = "/dev/sda1";
12085     int r;
12086     suppress_error = 0;
12087     r = guestfs_mkfs (g, fstype, device);
12088     if (r == -1)
12089       return -1;
12090   }
12091   {
12092     char device[] = "/dev/sda1";
12093     char mountpoint[] = "/";
12094     int r;
12095     suppress_error = 0;
12096     r = guestfs_mount (g, device, mountpoint);
12097     if (r == -1)
12098       return -1;
12099   }
12100   /* TestOutput for write_file (4) */
12101   char expected[] = "\n\n\n";
12102   {
12103     char path[] = "/new";
12104     char content[] = "\n\n\n";
12105     int r;
12106     suppress_error = 0;
12107     r = guestfs_write_file (g, path, content, 0);
12108     if (r == -1)
12109       return -1;
12110   }
12111   {
12112     char path[] = "/new";
12113     char *r;
12114     suppress_error = 0;
12115     r = guestfs_cat (g, path);
12116     if (r == NULL)
12117       return -1;
12118     if (strcmp (r, expected) != 0) {
12119       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
12120       return -1;
12121     }
12122     free (r);
12123   }
12124   return 0;
12125 }
12126
12127 static int test_write_file_5_skip (void)
12128 {
12129   const char *str;
12130
12131   str = getenv ("TEST_ONLY");
12132   if (str)
12133     return strstr (str, "write_file") == NULL;
12134   str = getenv ("SKIP_TEST_WRITE_FILE_5");
12135   if (str && strcmp (str, "1") == 0) return 1;
12136   str = getenv ("SKIP_TEST_WRITE_FILE");
12137   if (str && strcmp (str, "1") == 0) return 1;
12138   return 0;
12139 }
12140
12141 static int test_write_file_5 (void)
12142 {
12143   if (test_write_file_5_skip ()) {
12144     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
12145     return 0;
12146   }
12147
12148   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
12149   {
12150     char device[] = "/dev/sda";
12151     int r;
12152     suppress_error = 0;
12153     r = guestfs_blockdev_setrw (g, device);
12154     if (r == -1)
12155       return -1;
12156   }
12157   {
12158     int r;
12159     suppress_error = 0;
12160     r = guestfs_umount_all (g);
12161     if (r == -1)
12162       return -1;
12163   }
12164   {
12165     int r;
12166     suppress_error = 0;
12167     r = guestfs_lvm_remove_all (g);
12168     if (r == -1)
12169       return -1;
12170   }
12171   {
12172     char device[] = "/dev/sda";
12173     char lines_0[] = ",";
12174     char *lines[] = {
12175       lines_0,
12176       NULL
12177     };
12178     int r;
12179     suppress_error = 0;
12180     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12181     if (r == -1)
12182       return -1;
12183   }
12184   {
12185     char fstype[] = "ext2";
12186     char device[] = "/dev/sda1";
12187     int r;
12188     suppress_error = 0;
12189     r = guestfs_mkfs (g, fstype, device);
12190     if (r == -1)
12191       return -1;
12192   }
12193   {
12194     char device[] = "/dev/sda1";
12195     char mountpoint[] = "/";
12196     int r;
12197     suppress_error = 0;
12198     r = guestfs_mount (g, device, mountpoint);
12199     if (r == -1)
12200       return -1;
12201   }
12202   /* TestOutput for write_file (5) */
12203   char expected[] = "\n";
12204   {
12205     char path[] = "/new";
12206     char content[] = "\n";
12207     int r;
12208     suppress_error = 0;
12209     r = guestfs_write_file (g, path, content, 0);
12210     if (r == -1)
12211       return -1;
12212   }
12213   {
12214     char path[] = "/new";
12215     char *r;
12216     suppress_error = 0;
12217     r = guestfs_cat (g, path);
12218     if (r == NULL)
12219       return -1;
12220     if (strcmp (r, expected) != 0) {
12221       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
12222       return -1;
12223     }
12224     free (r);
12225   }
12226   return 0;
12227 }
12228
12229 static int test_mkfs_0_skip (void)
12230 {
12231   const char *str;
12232
12233   str = getenv ("TEST_ONLY");
12234   if (str)
12235     return strstr (str, "mkfs") == NULL;
12236   str = getenv ("SKIP_TEST_MKFS_0");
12237   if (str && strcmp (str, "1") == 0) return 1;
12238   str = getenv ("SKIP_TEST_MKFS");
12239   if (str && strcmp (str, "1") == 0) return 1;
12240   return 0;
12241 }
12242
12243 static int test_mkfs_0 (void)
12244 {
12245   if (test_mkfs_0_skip ()) {
12246     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
12247     return 0;
12248   }
12249
12250   /* InitNone|InitEmpty for test_mkfs_0 */
12251   {
12252     char device[] = "/dev/sda";
12253     int r;
12254     suppress_error = 0;
12255     r = guestfs_blockdev_setrw (g, device);
12256     if (r == -1)
12257       return -1;
12258   }
12259   {
12260     int r;
12261     suppress_error = 0;
12262     r = guestfs_umount_all (g);
12263     if (r == -1)
12264       return -1;
12265   }
12266   {
12267     int r;
12268     suppress_error = 0;
12269     r = guestfs_lvm_remove_all (g);
12270     if (r == -1)
12271       return -1;
12272   }
12273   /* TestOutput for mkfs (0) */
12274   char expected[] = "new file contents";
12275   {
12276     char device[] = "/dev/sda";
12277     char lines_0[] = ",";
12278     char *lines[] = {
12279       lines_0,
12280       NULL
12281     };
12282     int r;
12283     suppress_error = 0;
12284     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12285     if (r == -1)
12286       return -1;
12287   }
12288   {
12289     char fstype[] = "ext2";
12290     char device[] = "/dev/sda1";
12291     int r;
12292     suppress_error = 0;
12293     r = guestfs_mkfs (g, fstype, device);
12294     if (r == -1)
12295       return -1;
12296   }
12297   {
12298     char device[] = "/dev/sda1";
12299     char mountpoint[] = "/";
12300     int r;
12301     suppress_error = 0;
12302     r = guestfs_mount (g, device, mountpoint);
12303     if (r == -1)
12304       return -1;
12305   }
12306   {
12307     char path[] = "/new";
12308     char content[] = "new file contents";
12309     int r;
12310     suppress_error = 0;
12311     r = guestfs_write_file (g, path, content, 0);
12312     if (r == -1)
12313       return -1;
12314   }
12315   {
12316     char path[] = "/new";
12317     char *r;
12318     suppress_error = 0;
12319     r = guestfs_cat (g, path);
12320     if (r == NULL)
12321       return -1;
12322     if (strcmp (r, expected) != 0) {
12323       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
12324       return -1;
12325     }
12326     free (r);
12327   }
12328   return 0;
12329 }
12330
12331 static int test_lvcreate_0_skip (void)
12332 {
12333   const char *str;
12334
12335   str = getenv ("TEST_ONLY");
12336   if (str)
12337     return strstr (str, "lvcreate") == NULL;
12338   str = getenv ("SKIP_TEST_LVCREATE_0");
12339   if (str && strcmp (str, "1") == 0) return 1;
12340   str = getenv ("SKIP_TEST_LVCREATE");
12341   if (str && strcmp (str, "1") == 0) return 1;
12342   return 0;
12343 }
12344
12345 static int test_lvcreate_0 (void)
12346 {
12347   if (test_lvcreate_0_skip ()) {
12348     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
12349     return 0;
12350   }
12351
12352   /* InitNone|InitEmpty for test_lvcreate_0 */
12353   {
12354     char device[] = "/dev/sda";
12355     int r;
12356     suppress_error = 0;
12357     r = guestfs_blockdev_setrw (g, device);
12358     if (r == -1)
12359       return -1;
12360   }
12361   {
12362     int r;
12363     suppress_error = 0;
12364     r = guestfs_umount_all (g);
12365     if (r == -1)
12366       return -1;
12367   }
12368   {
12369     int r;
12370     suppress_error = 0;
12371     r = guestfs_lvm_remove_all (g);
12372     if (r == -1)
12373       return -1;
12374   }
12375   /* TestOutputList for lvcreate (0) */
12376   {
12377     char device[] = "/dev/sda";
12378     char lines_0[] = ",10";
12379     char lines_1[] = ",20";
12380     char lines_2[] = ",";
12381     char *lines[] = {
12382       lines_0,
12383       lines_1,
12384       lines_2,
12385       NULL
12386     };
12387     int r;
12388     suppress_error = 0;
12389     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12390     if (r == -1)
12391       return -1;
12392   }
12393   {
12394     char device[] = "/dev/sda1";
12395     int r;
12396     suppress_error = 0;
12397     r = guestfs_pvcreate (g, device);
12398     if (r == -1)
12399       return -1;
12400   }
12401   {
12402     char device[] = "/dev/sda2";
12403     int r;
12404     suppress_error = 0;
12405     r = guestfs_pvcreate (g, device);
12406     if (r == -1)
12407       return -1;
12408   }
12409   {
12410     char device[] = "/dev/sda3";
12411     int r;
12412     suppress_error = 0;
12413     r = guestfs_pvcreate (g, device);
12414     if (r == -1)
12415       return -1;
12416   }
12417   {
12418     char volgroup[] = "VG1";
12419     char physvols_0[] = "/dev/sda1";
12420     char physvols_1[] = "/dev/sda2";
12421     char *physvols[] = {
12422       physvols_0,
12423       physvols_1,
12424       NULL
12425     };
12426     int r;
12427     suppress_error = 0;
12428     r = guestfs_vgcreate (g, volgroup, physvols);
12429     if (r == -1)
12430       return -1;
12431   }
12432   {
12433     char volgroup[] = "VG2";
12434     char physvols_0[] = "/dev/sda3";
12435     char *physvols[] = {
12436       physvols_0,
12437       NULL
12438     };
12439     int r;
12440     suppress_error = 0;
12441     r = guestfs_vgcreate (g, volgroup, physvols);
12442     if (r == -1)
12443       return -1;
12444   }
12445   {
12446     char logvol[] = "LV1";
12447     char volgroup[] = "VG1";
12448     int r;
12449     suppress_error = 0;
12450     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12451     if (r == -1)
12452       return -1;
12453   }
12454   {
12455     char logvol[] = "LV2";
12456     char volgroup[] = "VG1";
12457     int r;
12458     suppress_error = 0;
12459     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12460     if (r == -1)
12461       return -1;
12462   }
12463   {
12464     char logvol[] = "LV3";
12465     char volgroup[] = "VG2";
12466     int r;
12467     suppress_error = 0;
12468     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12469     if (r == -1)
12470       return -1;
12471   }
12472   {
12473     char logvol[] = "LV4";
12474     char volgroup[] = "VG2";
12475     int r;
12476     suppress_error = 0;
12477     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12478     if (r == -1)
12479       return -1;
12480   }
12481   {
12482     char logvol[] = "LV5";
12483     char volgroup[] = "VG2";
12484     int r;
12485     suppress_error = 0;
12486     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12487     if (r == -1)
12488       return -1;
12489   }
12490   {
12491     char **r;
12492     int i;
12493     suppress_error = 0;
12494     r = guestfs_lvs (g);
12495     if (r == NULL)
12496       return -1;
12497     if (!r[0]) {
12498       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12499       print_strings (r);
12500       return -1;
12501     }
12502     {
12503       char expected[] = "/dev/VG1/LV1";
12504       if (strcmp (r[0], expected) != 0) {
12505         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12506         return -1;
12507       }
12508     }
12509     if (!r[1]) {
12510       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12511       print_strings (r);
12512       return -1;
12513     }
12514     {
12515       char expected[] = "/dev/VG1/LV2";
12516       if (strcmp (r[1], expected) != 0) {
12517         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12518         return -1;
12519       }
12520     }
12521     if (!r[2]) {
12522       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12523       print_strings (r);
12524       return -1;
12525     }
12526     {
12527       char expected[] = "/dev/VG2/LV3";
12528       if (strcmp (r[2], expected) != 0) {
12529         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12530         return -1;
12531       }
12532     }
12533     if (!r[3]) {
12534       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12535       print_strings (r);
12536       return -1;
12537     }
12538     {
12539       char expected[] = "/dev/VG2/LV4";
12540       if (strcmp (r[3], expected) != 0) {
12541         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12542         return -1;
12543       }
12544     }
12545     if (!r[4]) {
12546       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12547       print_strings (r);
12548       return -1;
12549     }
12550     {
12551       char expected[] = "/dev/VG2/LV5";
12552       if (strcmp (r[4], expected) != 0) {
12553         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
12554         return -1;
12555       }
12556     }
12557     if (r[5] != NULL) {
12558       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
12559       print_strings (r);
12560       return -1;
12561     }
12562     for (i = 0; r[i] != NULL; ++i)
12563       free (r[i]);
12564     free (r);
12565   }
12566   return 0;
12567 }
12568
12569 static int test_vgcreate_0_skip (void)
12570 {
12571   const char *str;
12572
12573   str = getenv ("TEST_ONLY");
12574   if (str)
12575     return strstr (str, "vgcreate") == NULL;
12576   str = getenv ("SKIP_TEST_VGCREATE_0");
12577   if (str && strcmp (str, "1") == 0) return 1;
12578   str = getenv ("SKIP_TEST_VGCREATE");
12579   if (str && strcmp (str, "1") == 0) return 1;
12580   return 0;
12581 }
12582
12583 static int test_vgcreate_0 (void)
12584 {
12585   if (test_vgcreate_0_skip ()) {
12586     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
12587     return 0;
12588   }
12589
12590   /* InitNone|InitEmpty for test_vgcreate_0 */
12591   {
12592     char device[] = "/dev/sda";
12593     int r;
12594     suppress_error = 0;
12595     r = guestfs_blockdev_setrw (g, device);
12596     if (r == -1)
12597       return -1;
12598   }
12599   {
12600     int r;
12601     suppress_error = 0;
12602     r = guestfs_umount_all (g);
12603     if (r == -1)
12604       return -1;
12605   }
12606   {
12607     int r;
12608     suppress_error = 0;
12609     r = guestfs_lvm_remove_all (g);
12610     if (r == -1)
12611       return -1;
12612   }
12613   /* TestOutputList for vgcreate (0) */
12614   {
12615     char device[] = "/dev/sda";
12616     char lines_0[] = ",10";
12617     char lines_1[] = ",20";
12618     char lines_2[] = ",";
12619     char *lines[] = {
12620       lines_0,
12621       lines_1,
12622       lines_2,
12623       NULL
12624     };
12625     int r;
12626     suppress_error = 0;
12627     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12628     if (r == -1)
12629       return -1;
12630   }
12631   {
12632     char device[] = "/dev/sda1";
12633     int r;
12634     suppress_error = 0;
12635     r = guestfs_pvcreate (g, device);
12636     if (r == -1)
12637       return -1;
12638   }
12639   {
12640     char device[] = "/dev/sda2";
12641     int r;
12642     suppress_error = 0;
12643     r = guestfs_pvcreate (g, device);
12644     if (r == -1)
12645       return -1;
12646   }
12647   {
12648     char device[] = "/dev/sda3";
12649     int r;
12650     suppress_error = 0;
12651     r = guestfs_pvcreate (g, device);
12652     if (r == -1)
12653       return -1;
12654   }
12655   {
12656     char volgroup[] = "VG1";
12657     char physvols_0[] = "/dev/sda1";
12658     char physvols_1[] = "/dev/sda2";
12659     char *physvols[] = {
12660       physvols_0,
12661       physvols_1,
12662       NULL
12663     };
12664     int r;
12665     suppress_error = 0;
12666     r = guestfs_vgcreate (g, volgroup, physvols);
12667     if (r == -1)
12668       return -1;
12669   }
12670   {
12671     char volgroup[] = "VG2";
12672     char physvols_0[] = "/dev/sda3";
12673     char *physvols[] = {
12674       physvols_0,
12675       NULL
12676     };
12677     int r;
12678     suppress_error = 0;
12679     r = guestfs_vgcreate (g, volgroup, physvols);
12680     if (r == -1)
12681       return -1;
12682   }
12683   {
12684     char **r;
12685     int i;
12686     suppress_error = 0;
12687     r = guestfs_vgs (g);
12688     if (r == NULL)
12689       return -1;
12690     if (!r[0]) {
12691       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12692       print_strings (r);
12693       return -1;
12694     }
12695     {
12696       char expected[] = "VG1";
12697       if (strcmp (r[0], expected) != 0) {
12698         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12699         return -1;
12700       }
12701     }
12702     if (!r[1]) {
12703       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12704       print_strings (r);
12705       return -1;
12706     }
12707     {
12708       char expected[] = "VG2";
12709       if (strcmp (r[1], expected) != 0) {
12710         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12711         return -1;
12712       }
12713     }
12714     if (r[2] != NULL) {
12715       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12716       print_strings (r);
12717       return -1;
12718     }
12719     for (i = 0; r[i] != NULL; ++i)
12720       free (r[i]);
12721     free (r);
12722   }
12723   return 0;
12724 }
12725
12726 static int test_pvcreate_0_skip (void)
12727 {
12728   const char *str;
12729
12730   str = getenv ("TEST_ONLY");
12731   if (str)
12732     return strstr (str, "pvcreate") == NULL;
12733   str = getenv ("SKIP_TEST_PVCREATE_0");
12734   if (str && strcmp (str, "1") == 0) return 1;
12735   str = getenv ("SKIP_TEST_PVCREATE");
12736   if (str && strcmp (str, "1") == 0) return 1;
12737   return 0;
12738 }
12739
12740 static int test_pvcreate_0 (void)
12741 {
12742   if (test_pvcreate_0_skip ()) {
12743     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12744     return 0;
12745   }
12746
12747   /* InitNone|InitEmpty for test_pvcreate_0 */
12748   {
12749     char device[] = "/dev/sda";
12750     int r;
12751     suppress_error = 0;
12752     r = guestfs_blockdev_setrw (g, device);
12753     if (r == -1)
12754       return -1;
12755   }
12756   {
12757     int r;
12758     suppress_error = 0;
12759     r = guestfs_umount_all (g);
12760     if (r == -1)
12761       return -1;
12762   }
12763   {
12764     int r;
12765     suppress_error = 0;
12766     r = guestfs_lvm_remove_all (g);
12767     if (r == -1)
12768       return -1;
12769   }
12770   /* TestOutputListOfDevices for pvcreate (0) */
12771   {
12772     char device[] = "/dev/sda";
12773     char lines_0[] = ",10";
12774     char lines_1[] = ",20";
12775     char lines_2[] = ",";
12776     char *lines[] = {
12777       lines_0,
12778       lines_1,
12779       lines_2,
12780       NULL
12781     };
12782     int r;
12783     suppress_error = 0;
12784     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12785     if (r == -1)
12786       return -1;
12787   }
12788   {
12789     char device[] = "/dev/sda1";
12790     int r;
12791     suppress_error = 0;
12792     r = guestfs_pvcreate (g, device);
12793     if (r == -1)
12794       return -1;
12795   }
12796   {
12797     char device[] = "/dev/sda2";
12798     int r;
12799     suppress_error = 0;
12800     r = guestfs_pvcreate (g, device);
12801     if (r == -1)
12802       return -1;
12803   }
12804   {
12805     char device[] = "/dev/sda3";
12806     int r;
12807     suppress_error = 0;
12808     r = guestfs_pvcreate (g, device);
12809     if (r == -1)
12810       return -1;
12811   }
12812   {
12813     char **r;
12814     int i;
12815     suppress_error = 0;
12816     r = guestfs_pvs (g);
12817     if (r == NULL)
12818       return -1;
12819     if (!r[0]) {
12820       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12821       print_strings (r);
12822       return -1;
12823     }
12824     {
12825       char expected[] = "/dev/sda1";
12826       r[0][5] = 's';
12827       if (strcmp (r[0], expected) != 0) {
12828         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12829         return -1;
12830       }
12831     }
12832     if (!r[1]) {
12833       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12834       print_strings (r);
12835       return -1;
12836     }
12837     {
12838       char expected[] = "/dev/sda2";
12839       r[1][5] = 's';
12840       if (strcmp (r[1], expected) != 0) {
12841         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12842         return -1;
12843       }
12844     }
12845     if (!r[2]) {
12846       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12847       print_strings (r);
12848       return -1;
12849     }
12850     {
12851       char expected[] = "/dev/sda3";
12852       r[2][5] = 's';
12853       if (strcmp (r[2], expected) != 0) {
12854         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12855         return -1;
12856       }
12857     }
12858     if (r[3] != NULL) {
12859       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12860       print_strings (r);
12861       return -1;
12862     }
12863     for (i = 0; r[i] != NULL; ++i)
12864       free (r[i]);
12865     free (r);
12866   }
12867   return 0;
12868 }
12869
12870 static int test_is_dir_0_skip (void)
12871 {
12872   const char *str;
12873
12874   str = getenv ("TEST_ONLY");
12875   if (str)
12876     return strstr (str, "is_dir") == NULL;
12877   str = getenv ("SKIP_TEST_IS_DIR_0");
12878   if (str && strcmp (str, "1") == 0) return 1;
12879   str = getenv ("SKIP_TEST_IS_DIR");
12880   if (str && strcmp (str, "1") == 0) return 1;
12881   return 0;
12882 }
12883
12884 static int test_is_dir_0 (void)
12885 {
12886   if (test_is_dir_0_skip ()) {
12887     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12888     return 0;
12889   }
12890
12891   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12892   {
12893     char device[] = "/dev/sda";
12894     int r;
12895     suppress_error = 0;
12896     r = guestfs_blockdev_setrw (g, device);
12897     if (r == -1)
12898       return -1;
12899   }
12900   {
12901     int r;
12902     suppress_error = 0;
12903     r = guestfs_umount_all (g);
12904     if (r == -1)
12905       return -1;
12906   }
12907   {
12908     int r;
12909     suppress_error = 0;
12910     r = guestfs_lvm_remove_all (g);
12911     if (r == -1)
12912       return -1;
12913   }
12914   {
12915     char device[] = "/dev/sda";
12916     char lines_0[] = ",";
12917     char *lines[] = {
12918       lines_0,
12919       NULL
12920     };
12921     int r;
12922     suppress_error = 0;
12923     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12924     if (r == -1)
12925       return -1;
12926   }
12927   {
12928     char fstype[] = "ext2";
12929     char device[] = "/dev/sda1";
12930     int r;
12931     suppress_error = 0;
12932     r = guestfs_mkfs (g, fstype, device);
12933     if (r == -1)
12934       return -1;
12935   }
12936   {
12937     char device[] = "/dev/sda1";
12938     char mountpoint[] = "/";
12939     int r;
12940     suppress_error = 0;
12941     r = guestfs_mount (g, device, mountpoint);
12942     if (r == -1)
12943       return -1;
12944   }
12945   /* TestOutputFalse for is_dir (0) */
12946   {
12947     char path[] = "/new";
12948     int r;
12949     suppress_error = 0;
12950     r = guestfs_touch (g, path);
12951     if (r == -1)
12952       return -1;
12953   }
12954   {
12955     char path[] = "/new";
12956     int r;
12957     suppress_error = 0;
12958     r = guestfs_is_dir (g, path);
12959     if (r == -1)
12960       return -1;
12961     if (r) {
12962       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12963       return -1;
12964     }
12965   }
12966   return 0;
12967 }
12968
12969 static int test_is_dir_1_skip (void)
12970 {
12971   const char *str;
12972
12973   str = getenv ("TEST_ONLY");
12974   if (str)
12975     return strstr (str, "is_dir") == NULL;
12976   str = getenv ("SKIP_TEST_IS_DIR_1");
12977   if (str && strcmp (str, "1") == 0) return 1;
12978   str = getenv ("SKIP_TEST_IS_DIR");
12979   if (str && strcmp (str, "1") == 0) return 1;
12980   return 0;
12981 }
12982
12983 static int test_is_dir_1 (void)
12984 {
12985   if (test_is_dir_1_skip ()) {
12986     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12987     return 0;
12988   }
12989
12990   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12991   {
12992     char device[] = "/dev/sda";
12993     int r;
12994     suppress_error = 0;
12995     r = guestfs_blockdev_setrw (g, device);
12996     if (r == -1)
12997       return -1;
12998   }
12999   {
13000     int r;
13001     suppress_error = 0;
13002     r = guestfs_umount_all (g);
13003     if (r == -1)
13004       return -1;
13005   }
13006   {
13007     int r;
13008     suppress_error = 0;
13009     r = guestfs_lvm_remove_all (g);
13010     if (r == -1)
13011       return -1;
13012   }
13013   {
13014     char device[] = "/dev/sda";
13015     char lines_0[] = ",";
13016     char *lines[] = {
13017       lines_0,
13018       NULL
13019     };
13020     int r;
13021     suppress_error = 0;
13022     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13023     if (r == -1)
13024       return -1;
13025   }
13026   {
13027     char fstype[] = "ext2";
13028     char device[] = "/dev/sda1";
13029     int r;
13030     suppress_error = 0;
13031     r = guestfs_mkfs (g, fstype, device);
13032     if (r == -1)
13033       return -1;
13034   }
13035   {
13036     char device[] = "/dev/sda1";
13037     char mountpoint[] = "/";
13038     int r;
13039     suppress_error = 0;
13040     r = guestfs_mount (g, device, mountpoint);
13041     if (r == -1)
13042       return -1;
13043   }
13044   /* TestOutputTrue for is_dir (1) */
13045   {
13046     char path[] = "/new";
13047     int r;
13048     suppress_error = 0;
13049     r = guestfs_mkdir (g, path);
13050     if (r == -1)
13051       return -1;
13052   }
13053   {
13054     char path[] = "/new";
13055     int r;
13056     suppress_error = 0;
13057     r = guestfs_is_dir (g, path);
13058     if (r == -1)
13059       return -1;
13060     if (!r) {
13061       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
13062       return -1;
13063     }
13064   }
13065   return 0;
13066 }
13067
13068 static int test_is_file_0_skip (void)
13069 {
13070   const char *str;
13071
13072   str = getenv ("TEST_ONLY");
13073   if (str)
13074     return strstr (str, "is_file") == NULL;
13075   str = getenv ("SKIP_TEST_IS_FILE_0");
13076   if (str && strcmp (str, "1") == 0) return 1;
13077   str = getenv ("SKIP_TEST_IS_FILE");
13078   if (str && strcmp (str, "1") == 0) return 1;
13079   return 0;
13080 }
13081
13082 static int test_is_file_0 (void)
13083 {
13084   if (test_is_file_0_skip ()) {
13085     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
13086     return 0;
13087   }
13088
13089   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
13090   {
13091     char device[] = "/dev/sda";
13092     int r;
13093     suppress_error = 0;
13094     r = guestfs_blockdev_setrw (g, device);
13095     if (r == -1)
13096       return -1;
13097   }
13098   {
13099     int r;
13100     suppress_error = 0;
13101     r = guestfs_umount_all (g);
13102     if (r == -1)
13103       return -1;
13104   }
13105   {
13106     int r;
13107     suppress_error = 0;
13108     r = guestfs_lvm_remove_all (g);
13109     if (r == -1)
13110       return -1;
13111   }
13112   {
13113     char device[] = "/dev/sda";
13114     char lines_0[] = ",";
13115     char *lines[] = {
13116       lines_0,
13117       NULL
13118     };
13119     int r;
13120     suppress_error = 0;
13121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13122     if (r == -1)
13123       return -1;
13124   }
13125   {
13126     char fstype[] = "ext2";
13127     char device[] = "/dev/sda1";
13128     int r;
13129     suppress_error = 0;
13130     r = guestfs_mkfs (g, fstype, device);
13131     if (r == -1)
13132       return -1;
13133   }
13134   {
13135     char device[] = "/dev/sda1";
13136     char mountpoint[] = "/";
13137     int r;
13138     suppress_error = 0;
13139     r = guestfs_mount (g, device, mountpoint);
13140     if (r == -1)
13141       return -1;
13142   }
13143   /* TestOutputTrue for is_file (0) */
13144   {
13145     char path[] = "/new";
13146     int r;
13147     suppress_error = 0;
13148     r = guestfs_touch (g, path);
13149     if (r == -1)
13150       return -1;
13151   }
13152   {
13153     char path[] = "/new";
13154     int r;
13155     suppress_error = 0;
13156     r = guestfs_is_file (g, path);
13157     if (r == -1)
13158       return -1;
13159     if (!r) {
13160       fprintf (stderr, "test_is_file_0: expected true, got false\n");
13161       return -1;
13162     }
13163   }
13164   return 0;
13165 }
13166
13167 static int test_is_file_1_skip (void)
13168 {
13169   const char *str;
13170
13171   str = getenv ("TEST_ONLY");
13172   if (str)
13173     return strstr (str, "is_file") == NULL;
13174   str = getenv ("SKIP_TEST_IS_FILE_1");
13175   if (str && strcmp (str, "1") == 0) return 1;
13176   str = getenv ("SKIP_TEST_IS_FILE");
13177   if (str && strcmp (str, "1") == 0) return 1;
13178   return 0;
13179 }
13180
13181 static int test_is_file_1 (void)
13182 {
13183   if (test_is_file_1_skip ()) {
13184     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
13185     return 0;
13186   }
13187
13188   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
13189   {
13190     char device[] = "/dev/sda";
13191     int r;
13192     suppress_error = 0;
13193     r = guestfs_blockdev_setrw (g, device);
13194     if (r == -1)
13195       return -1;
13196   }
13197   {
13198     int r;
13199     suppress_error = 0;
13200     r = guestfs_umount_all (g);
13201     if (r == -1)
13202       return -1;
13203   }
13204   {
13205     int r;
13206     suppress_error = 0;
13207     r = guestfs_lvm_remove_all (g);
13208     if (r == -1)
13209       return -1;
13210   }
13211   {
13212     char device[] = "/dev/sda";
13213     char lines_0[] = ",";
13214     char *lines[] = {
13215       lines_0,
13216       NULL
13217     };
13218     int r;
13219     suppress_error = 0;
13220     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13221     if (r == -1)
13222       return -1;
13223   }
13224   {
13225     char fstype[] = "ext2";
13226     char device[] = "/dev/sda1";
13227     int r;
13228     suppress_error = 0;
13229     r = guestfs_mkfs (g, fstype, device);
13230     if (r == -1)
13231       return -1;
13232   }
13233   {
13234     char device[] = "/dev/sda1";
13235     char mountpoint[] = "/";
13236     int r;
13237     suppress_error = 0;
13238     r = guestfs_mount (g, device, mountpoint);
13239     if (r == -1)
13240       return -1;
13241   }
13242   /* TestOutputFalse for is_file (1) */
13243   {
13244     char path[] = "/new";
13245     int r;
13246     suppress_error = 0;
13247     r = guestfs_mkdir (g, path);
13248     if (r == -1)
13249       return -1;
13250   }
13251   {
13252     char path[] = "/new";
13253     int r;
13254     suppress_error = 0;
13255     r = guestfs_is_file (g, path);
13256     if (r == -1)
13257       return -1;
13258     if (r) {
13259       fprintf (stderr, "test_is_file_1: expected false, got true\n");
13260       return -1;
13261     }
13262   }
13263   return 0;
13264 }
13265
13266 static int test_exists_0_skip (void)
13267 {
13268   const char *str;
13269
13270   str = getenv ("TEST_ONLY");
13271   if (str)
13272     return strstr (str, "exists") == NULL;
13273   str = getenv ("SKIP_TEST_EXISTS_0");
13274   if (str && strcmp (str, "1") == 0) return 1;
13275   str = getenv ("SKIP_TEST_EXISTS");
13276   if (str && strcmp (str, "1") == 0) return 1;
13277   return 0;
13278 }
13279
13280 static int test_exists_0 (void)
13281 {
13282   if (test_exists_0_skip ()) {
13283     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
13284     return 0;
13285   }
13286
13287   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
13288   {
13289     char device[] = "/dev/sda";
13290     int r;
13291     suppress_error = 0;
13292     r = guestfs_blockdev_setrw (g, device);
13293     if (r == -1)
13294       return -1;
13295   }
13296   {
13297     int r;
13298     suppress_error = 0;
13299     r = guestfs_umount_all (g);
13300     if (r == -1)
13301       return -1;
13302   }
13303   {
13304     int r;
13305     suppress_error = 0;
13306     r = guestfs_lvm_remove_all (g);
13307     if (r == -1)
13308       return -1;
13309   }
13310   {
13311     char device[] = "/dev/sda";
13312     char lines_0[] = ",";
13313     char *lines[] = {
13314       lines_0,
13315       NULL
13316     };
13317     int r;
13318     suppress_error = 0;
13319     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13320     if (r == -1)
13321       return -1;
13322   }
13323   {
13324     char fstype[] = "ext2";
13325     char device[] = "/dev/sda1";
13326     int r;
13327     suppress_error = 0;
13328     r = guestfs_mkfs (g, fstype, device);
13329     if (r == -1)
13330       return -1;
13331   }
13332   {
13333     char device[] = "/dev/sda1";
13334     char mountpoint[] = "/";
13335     int r;
13336     suppress_error = 0;
13337     r = guestfs_mount (g, device, mountpoint);
13338     if (r == -1)
13339       return -1;
13340   }
13341   /* TestOutputTrue for exists (0) */
13342   {
13343     char path[] = "/new";
13344     int r;
13345     suppress_error = 0;
13346     r = guestfs_touch (g, path);
13347     if (r == -1)
13348       return -1;
13349   }
13350   {
13351     char path[] = "/new";
13352     int r;
13353     suppress_error = 0;
13354     r = guestfs_exists (g, path);
13355     if (r == -1)
13356       return -1;
13357     if (!r) {
13358       fprintf (stderr, "test_exists_0: expected true, got false\n");
13359       return -1;
13360     }
13361   }
13362   return 0;
13363 }
13364
13365 static int test_exists_1_skip (void)
13366 {
13367   const char *str;
13368
13369   str = getenv ("TEST_ONLY");
13370   if (str)
13371     return strstr (str, "exists") == NULL;
13372   str = getenv ("SKIP_TEST_EXISTS_1");
13373   if (str && strcmp (str, "1") == 0) return 1;
13374   str = getenv ("SKIP_TEST_EXISTS");
13375   if (str && strcmp (str, "1") == 0) return 1;
13376   return 0;
13377 }
13378
13379 static int test_exists_1 (void)
13380 {
13381   if (test_exists_1_skip ()) {
13382     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
13383     return 0;
13384   }
13385
13386   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
13387   {
13388     char device[] = "/dev/sda";
13389     int r;
13390     suppress_error = 0;
13391     r = guestfs_blockdev_setrw (g, device);
13392     if (r == -1)
13393       return -1;
13394   }
13395   {
13396     int r;
13397     suppress_error = 0;
13398     r = guestfs_umount_all (g);
13399     if (r == -1)
13400       return -1;
13401   }
13402   {
13403     int r;
13404     suppress_error = 0;
13405     r = guestfs_lvm_remove_all (g);
13406     if (r == -1)
13407       return -1;
13408   }
13409   {
13410     char device[] = "/dev/sda";
13411     char lines_0[] = ",";
13412     char *lines[] = {
13413       lines_0,
13414       NULL
13415     };
13416     int r;
13417     suppress_error = 0;
13418     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13419     if (r == -1)
13420       return -1;
13421   }
13422   {
13423     char fstype[] = "ext2";
13424     char device[] = "/dev/sda1";
13425     int r;
13426     suppress_error = 0;
13427     r = guestfs_mkfs (g, fstype, device);
13428     if (r == -1)
13429       return -1;
13430   }
13431   {
13432     char device[] = "/dev/sda1";
13433     char mountpoint[] = "/";
13434     int r;
13435     suppress_error = 0;
13436     r = guestfs_mount (g, device, mountpoint);
13437     if (r == -1)
13438       return -1;
13439   }
13440   /* TestOutputTrue for exists (1) */
13441   {
13442     char path[] = "/new";
13443     int r;
13444     suppress_error = 0;
13445     r = guestfs_mkdir (g, path);
13446     if (r == -1)
13447       return -1;
13448   }
13449   {
13450     char path[] = "/new";
13451     int r;
13452     suppress_error = 0;
13453     r = guestfs_exists (g, path);
13454     if (r == -1)
13455       return -1;
13456     if (!r) {
13457       fprintf (stderr, "test_exists_1: expected true, got false\n");
13458       return -1;
13459     }
13460   }
13461   return 0;
13462 }
13463
13464 static int test_mkdir_p_0_skip (void)
13465 {
13466   const char *str;
13467
13468   str = getenv ("TEST_ONLY");
13469   if (str)
13470     return strstr (str, "mkdir_p") == NULL;
13471   str = getenv ("SKIP_TEST_MKDIR_P_0");
13472   if (str && strcmp (str, "1") == 0) return 1;
13473   str = getenv ("SKIP_TEST_MKDIR_P");
13474   if (str && strcmp (str, "1") == 0) return 1;
13475   return 0;
13476 }
13477
13478 static int test_mkdir_p_0 (void)
13479 {
13480   if (test_mkdir_p_0_skip ()) {
13481     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
13482     return 0;
13483   }
13484
13485   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
13486   {
13487     char device[] = "/dev/sda";
13488     int r;
13489     suppress_error = 0;
13490     r = guestfs_blockdev_setrw (g, device);
13491     if (r == -1)
13492       return -1;
13493   }
13494   {
13495     int r;
13496     suppress_error = 0;
13497     r = guestfs_umount_all (g);
13498     if (r == -1)
13499       return -1;
13500   }
13501   {
13502     int r;
13503     suppress_error = 0;
13504     r = guestfs_lvm_remove_all (g);
13505     if (r == -1)
13506       return -1;
13507   }
13508   {
13509     char device[] = "/dev/sda";
13510     char lines_0[] = ",";
13511     char *lines[] = {
13512       lines_0,
13513       NULL
13514     };
13515     int r;
13516     suppress_error = 0;
13517     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13518     if (r == -1)
13519       return -1;
13520   }
13521   {
13522     char fstype[] = "ext2";
13523     char device[] = "/dev/sda1";
13524     int r;
13525     suppress_error = 0;
13526     r = guestfs_mkfs (g, fstype, device);
13527     if (r == -1)
13528       return -1;
13529   }
13530   {
13531     char device[] = "/dev/sda1";
13532     char mountpoint[] = "/";
13533     int r;
13534     suppress_error = 0;
13535     r = guestfs_mount (g, device, mountpoint);
13536     if (r == -1)
13537       return -1;
13538   }
13539   /* TestOutputTrue for mkdir_p (0) */
13540   {
13541     char path[] = "/new/foo/bar";
13542     int r;
13543     suppress_error = 0;
13544     r = guestfs_mkdir_p (g, path);
13545     if (r == -1)
13546       return -1;
13547   }
13548   {
13549     char path[] = "/new/foo/bar";
13550     int r;
13551     suppress_error = 0;
13552     r = guestfs_is_dir (g, path);
13553     if (r == -1)
13554       return -1;
13555     if (!r) {
13556       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
13557       return -1;
13558     }
13559   }
13560   return 0;
13561 }
13562
13563 static int test_mkdir_p_1_skip (void)
13564 {
13565   const char *str;
13566
13567   str = getenv ("TEST_ONLY");
13568   if (str)
13569     return strstr (str, "mkdir_p") == NULL;
13570   str = getenv ("SKIP_TEST_MKDIR_P_1");
13571   if (str && strcmp (str, "1") == 0) return 1;
13572   str = getenv ("SKIP_TEST_MKDIR_P");
13573   if (str && strcmp (str, "1") == 0) return 1;
13574   return 0;
13575 }
13576
13577 static int test_mkdir_p_1 (void)
13578 {
13579   if (test_mkdir_p_1_skip ()) {
13580     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
13581     return 0;
13582   }
13583
13584   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
13585   {
13586     char device[] = "/dev/sda";
13587     int r;
13588     suppress_error = 0;
13589     r = guestfs_blockdev_setrw (g, device);
13590     if (r == -1)
13591       return -1;
13592   }
13593   {
13594     int r;
13595     suppress_error = 0;
13596     r = guestfs_umount_all (g);
13597     if (r == -1)
13598       return -1;
13599   }
13600   {
13601     int r;
13602     suppress_error = 0;
13603     r = guestfs_lvm_remove_all (g);
13604     if (r == -1)
13605       return -1;
13606   }
13607   {
13608     char device[] = "/dev/sda";
13609     char lines_0[] = ",";
13610     char *lines[] = {
13611       lines_0,
13612       NULL
13613     };
13614     int r;
13615     suppress_error = 0;
13616     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13617     if (r == -1)
13618       return -1;
13619   }
13620   {
13621     char fstype[] = "ext2";
13622     char device[] = "/dev/sda1";
13623     int r;
13624     suppress_error = 0;
13625     r = guestfs_mkfs (g, fstype, device);
13626     if (r == -1)
13627       return -1;
13628   }
13629   {
13630     char device[] = "/dev/sda1";
13631     char mountpoint[] = "/";
13632     int r;
13633     suppress_error = 0;
13634     r = guestfs_mount (g, device, mountpoint);
13635     if (r == -1)
13636       return -1;
13637   }
13638   /* TestOutputTrue for mkdir_p (1) */
13639   {
13640     char path[] = "/new/foo/bar";
13641     int r;
13642     suppress_error = 0;
13643     r = guestfs_mkdir_p (g, path);
13644     if (r == -1)
13645       return -1;
13646   }
13647   {
13648     char path[] = "/new/foo";
13649     int r;
13650     suppress_error = 0;
13651     r = guestfs_is_dir (g, path);
13652     if (r == -1)
13653       return -1;
13654     if (!r) {
13655       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
13656       return -1;
13657     }
13658   }
13659   return 0;
13660 }
13661
13662 static int test_mkdir_p_2_skip (void)
13663 {
13664   const char *str;
13665
13666   str = getenv ("TEST_ONLY");
13667   if (str)
13668     return strstr (str, "mkdir_p") == NULL;
13669   str = getenv ("SKIP_TEST_MKDIR_P_2");
13670   if (str && strcmp (str, "1") == 0) return 1;
13671   str = getenv ("SKIP_TEST_MKDIR_P");
13672   if (str && strcmp (str, "1") == 0) return 1;
13673   return 0;
13674 }
13675
13676 static int test_mkdir_p_2 (void)
13677 {
13678   if (test_mkdir_p_2_skip ()) {
13679     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
13680     return 0;
13681   }
13682
13683   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
13684   {
13685     char device[] = "/dev/sda";
13686     int r;
13687     suppress_error = 0;
13688     r = guestfs_blockdev_setrw (g, device);
13689     if (r == -1)
13690       return -1;
13691   }
13692   {
13693     int r;
13694     suppress_error = 0;
13695     r = guestfs_umount_all (g);
13696     if (r == -1)
13697       return -1;
13698   }
13699   {
13700     int r;
13701     suppress_error = 0;
13702     r = guestfs_lvm_remove_all (g);
13703     if (r == -1)
13704       return -1;
13705   }
13706   {
13707     char device[] = "/dev/sda";
13708     char lines_0[] = ",";
13709     char *lines[] = {
13710       lines_0,
13711       NULL
13712     };
13713     int r;
13714     suppress_error = 0;
13715     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13716     if (r == -1)
13717       return -1;
13718   }
13719   {
13720     char fstype[] = "ext2";
13721     char device[] = "/dev/sda1";
13722     int r;
13723     suppress_error = 0;
13724     r = guestfs_mkfs (g, fstype, device);
13725     if (r == -1)
13726       return -1;
13727   }
13728   {
13729     char device[] = "/dev/sda1";
13730     char mountpoint[] = "/";
13731     int r;
13732     suppress_error = 0;
13733     r = guestfs_mount (g, device, mountpoint);
13734     if (r == -1)
13735       return -1;
13736   }
13737   /* TestOutputTrue for mkdir_p (2) */
13738   {
13739     char path[] = "/new/foo/bar";
13740     int r;
13741     suppress_error = 0;
13742     r = guestfs_mkdir_p (g, path);
13743     if (r == -1)
13744       return -1;
13745   }
13746   {
13747     char path[] = "/new";
13748     int r;
13749     suppress_error = 0;
13750     r = guestfs_is_dir (g, path);
13751     if (r == -1)
13752       return -1;
13753     if (!r) {
13754       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13755       return -1;
13756     }
13757   }
13758   return 0;
13759 }
13760
13761 static int test_mkdir_p_3_skip (void)
13762 {
13763   const char *str;
13764
13765   str = getenv ("TEST_ONLY");
13766   if (str)
13767     return strstr (str, "mkdir_p") == NULL;
13768   str = getenv ("SKIP_TEST_MKDIR_P_3");
13769   if (str && strcmp (str, "1") == 0) return 1;
13770   str = getenv ("SKIP_TEST_MKDIR_P");
13771   if (str && strcmp (str, "1") == 0) return 1;
13772   return 0;
13773 }
13774
13775 static int test_mkdir_p_3 (void)
13776 {
13777   if (test_mkdir_p_3_skip ()) {
13778     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13779     return 0;
13780   }
13781
13782   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13783   {
13784     char device[] = "/dev/sda";
13785     int r;
13786     suppress_error = 0;
13787     r = guestfs_blockdev_setrw (g, device);
13788     if (r == -1)
13789       return -1;
13790   }
13791   {
13792     int r;
13793     suppress_error = 0;
13794     r = guestfs_umount_all (g);
13795     if (r == -1)
13796       return -1;
13797   }
13798   {
13799     int r;
13800     suppress_error = 0;
13801     r = guestfs_lvm_remove_all (g);
13802     if (r == -1)
13803       return -1;
13804   }
13805   {
13806     char device[] = "/dev/sda";
13807     char lines_0[] = ",";
13808     char *lines[] = {
13809       lines_0,
13810       NULL
13811     };
13812     int r;
13813     suppress_error = 0;
13814     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13815     if (r == -1)
13816       return -1;
13817   }
13818   {
13819     char fstype[] = "ext2";
13820     char device[] = "/dev/sda1";
13821     int r;
13822     suppress_error = 0;
13823     r = guestfs_mkfs (g, fstype, device);
13824     if (r == -1)
13825       return -1;
13826   }
13827   {
13828     char device[] = "/dev/sda1";
13829     char mountpoint[] = "/";
13830     int r;
13831     suppress_error = 0;
13832     r = guestfs_mount (g, device, mountpoint);
13833     if (r == -1)
13834       return -1;
13835   }
13836   /* TestRun for mkdir_p (3) */
13837   {
13838     char path[] = "/new";
13839     int r;
13840     suppress_error = 0;
13841     r = guestfs_mkdir (g, path);
13842     if (r == -1)
13843       return -1;
13844   }
13845   {
13846     char path[] = "/new";
13847     int r;
13848     suppress_error = 0;
13849     r = guestfs_mkdir_p (g, path);
13850     if (r == -1)
13851       return -1;
13852   }
13853   return 0;
13854 }
13855
13856 static int test_mkdir_p_4_skip (void)
13857 {
13858   const char *str;
13859
13860   str = getenv ("TEST_ONLY");
13861   if (str)
13862     return strstr (str, "mkdir_p") == NULL;
13863   str = getenv ("SKIP_TEST_MKDIR_P_4");
13864   if (str && strcmp (str, "1") == 0) return 1;
13865   str = getenv ("SKIP_TEST_MKDIR_P");
13866   if (str && strcmp (str, "1") == 0) return 1;
13867   return 0;
13868 }
13869
13870 static int test_mkdir_p_4 (void)
13871 {
13872   if (test_mkdir_p_4_skip ()) {
13873     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13874     return 0;
13875   }
13876
13877   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13878   {
13879     char device[] = "/dev/sda";
13880     int r;
13881     suppress_error = 0;
13882     r = guestfs_blockdev_setrw (g, device);
13883     if (r == -1)
13884       return -1;
13885   }
13886   {
13887     int r;
13888     suppress_error = 0;
13889     r = guestfs_umount_all (g);
13890     if (r == -1)
13891       return -1;
13892   }
13893   {
13894     int r;
13895     suppress_error = 0;
13896     r = guestfs_lvm_remove_all (g);
13897     if (r == -1)
13898       return -1;
13899   }
13900   {
13901     char device[] = "/dev/sda";
13902     char lines_0[] = ",";
13903     char *lines[] = {
13904       lines_0,
13905       NULL
13906     };
13907     int r;
13908     suppress_error = 0;
13909     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13910     if (r == -1)
13911       return -1;
13912   }
13913   {
13914     char fstype[] = "ext2";
13915     char device[] = "/dev/sda1";
13916     int r;
13917     suppress_error = 0;
13918     r = guestfs_mkfs (g, fstype, device);
13919     if (r == -1)
13920       return -1;
13921   }
13922   {
13923     char device[] = "/dev/sda1";
13924     char mountpoint[] = "/";
13925     int r;
13926     suppress_error = 0;
13927     r = guestfs_mount (g, device, mountpoint);
13928     if (r == -1)
13929       return -1;
13930   }
13931   /* TestLastFail for mkdir_p (4) */
13932   {
13933     char path[] = "/new";
13934     int r;
13935     suppress_error = 0;
13936     r = guestfs_touch (g, path);
13937     if (r == -1)
13938       return -1;
13939   }
13940   {
13941     char path[] = "/new";
13942     int r;
13943     suppress_error = 1;
13944     r = guestfs_mkdir_p (g, path);
13945     if (r != -1)
13946       return -1;
13947   }
13948   return 0;
13949 }
13950
13951 static int test_mkdir_0_skip (void)
13952 {
13953   const char *str;
13954
13955   str = getenv ("TEST_ONLY");
13956   if (str)
13957     return strstr (str, "mkdir") == NULL;
13958   str = getenv ("SKIP_TEST_MKDIR_0");
13959   if (str && strcmp (str, "1") == 0) return 1;
13960   str = getenv ("SKIP_TEST_MKDIR");
13961   if (str && strcmp (str, "1") == 0) return 1;
13962   return 0;
13963 }
13964
13965 static int test_mkdir_0 (void)
13966 {
13967   if (test_mkdir_0_skip ()) {
13968     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13969     return 0;
13970   }
13971
13972   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13973   {
13974     char device[] = "/dev/sda";
13975     int r;
13976     suppress_error = 0;
13977     r = guestfs_blockdev_setrw (g, device);
13978     if (r == -1)
13979       return -1;
13980   }
13981   {
13982     int r;
13983     suppress_error = 0;
13984     r = guestfs_umount_all (g);
13985     if (r == -1)
13986       return -1;
13987   }
13988   {
13989     int r;
13990     suppress_error = 0;
13991     r = guestfs_lvm_remove_all (g);
13992     if (r == -1)
13993       return -1;
13994   }
13995   {
13996     char device[] = "/dev/sda";
13997     char lines_0[] = ",";
13998     char *lines[] = {
13999       lines_0,
14000       NULL
14001     };
14002     int r;
14003     suppress_error = 0;
14004     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14005     if (r == -1)
14006       return -1;
14007   }
14008   {
14009     char fstype[] = "ext2";
14010     char device[] = "/dev/sda1";
14011     int r;
14012     suppress_error = 0;
14013     r = guestfs_mkfs (g, fstype, device);
14014     if (r == -1)
14015       return -1;
14016   }
14017   {
14018     char device[] = "/dev/sda1";
14019     char mountpoint[] = "/";
14020     int r;
14021     suppress_error = 0;
14022     r = guestfs_mount (g, device, mountpoint);
14023     if (r == -1)
14024       return -1;
14025   }
14026   /* TestOutputTrue for mkdir (0) */
14027   {
14028     char path[] = "/new";
14029     int r;
14030     suppress_error = 0;
14031     r = guestfs_mkdir (g, path);
14032     if (r == -1)
14033       return -1;
14034   }
14035   {
14036     char path[] = "/new";
14037     int r;
14038     suppress_error = 0;
14039     r = guestfs_is_dir (g, path);
14040     if (r == -1)
14041       return -1;
14042     if (!r) {
14043       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
14044       return -1;
14045     }
14046   }
14047   return 0;
14048 }
14049
14050 static int test_mkdir_1_skip (void)
14051 {
14052   const char *str;
14053
14054   str = getenv ("TEST_ONLY");
14055   if (str)
14056     return strstr (str, "mkdir") == NULL;
14057   str = getenv ("SKIP_TEST_MKDIR_1");
14058   if (str && strcmp (str, "1") == 0) return 1;
14059   str = getenv ("SKIP_TEST_MKDIR");
14060   if (str && strcmp (str, "1") == 0) return 1;
14061   return 0;
14062 }
14063
14064 static int test_mkdir_1 (void)
14065 {
14066   if (test_mkdir_1_skip ()) {
14067     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
14068     return 0;
14069   }
14070
14071   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
14072   {
14073     char device[] = "/dev/sda";
14074     int r;
14075     suppress_error = 0;
14076     r = guestfs_blockdev_setrw (g, device);
14077     if (r == -1)
14078       return -1;
14079   }
14080   {
14081     int r;
14082     suppress_error = 0;
14083     r = guestfs_umount_all (g);
14084     if (r == -1)
14085       return -1;
14086   }
14087   {
14088     int r;
14089     suppress_error = 0;
14090     r = guestfs_lvm_remove_all (g);
14091     if (r == -1)
14092       return -1;
14093   }
14094   {
14095     char device[] = "/dev/sda";
14096     char lines_0[] = ",";
14097     char *lines[] = {
14098       lines_0,
14099       NULL
14100     };
14101     int r;
14102     suppress_error = 0;
14103     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14104     if (r == -1)
14105       return -1;
14106   }
14107   {
14108     char fstype[] = "ext2";
14109     char device[] = "/dev/sda1";
14110     int r;
14111     suppress_error = 0;
14112     r = guestfs_mkfs (g, fstype, device);
14113     if (r == -1)
14114       return -1;
14115   }
14116   {
14117     char device[] = "/dev/sda1";
14118     char mountpoint[] = "/";
14119     int r;
14120     suppress_error = 0;
14121     r = guestfs_mount (g, device, mountpoint);
14122     if (r == -1)
14123       return -1;
14124   }
14125   /* TestLastFail for mkdir (1) */
14126   {
14127     char path[] = "/new/foo/bar";
14128     int r;
14129     suppress_error = 1;
14130     r = guestfs_mkdir (g, path);
14131     if (r != -1)
14132       return -1;
14133   }
14134   return 0;
14135 }
14136
14137 static int test_rm_rf_0_skip (void)
14138 {
14139   const char *str;
14140
14141   str = getenv ("TEST_ONLY");
14142   if (str)
14143     return strstr (str, "rm_rf") == NULL;
14144   str = getenv ("SKIP_TEST_RM_RF_0");
14145   if (str && strcmp (str, "1") == 0) return 1;
14146   str = getenv ("SKIP_TEST_RM_RF");
14147   if (str && strcmp (str, "1") == 0) return 1;
14148   return 0;
14149 }
14150
14151 static int test_rm_rf_0 (void)
14152 {
14153   if (test_rm_rf_0_skip ()) {
14154     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
14155     return 0;
14156   }
14157
14158   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
14159   {
14160     char device[] = "/dev/sda";
14161     int r;
14162     suppress_error = 0;
14163     r = guestfs_blockdev_setrw (g, device);
14164     if (r == -1)
14165       return -1;
14166   }
14167   {
14168     int r;
14169     suppress_error = 0;
14170     r = guestfs_umount_all (g);
14171     if (r == -1)
14172       return -1;
14173   }
14174   {
14175     int r;
14176     suppress_error = 0;
14177     r = guestfs_lvm_remove_all (g);
14178     if (r == -1)
14179       return -1;
14180   }
14181   {
14182     char device[] = "/dev/sda";
14183     char lines_0[] = ",";
14184     char *lines[] = {
14185       lines_0,
14186       NULL
14187     };
14188     int r;
14189     suppress_error = 0;
14190     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14191     if (r == -1)
14192       return -1;
14193   }
14194   {
14195     char fstype[] = "ext2";
14196     char device[] = "/dev/sda1";
14197     int r;
14198     suppress_error = 0;
14199     r = guestfs_mkfs (g, fstype, device);
14200     if (r == -1)
14201       return -1;
14202   }
14203   {
14204     char device[] = "/dev/sda1";
14205     char mountpoint[] = "/";
14206     int r;
14207     suppress_error = 0;
14208     r = guestfs_mount (g, device, mountpoint);
14209     if (r == -1)
14210       return -1;
14211   }
14212   /* TestOutputFalse for rm_rf (0) */
14213   {
14214     char path[] = "/new";
14215     int r;
14216     suppress_error = 0;
14217     r = guestfs_mkdir (g, path);
14218     if (r == -1)
14219       return -1;
14220   }
14221   {
14222     char path[] = "/new/foo";
14223     int r;
14224     suppress_error = 0;
14225     r = guestfs_mkdir (g, path);
14226     if (r == -1)
14227       return -1;
14228   }
14229   {
14230     char path[] = "/new/foo/bar";
14231     int r;
14232     suppress_error = 0;
14233     r = guestfs_touch (g, path);
14234     if (r == -1)
14235       return -1;
14236   }
14237   {
14238     char path[] = "/new";
14239     int r;
14240     suppress_error = 0;
14241     r = guestfs_rm_rf (g, path);
14242     if (r == -1)
14243       return -1;
14244   }
14245   {
14246     char path[] = "/new";
14247     int r;
14248     suppress_error = 0;
14249     r = guestfs_exists (g, path);
14250     if (r == -1)
14251       return -1;
14252     if (r) {
14253       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
14254       return -1;
14255     }
14256   }
14257   return 0;
14258 }
14259
14260 static int test_rmdir_0_skip (void)
14261 {
14262   const char *str;
14263
14264   str = getenv ("TEST_ONLY");
14265   if (str)
14266     return strstr (str, "rmdir") == NULL;
14267   str = getenv ("SKIP_TEST_RMDIR_0");
14268   if (str && strcmp (str, "1") == 0) return 1;
14269   str = getenv ("SKIP_TEST_RMDIR");
14270   if (str && strcmp (str, "1") == 0) return 1;
14271   return 0;
14272 }
14273
14274 static int test_rmdir_0 (void)
14275 {
14276   if (test_rmdir_0_skip ()) {
14277     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
14278     return 0;
14279   }
14280
14281   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
14282   {
14283     char device[] = "/dev/sda";
14284     int r;
14285     suppress_error = 0;
14286     r = guestfs_blockdev_setrw (g, device);
14287     if (r == -1)
14288       return -1;
14289   }
14290   {
14291     int r;
14292     suppress_error = 0;
14293     r = guestfs_umount_all (g);
14294     if (r == -1)
14295       return -1;
14296   }
14297   {
14298     int r;
14299     suppress_error = 0;
14300     r = guestfs_lvm_remove_all (g);
14301     if (r == -1)
14302       return -1;
14303   }
14304   {
14305     char device[] = "/dev/sda";
14306     char lines_0[] = ",";
14307     char *lines[] = {
14308       lines_0,
14309       NULL
14310     };
14311     int r;
14312     suppress_error = 0;
14313     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14314     if (r == -1)
14315       return -1;
14316   }
14317   {
14318     char fstype[] = "ext2";
14319     char device[] = "/dev/sda1";
14320     int r;
14321     suppress_error = 0;
14322     r = guestfs_mkfs (g, fstype, device);
14323     if (r == -1)
14324       return -1;
14325   }
14326   {
14327     char device[] = "/dev/sda1";
14328     char mountpoint[] = "/";
14329     int r;
14330     suppress_error = 0;
14331     r = guestfs_mount (g, device, mountpoint);
14332     if (r == -1)
14333       return -1;
14334   }
14335   /* TestRun for rmdir (0) */
14336   {
14337     char path[] = "/new";
14338     int r;
14339     suppress_error = 0;
14340     r = guestfs_mkdir (g, path);
14341     if (r == -1)
14342       return -1;
14343   }
14344   {
14345     char path[] = "/new";
14346     int r;
14347     suppress_error = 0;
14348     r = guestfs_rmdir (g, path);
14349     if (r == -1)
14350       return -1;
14351   }
14352   return 0;
14353 }
14354
14355 static int test_rmdir_1_skip (void)
14356 {
14357   const char *str;
14358
14359   str = getenv ("TEST_ONLY");
14360   if (str)
14361     return strstr (str, "rmdir") == NULL;
14362   str = getenv ("SKIP_TEST_RMDIR_1");
14363   if (str && strcmp (str, "1") == 0) return 1;
14364   str = getenv ("SKIP_TEST_RMDIR");
14365   if (str && strcmp (str, "1") == 0) return 1;
14366   return 0;
14367 }
14368
14369 static int test_rmdir_1 (void)
14370 {
14371   if (test_rmdir_1_skip ()) {
14372     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
14373     return 0;
14374   }
14375
14376   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
14377   {
14378     char device[] = "/dev/sda";
14379     int r;
14380     suppress_error = 0;
14381     r = guestfs_blockdev_setrw (g, device);
14382     if (r == -1)
14383       return -1;
14384   }
14385   {
14386     int r;
14387     suppress_error = 0;
14388     r = guestfs_umount_all (g);
14389     if (r == -1)
14390       return -1;
14391   }
14392   {
14393     int r;
14394     suppress_error = 0;
14395     r = guestfs_lvm_remove_all (g);
14396     if (r == -1)
14397       return -1;
14398   }
14399   {
14400     char device[] = "/dev/sda";
14401     char lines_0[] = ",";
14402     char *lines[] = {
14403       lines_0,
14404       NULL
14405     };
14406     int r;
14407     suppress_error = 0;
14408     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14409     if (r == -1)
14410       return -1;
14411   }
14412   {
14413     char fstype[] = "ext2";
14414     char device[] = "/dev/sda1";
14415     int r;
14416     suppress_error = 0;
14417     r = guestfs_mkfs (g, fstype, device);
14418     if (r == -1)
14419       return -1;
14420   }
14421   {
14422     char device[] = "/dev/sda1";
14423     char mountpoint[] = "/";
14424     int r;
14425     suppress_error = 0;
14426     r = guestfs_mount (g, device, mountpoint);
14427     if (r == -1)
14428       return -1;
14429   }
14430   /* TestLastFail for rmdir (1) */
14431   {
14432     char path[] = "/new";
14433     int r;
14434     suppress_error = 1;
14435     r = guestfs_rmdir (g, path);
14436     if (r != -1)
14437       return -1;
14438   }
14439   return 0;
14440 }
14441
14442 static int test_rmdir_2_skip (void)
14443 {
14444   const char *str;
14445
14446   str = getenv ("TEST_ONLY");
14447   if (str)
14448     return strstr (str, "rmdir") == NULL;
14449   str = getenv ("SKIP_TEST_RMDIR_2");
14450   if (str && strcmp (str, "1") == 0) return 1;
14451   str = getenv ("SKIP_TEST_RMDIR");
14452   if (str && strcmp (str, "1") == 0) return 1;
14453   return 0;
14454 }
14455
14456 static int test_rmdir_2 (void)
14457 {
14458   if (test_rmdir_2_skip ()) {
14459     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
14460     return 0;
14461   }
14462
14463   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
14464   {
14465     char device[] = "/dev/sda";
14466     int r;
14467     suppress_error = 0;
14468     r = guestfs_blockdev_setrw (g, device);
14469     if (r == -1)
14470       return -1;
14471   }
14472   {
14473     int r;
14474     suppress_error = 0;
14475     r = guestfs_umount_all (g);
14476     if (r == -1)
14477       return -1;
14478   }
14479   {
14480     int r;
14481     suppress_error = 0;
14482     r = guestfs_lvm_remove_all (g);
14483     if (r == -1)
14484       return -1;
14485   }
14486   {
14487     char device[] = "/dev/sda";
14488     char lines_0[] = ",";
14489     char *lines[] = {
14490       lines_0,
14491       NULL
14492     };
14493     int r;
14494     suppress_error = 0;
14495     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14496     if (r == -1)
14497       return -1;
14498   }
14499   {
14500     char fstype[] = "ext2";
14501     char device[] = "/dev/sda1";
14502     int r;
14503     suppress_error = 0;
14504     r = guestfs_mkfs (g, fstype, device);
14505     if (r == -1)
14506       return -1;
14507   }
14508   {
14509     char device[] = "/dev/sda1";
14510     char mountpoint[] = "/";
14511     int r;
14512     suppress_error = 0;
14513     r = guestfs_mount (g, device, mountpoint);
14514     if (r == -1)
14515       return -1;
14516   }
14517   /* TestLastFail for rmdir (2) */
14518   {
14519     char path[] = "/new";
14520     int r;
14521     suppress_error = 0;
14522     r = guestfs_touch (g, path);
14523     if (r == -1)
14524       return -1;
14525   }
14526   {
14527     char path[] = "/new";
14528     int r;
14529     suppress_error = 1;
14530     r = guestfs_rmdir (g, path);
14531     if (r != -1)
14532       return -1;
14533   }
14534   return 0;
14535 }
14536
14537 static int test_rm_0_skip (void)
14538 {
14539   const char *str;
14540
14541   str = getenv ("TEST_ONLY");
14542   if (str)
14543     return strstr (str, "rm") == NULL;
14544   str = getenv ("SKIP_TEST_RM_0");
14545   if (str && strcmp (str, "1") == 0) return 1;
14546   str = getenv ("SKIP_TEST_RM");
14547   if (str && strcmp (str, "1") == 0) return 1;
14548   return 0;
14549 }
14550
14551 static int test_rm_0 (void)
14552 {
14553   if (test_rm_0_skip ()) {
14554     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
14555     return 0;
14556   }
14557
14558   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
14559   {
14560     char device[] = "/dev/sda";
14561     int r;
14562     suppress_error = 0;
14563     r = guestfs_blockdev_setrw (g, device);
14564     if (r == -1)
14565       return -1;
14566   }
14567   {
14568     int r;
14569     suppress_error = 0;
14570     r = guestfs_umount_all (g);
14571     if (r == -1)
14572       return -1;
14573   }
14574   {
14575     int r;
14576     suppress_error = 0;
14577     r = guestfs_lvm_remove_all (g);
14578     if (r == -1)
14579       return -1;
14580   }
14581   {
14582     char device[] = "/dev/sda";
14583     char lines_0[] = ",";
14584     char *lines[] = {
14585       lines_0,
14586       NULL
14587     };
14588     int r;
14589     suppress_error = 0;
14590     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14591     if (r == -1)
14592       return -1;
14593   }
14594   {
14595     char fstype[] = "ext2";
14596     char device[] = "/dev/sda1";
14597     int r;
14598     suppress_error = 0;
14599     r = guestfs_mkfs (g, fstype, device);
14600     if (r == -1)
14601       return -1;
14602   }
14603   {
14604     char device[] = "/dev/sda1";
14605     char mountpoint[] = "/";
14606     int r;
14607     suppress_error = 0;
14608     r = guestfs_mount (g, device, mountpoint);
14609     if (r == -1)
14610       return -1;
14611   }
14612   /* TestRun for rm (0) */
14613   {
14614     char path[] = "/new";
14615     int r;
14616     suppress_error = 0;
14617     r = guestfs_touch (g, path);
14618     if (r == -1)
14619       return -1;
14620   }
14621   {
14622     char path[] = "/new";
14623     int r;
14624     suppress_error = 0;
14625     r = guestfs_rm (g, path);
14626     if (r == -1)
14627       return -1;
14628   }
14629   return 0;
14630 }
14631
14632 static int test_rm_1_skip (void)
14633 {
14634   const char *str;
14635
14636   str = getenv ("TEST_ONLY");
14637   if (str)
14638     return strstr (str, "rm") == NULL;
14639   str = getenv ("SKIP_TEST_RM_1");
14640   if (str && strcmp (str, "1") == 0) return 1;
14641   str = getenv ("SKIP_TEST_RM");
14642   if (str && strcmp (str, "1") == 0) return 1;
14643   return 0;
14644 }
14645
14646 static int test_rm_1 (void)
14647 {
14648   if (test_rm_1_skip ()) {
14649     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
14650     return 0;
14651   }
14652
14653   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14654   {
14655     char device[] = "/dev/sda";
14656     int r;
14657     suppress_error = 0;
14658     r = guestfs_blockdev_setrw (g, device);
14659     if (r == -1)
14660       return -1;
14661   }
14662   {
14663     int r;
14664     suppress_error = 0;
14665     r = guestfs_umount_all (g);
14666     if (r == -1)
14667       return -1;
14668   }
14669   {
14670     int r;
14671     suppress_error = 0;
14672     r = guestfs_lvm_remove_all (g);
14673     if (r == -1)
14674       return -1;
14675   }
14676   {
14677     char device[] = "/dev/sda";
14678     char lines_0[] = ",";
14679     char *lines[] = {
14680       lines_0,
14681       NULL
14682     };
14683     int r;
14684     suppress_error = 0;
14685     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14686     if (r == -1)
14687       return -1;
14688   }
14689   {
14690     char fstype[] = "ext2";
14691     char device[] = "/dev/sda1";
14692     int r;
14693     suppress_error = 0;
14694     r = guestfs_mkfs (g, fstype, device);
14695     if (r == -1)
14696       return -1;
14697   }
14698   {
14699     char device[] = "/dev/sda1";
14700     char mountpoint[] = "/";
14701     int r;
14702     suppress_error = 0;
14703     r = guestfs_mount (g, device, mountpoint);
14704     if (r == -1)
14705       return -1;
14706   }
14707   /* TestLastFail for rm (1) */
14708   {
14709     char path[] = "/new";
14710     int r;
14711     suppress_error = 1;
14712     r = guestfs_rm (g, path);
14713     if (r != -1)
14714       return -1;
14715   }
14716   return 0;
14717 }
14718
14719 static int test_rm_2_skip (void)
14720 {
14721   const char *str;
14722
14723   str = getenv ("TEST_ONLY");
14724   if (str)
14725     return strstr (str, "rm") == NULL;
14726   str = getenv ("SKIP_TEST_RM_2");
14727   if (str && strcmp (str, "1") == 0) return 1;
14728   str = getenv ("SKIP_TEST_RM");
14729   if (str && strcmp (str, "1") == 0) return 1;
14730   return 0;
14731 }
14732
14733 static int test_rm_2 (void)
14734 {
14735   if (test_rm_2_skip ()) {
14736     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
14737     return 0;
14738   }
14739
14740   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
14741   {
14742     char device[] = "/dev/sda";
14743     int r;
14744     suppress_error = 0;
14745     r = guestfs_blockdev_setrw (g, device);
14746     if (r == -1)
14747       return -1;
14748   }
14749   {
14750     int r;
14751     suppress_error = 0;
14752     r = guestfs_umount_all (g);
14753     if (r == -1)
14754       return -1;
14755   }
14756   {
14757     int r;
14758     suppress_error = 0;
14759     r = guestfs_lvm_remove_all (g);
14760     if (r == -1)
14761       return -1;
14762   }
14763   {
14764     char device[] = "/dev/sda";
14765     char lines_0[] = ",";
14766     char *lines[] = {
14767       lines_0,
14768       NULL
14769     };
14770     int r;
14771     suppress_error = 0;
14772     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14773     if (r == -1)
14774       return -1;
14775   }
14776   {
14777     char fstype[] = "ext2";
14778     char device[] = "/dev/sda1";
14779     int r;
14780     suppress_error = 0;
14781     r = guestfs_mkfs (g, fstype, device);
14782     if (r == -1)
14783       return -1;
14784   }
14785   {
14786     char device[] = "/dev/sda1";
14787     char mountpoint[] = "/";
14788     int r;
14789     suppress_error = 0;
14790     r = guestfs_mount (g, device, mountpoint);
14791     if (r == -1)
14792       return -1;
14793   }
14794   /* TestLastFail for rm (2) */
14795   {
14796     char path[] = "/new";
14797     int r;
14798     suppress_error = 0;
14799     r = guestfs_mkdir (g, path);
14800     if (r == -1)
14801       return -1;
14802   }
14803   {
14804     char path[] = "/new";
14805     int r;
14806     suppress_error = 1;
14807     r = guestfs_rm (g, path);
14808     if (r != -1)
14809       return -1;
14810   }
14811   return 0;
14812 }
14813
14814 static int test_read_lines_0_skip (void)
14815 {
14816   const char *str;
14817
14818   str = getenv ("TEST_ONLY");
14819   if (str)
14820     return strstr (str, "read_lines") == NULL;
14821   str = getenv ("SKIP_TEST_READ_LINES_0");
14822   if (str && strcmp (str, "1") == 0) return 1;
14823   str = getenv ("SKIP_TEST_READ_LINES");
14824   if (str && strcmp (str, "1") == 0) return 1;
14825   return 0;
14826 }
14827
14828 static int test_read_lines_0 (void)
14829 {
14830   if (test_read_lines_0_skip ()) {
14831     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14832     return 0;
14833   }
14834
14835   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14836   {
14837     char device[] = "/dev/sda";
14838     int r;
14839     suppress_error = 0;
14840     r = guestfs_blockdev_setrw (g, device);
14841     if (r == -1)
14842       return -1;
14843   }
14844   {
14845     int r;
14846     suppress_error = 0;
14847     r = guestfs_umount_all (g);
14848     if (r == -1)
14849       return -1;
14850   }
14851   {
14852     int r;
14853     suppress_error = 0;
14854     r = guestfs_lvm_remove_all (g);
14855     if (r == -1)
14856       return -1;
14857   }
14858   {
14859     char device[] = "/dev/sda";
14860     char lines_0[] = ",";
14861     char *lines[] = {
14862       lines_0,
14863       NULL
14864     };
14865     int r;
14866     suppress_error = 0;
14867     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14868     if (r == -1)
14869       return -1;
14870   }
14871   {
14872     char fstype[] = "ext2";
14873     char device[] = "/dev/sda1";
14874     int r;
14875     suppress_error = 0;
14876     r = guestfs_mkfs (g, fstype, device);
14877     if (r == -1)
14878       return -1;
14879   }
14880   {
14881     char device[] = "/dev/sda1";
14882     char mountpoint[] = "/";
14883     int r;
14884     suppress_error = 0;
14885     r = guestfs_mount (g, device, mountpoint);
14886     if (r == -1)
14887       return -1;
14888   }
14889   /* TestOutputList for read_lines (0) */
14890   {
14891     char path[] = "/new";
14892     char content[] = "line1\r\nline2\nline3";
14893     int r;
14894     suppress_error = 0;
14895     r = guestfs_write_file (g, path, content, 0);
14896     if (r == -1)
14897       return -1;
14898   }
14899   {
14900     char path[] = "/new";
14901     char **r;
14902     int i;
14903     suppress_error = 0;
14904     r = guestfs_read_lines (g, path);
14905     if (r == NULL)
14906       return -1;
14907     if (!r[0]) {
14908       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14909       print_strings (r);
14910       return -1;
14911     }
14912     {
14913       char expected[] = "line1";
14914       if (strcmp (r[0], expected) != 0) {
14915         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14916         return -1;
14917       }
14918     }
14919     if (!r[1]) {
14920       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14921       print_strings (r);
14922       return -1;
14923     }
14924     {
14925       char expected[] = "line2";
14926       if (strcmp (r[1], expected) != 0) {
14927         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14928         return -1;
14929       }
14930     }
14931     if (!r[2]) {
14932       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14933       print_strings (r);
14934       return -1;
14935     }
14936     {
14937       char expected[] = "line3";
14938       if (strcmp (r[2], expected) != 0) {
14939         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14940         return -1;
14941       }
14942     }
14943     if (r[3] != NULL) {
14944       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14945       print_strings (r);
14946       return -1;
14947     }
14948     for (i = 0; r[i] != NULL; ++i)
14949       free (r[i]);
14950     free (r);
14951   }
14952   return 0;
14953 }
14954
14955 static int test_read_lines_1_skip (void)
14956 {
14957   const char *str;
14958
14959   str = getenv ("TEST_ONLY");
14960   if (str)
14961     return strstr (str, "read_lines") == NULL;
14962   str = getenv ("SKIP_TEST_READ_LINES_1");
14963   if (str && strcmp (str, "1") == 0) return 1;
14964   str = getenv ("SKIP_TEST_READ_LINES");
14965   if (str && strcmp (str, "1") == 0) return 1;
14966   return 0;
14967 }
14968
14969 static int test_read_lines_1 (void)
14970 {
14971   if (test_read_lines_1_skip ()) {
14972     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14973     return 0;
14974   }
14975
14976   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14977   {
14978     char device[] = "/dev/sda";
14979     int r;
14980     suppress_error = 0;
14981     r = guestfs_blockdev_setrw (g, device);
14982     if (r == -1)
14983       return -1;
14984   }
14985   {
14986     int r;
14987     suppress_error = 0;
14988     r = guestfs_umount_all (g);
14989     if (r == -1)
14990       return -1;
14991   }
14992   {
14993     int r;
14994     suppress_error = 0;
14995     r = guestfs_lvm_remove_all (g);
14996     if (r == -1)
14997       return -1;
14998   }
14999   {
15000     char device[] = "/dev/sda";
15001     char lines_0[] = ",";
15002     char *lines[] = {
15003       lines_0,
15004       NULL
15005     };
15006     int r;
15007     suppress_error = 0;
15008     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15009     if (r == -1)
15010       return -1;
15011   }
15012   {
15013     char fstype[] = "ext2";
15014     char device[] = "/dev/sda1";
15015     int r;
15016     suppress_error = 0;
15017     r = guestfs_mkfs (g, fstype, device);
15018     if (r == -1)
15019       return -1;
15020   }
15021   {
15022     char device[] = "/dev/sda1";
15023     char mountpoint[] = "/";
15024     int r;
15025     suppress_error = 0;
15026     r = guestfs_mount (g, device, mountpoint);
15027     if (r == -1)
15028       return -1;
15029   }
15030   /* TestOutputList for read_lines (1) */
15031   {
15032     char path[] = "/new";
15033     char content[] = "";
15034     int r;
15035     suppress_error = 0;
15036     r = guestfs_write_file (g, path, content, 0);
15037     if (r == -1)
15038       return -1;
15039   }
15040   {
15041     char path[] = "/new";
15042     char **r;
15043     int i;
15044     suppress_error = 0;
15045     r = guestfs_read_lines (g, path);
15046     if (r == NULL)
15047       return -1;
15048     if (r[0] != NULL) {
15049       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
15050       print_strings (r);
15051       return -1;
15052     }
15053     for (i = 0; r[i] != NULL; ++i)
15054       free (r[i]);
15055     free (r);
15056   }
15057   return 0;
15058 }
15059
15060 static int test_lvs_0_skip (void)
15061 {
15062   const char *str;
15063
15064   str = getenv ("TEST_ONLY");
15065   if (str)
15066     return strstr (str, "lvs") == NULL;
15067   str = getenv ("SKIP_TEST_LVS_0");
15068   if (str && strcmp (str, "1") == 0) return 1;
15069   str = getenv ("SKIP_TEST_LVS");
15070   if (str && strcmp (str, "1") == 0) return 1;
15071   return 0;
15072 }
15073
15074 static int test_lvs_0 (void)
15075 {
15076   if (test_lvs_0_skip ()) {
15077     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
15078     return 0;
15079   }
15080
15081   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
15082   {
15083     char device[] = "/dev/sda";
15084     int r;
15085     suppress_error = 0;
15086     r = guestfs_blockdev_setrw (g, device);
15087     if (r == -1)
15088       return -1;
15089   }
15090   {
15091     int r;
15092     suppress_error = 0;
15093     r = guestfs_umount_all (g);
15094     if (r == -1)
15095       return -1;
15096   }
15097   {
15098     int r;
15099     suppress_error = 0;
15100     r = guestfs_lvm_remove_all (g);
15101     if (r == -1)
15102       return -1;
15103   }
15104   {
15105     char device[] = "/dev/sda";
15106     char lines_0[] = ",";
15107     char *lines[] = {
15108       lines_0,
15109       NULL
15110     };
15111     int r;
15112     suppress_error = 0;
15113     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15114     if (r == -1)
15115       return -1;
15116   }
15117   {
15118     char device[] = "/dev/sda1";
15119     int r;
15120     suppress_error = 0;
15121     r = guestfs_pvcreate (g, device);
15122     if (r == -1)
15123       return -1;
15124   }
15125   {
15126     char volgroup[] = "VG";
15127     char physvols_0[] = "/dev/sda1";
15128     char *physvols[] = {
15129       physvols_0,
15130       NULL
15131     };
15132     int r;
15133     suppress_error = 0;
15134     r = guestfs_vgcreate (g, volgroup, physvols);
15135     if (r == -1)
15136       return -1;
15137   }
15138   {
15139     char logvol[] = "LV";
15140     char volgroup[] = "VG";
15141     int r;
15142     suppress_error = 0;
15143     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15144     if (r == -1)
15145       return -1;
15146   }
15147   {
15148     char fstype[] = "ext2";
15149     char device[] = "/dev/VG/LV";
15150     int r;
15151     suppress_error = 0;
15152     r = guestfs_mkfs (g, fstype, device);
15153     if (r == -1)
15154       return -1;
15155   }
15156   {
15157     char device[] = "/dev/VG/LV";
15158     char mountpoint[] = "/";
15159     int r;
15160     suppress_error = 0;
15161     r = guestfs_mount (g, device, mountpoint);
15162     if (r == -1)
15163       return -1;
15164   }
15165   /* TestOutputList for lvs (0) */
15166   {
15167     char **r;
15168     int i;
15169     suppress_error = 0;
15170     r = guestfs_lvs (g);
15171     if (r == NULL)
15172       return -1;
15173     if (!r[0]) {
15174       fprintf (stderr, "test_lvs_0: short list returned from command\n");
15175       print_strings (r);
15176       return -1;
15177     }
15178     {
15179       char expected[] = "/dev/VG/LV";
15180       if (strcmp (r[0], expected) != 0) {
15181         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15182         return -1;
15183       }
15184     }
15185     if (r[1] != NULL) {
15186       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
15187       print_strings (r);
15188       return -1;
15189     }
15190     for (i = 0; r[i] != NULL; ++i)
15191       free (r[i]);
15192     free (r);
15193   }
15194   return 0;
15195 }
15196
15197 static int test_lvs_1_skip (void)
15198 {
15199   const char *str;
15200
15201   str = getenv ("TEST_ONLY");
15202   if (str)
15203     return strstr (str, "lvs") == NULL;
15204   str = getenv ("SKIP_TEST_LVS_1");
15205   if (str && strcmp (str, "1") == 0) return 1;
15206   str = getenv ("SKIP_TEST_LVS");
15207   if (str && strcmp (str, "1") == 0) return 1;
15208   return 0;
15209 }
15210
15211 static int test_lvs_1 (void)
15212 {
15213   if (test_lvs_1_skip ()) {
15214     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
15215     return 0;
15216   }
15217
15218   /* InitNone|InitEmpty for test_lvs_1 */
15219   {
15220     char device[] = "/dev/sda";
15221     int r;
15222     suppress_error = 0;
15223     r = guestfs_blockdev_setrw (g, device);
15224     if (r == -1)
15225       return -1;
15226   }
15227   {
15228     int r;
15229     suppress_error = 0;
15230     r = guestfs_umount_all (g);
15231     if (r == -1)
15232       return -1;
15233   }
15234   {
15235     int r;
15236     suppress_error = 0;
15237     r = guestfs_lvm_remove_all (g);
15238     if (r == -1)
15239       return -1;
15240   }
15241   /* TestOutputList for lvs (1) */
15242   {
15243     char device[] = "/dev/sda";
15244     char lines_0[] = ",10";
15245     char lines_1[] = ",20";
15246     char lines_2[] = ",";
15247     char *lines[] = {
15248       lines_0,
15249       lines_1,
15250       lines_2,
15251       NULL
15252     };
15253     int r;
15254     suppress_error = 0;
15255     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15256     if (r == -1)
15257       return -1;
15258   }
15259   {
15260     char device[] = "/dev/sda1";
15261     int r;
15262     suppress_error = 0;
15263     r = guestfs_pvcreate (g, device);
15264     if (r == -1)
15265       return -1;
15266   }
15267   {
15268     char device[] = "/dev/sda2";
15269     int r;
15270     suppress_error = 0;
15271     r = guestfs_pvcreate (g, device);
15272     if (r == -1)
15273       return -1;
15274   }
15275   {
15276     char device[] = "/dev/sda3";
15277     int r;
15278     suppress_error = 0;
15279     r = guestfs_pvcreate (g, device);
15280     if (r == -1)
15281       return -1;
15282   }
15283   {
15284     char volgroup[] = "VG1";
15285     char physvols_0[] = "/dev/sda1";
15286     char physvols_1[] = "/dev/sda2";
15287     char *physvols[] = {
15288       physvols_0,
15289       physvols_1,
15290       NULL
15291     };
15292     int r;
15293     suppress_error = 0;
15294     r = guestfs_vgcreate (g, volgroup, physvols);
15295     if (r == -1)
15296       return -1;
15297   }
15298   {
15299     char volgroup[] = "VG2";
15300     char physvols_0[] = "/dev/sda3";
15301     char *physvols[] = {
15302       physvols_0,
15303       NULL
15304     };
15305     int r;
15306     suppress_error = 0;
15307     r = guestfs_vgcreate (g, volgroup, physvols);
15308     if (r == -1)
15309       return -1;
15310   }
15311   {
15312     char logvol[] = "LV1";
15313     char volgroup[] = "VG1";
15314     int r;
15315     suppress_error = 0;
15316     r = guestfs_lvcreate (g, logvol, volgroup, 50);
15317     if (r == -1)
15318       return -1;
15319   }
15320   {
15321     char logvol[] = "LV2";
15322     char volgroup[] = "VG1";
15323     int r;
15324     suppress_error = 0;
15325     r = guestfs_lvcreate (g, logvol, volgroup, 50);
15326     if (r == -1)
15327       return -1;
15328   }
15329   {
15330     char logvol[] = "LV3";
15331     char volgroup[] = "VG2";
15332     int r;
15333     suppress_error = 0;
15334     r = guestfs_lvcreate (g, logvol, volgroup, 50);
15335     if (r == -1)
15336       return -1;
15337   }
15338   {
15339     char **r;
15340     int i;
15341     suppress_error = 0;
15342     r = guestfs_lvs (g);
15343     if (r == NULL)
15344       return -1;
15345     if (!r[0]) {
15346       fprintf (stderr, "test_lvs_1: short list returned from command\n");
15347       print_strings (r);
15348       return -1;
15349     }
15350     {
15351       char expected[] = "/dev/VG1/LV1";
15352       if (strcmp (r[0], expected) != 0) {
15353         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15354         return -1;
15355       }
15356     }
15357     if (!r[1]) {
15358       fprintf (stderr, "test_lvs_1: short list returned from command\n");
15359       print_strings (r);
15360       return -1;
15361     }
15362     {
15363       char expected[] = "/dev/VG1/LV2";
15364       if (strcmp (r[1], expected) != 0) {
15365         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15366         return -1;
15367       }
15368     }
15369     if (!r[2]) {
15370       fprintf (stderr, "test_lvs_1: short list returned from command\n");
15371       print_strings (r);
15372       return -1;
15373     }
15374     {
15375       char expected[] = "/dev/VG2/LV3";
15376       if (strcmp (r[2], expected) != 0) {
15377         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15378         return -1;
15379       }
15380     }
15381     if (r[3] != NULL) {
15382       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
15383       print_strings (r);
15384       return -1;
15385     }
15386     for (i = 0; r[i] != NULL; ++i)
15387       free (r[i]);
15388     free (r);
15389   }
15390   return 0;
15391 }
15392
15393 static int test_vgs_0_skip (void)
15394 {
15395   const char *str;
15396
15397   str = getenv ("TEST_ONLY");
15398   if (str)
15399     return strstr (str, "vgs") == NULL;
15400   str = getenv ("SKIP_TEST_VGS_0");
15401   if (str && strcmp (str, "1") == 0) return 1;
15402   str = getenv ("SKIP_TEST_VGS");
15403   if (str && strcmp (str, "1") == 0) return 1;
15404   return 0;
15405 }
15406
15407 static int test_vgs_0 (void)
15408 {
15409   if (test_vgs_0_skip ()) {
15410     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
15411     return 0;
15412   }
15413
15414   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
15415   {
15416     char device[] = "/dev/sda";
15417     int r;
15418     suppress_error = 0;
15419     r = guestfs_blockdev_setrw (g, device);
15420     if (r == -1)
15421       return -1;
15422   }
15423   {
15424     int r;
15425     suppress_error = 0;
15426     r = guestfs_umount_all (g);
15427     if (r == -1)
15428       return -1;
15429   }
15430   {
15431     int r;
15432     suppress_error = 0;
15433     r = guestfs_lvm_remove_all (g);
15434     if (r == -1)
15435       return -1;
15436   }
15437   {
15438     char device[] = "/dev/sda";
15439     char lines_0[] = ",";
15440     char *lines[] = {
15441       lines_0,
15442       NULL
15443     };
15444     int r;
15445     suppress_error = 0;
15446     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15447     if (r == -1)
15448       return -1;
15449   }
15450   {
15451     char device[] = "/dev/sda1";
15452     int r;
15453     suppress_error = 0;
15454     r = guestfs_pvcreate (g, device);
15455     if (r == -1)
15456       return -1;
15457   }
15458   {
15459     char volgroup[] = "VG";
15460     char physvols_0[] = "/dev/sda1";
15461     char *physvols[] = {
15462       physvols_0,
15463       NULL
15464     };
15465     int r;
15466     suppress_error = 0;
15467     r = guestfs_vgcreate (g, volgroup, physvols);
15468     if (r == -1)
15469       return -1;
15470   }
15471   {
15472     char logvol[] = "LV";
15473     char volgroup[] = "VG";
15474     int r;
15475     suppress_error = 0;
15476     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15477     if (r == -1)
15478       return -1;
15479   }
15480   {
15481     char fstype[] = "ext2";
15482     char device[] = "/dev/VG/LV";
15483     int r;
15484     suppress_error = 0;
15485     r = guestfs_mkfs (g, fstype, device);
15486     if (r == -1)
15487       return -1;
15488   }
15489   {
15490     char device[] = "/dev/VG/LV";
15491     char mountpoint[] = "/";
15492     int r;
15493     suppress_error = 0;
15494     r = guestfs_mount (g, device, mountpoint);
15495     if (r == -1)
15496       return -1;
15497   }
15498   /* TestOutputList for vgs (0) */
15499   {
15500     char **r;
15501     int i;
15502     suppress_error = 0;
15503     r = guestfs_vgs (g);
15504     if (r == NULL)
15505       return -1;
15506     if (!r[0]) {
15507       fprintf (stderr, "test_vgs_0: short list returned from command\n");
15508       print_strings (r);
15509       return -1;
15510     }
15511     {
15512       char expected[] = "VG";
15513       if (strcmp (r[0], expected) != 0) {
15514         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15515         return -1;
15516       }
15517     }
15518     if (r[1] != NULL) {
15519       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
15520       print_strings (r);
15521       return -1;
15522     }
15523     for (i = 0; r[i] != NULL; ++i)
15524       free (r[i]);
15525     free (r);
15526   }
15527   return 0;
15528 }
15529
15530 static int test_vgs_1_skip (void)
15531 {
15532   const char *str;
15533
15534   str = getenv ("TEST_ONLY");
15535   if (str)
15536     return strstr (str, "vgs") == NULL;
15537   str = getenv ("SKIP_TEST_VGS_1");
15538   if (str && strcmp (str, "1") == 0) return 1;
15539   str = getenv ("SKIP_TEST_VGS");
15540   if (str && strcmp (str, "1") == 0) return 1;
15541   return 0;
15542 }
15543
15544 static int test_vgs_1 (void)
15545 {
15546   if (test_vgs_1_skip ()) {
15547     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
15548     return 0;
15549   }
15550
15551   /* InitNone|InitEmpty for test_vgs_1 */
15552   {
15553     char device[] = "/dev/sda";
15554     int r;
15555     suppress_error = 0;
15556     r = guestfs_blockdev_setrw (g, device);
15557     if (r == -1)
15558       return -1;
15559   }
15560   {
15561     int r;
15562     suppress_error = 0;
15563     r = guestfs_umount_all (g);
15564     if (r == -1)
15565       return -1;
15566   }
15567   {
15568     int r;
15569     suppress_error = 0;
15570     r = guestfs_lvm_remove_all (g);
15571     if (r == -1)
15572       return -1;
15573   }
15574   /* TestOutputList for vgs (1) */
15575   {
15576     char device[] = "/dev/sda";
15577     char lines_0[] = ",10";
15578     char lines_1[] = ",20";
15579     char lines_2[] = ",";
15580     char *lines[] = {
15581       lines_0,
15582       lines_1,
15583       lines_2,
15584       NULL
15585     };
15586     int r;
15587     suppress_error = 0;
15588     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15589     if (r == -1)
15590       return -1;
15591   }
15592   {
15593     char device[] = "/dev/sda1";
15594     int r;
15595     suppress_error = 0;
15596     r = guestfs_pvcreate (g, device);
15597     if (r == -1)
15598       return -1;
15599   }
15600   {
15601     char device[] = "/dev/sda2";
15602     int r;
15603     suppress_error = 0;
15604     r = guestfs_pvcreate (g, device);
15605     if (r == -1)
15606       return -1;
15607   }
15608   {
15609     char device[] = "/dev/sda3";
15610     int r;
15611     suppress_error = 0;
15612     r = guestfs_pvcreate (g, device);
15613     if (r == -1)
15614       return -1;
15615   }
15616   {
15617     char volgroup[] = "VG1";
15618     char physvols_0[] = "/dev/sda1";
15619     char physvols_1[] = "/dev/sda2";
15620     char *physvols[] = {
15621       physvols_0,
15622       physvols_1,
15623       NULL
15624     };
15625     int r;
15626     suppress_error = 0;
15627     r = guestfs_vgcreate (g, volgroup, physvols);
15628     if (r == -1)
15629       return -1;
15630   }
15631   {
15632     char volgroup[] = "VG2";
15633     char physvols_0[] = "/dev/sda3";
15634     char *physvols[] = {
15635       physvols_0,
15636       NULL
15637     };
15638     int r;
15639     suppress_error = 0;
15640     r = guestfs_vgcreate (g, volgroup, physvols);
15641     if (r == -1)
15642       return -1;
15643   }
15644   {
15645     char **r;
15646     int i;
15647     suppress_error = 0;
15648     r = guestfs_vgs (g);
15649     if (r == NULL)
15650       return -1;
15651     if (!r[0]) {
15652       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15653       print_strings (r);
15654       return -1;
15655     }
15656     {
15657       char expected[] = "VG1";
15658       if (strcmp (r[0], expected) != 0) {
15659         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15660         return -1;
15661       }
15662     }
15663     if (!r[1]) {
15664       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15665       print_strings (r);
15666       return -1;
15667     }
15668     {
15669       char expected[] = "VG2";
15670       if (strcmp (r[1], expected) != 0) {
15671         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15672         return -1;
15673       }
15674     }
15675     if (r[2] != NULL) {
15676       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15677       print_strings (r);
15678       return -1;
15679     }
15680     for (i = 0; r[i] != NULL; ++i)
15681       free (r[i]);
15682     free (r);
15683   }
15684   return 0;
15685 }
15686
15687 static int test_pvs_0_skip (void)
15688 {
15689   const char *str;
15690
15691   str = getenv ("TEST_ONLY");
15692   if (str)
15693     return strstr (str, "pvs") == NULL;
15694   str = getenv ("SKIP_TEST_PVS_0");
15695   if (str && strcmp (str, "1") == 0) return 1;
15696   str = getenv ("SKIP_TEST_PVS");
15697   if (str && strcmp (str, "1") == 0) return 1;
15698   return 0;
15699 }
15700
15701 static int test_pvs_0 (void)
15702 {
15703   if (test_pvs_0_skip ()) {
15704     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
15705     return 0;
15706   }
15707
15708   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
15709   {
15710     char device[] = "/dev/sda";
15711     int r;
15712     suppress_error = 0;
15713     r = guestfs_blockdev_setrw (g, device);
15714     if (r == -1)
15715       return -1;
15716   }
15717   {
15718     int r;
15719     suppress_error = 0;
15720     r = guestfs_umount_all (g);
15721     if (r == -1)
15722       return -1;
15723   }
15724   {
15725     int r;
15726     suppress_error = 0;
15727     r = guestfs_lvm_remove_all (g);
15728     if (r == -1)
15729       return -1;
15730   }
15731   {
15732     char device[] = "/dev/sda";
15733     char lines_0[] = ",";
15734     char *lines[] = {
15735       lines_0,
15736       NULL
15737     };
15738     int r;
15739     suppress_error = 0;
15740     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15741     if (r == -1)
15742       return -1;
15743   }
15744   {
15745     char device[] = "/dev/sda1";
15746     int r;
15747     suppress_error = 0;
15748     r = guestfs_pvcreate (g, device);
15749     if (r == -1)
15750       return -1;
15751   }
15752   {
15753     char volgroup[] = "VG";
15754     char physvols_0[] = "/dev/sda1";
15755     char *physvols[] = {
15756       physvols_0,
15757       NULL
15758     };
15759     int r;
15760     suppress_error = 0;
15761     r = guestfs_vgcreate (g, volgroup, physvols);
15762     if (r == -1)
15763       return -1;
15764   }
15765   {
15766     char logvol[] = "LV";
15767     char volgroup[] = "VG";
15768     int r;
15769     suppress_error = 0;
15770     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15771     if (r == -1)
15772       return -1;
15773   }
15774   {
15775     char fstype[] = "ext2";
15776     char device[] = "/dev/VG/LV";
15777     int r;
15778     suppress_error = 0;
15779     r = guestfs_mkfs (g, fstype, device);
15780     if (r == -1)
15781       return -1;
15782   }
15783   {
15784     char device[] = "/dev/VG/LV";
15785     char mountpoint[] = "/";
15786     int r;
15787     suppress_error = 0;
15788     r = guestfs_mount (g, device, mountpoint);
15789     if (r == -1)
15790       return -1;
15791   }
15792   /* TestOutputListOfDevices for pvs (0) */
15793   {
15794     char **r;
15795     int i;
15796     suppress_error = 0;
15797     r = guestfs_pvs (g);
15798     if (r == NULL)
15799       return -1;
15800     if (!r[0]) {
15801       fprintf (stderr, "test_pvs_0: short list returned from command\n");
15802       print_strings (r);
15803       return -1;
15804     }
15805     {
15806       char expected[] = "/dev/sda1";
15807       r[0][5] = 's';
15808       if (strcmp (r[0], expected) != 0) {
15809         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15810         return -1;
15811       }
15812     }
15813     if (r[1] != NULL) {
15814       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15815       print_strings (r);
15816       return -1;
15817     }
15818     for (i = 0; r[i] != NULL; ++i)
15819       free (r[i]);
15820     free (r);
15821   }
15822   return 0;
15823 }
15824
15825 static int test_pvs_1_skip (void)
15826 {
15827   const char *str;
15828
15829   str = getenv ("TEST_ONLY");
15830   if (str)
15831     return strstr (str, "pvs") == NULL;
15832   str = getenv ("SKIP_TEST_PVS_1");
15833   if (str && strcmp (str, "1") == 0) return 1;
15834   str = getenv ("SKIP_TEST_PVS");
15835   if (str && strcmp (str, "1") == 0) return 1;
15836   return 0;
15837 }
15838
15839 static int test_pvs_1 (void)
15840 {
15841   if (test_pvs_1_skip ()) {
15842     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15843     return 0;
15844   }
15845
15846   /* InitNone|InitEmpty for test_pvs_1 */
15847   {
15848     char device[] = "/dev/sda";
15849     int r;
15850     suppress_error = 0;
15851     r = guestfs_blockdev_setrw (g, device);
15852     if (r == -1)
15853       return -1;
15854   }
15855   {
15856     int r;
15857     suppress_error = 0;
15858     r = guestfs_umount_all (g);
15859     if (r == -1)
15860       return -1;
15861   }
15862   {
15863     int r;
15864     suppress_error = 0;
15865     r = guestfs_lvm_remove_all (g);
15866     if (r == -1)
15867       return -1;
15868   }
15869   /* TestOutputListOfDevices for pvs (1) */
15870   {
15871     char device[] = "/dev/sda";
15872     char lines_0[] = ",10";
15873     char lines_1[] = ",20";
15874     char lines_2[] = ",";
15875     char *lines[] = {
15876       lines_0,
15877       lines_1,
15878       lines_2,
15879       NULL
15880     };
15881     int r;
15882     suppress_error = 0;
15883     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15884     if (r == -1)
15885       return -1;
15886   }
15887   {
15888     char device[] = "/dev/sda1";
15889     int r;
15890     suppress_error = 0;
15891     r = guestfs_pvcreate (g, device);
15892     if (r == -1)
15893       return -1;
15894   }
15895   {
15896     char device[] = "/dev/sda2";
15897     int r;
15898     suppress_error = 0;
15899     r = guestfs_pvcreate (g, device);
15900     if (r == -1)
15901       return -1;
15902   }
15903   {
15904     char device[] = "/dev/sda3";
15905     int r;
15906     suppress_error = 0;
15907     r = guestfs_pvcreate (g, device);
15908     if (r == -1)
15909       return -1;
15910   }
15911   {
15912     char **r;
15913     int i;
15914     suppress_error = 0;
15915     r = guestfs_pvs (g);
15916     if (r == NULL)
15917       return -1;
15918     if (!r[0]) {
15919       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15920       print_strings (r);
15921       return -1;
15922     }
15923     {
15924       char expected[] = "/dev/sda1";
15925       r[0][5] = 's';
15926       if (strcmp (r[0], expected) != 0) {
15927         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15928         return -1;
15929       }
15930     }
15931     if (!r[1]) {
15932       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15933       print_strings (r);
15934       return -1;
15935     }
15936     {
15937       char expected[] = "/dev/sda2";
15938       r[1][5] = 's';
15939       if (strcmp (r[1], expected) != 0) {
15940         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15941         return -1;
15942       }
15943     }
15944     if (!r[2]) {
15945       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15946       print_strings (r);
15947       return -1;
15948     }
15949     {
15950       char expected[] = "/dev/sda3";
15951       r[2][5] = 's';
15952       if (strcmp (r[2], expected) != 0) {
15953         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15954         return -1;
15955       }
15956     }
15957     if (r[3] != NULL) {
15958       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15959       print_strings (r);
15960       return -1;
15961     }
15962     for (i = 0; r[i] != NULL; ++i)
15963       free (r[i]);
15964     free (r);
15965   }
15966   return 0;
15967 }
15968
15969 static int test_list_partitions_0_skip (void)
15970 {
15971   const char *str;
15972
15973   str = getenv ("TEST_ONLY");
15974   if (str)
15975     return strstr (str, "list_partitions") == NULL;
15976   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15977   if (str && strcmp (str, "1") == 0) return 1;
15978   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15979   if (str && strcmp (str, "1") == 0) return 1;
15980   return 0;
15981 }
15982
15983 static int test_list_partitions_0 (void)
15984 {
15985   if (test_list_partitions_0_skip ()) {
15986     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15987     return 0;
15988   }
15989
15990   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15991   {
15992     char device[] = "/dev/sda";
15993     int r;
15994     suppress_error = 0;
15995     r = guestfs_blockdev_setrw (g, device);
15996     if (r == -1)
15997       return -1;
15998   }
15999   {
16000     int r;
16001     suppress_error = 0;
16002     r = guestfs_umount_all (g);
16003     if (r == -1)
16004       return -1;
16005   }
16006   {
16007     int r;
16008     suppress_error = 0;
16009     r = guestfs_lvm_remove_all (g);
16010     if (r == -1)
16011       return -1;
16012   }
16013   {
16014     char device[] = "/dev/sda";
16015     char lines_0[] = ",";
16016     char *lines[] = {
16017       lines_0,
16018       NULL
16019     };
16020     int r;
16021     suppress_error = 0;
16022     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16023     if (r == -1)
16024       return -1;
16025   }
16026   {
16027     char fstype[] = "ext2";
16028     char device[] = "/dev/sda1";
16029     int r;
16030     suppress_error = 0;
16031     r = guestfs_mkfs (g, fstype, device);
16032     if (r == -1)
16033       return -1;
16034   }
16035   {
16036     char device[] = "/dev/sda1";
16037     char mountpoint[] = "/";
16038     int r;
16039     suppress_error = 0;
16040     r = guestfs_mount (g, device, mountpoint);
16041     if (r == -1)
16042       return -1;
16043   }
16044   /* TestOutputListOfDevices for list_partitions (0) */
16045   {
16046     char **r;
16047     int i;
16048     suppress_error = 0;
16049     r = guestfs_list_partitions (g);
16050     if (r == NULL)
16051       return -1;
16052     if (!r[0]) {
16053       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
16054       print_strings (r);
16055       return -1;
16056     }
16057     {
16058       char expected[] = "/dev/sda1";
16059       r[0][5] = 's';
16060       if (strcmp (r[0], expected) != 0) {
16061         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16062         return -1;
16063       }
16064     }
16065     if (r[1] != NULL) {
16066       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
16067       print_strings (r);
16068       return -1;
16069     }
16070     for (i = 0; r[i] != NULL; ++i)
16071       free (r[i]);
16072     free (r);
16073   }
16074   return 0;
16075 }
16076
16077 static int test_list_partitions_1_skip (void)
16078 {
16079   const char *str;
16080
16081   str = getenv ("TEST_ONLY");
16082   if (str)
16083     return strstr (str, "list_partitions") == NULL;
16084   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
16085   if (str && strcmp (str, "1") == 0) return 1;
16086   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
16087   if (str && strcmp (str, "1") == 0) return 1;
16088   return 0;
16089 }
16090
16091 static int test_list_partitions_1 (void)
16092 {
16093   if (test_list_partitions_1_skip ()) {
16094     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
16095     return 0;
16096   }
16097
16098   /* InitNone|InitEmpty for test_list_partitions_1 */
16099   {
16100     char device[] = "/dev/sda";
16101     int r;
16102     suppress_error = 0;
16103     r = guestfs_blockdev_setrw (g, device);
16104     if (r == -1)
16105       return -1;
16106   }
16107   {
16108     int r;
16109     suppress_error = 0;
16110     r = guestfs_umount_all (g);
16111     if (r == -1)
16112       return -1;
16113   }
16114   {
16115     int r;
16116     suppress_error = 0;
16117     r = guestfs_lvm_remove_all (g);
16118     if (r == -1)
16119       return -1;
16120   }
16121   /* TestOutputListOfDevices for list_partitions (1) */
16122   {
16123     char device[] = "/dev/sda";
16124     char lines_0[] = ",10";
16125     char lines_1[] = ",20";
16126     char lines_2[] = ",";
16127     char *lines[] = {
16128       lines_0,
16129       lines_1,
16130       lines_2,
16131       NULL
16132     };
16133     int r;
16134     suppress_error = 0;
16135     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16136     if (r == -1)
16137       return -1;
16138   }
16139   {
16140     char **r;
16141     int i;
16142     suppress_error = 0;
16143     r = guestfs_list_partitions (g);
16144     if (r == NULL)
16145       return -1;
16146     if (!r[0]) {
16147       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
16148       print_strings (r);
16149       return -1;
16150     }
16151     {
16152       char expected[] = "/dev/sda1";
16153       r[0][5] = 's';
16154       if (strcmp (r[0], expected) != 0) {
16155         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16156         return -1;
16157       }
16158     }
16159     if (!r[1]) {
16160       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
16161       print_strings (r);
16162       return -1;
16163     }
16164     {
16165       char expected[] = "/dev/sda2";
16166       r[1][5] = 's';
16167       if (strcmp (r[1], expected) != 0) {
16168         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16169         return -1;
16170       }
16171     }
16172     if (!r[2]) {
16173       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
16174       print_strings (r);
16175       return -1;
16176     }
16177     {
16178       char expected[] = "/dev/sda3";
16179       r[2][5] = 's';
16180       if (strcmp (r[2], expected) != 0) {
16181         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16182         return -1;
16183       }
16184     }
16185     if (r[3] != NULL) {
16186       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
16187       print_strings (r);
16188       return -1;
16189     }
16190     for (i = 0; r[i] != NULL; ++i)
16191       free (r[i]);
16192     free (r);
16193   }
16194   return 0;
16195 }
16196
16197 static int test_list_devices_0_skip (void)
16198 {
16199   const char *str;
16200
16201   str = getenv ("TEST_ONLY");
16202   if (str)
16203     return strstr (str, "list_devices") == NULL;
16204   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
16205   if (str && strcmp (str, "1") == 0) return 1;
16206   str = getenv ("SKIP_TEST_LIST_DEVICES");
16207   if (str && strcmp (str, "1") == 0) return 1;
16208   return 0;
16209 }
16210
16211 static int test_list_devices_0 (void)
16212 {
16213   if (test_list_devices_0_skip ()) {
16214     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
16215     return 0;
16216   }
16217
16218   /* InitNone|InitEmpty for test_list_devices_0 */
16219   {
16220     char device[] = "/dev/sda";
16221     int r;
16222     suppress_error = 0;
16223     r = guestfs_blockdev_setrw (g, device);
16224     if (r == -1)
16225       return -1;
16226   }
16227   {
16228     int r;
16229     suppress_error = 0;
16230     r = guestfs_umount_all (g);
16231     if (r == -1)
16232       return -1;
16233   }
16234   {
16235     int r;
16236     suppress_error = 0;
16237     r = guestfs_lvm_remove_all (g);
16238     if (r == -1)
16239       return -1;
16240   }
16241   /* TestOutputListOfDevices for list_devices (0) */
16242   {
16243     char **r;
16244     int i;
16245     suppress_error = 0;
16246     r = guestfs_list_devices (g);
16247     if (r == NULL)
16248       return -1;
16249     if (!r[0]) {
16250       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16251       print_strings (r);
16252       return -1;
16253     }
16254     {
16255       char expected[] = "/dev/sda";
16256       r[0][5] = 's';
16257       if (strcmp (r[0], expected) != 0) {
16258         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16259         return -1;
16260       }
16261     }
16262     if (!r[1]) {
16263       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16264       print_strings (r);
16265       return -1;
16266     }
16267     {
16268       char expected[] = "/dev/sdb";
16269       r[1][5] = 's';
16270       if (strcmp (r[1], expected) != 0) {
16271         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16272         return -1;
16273       }
16274     }
16275     if (!r[2]) {
16276       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16277       print_strings (r);
16278       return -1;
16279     }
16280     {
16281       char expected[] = "/dev/sdc";
16282       r[2][5] = 's';
16283       if (strcmp (r[2], expected) != 0) {
16284         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16285         return -1;
16286       }
16287     }
16288     if (!r[3]) {
16289       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16290       print_strings (r);
16291       return -1;
16292     }
16293     {
16294       char expected[] = "/dev/sdd";
16295       r[3][5] = 's';
16296       if (strcmp (r[3], expected) != 0) {
16297         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
16298         return -1;
16299       }
16300     }
16301     if (r[4] != NULL) {
16302       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
16303       print_strings (r);
16304       return -1;
16305     }
16306     for (i = 0; r[i] != NULL; ++i)
16307       free (r[i]);
16308     free (r);
16309   }
16310   return 0;
16311 }
16312
16313 static int test_ls_0_skip (void)
16314 {
16315   const char *str;
16316
16317   str = getenv ("TEST_ONLY");
16318   if (str)
16319     return strstr (str, "ls") == NULL;
16320   str = getenv ("SKIP_TEST_LS_0");
16321   if (str && strcmp (str, "1") == 0) return 1;
16322   str = getenv ("SKIP_TEST_LS");
16323   if (str && strcmp (str, "1") == 0) return 1;
16324   return 0;
16325 }
16326
16327 static int test_ls_0 (void)
16328 {
16329   if (test_ls_0_skip ()) {
16330     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
16331     return 0;
16332   }
16333
16334   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
16335   {
16336     char device[] = "/dev/sda";
16337     int r;
16338     suppress_error = 0;
16339     r = guestfs_blockdev_setrw (g, device);
16340     if (r == -1)
16341       return -1;
16342   }
16343   {
16344     int r;
16345     suppress_error = 0;
16346     r = guestfs_umount_all (g);
16347     if (r == -1)
16348       return -1;
16349   }
16350   {
16351     int r;
16352     suppress_error = 0;
16353     r = guestfs_lvm_remove_all (g);
16354     if (r == -1)
16355       return -1;
16356   }
16357   {
16358     char device[] = "/dev/sda";
16359     char lines_0[] = ",";
16360     char *lines[] = {
16361       lines_0,
16362       NULL
16363     };
16364     int r;
16365     suppress_error = 0;
16366     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16367     if (r == -1)
16368       return -1;
16369   }
16370   {
16371     char fstype[] = "ext2";
16372     char device[] = "/dev/sda1";
16373     int r;
16374     suppress_error = 0;
16375     r = guestfs_mkfs (g, fstype, device);
16376     if (r == -1)
16377       return -1;
16378   }
16379   {
16380     char device[] = "/dev/sda1";
16381     char mountpoint[] = "/";
16382     int r;
16383     suppress_error = 0;
16384     r = guestfs_mount (g, device, mountpoint);
16385     if (r == -1)
16386       return -1;
16387   }
16388   /* TestOutputList for ls (0) */
16389   {
16390     char path[] = "/new";
16391     int r;
16392     suppress_error = 0;
16393     r = guestfs_touch (g, path);
16394     if (r == -1)
16395       return -1;
16396   }
16397   {
16398     char path[] = "/newer";
16399     int r;
16400     suppress_error = 0;
16401     r = guestfs_touch (g, path);
16402     if (r == -1)
16403       return -1;
16404   }
16405   {
16406     char path[] = "/newest";
16407     int r;
16408     suppress_error = 0;
16409     r = guestfs_touch (g, path);
16410     if (r == -1)
16411       return -1;
16412   }
16413   {
16414     char directory[] = "/";
16415     char **r;
16416     int i;
16417     suppress_error = 0;
16418     r = guestfs_ls (g, directory);
16419     if (r == NULL)
16420       return -1;
16421     if (!r[0]) {
16422       fprintf (stderr, "test_ls_0: short list returned from command\n");
16423       print_strings (r);
16424       return -1;
16425     }
16426     {
16427       char expected[] = "lost+found";
16428       if (strcmp (r[0], expected) != 0) {
16429         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16430         return -1;
16431       }
16432     }
16433     if (!r[1]) {
16434       fprintf (stderr, "test_ls_0: short list returned from command\n");
16435       print_strings (r);
16436       return -1;
16437     }
16438     {
16439       char expected[] = "new";
16440       if (strcmp (r[1], expected) != 0) {
16441         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16442         return -1;
16443       }
16444     }
16445     if (!r[2]) {
16446       fprintf (stderr, "test_ls_0: short list returned from command\n");
16447       print_strings (r);
16448       return -1;
16449     }
16450     {
16451       char expected[] = "newer";
16452       if (strcmp (r[2], expected) != 0) {
16453         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16454         return -1;
16455       }
16456     }
16457     if (!r[3]) {
16458       fprintf (stderr, "test_ls_0: short list returned from command\n");
16459       print_strings (r);
16460       return -1;
16461     }
16462     {
16463       char expected[] = "newest";
16464       if (strcmp (r[3], expected) != 0) {
16465         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
16466         return -1;
16467       }
16468     }
16469     if (r[4] != NULL) {
16470       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
16471       print_strings (r);
16472       return -1;
16473     }
16474     for (i = 0; r[i] != NULL; ++i)
16475       free (r[i]);
16476     free (r);
16477   }
16478   return 0;
16479 }
16480
16481 static int test_cat_0_skip (void)
16482 {
16483   const char *str;
16484
16485   str = getenv ("TEST_ONLY");
16486   if (str)
16487     return strstr (str, "cat") == NULL;
16488   str = getenv ("SKIP_TEST_CAT_0");
16489   if (str && strcmp (str, "1") == 0) return 1;
16490   str = getenv ("SKIP_TEST_CAT");
16491   if (str && strcmp (str, "1") == 0) return 1;
16492   return 0;
16493 }
16494
16495 static int test_cat_0 (void)
16496 {
16497   if (test_cat_0_skip ()) {
16498     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
16499     return 0;
16500   }
16501
16502   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
16503   {
16504     char device[] = "/dev/sda";
16505     int r;
16506     suppress_error = 0;
16507     r = guestfs_blockdev_setrw (g, device);
16508     if (r == -1)
16509       return -1;
16510   }
16511   {
16512     int r;
16513     suppress_error = 0;
16514     r = guestfs_umount_all (g);
16515     if (r == -1)
16516       return -1;
16517   }
16518   {
16519     int r;
16520     suppress_error = 0;
16521     r = guestfs_lvm_remove_all (g);
16522     if (r == -1)
16523       return -1;
16524   }
16525   {
16526     char device[] = "/dev/sda";
16527     char lines_0[] = ",";
16528     char *lines[] = {
16529       lines_0,
16530       NULL
16531     };
16532     int r;
16533     suppress_error = 0;
16534     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16535     if (r == -1)
16536       return -1;
16537   }
16538   {
16539     char fstype[] = "ext2";
16540     char device[] = "/dev/sda1";
16541     int r;
16542     suppress_error = 0;
16543     r = guestfs_mkfs (g, fstype, device);
16544     if (r == -1)
16545       return -1;
16546   }
16547   {
16548     char device[] = "/dev/sda1";
16549     char mountpoint[] = "/";
16550     int r;
16551     suppress_error = 0;
16552     r = guestfs_mount (g, device, mountpoint);
16553     if (r == -1)
16554       return -1;
16555   }
16556   /* TestOutput for cat (0) */
16557   char expected[] = "new file contents";
16558   {
16559     char path[] = "/new";
16560     char content[] = "new file contents";
16561     int r;
16562     suppress_error = 0;
16563     r = guestfs_write_file (g, path, content, 0);
16564     if (r == -1)
16565       return -1;
16566   }
16567   {
16568     char path[] = "/new";
16569     char *r;
16570     suppress_error = 0;
16571     r = guestfs_cat (g, path);
16572     if (r == NULL)
16573       return -1;
16574     if (strcmp (r, expected) != 0) {
16575       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
16576       return -1;
16577     }
16578     free (r);
16579   }
16580   return 0;
16581 }
16582
16583 static int test_touch_0_skip (void)
16584 {
16585   const char *str;
16586
16587   str = getenv ("TEST_ONLY");
16588   if (str)
16589     return strstr (str, "touch") == NULL;
16590   str = getenv ("SKIP_TEST_TOUCH_0");
16591   if (str && strcmp (str, "1") == 0) return 1;
16592   str = getenv ("SKIP_TEST_TOUCH");
16593   if (str && strcmp (str, "1") == 0) return 1;
16594   return 0;
16595 }
16596
16597 static int test_touch_0 (void)
16598 {
16599   if (test_touch_0_skip ()) {
16600     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
16601     return 0;
16602   }
16603
16604   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
16605   {
16606     char device[] = "/dev/sda";
16607     int r;
16608     suppress_error = 0;
16609     r = guestfs_blockdev_setrw (g, device);
16610     if (r == -1)
16611       return -1;
16612   }
16613   {
16614     int r;
16615     suppress_error = 0;
16616     r = guestfs_umount_all (g);
16617     if (r == -1)
16618       return -1;
16619   }
16620   {
16621     int r;
16622     suppress_error = 0;
16623     r = guestfs_lvm_remove_all (g);
16624     if (r == -1)
16625       return -1;
16626   }
16627   {
16628     char device[] = "/dev/sda";
16629     char lines_0[] = ",";
16630     char *lines[] = {
16631       lines_0,
16632       NULL
16633     };
16634     int r;
16635     suppress_error = 0;
16636     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16637     if (r == -1)
16638       return -1;
16639   }
16640   {
16641     char fstype[] = "ext2";
16642     char device[] = "/dev/sda1";
16643     int r;
16644     suppress_error = 0;
16645     r = guestfs_mkfs (g, fstype, device);
16646     if (r == -1)
16647       return -1;
16648   }
16649   {
16650     char device[] = "/dev/sda1";
16651     char mountpoint[] = "/";
16652     int r;
16653     suppress_error = 0;
16654     r = guestfs_mount (g, device, mountpoint);
16655     if (r == -1)
16656       return -1;
16657   }
16658   /* TestOutputTrue for touch (0) */
16659   {
16660     char path[] = "/new";
16661     int r;
16662     suppress_error = 0;
16663     r = guestfs_touch (g, path);
16664     if (r == -1)
16665       return -1;
16666   }
16667   {
16668     char path[] = "/new";
16669     int r;
16670     suppress_error = 0;
16671     r = guestfs_exists (g, path);
16672     if (r == -1)
16673       return -1;
16674     if (!r) {
16675       fprintf (stderr, "test_touch_0: expected true, got false\n");
16676       return -1;
16677     }
16678   }
16679   return 0;
16680 }
16681
16682 static int test_sync_0_skip (void)
16683 {
16684   const char *str;
16685
16686   str = getenv ("TEST_ONLY");
16687   if (str)
16688     return strstr (str, "sync") == NULL;
16689   str = getenv ("SKIP_TEST_SYNC_0");
16690   if (str && strcmp (str, "1") == 0) return 1;
16691   str = getenv ("SKIP_TEST_SYNC");
16692   if (str && strcmp (str, "1") == 0) return 1;
16693   return 0;
16694 }
16695
16696 static int test_sync_0 (void)
16697 {
16698   if (test_sync_0_skip ()) {
16699     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
16700     return 0;
16701   }
16702
16703   /* InitNone|InitEmpty for test_sync_0 */
16704   {
16705     char device[] = "/dev/sda";
16706     int r;
16707     suppress_error = 0;
16708     r = guestfs_blockdev_setrw (g, device);
16709     if (r == -1)
16710       return -1;
16711   }
16712   {
16713     int r;
16714     suppress_error = 0;
16715     r = guestfs_umount_all (g);
16716     if (r == -1)
16717       return -1;
16718   }
16719   {
16720     int r;
16721     suppress_error = 0;
16722     r = guestfs_lvm_remove_all (g);
16723     if (r == -1)
16724       return -1;
16725   }
16726   /* TestRun for sync (0) */
16727   {
16728     int r;
16729     suppress_error = 0;
16730     r = guestfs_sync (g);
16731     if (r == -1)
16732       return -1;
16733   }
16734   return 0;
16735 }
16736
16737 static int test_mount_0_skip (void)
16738 {
16739   const char *str;
16740
16741   str = getenv ("TEST_ONLY");
16742   if (str)
16743     return strstr (str, "mount") == NULL;
16744   str = getenv ("SKIP_TEST_MOUNT_0");
16745   if (str && strcmp (str, "1") == 0) return 1;
16746   str = getenv ("SKIP_TEST_MOUNT");
16747   if (str && strcmp (str, "1") == 0) return 1;
16748   return 0;
16749 }
16750
16751 static int test_mount_0 (void)
16752 {
16753   if (test_mount_0_skip ()) {
16754     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
16755     return 0;
16756   }
16757
16758   /* InitNone|InitEmpty for test_mount_0 */
16759   {
16760     char device[] = "/dev/sda";
16761     int r;
16762     suppress_error = 0;
16763     r = guestfs_blockdev_setrw (g, device);
16764     if (r == -1)
16765       return -1;
16766   }
16767   {
16768     int r;
16769     suppress_error = 0;
16770     r = guestfs_umount_all (g);
16771     if (r == -1)
16772       return -1;
16773   }
16774   {
16775     int r;
16776     suppress_error = 0;
16777     r = guestfs_lvm_remove_all (g);
16778     if (r == -1)
16779       return -1;
16780   }
16781   /* TestOutput for mount (0) */
16782   char expected[] = "new file contents";
16783   {
16784     char device[] = "/dev/sda";
16785     char lines_0[] = ",";
16786     char *lines[] = {
16787       lines_0,
16788       NULL
16789     };
16790     int r;
16791     suppress_error = 0;
16792     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16793     if (r == -1)
16794       return -1;
16795   }
16796   {
16797     char fstype[] = "ext2";
16798     char device[] = "/dev/sda1";
16799     int r;
16800     suppress_error = 0;
16801     r = guestfs_mkfs (g, fstype, device);
16802     if (r == -1)
16803       return -1;
16804   }
16805   {
16806     char device[] = "/dev/sda1";
16807     char mountpoint[] = "/";
16808     int r;
16809     suppress_error = 0;
16810     r = guestfs_mount (g, device, mountpoint);
16811     if (r == -1)
16812       return -1;
16813   }
16814   {
16815     char path[] = "/new";
16816     char content[] = "new file contents";
16817     int r;
16818     suppress_error = 0;
16819     r = guestfs_write_file (g, path, content, 0);
16820     if (r == -1)
16821       return -1;
16822   }
16823   {
16824     char path[] = "/new";
16825     char *r;
16826     suppress_error = 0;
16827     r = guestfs_cat (g, path);
16828     if (r == NULL)
16829       return -1;
16830     if (strcmp (r, expected) != 0) {
16831       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16832       return -1;
16833     }
16834     free (r);
16835   }
16836   return 0;
16837 }
16838
16839 int main (int argc, char *argv[])
16840 {
16841   char c = 0;
16842   int failed = 0;
16843   const char *filename;
16844   int fd;
16845   int nr_tests, test_num = 0;
16846
16847   no_test_warnings ();
16848
16849   g = guestfs_create ();
16850   if (g == NULL) {
16851     printf ("guestfs_create FAILED\n");
16852     exit (1);
16853   }
16854
16855   guestfs_set_error_handler (g, print_error, NULL);
16856
16857   guestfs_set_path (g, "../appliance");
16858
16859   filename = "test1.img";
16860   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16861   if (fd == -1) {
16862     perror (filename);
16863     exit (1);
16864   }
16865   if (lseek (fd, 524288000, SEEK_SET) == -1) {
16866     perror ("lseek");
16867     close (fd);
16868     unlink (filename);
16869     exit (1);
16870   }
16871   if (write (fd, &c, 1) == -1) {
16872     perror ("write");
16873     close (fd);
16874     unlink (filename);
16875     exit (1);
16876   }
16877   if (close (fd) == -1) {
16878     perror (filename);
16879     unlink (filename);
16880     exit (1);
16881   }
16882   if (guestfs_add_drive (g, filename) == -1) {
16883     printf ("guestfs_add_drive %s FAILED\n", filename);
16884     exit (1);
16885   }
16886
16887   filename = "test2.img";
16888   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16889   if (fd == -1) {
16890     perror (filename);
16891     exit (1);
16892   }
16893   if (lseek (fd, 52428800, SEEK_SET) == -1) {
16894     perror ("lseek");
16895     close (fd);
16896     unlink (filename);
16897     exit (1);
16898   }
16899   if (write (fd, &c, 1) == -1) {
16900     perror ("write");
16901     close (fd);
16902     unlink (filename);
16903     exit (1);
16904   }
16905   if (close (fd) == -1) {
16906     perror (filename);
16907     unlink (filename);
16908     exit (1);
16909   }
16910   if (guestfs_add_drive (g, filename) == -1) {
16911     printf ("guestfs_add_drive %s FAILED\n", filename);
16912     exit (1);
16913   }
16914
16915   filename = "test3.img";
16916   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16917   if (fd == -1) {
16918     perror (filename);
16919     exit (1);
16920   }
16921   if (lseek (fd, 10485760, SEEK_SET) == -1) {
16922     perror ("lseek");
16923     close (fd);
16924     unlink (filename);
16925     exit (1);
16926   }
16927   if (write (fd, &c, 1) == -1) {
16928     perror ("write");
16929     close (fd);
16930     unlink (filename);
16931     exit (1);
16932   }
16933   if (close (fd) == -1) {
16934     perror (filename);
16935     unlink (filename);
16936     exit (1);
16937   }
16938   if (guestfs_add_drive (g, filename) == -1) {
16939     printf ("guestfs_add_drive %s FAILED\n", filename);
16940     exit (1);
16941   }
16942
16943   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16944     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16945     exit (1);
16946   }
16947
16948   if (guestfs_launch (g) == -1) {
16949     printf ("guestfs_launch FAILED\n");
16950     exit (1);
16951   }
16952
16953   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
16954   alarm (600);
16955
16956   if (guestfs_wait_ready (g) == -1) {
16957     printf ("guestfs_wait_ready FAILED\n");
16958     exit (1);
16959   }
16960
16961   /* Cancel previous alarm. */
16962   alarm (0);
16963
16964   nr_tests = 153;
16965
16966   test_num++;
16967   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
16968   if (test_mkdtemp_0 () == -1) {
16969     printf ("test_mkdtemp_0 FAILED\n");
16970     failed++;
16971   }
16972   test_num++;
16973   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
16974   if (test_scrub_file_0 () == -1) {
16975     printf ("test_scrub_file_0 FAILED\n");
16976     failed++;
16977   }
16978   test_num++;
16979   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
16980   if (test_scrub_device_0 () == -1) {
16981     printf ("test_scrub_device_0 FAILED\n");
16982     failed++;
16983   }
16984   test_num++;
16985   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
16986   if (test_glob_expand_0 () == -1) {
16987     printf ("test_glob_expand_0 FAILED\n");
16988     failed++;
16989   }
16990   test_num++;
16991   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
16992   if (test_glob_expand_1 () == -1) {
16993     printf ("test_glob_expand_1 FAILED\n");
16994     failed++;
16995   }
16996   test_num++;
16997   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
16998   if (test_glob_expand_2 () == -1) {
16999     printf ("test_glob_expand_2 FAILED\n");
17000     failed++;
17001   }
17002   test_num++;
17003   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
17004   if (test_ntfs_3g_probe_0 () == -1) {
17005     printf ("test_ntfs_3g_probe_0 FAILED\n");
17006     failed++;
17007   }
17008   test_num++;
17009   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
17010   if (test_ntfs_3g_probe_1 () == -1) {
17011     printf ("test_ntfs_3g_probe_1 FAILED\n");
17012     failed++;
17013   }
17014   test_num++;
17015   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
17016   if (test_sleep_0 () == -1) {
17017     printf ("test_sleep_0 FAILED\n");
17018     failed++;
17019   }
17020   test_num++;
17021   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
17022   if (test_find_0 () == -1) {
17023     printf ("test_find_0 FAILED\n");
17024     failed++;
17025   }
17026   test_num++;
17027   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
17028   if (test_find_1 () == -1) {
17029     printf ("test_find_1 FAILED\n");
17030     failed++;
17031   }
17032   test_num++;
17033   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
17034   if (test_find_2 () == -1) {
17035     printf ("test_find_2 FAILED\n");
17036     failed++;
17037   }
17038   test_num++;
17039   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
17040   if (test_lvresize_0 () == -1) {
17041     printf ("test_lvresize_0 FAILED\n");
17042     failed++;
17043   }
17044   test_num++;
17045   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
17046   if (test_zerofree_0 () == -1) {
17047     printf ("test_zerofree_0 FAILED\n");
17048     failed++;
17049   }
17050   test_num++;
17051   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
17052   if (test_hexdump_0 () == -1) {
17053     printf ("test_hexdump_0 FAILED\n");
17054     failed++;
17055   }
17056   test_num++;
17057   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
17058   if (test_hexdump_1 () == -1) {
17059     printf ("test_hexdump_1 FAILED\n");
17060     failed++;
17061   }
17062   test_num++;
17063   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
17064   if (test_strings_e_0 () == -1) {
17065     printf ("test_strings_e_0 FAILED\n");
17066     failed++;
17067   }
17068   test_num++;
17069   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
17070   if (test_strings_e_1 () == -1) {
17071     printf ("test_strings_e_1 FAILED\n");
17072     failed++;
17073   }
17074   test_num++;
17075   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
17076   if (test_strings_0 () == -1) {
17077     printf ("test_strings_0 FAILED\n");
17078     failed++;
17079   }
17080   test_num++;
17081   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
17082   if (test_strings_1 () == -1) {
17083     printf ("test_strings_1 FAILED\n");
17084     failed++;
17085   }
17086   test_num++;
17087   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
17088   if (test_equal_0 () == -1) {
17089     printf ("test_equal_0 FAILED\n");
17090     failed++;
17091   }
17092   test_num++;
17093   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
17094   if (test_equal_1 () == -1) {
17095     printf ("test_equal_1 FAILED\n");
17096     failed++;
17097   }
17098   test_num++;
17099   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
17100   if (test_equal_2 () == -1) {
17101     printf ("test_equal_2 FAILED\n");
17102     failed++;
17103   }
17104   test_num++;
17105   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
17106   if (test_ping_daemon_0 () == -1) {
17107     printf ("test_ping_daemon_0 FAILED\n");
17108     failed++;
17109   }
17110   test_num++;
17111   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
17112   if (test_dmesg_0 () == -1) {
17113     printf ("test_dmesg_0 FAILED\n");
17114     failed++;
17115   }
17116   test_num++;
17117   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
17118   if (test_drop_caches_0 () == -1) {
17119     printf ("test_drop_caches_0 FAILED\n");
17120     failed++;
17121   }
17122   test_num++;
17123   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
17124   if (test_mv_0 () == -1) {
17125     printf ("test_mv_0 FAILED\n");
17126     failed++;
17127   }
17128   test_num++;
17129   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
17130   if (test_mv_1 () == -1) {
17131     printf ("test_mv_1 FAILED\n");
17132     failed++;
17133   }
17134   test_num++;
17135   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
17136   if (test_cp_a_0 () == -1) {
17137     printf ("test_cp_a_0 FAILED\n");
17138     failed++;
17139   }
17140   test_num++;
17141   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
17142   if (test_cp_0 () == -1) {
17143     printf ("test_cp_0 FAILED\n");
17144     failed++;
17145   }
17146   test_num++;
17147   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
17148   if (test_cp_1 () == -1) {
17149     printf ("test_cp_1 FAILED\n");
17150     failed++;
17151   }
17152   test_num++;
17153   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
17154   if (test_cp_2 () == -1) {
17155     printf ("test_cp_2 FAILED\n");
17156     failed++;
17157   }
17158   test_num++;
17159   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
17160   if (test_grub_install_0 () == -1) {
17161     printf ("test_grub_install_0 FAILED\n");
17162     failed++;
17163   }
17164   test_num++;
17165   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
17166   if (test_zero_0 () == -1) {
17167     printf ("test_zero_0 FAILED\n");
17168     failed++;
17169   }
17170   test_num++;
17171   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
17172   if (test_fsck_0 () == -1) {
17173     printf ("test_fsck_0 FAILED\n");
17174     failed++;
17175   }
17176   test_num++;
17177   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
17178   if (test_fsck_1 () == -1) {
17179     printf ("test_fsck_1 FAILED\n");
17180     failed++;
17181   }
17182   test_num++;
17183   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
17184   if (test_set_e2uuid_0 () == -1) {
17185     printf ("test_set_e2uuid_0 FAILED\n");
17186     failed++;
17187   }
17188   test_num++;
17189   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
17190   if (test_set_e2uuid_1 () == -1) {
17191     printf ("test_set_e2uuid_1 FAILED\n");
17192     failed++;
17193   }
17194   test_num++;
17195   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
17196   if (test_set_e2uuid_2 () == -1) {
17197     printf ("test_set_e2uuid_2 FAILED\n");
17198     failed++;
17199   }
17200   test_num++;
17201   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
17202   if (test_set_e2uuid_3 () == -1) {
17203     printf ("test_set_e2uuid_3 FAILED\n");
17204     failed++;
17205   }
17206   test_num++;
17207   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
17208   if (test_set_e2label_0 () == -1) {
17209     printf ("test_set_e2label_0 FAILED\n");
17210     failed++;
17211   }
17212   test_num++;
17213   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
17214   if (test_pvremove_0 () == -1) {
17215     printf ("test_pvremove_0 FAILED\n");
17216     failed++;
17217   }
17218   test_num++;
17219   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
17220   if (test_pvremove_1 () == -1) {
17221     printf ("test_pvremove_1 FAILED\n");
17222     failed++;
17223   }
17224   test_num++;
17225   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
17226   if (test_pvremove_2 () == -1) {
17227     printf ("test_pvremove_2 FAILED\n");
17228     failed++;
17229   }
17230   test_num++;
17231   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
17232   if (test_vgremove_0 () == -1) {
17233     printf ("test_vgremove_0 FAILED\n");
17234     failed++;
17235   }
17236   test_num++;
17237   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
17238   if (test_vgremove_1 () == -1) {
17239     printf ("test_vgremove_1 FAILED\n");
17240     failed++;
17241   }
17242   test_num++;
17243   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
17244   if (test_lvremove_0 () == -1) {
17245     printf ("test_lvremove_0 FAILED\n");
17246     failed++;
17247   }
17248   test_num++;
17249   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
17250   if (test_lvremove_1 () == -1) {
17251     printf ("test_lvremove_1 FAILED\n");
17252     failed++;
17253   }
17254   test_num++;
17255   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
17256   if (test_lvremove_2 () == -1) {
17257     printf ("test_lvremove_2 FAILED\n");
17258     failed++;
17259   }
17260   test_num++;
17261   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
17262   if (test_mount_ro_0 () == -1) {
17263     printf ("test_mount_ro_0 FAILED\n");
17264     failed++;
17265   }
17266   test_num++;
17267   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
17268   if (test_mount_ro_1 () == -1) {
17269     printf ("test_mount_ro_1 FAILED\n");
17270     failed++;
17271   }
17272   test_num++;
17273   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
17274   if (test_tgz_in_0 () == -1) {
17275     printf ("test_tgz_in_0 FAILED\n");
17276     failed++;
17277   }
17278   test_num++;
17279   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
17280   if (test_tar_in_0 () == -1) {
17281     printf ("test_tar_in_0 FAILED\n");
17282     failed++;
17283   }
17284   test_num++;
17285   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
17286   if (test_checksum_0 () == -1) {
17287     printf ("test_checksum_0 FAILED\n");
17288     failed++;
17289   }
17290   test_num++;
17291   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
17292   if (test_checksum_1 () == -1) {
17293     printf ("test_checksum_1 FAILED\n");
17294     failed++;
17295   }
17296   test_num++;
17297   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
17298   if (test_checksum_2 () == -1) {
17299     printf ("test_checksum_2 FAILED\n");
17300     failed++;
17301   }
17302   test_num++;
17303   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
17304   if (test_checksum_3 () == -1) {
17305     printf ("test_checksum_3 FAILED\n");
17306     failed++;
17307   }
17308   test_num++;
17309   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
17310   if (test_checksum_4 () == -1) {
17311     printf ("test_checksum_4 FAILED\n");
17312     failed++;
17313   }
17314   test_num++;
17315   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
17316   if (test_checksum_5 () == -1) {
17317     printf ("test_checksum_5 FAILED\n");
17318     failed++;
17319   }
17320   test_num++;
17321   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
17322   if (test_checksum_6 () == -1) {
17323     printf ("test_checksum_6 FAILED\n");
17324     failed++;
17325   }
17326   test_num++;
17327   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
17328   if (test_checksum_7 () == -1) {
17329     printf ("test_checksum_7 FAILED\n");
17330     failed++;
17331   }
17332   test_num++;
17333   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
17334   if (test_checksum_8 () == -1) {
17335     printf ("test_checksum_8 FAILED\n");
17336     failed++;
17337   }
17338   test_num++;
17339   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
17340   if (test_download_0 () == -1) {
17341     printf ("test_download_0 FAILED\n");
17342     failed++;
17343   }
17344   test_num++;
17345   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
17346   if (test_upload_0 () == -1) {
17347     printf ("test_upload_0 FAILED\n");
17348     failed++;
17349   }
17350   test_num++;
17351   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
17352   if (test_blockdev_rereadpt_0 () == -1) {
17353     printf ("test_blockdev_rereadpt_0 FAILED\n");
17354     failed++;
17355   }
17356   test_num++;
17357   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
17358   if (test_blockdev_flushbufs_0 () == -1) {
17359     printf ("test_blockdev_flushbufs_0 FAILED\n");
17360     failed++;
17361   }
17362   test_num++;
17363   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
17364   if (test_blockdev_getsize64_0 () == -1) {
17365     printf ("test_blockdev_getsize64_0 FAILED\n");
17366     failed++;
17367   }
17368   test_num++;
17369   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
17370   if (test_blockdev_getsz_0 () == -1) {
17371     printf ("test_blockdev_getsz_0 FAILED\n");
17372     failed++;
17373   }
17374   test_num++;
17375   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
17376   if (test_blockdev_getbsz_0 () == -1) {
17377     printf ("test_blockdev_getbsz_0 FAILED\n");
17378     failed++;
17379   }
17380   test_num++;
17381   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
17382   if (test_blockdev_getss_0 () == -1) {
17383     printf ("test_blockdev_getss_0 FAILED\n");
17384     failed++;
17385   }
17386   test_num++;
17387   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
17388   if (test_blockdev_getro_0 () == -1) {
17389     printf ("test_blockdev_getro_0 FAILED\n");
17390     failed++;
17391   }
17392   test_num++;
17393   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
17394   if (test_blockdev_setrw_0 () == -1) {
17395     printf ("test_blockdev_setrw_0 FAILED\n");
17396     failed++;
17397   }
17398   test_num++;
17399   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
17400   if (test_blockdev_setro_0 () == -1) {
17401     printf ("test_blockdev_setro_0 FAILED\n");
17402     failed++;
17403   }
17404   test_num++;
17405   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
17406   if (test_statvfs_0 () == -1) {
17407     printf ("test_statvfs_0 FAILED\n");
17408     failed++;
17409   }
17410   test_num++;
17411   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
17412   if (test_lstat_0 () == -1) {
17413     printf ("test_lstat_0 FAILED\n");
17414     failed++;
17415   }
17416   test_num++;
17417   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
17418   if (test_stat_0 () == -1) {
17419     printf ("test_stat_0 FAILED\n");
17420     failed++;
17421   }
17422   test_num++;
17423   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
17424   if (test_command_lines_0 () == -1) {
17425     printf ("test_command_lines_0 FAILED\n");
17426     failed++;
17427   }
17428   test_num++;
17429   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
17430   if (test_command_lines_1 () == -1) {
17431     printf ("test_command_lines_1 FAILED\n");
17432     failed++;
17433   }
17434   test_num++;
17435   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
17436   if (test_command_lines_2 () == -1) {
17437     printf ("test_command_lines_2 FAILED\n");
17438     failed++;
17439   }
17440   test_num++;
17441   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
17442   if (test_command_lines_3 () == -1) {
17443     printf ("test_command_lines_3 FAILED\n");
17444     failed++;
17445   }
17446   test_num++;
17447   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
17448   if (test_command_lines_4 () == -1) {
17449     printf ("test_command_lines_4 FAILED\n");
17450     failed++;
17451   }
17452   test_num++;
17453   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
17454   if (test_command_lines_5 () == -1) {
17455     printf ("test_command_lines_5 FAILED\n");
17456     failed++;
17457   }
17458   test_num++;
17459   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
17460   if (test_command_lines_6 () == -1) {
17461     printf ("test_command_lines_6 FAILED\n");
17462     failed++;
17463   }
17464   test_num++;
17465   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
17466   if (test_command_lines_7 () == -1) {
17467     printf ("test_command_lines_7 FAILED\n");
17468     failed++;
17469   }
17470   test_num++;
17471   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
17472   if (test_command_lines_8 () == -1) {
17473     printf ("test_command_lines_8 FAILED\n");
17474     failed++;
17475   }
17476   test_num++;
17477   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
17478   if (test_command_lines_9 () == -1) {
17479     printf ("test_command_lines_9 FAILED\n");
17480     failed++;
17481   }
17482   test_num++;
17483   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
17484   if (test_command_lines_10 () == -1) {
17485     printf ("test_command_lines_10 FAILED\n");
17486     failed++;
17487   }
17488   test_num++;
17489   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
17490   if (test_command_0 () == -1) {
17491     printf ("test_command_0 FAILED\n");
17492     failed++;
17493   }
17494   test_num++;
17495   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
17496   if (test_command_1 () == -1) {
17497     printf ("test_command_1 FAILED\n");
17498     failed++;
17499   }
17500   test_num++;
17501   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
17502   if (test_command_2 () == -1) {
17503     printf ("test_command_2 FAILED\n");
17504     failed++;
17505   }
17506   test_num++;
17507   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
17508   if (test_command_3 () == -1) {
17509     printf ("test_command_3 FAILED\n");
17510     failed++;
17511   }
17512   test_num++;
17513   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
17514   if (test_command_4 () == -1) {
17515     printf ("test_command_4 FAILED\n");
17516     failed++;
17517   }
17518   test_num++;
17519   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
17520   if (test_command_5 () == -1) {
17521     printf ("test_command_5 FAILED\n");
17522     failed++;
17523   }
17524   test_num++;
17525   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
17526   if (test_command_6 () == -1) {
17527     printf ("test_command_6 FAILED\n");
17528     failed++;
17529   }
17530   test_num++;
17531   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
17532   if (test_command_7 () == -1) {
17533     printf ("test_command_7 FAILED\n");
17534     failed++;
17535   }
17536   test_num++;
17537   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
17538   if (test_command_8 () == -1) {
17539     printf ("test_command_8 FAILED\n");
17540     failed++;
17541   }
17542   test_num++;
17543   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
17544   if (test_command_9 () == -1) {
17545     printf ("test_command_9 FAILED\n");
17546     failed++;
17547   }
17548   test_num++;
17549   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
17550   if (test_command_10 () == -1) {
17551     printf ("test_command_10 FAILED\n");
17552     failed++;
17553   }
17554   test_num++;
17555   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
17556   if (test_command_11 () == -1) {
17557     printf ("test_command_11 FAILED\n");
17558     failed++;
17559   }
17560   test_num++;
17561   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
17562   if (test_file_0 () == -1) {
17563     printf ("test_file_0 FAILED\n");
17564     failed++;
17565   }
17566   test_num++;
17567   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
17568   if (test_file_1 () == -1) {
17569     printf ("test_file_1 FAILED\n");
17570     failed++;
17571   }
17572   test_num++;
17573   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
17574   if (test_file_2 () == -1) {
17575     printf ("test_file_2 FAILED\n");
17576     failed++;
17577   }
17578   test_num++;
17579   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
17580   if (test_umount_all_0 () == -1) {
17581     printf ("test_umount_all_0 FAILED\n");
17582     failed++;
17583   }
17584   test_num++;
17585   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
17586   if (test_umount_all_1 () == -1) {
17587     printf ("test_umount_all_1 FAILED\n");
17588     failed++;
17589   }
17590   test_num++;
17591   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
17592   if (test_mounts_0 () == -1) {
17593     printf ("test_mounts_0 FAILED\n");
17594     failed++;
17595   }
17596   test_num++;
17597   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
17598   if (test_umount_0 () == -1) {
17599     printf ("test_umount_0 FAILED\n");
17600     failed++;
17601   }
17602   test_num++;
17603   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
17604   if (test_umount_1 () == -1) {
17605     printf ("test_umount_1 FAILED\n");
17606     failed++;
17607   }
17608   test_num++;
17609   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
17610   if (test_write_file_0 () == -1) {
17611     printf ("test_write_file_0 FAILED\n");
17612     failed++;
17613   }
17614   test_num++;
17615   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
17616   if (test_write_file_1 () == -1) {
17617     printf ("test_write_file_1 FAILED\n");
17618     failed++;
17619   }
17620   test_num++;
17621   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
17622   if (test_write_file_2 () == -1) {
17623     printf ("test_write_file_2 FAILED\n");
17624     failed++;
17625   }
17626   test_num++;
17627   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
17628   if (test_write_file_3 () == -1) {
17629     printf ("test_write_file_3 FAILED\n");
17630     failed++;
17631   }
17632   test_num++;
17633   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
17634   if (test_write_file_4 () == -1) {
17635     printf ("test_write_file_4 FAILED\n");
17636     failed++;
17637   }
17638   test_num++;
17639   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
17640   if (test_write_file_5 () == -1) {
17641     printf ("test_write_file_5 FAILED\n");
17642     failed++;
17643   }
17644   test_num++;
17645   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
17646   if (test_mkfs_0 () == -1) {
17647     printf ("test_mkfs_0 FAILED\n");
17648     failed++;
17649   }
17650   test_num++;
17651   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
17652   if (test_lvcreate_0 () == -1) {
17653     printf ("test_lvcreate_0 FAILED\n");
17654     failed++;
17655   }
17656   test_num++;
17657   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
17658   if (test_vgcreate_0 () == -1) {
17659     printf ("test_vgcreate_0 FAILED\n");
17660     failed++;
17661   }
17662   test_num++;
17663   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17664   if (test_pvcreate_0 () == -1) {
17665     printf ("test_pvcreate_0 FAILED\n");
17666     failed++;
17667   }
17668   test_num++;
17669   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17670   if (test_is_dir_0 () == -1) {
17671     printf ("test_is_dir_0 FAILED\n");
17672     failed++;
17673   }
17674   test_num++;
17675   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
17676   if (test_is_dir_1 () == -1) {
17677     printf ("test_is_dir_1 FAILED\n");
17678     failed++;
17679   }
17680   test_num++;
17681   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
17682   if (test_is_file_0 () == -1) {
17683     printf ("test_is_file_0 FAILED\n");
17684     failed++;
17685   }
17686   test_num++;
17687   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
17688   if (test_is_file_1 () == -1) {
17689     printf ("test_is_file_1 FAILED\n");
17690     failed++;
17691   }
17692   test_num++;
17693   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
17694   if (test_exists_0 () == -1) {
17695     printf ("test_exists_0 FAILED\n");
17696     failed++;
17697   }
17698   test_num++;
17699   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
17700   if (test_exists_1 () == -1) {
17701     printf ("test_exists_1 FAILED\n");
17702     failed++;
17703   }
17704   test_num++;
17705   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
17706   if (test_mkdir_p_0 () == -1) {
17707     printf ("test_mkdir_p_0 FAILED\n");
17708     failed++;
17709   }
17710   test_num++;
17711   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
17712   if (test_mkdir_p_1 () == -1) {
17713     printf ("test_mkdir_p_1 FAILED\n");
17714     failed++;
17715   }
17716   test_num++;
17717   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
17718   if (test_mkdir_p_2 () == -1) {
17719     printf ("test_mkdir_p_2 FAILED\n");
17720     failed++;
17721   }
17722   test_num++;
17723   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
17724   if (test_mkdir_p_3 () == -1) {
17725     printf ("test_mkdir_p_3 FAILED\n");
17726     failed++;
17727   }
17728   test_num++;
17729   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
17730   if (test_mkdir_p_4 () == -1) {
17731     printf ("test_mkdir_p_4 FAILED\n");
17732     failed++;
17733   }
17734   test_num++;
17735   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
17736   if (test_mkdir_0 () == -1) {
17737     printf ("test_mkdir_0 FAILED\n");
17738     failed++;
17739   }
17740   test_num++;
17741   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
17742   if (test_mkdir_1 () == -1) {
17743     printf ("test_mkdir_1 FAILED\n");
17744     failed++;
17745   }
17746   test_num++;
17747   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
17748   if (test_rm_rf_0 () == -1) {
17749     printf ("test_rm_rf_0 FAILED\n");
17750     failed++;
17751   }
17752   test_num++;
17753   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
17754   if (test_rmdir_0 () == -1) {
17755     printf ("test_rmdir_0 FAILED\n");
17756     failed++;
17757   }
17758   test_num++;
17759   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
17760   if (test_rmdir_1 () == -1) {
17761     printf ("test_rmdir_1 FAILED\n");
17762     failed++;
17763   }
17764   test_num++;
17765   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
17766   if (test_rmdir_2 () == -1) {
17767     printf ("test_rmdir_2 FAILED\n");
17768     failed++;
17769   }
17770   test_num++;
17771   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
17772   if (test_rm_0 () == -1) {
17773     printf ("test_rm_0 FAILED\n");
17774     failed++;
17775   }
17776   test_num++;
17777   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
17778   if (test_rm_1 () == -1) {
17779     printf ("test_rm_1 FAILED\n");
17780     failed++;
17781   }
17782   test_num++;
17783   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
17784   if (test_rm_2 () == -1) {
17785     printf ("test_rm_2 FAILED\n");
17786     failed++;
17787   }
17788   test_num++;
17789   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
17790   if (test_read_lines_0 () == -1) {
17791     printf ("test_read_lines_0 FAILED\n");
17792     failed++;
17793   }
17794   test_num++;
17795   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
17796   if (test_read_lines_1 () == -1) {
17797     printf ("test_read_lines_1 FAILED\n");
17798     failed++;
17799   }
17800   test_num++;
17801   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
17802   if (test_lvs_0 () == -1) {
17803     printf ("test_lvs_0 FAILED\n");
17804     failed++;
17805   }
17806   test_num++;
17807   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
17808   if (test_lvs_1 () == -1) {
17809     printf ("test_lvs_1 FAILED\n");
17810     failed++;
17811   }
17812   test_num++;
17813   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
17814   if (test_vgs_0 () == -1) {
17815     printf ("test_vgs_0 FAILED\n");
17816     failed++;
17817   }
17818   test_num++;
17819   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17820   if (test_vgs_1 () == -1) {
17821     printf ("test_vgs_1 FAILED\n");
17822     failed++;
17823   }
17824   test_num++;
17825   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17826   if (test_pvs_0 () == -1) {
17827     printf ("test_pvs_0 FAILED\n");
17828     failed++;
17829   }
17830   test_num++;
17831   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17832   if (test_pvs_1 () == -1) {
17833     printf ("test_pvs_1 FAILED\n");
17834     failed++;
17835   }
17836   test_num++;
17837   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17838   if (test_list_partitions_0 () == -1) {
17839     printf ("test_list_partitions_0 FAILED\n");
17840     failed++;
17841   }
17842   test_num++;
17843   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17844   if (test_list_partitions_1 () == -1) {
17845     printf ("test_list_partitions_1 FAILED\n");
17846     failed++;
17847   }
17848   test_num++;
17849   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17850   if (test_list_devices_0 () == -1) {
17851     printf ("test_list_devices_0 FAILED\n");
17852     failed++;
17853   }
17854   test_num++;
17855   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17856   if (test_ls_0 () == -1) {
17857     printf ("test_ls_0 FAILED\n");
17858     failed++;
17859   }
17860   test_num++;
17861   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17862   if (test_cat_0 () == -1) {
17863     printf ("test_cat_0 FAILED\n");
17864     failed++;
17865   }
17866   test_num++;
17867   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17868   if (test_touch_0 () == -1) {
17869     printf ("test_touch_0 FAILED\n");
17870     failed++;
17871   }
17872   test_num++;
17873   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17874   if (test_sync_0 () == -1) {
17875     printf ("test_sync_0 FAILED\n");
17876     failed++;
17877   }
17878   test_num++;
17879   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17880   if (test_mount_0 () == -1) {
17881     printf ("test_mount_0 FAILED\n");
17882     failed++;
17883   }
17884
17885   guestfs_close (g);
17886   unlink ("test1.img");
17887   unlink ("test2.img");
17888   unlink ("test3.img");
17889
17890   if (failed > 0) {
17891     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
17892     exit (1);
17893   }
17894
17895   exit (0);
17896 }